drivers/mfd/wm831x-core.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * wm831x-core.c  --  Device access for Wolfson WM831x PMICs
   4  *
   5  * Copyright 2009 Wolfson Microelectronics PLC.
   6  *
   7  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/init.h>
  12 #include <linux/export.h>
  13 #include <linux/bcd.h>
  14 #include <linux/delay.h>
  15 #include <linux/mfd/core.h>
  16 #include <linux/slab.h>
  17 #include <linux/err.h>
  18 #include <linux/of.h>
  19 #include <linux/of_device.h>
  20
  21 #include <linux/mfd/wm831x/core.h>
  22 #include <linux/mfd/wm831x/pdata.h>
  23 #include <linux/mfd/wm831x/irq.h>
  24 #include <linux/mfd/wm831x/auxadc.h>
  25 #include <linux/mfd/wm831x/otp.h>
  26 #include <linux/mfd/wm831x/pmu.h>
  27 #include <linux/mfd/wm831x/regulator.h>
  28
  29 /* Current settings - values are 2*2^(reg_val/4) microamps.  These are
  30  * exported since they are used by multiple drivers.
  31  */
  32 const unsigned int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1] = {
  33         2,
  34         2,
  35         3,
  36         3,
  37         4,
  38         5,
  39         6,
  40         7,
  41         8,
  42         10,
  43         11,
  44         13,
  45         16,
  46         19,
  47         23,
  48         27,
  49         32,
  50         38,
  51         45,
  52         54,
  53         64,
  54         76,
  55         91,
  56         108,
  57         128,
  58         152,
  59         181,
  60         215,
  61         256,
  62         304,
  63         362,
  64         431,
  65         512,
  66         609,
  67         724,
  68         861,
  69         1024,
  70         1218,
  71         1448,
  72         1722,
  73         2048,
  74         2435,
  75         2896,
  76         3444,
  77         4096,
  78         4871,
  79         5793,
  80         6889,
  81         8192,
  82         9742,
  83         11585,
  84         13777,
  85         16384,
  86         19484,
  87         23170,
  88         27554,
  89 };
  90 EXPORT_SYMBOL_GPL(wm831x_isinkv_values);
  91
  92 static int wm831x_reg_locked(struct wm831x *wm831x, unsigned short reg)
  93 {
  94         if (!wm831x->locked)
  95                 return 0;
  96
  97         switch (reg) {
  98         case WM831X_WATCHDOG:
  99         case WM831X_DC4_CONTROL:
 100         case WM831X_ON_PIN_CONTROL:
 101         case WM831X_BACKUP_CHARGER_CONTROL:
 102         case WM831X_CHARGER_CONTROL_1:
 103         case WM831X_CHARGER_CONTROL_2:
 104                 return 1;
 105
 106         default:
 107                 return 0;
 108         }
 109 }
 110
 111 /**
 112  * wm831x_reg_lock: Unlock user keyed registers
 113  *
 114  * The WM831x has a user key preventing writes to particularly
 115  * critical registers.  This function locks those registers,
 116  * allowing writes to them.
 117  *
 118  * @wm831x: pointer to local driver data structure
 119  */
 120 void wm831x_reg_lock(struct wm831x *wm831x)
 121 {
 122         int ret;
 123
 124         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
 125         if (ret == 0) {
 126                 dev_vdbg(wm831x->dev, "Registers locked\n");
 127
 128                 mutex_lock(&wm831x->io_lock);
 129                 WARN_ON(wm831x->locked);
 130                 wm831x->locked = 1;
 131                 mutex_unlock(&wm831x->io_lock);
 132         } else {
 133                 dev_err(wm831x->dev, "Failed to lock registers: %d\n", ret);
 134         }
 135
 136 }
 137 EXPORT_SYMBOL_GPL(wm831x_reg_lock);
 138
 139 /**
 140  * wm831x_reg_unlock: Unlock user keyed registers
 141  *
 142  * The WM831x has a user key preventing writes to particularly
 143  * critical registers.  This function locks those registers,
 144  * preventing spurious writes.
 145  *
 146  * @wm831x: pointer to local driver data structure
 147  */
 148 int wm831x_reg_unlock(struct wm831x *wm831x)
 149 {
 150         int ret;
 151
 152         /* 0x9716 is the value required to unlock the registers */
 153         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0x9716);
 154         if (ret == 0) {
 155                 dev_vdbg(wm831x->dev, "Registers unlocked\n");
 156
 157                 mutex_lock(&wm831x->io_lock);
 158                 WARN_ON(!wm831x->locked);
 159                 wm831x->locked = 0;
 160                 mutex_unlock(&wm831x->io_lock);
 161         }
 162
 163         return ret;
 164 }
 165 EXPORT_SYMBOL_GPL(wm831x_reg_unlock);
 166
 167 static bool wm831x_reg_readable(struct device *dev, unsigned int reg)
 168 {
 169         switch (reg) {
 170         case WM831X_RESET_ID:
 171         case WM831X_REVISION:
 172         case WM831X_PARENT_ID:
 173         case WM831X_SYSVDD_CONTROL:
 174         case WM831X_THERMAL_MONITORING:
 175         case WM831X_POWER_STATE:
 176         case WM831X_WATCHDOG:
 177         case WM831X_ON_PIN_CONTROL:
 178         case WM831X_RESET_CONTROL:
 179         case WM831X_CONTROL_INTERFACE:
 180         case WM831X_SECURITY_KEY:
 181         case WM831X_SOFTWARE_SCRATCH:
 182         case WM831X_OTP_CONTROL:
 183         case WM831X_GPIO_LEVEL:
 184         case WM831X_SYSTEM_STATUS:
 185         case WM831X_ON_SOURCE:
 186         case WM831X_OFF_SOURCE:
 187         case WM831X_SYSTEM_INTERRUPTS:
 188         case WM831X_INTERRUPT_STATUS_1:
 189         case WM831X_INTERRUPT_STATUS_2:
 190         case WM831X_INTERRUPT_STATUS_3:
 191         case WM831X_INTERRUPT_STATUS_4:
 192         case WM831X_INTERRUPT_STATUS_5:
 193         case WM831X_IRQ_CONFIG:
 194         case WM831X_SYSTEM_INTERRUPTS_MASK:
 195         case WM831X_INTERRUPT_STATUS_1_MASK:
 196         case WM831X_INTERRUPT_STATUS_2_MASK:
 197         case WM831X_INTERRUPT_STATUS_3_MASK:
 198         case WM831X_INTERRUPT_STATUS_4_MASK:
 199         case WM831X_INTERRUPT_STATUS_5_MASK:
 200         case WM831X_RTC_WRITE_COUNTER:
 201         case WM831X_RTC_TIME_1:
 202         case WM831X_RTC_TIME_2:
 203         case WM831X_RTC_ALARM_1:
 204         case WM831X_RTC_ALARM_2:
 205         case WM831X_RTC_CONTROL:
 206         case WM831X_RTC_TRIM:
 207         case WM831X_TOUCH_CONTROL_1:
 208         case WM831X_TOUCH_CONTROL_2:
 209         case WM831X_TOUCH_DATA_X:
 210         case WM831X_TOUCH_DATA_Y:
 211         case WM831X_TOUCH_DATA_Z:
 212         case WM831X_AUXADC_DATA:
 213         case WM831X_AUXADC_CONTROL:
 214         case WM831X_AUXADC_SOURCE:
 215         case WM831X_COMPARATOR_CONTROL:
 216         case WM831X_COMPARATOR_1:
 217         case WM831X_COMPARATOR_2:
 218         case WM831X_COMPARATOR_3:
 219         case WM831X_COMPARATOR_4:
 220         case WM831X_GPIO1_CONTROL:
 221         case WM831X_GPIO2_CONTROL:
 222         case WM831X_GPIO3_CONTROL:
 223         case WM831X_GPIO4_CONTROL:
 224         case WM831X_GPIO5_CONTROL:
 225         case WM831X_GPIO6_CONTROL:
 226         case WM831X_GPIO7_CONTROL:
 227         case WM831X_GPIO8_CONTROL:
 228         case WM831X_GPIO9_CONTROL:
 229         case WM831X_GPIO10_CONTROL:
 230         case WM831X_GPIO11_CONTROL:
 231         case WM831X_GPIO12_CONTROL:
 232         case WM831X_GPIO13_CONTROL:
 233         case WM831X_GPIO14_CONTROL:
 234         case WM831X_GPIO15_CONTROL:
 235         case WM831X_GPIO16_CONTROL:
 236         case WM831X_CHARGER_CONTROL_1:
 237         case WM831X_CHARGER_CONTROL_2:
 238         case WM831X_CHARGER_STATUS:
 239         case WM831X_BACKUP_CHARGER_CONTROL:
 240         case WM831X_STATUS_LED_1:
 241         case WM831X_STATUS_LED_2:
 242         case WM831X_CURRENT_SINK_1:
 243         case WM831X_CURRENT_SINK_2:
 244         case WM831X_DCDC_ENABLE:
 245         case WM831X_LDO_ENABLE:
 246         case WM831X_DCDC_STATUS:
 247         case WM831X_LDO_STATUS:
 248         case WM831X_DCDC_UV_STATUS:
 249         case WM831X_LDO_UV_STATUS:
 250         case WM831X_DC1_CONTROL_1:
 251         case WM831X_DC1_CONTROL_2:
 252         case WM831X_DC1_ON_CONFIG:
 253         case WM831X_DC1_SLEEP_CONTROL:
 254         case WM831X_DC1_DVS_CONTROL:
 255         case WM831X_DC2_CONTROL_1:
 256         case WM831X_DC2_CONTROL_2:
 257         case WM831X_DC2_ON_CONFIG:
 258         case WM831X_DC2_SLEEP_CONTROL:
 259         case WM831X_DC2_DVS_CONTROL:
 260         case WM831X_DC3_CONTROL_1:
 261         case WM831X_DC3_CONTROL_2:
 262         case WM831X_DC3_ON_CONFIG:
 263         case WM831X_DC3_SLEEP_CONTROL:
 264         case WM831X_DC4_CONTROL:
 265         case WM831X_DC4_SLEEP_CONTROL:
 266         case WM831X_EPE1_CONTROL:
 267         case WM831X_EPE2_CONTROL:
 268         case WM831X_LDO1_CONTROL:
 269         case WM831X_LDO1_ON_CONTROL:
 270         case WM831X_LDO1_SLEEP_CONTROL:
 271         case WM831X_LDO2_CONTROL:
 272         case WM831X_LDO2_ON_CONTROL:
 273         case WM831X_LDO2_SLEEP_CONTROL:
 274         case WM831X_LDO3_CONTROL:
 275         case WM831X_LDO3_ON_CONTROL:
 276         case WM831X_LDO3_SLEEP_CONTROL:
 277         case WM831X_LDO4_CONTROL:
 278         case WM831X_LDO4_ON_CONTROL:
 279         case WM831X_LDO4_SLEEP_CONTROL:
 280         case WM831X_LDO5_CONTROL:
 281         case WM831X_LDO5_ON_CONTROL:
 282         case WM831X_LDO5_SLEEP_CONTROL:
 283         case WM831X_LDO6_CONTROL:
 284         case WM831X_LDO6_ON_CONTROL:
 285         case WM831X_LDO6_SLEEP_CONTROL:
 286         case WM831X_LDO7_CONTROL:
 287         case WM831X_LDO7_ON_CONTROL:
 288         case WM831X_LDO7_SLEEP_CONTROL:
 289         case WM831X_LDO8_CONTROL:
 290         case WM831X_LDO8_ON_CONTROL:
 291         case WM831X_LDO8_SLEEP_CONTROL:
 292         case WM831X_LDO9_CONTROL:
 293         case WM831X_LDO9_ON_CONTROL:
 294         case WM831X_LDO9_SLEEP_CONTROL:
 295         case WM831X_LDO10_CONTROL:
 296         case WM831X_LDO10_ON_CONTROL:
 297         case WM831X_LDO10_SLEEP_CONTROL:
 298         case WM831X_LDO11_ON_CONTROL:
 299         case WM831X_LDO11_SLEEP_CONTROL:
 300         case WM831X_POWER_GOOD_SOURCE_1:
 301         case WM831X_POWER_GOOD_SOURCE_2:
 302         case WM831X_CLOCK_CONTROL_1:
 303         case WM831X_CLOCK_CONTROL_2:
 304         case WM831X_FLL_CONTROL_1:
 305         case WM831X_FLL_CONTROL_2:
 306         case WM831X_FLL_CONTROL_3:
 307         case WM831X_FLL_CONTROL_4:
 308         case WM831X_FLL_CONTROL_5:
 309         case WM831X_UNIQUE_ID_1:
 310         case WM831X_UNIQUE_ID_2:
 311         case WM831X_UNIQUE_ID_3:
 312         case WM831X_UNIQUE_ID_4:
 313         case WM831X_UNIQUE_ID_5:
 314         case WM831X_UNIQUE_ID_6:
 315         case WM831X_UNIQUE_ID_7:
 316         case WM831X_UNIQUE_ID_8:
 317         case WM831X_FACTORY_OTP_ID:
 318         case WM831X_FACTORY_OTP_1:
 319         case WM831X_FACTORY_OTP_2:
 320         case WM831X_FACTORY_OTP_3:
 321         case WM831X_FACTORY_OTP_4:
 322         case WM831X_FACTORY_OTP_5:
 323         case WM831X_CUSTOMER_OTP_ID:
 324         case WM831X_DC1_OTP_CONTROL:
 325         case WM831X_DC2_OTP_CONTROL:
 326         case WM831X_DC3_OTP_CONTROL:
 327         case WM831X_LDO1_2_OTP_CONTROL:
 328         case WM831X_LDO3_4_OTP_CONTROL:
 329         case WM831X_LDO5_6_OTP_CONTROL:
 330         case WM831X_LDO7_8_OTP_CONTROL:
 331         case WM831X_LDO9_10_OTP_CONTROL:
 332         case WM831X_LDO11_EPE_CONTROL:
 333         case WM831X_GPIO1_OTP_CONTROL:
 334         case WM831X_GPIO2_OTP_CONTROL:
 335         case WM831X_GPIO3_OTP_CONTROL:
 336         case WM831X_GPIO4_OTP_CONTROL:
 337         case WM831X_GPIO5_OTP_CONTROL:
 338         case WM831X_GPIO6_OTP_CONTROL:
 339         case WM831X_DBE_CHECK_DATA:
 340                 return true;
 341         default:
 342                 return false;
 343         }
 344 }
 345
 346 static bool wm831x_reg_writeable(struct device *dev, unsigned int reg)
 347 {
 348         struct wm831x *wm831x = dev_get_drvdata(dev);
 349
 350         if (wm831x_reg_locked(wm831x, reg))
 351                 return false;
 352
 353         switch (reg) {
 354         case WM831X_SYSVDD_CONTROL:
 355         case WM831X_THERMAL_MONITORING:
 356         case WM831X_POWER_STATE:
 357         case WM831X_WATCHDOG:
 358         case WM831X_ON_PIN_CONTROL:
 359         case WM831X_RESET_CONTROL:
 360         case WM831X_CONTROL_INTERFACE:
 361         case WM831X_SECURITY_KEY:
 362         case WM831X_SOFTWARE_SCRATCH:
 363         case WM831X_OTP_CONTROL:
 364         case WM831X_GPIO_LEVEL:
 365         case WM831X_INTERRUPT_STATUS_1:
 366         case WM831X_INTERRUPT_STATUS_2:
 367         case WM831X_INTERRUPT_STATUS_3:
 368         case WM831X_INTERRUPT_STATUS_4:
 369         case WM831X_INTERRUPT_STATUS_5:
 370         case WM831X_IRQ_CONFIG:
 371         case WM831X_SYSTEM_INTERRUPTS_MASK:
 372         case WM831X_INTERRUPT_STATUS_1_MASK:
 373         case WM831X_INTERRUPT_STATUS_2_MASK:
 374         case WM831X_INTERRUPT_STATUS_3_MASK:
 375         case WM831X_INTERRUPT_STATUS_4_MASK:
 376         case WM831X_INTERRUPT_STATUS_5_MASK:
 377         case WM831X_RTC_TIME_1:
 378         case WM831X_RTC_TIME_2:
 379         case WM831X_RTC_ALARM_1:
 380         case WM831X_RTC_ALARM_2:
 381         case WM831X_RTC_CONTROL:
 382         case WM831X_RTC_TRIM:
 383         case WM831X_TOUCH_CONTROL_1:
 384         case WM831X_TOUCH_CONTROL_2:
 385         case WM831X_AUXADC_CONTROL:
 386         case WM831X_AUXADC_SOURCE:
 387         case WM831X_COMPARATOR_CONTROL:
 388         case WM831X_COMPARATOR_1:
 389         case WM831X_COMPARATOR_2:
 390         case WM831X_COMPARATOR_3:
 391         case WM831X_COMPARATOR_4:
 392         case WM831X_GPIO1_CONTROL:
 393         case WM831X_GPIO2_CONTROL:
 394         case WM831X_GPIO3_CONTROL:
 395         case WM831X_GPIO4_CONTROL:
 396         case WM831X_GPIO5_CONTROL:
 397         case WM831X_GPIO6_CONTROL:
 398         case WM831X_GPIO7_CONTROL:
 399         case WM831X_GPIO8_CONTROL:
 400         case WM831X_GPIO9_CONTROL:
 401         case WM831X_GPIO10_CONTROL:
 402         case WM831X_GPIO11_CONTROL:
 403         case WM831X_GPIO12_CONTROL:
 404         case WM831X_GPIO13_CONTROL:
 405         case WM831X_GPIO14_CONTROL:
 406         case WM831X_GPIO15_CONTROL:
 407         case WM831X_GPIO16_CONTROL:
 408         case WM831X_CHARGER_CONTROL_1:
 409         case WM831X_CHARGER_CONTROL_2:
 410         case WM831X_CHARGER_STATUS:
 411         case WM831X_BACKUP_CHARGER_CONTROL:
 412         case WM831X_STATUS_LED_1:
 413         case WM831X_STATUS_LED_2:
 414         case WM831X_CURRENT_SINK_1:
 415         case WM831X_CURRENT_SINK_2:
 416         case WM831X_DCDC_ENABLE:
 417         case WM831X_LDO_ENABLE:
 418         case WM831X_DC1_CONTROL_1:
 419         case WM831X_DC1_CONTROL_2:
 420         case WM831X_DC1_ON_CONFIG:
 421         case WM831X_DC1_SLEEP_CONTROL:
 422         case WM831X_DC1_DVS_CONTROL:
 423         case WM831X_DC2_CONTROL_1:
 424         case WM831X_DC2_CONTROL_2:
 425         case WM831X_DC2_ON_CONFIG:
 426         case WM831X_DC2_SLEEP_CONTROL:
 427         case WM831X_DC2_DVS_CONTROL:
 428         case WM831X_DC3_CONTROL_1:
 429         case WM831X_DC3_CONTROL_2:
 430         case WM831X_DC3_ON_CONFIG:
 431         case WM831X_DC3_SLEEP_CONTROL:
 432         case WM831X_DC4_CONTROL:
 433         case WM831X_DC4_SLEEP_CONTROL:
 434         case WM831X_EPE1_CONTROL:
 435         case WM831X_EPE2_CONTROL:
 436         case WM831X_LDO1_CONTROL:
 437         case WM831X_LDO1_ON_CONTROL:
 438         case WM831X_LDO1_SLEEP_CONTROL:
 439         case WM831X_LDO2_CONTROL:
 440         case WM831X_LDO2_ON_CONTROL:
 441         case WM831X_LDO2_SLEEP_CONTROL:
 442         case WM831X_LDO3_CONTROL:
 443         case WM831X_LDO3_ON_CONTROL:
 444         case WM831X_LDO3_SLEEP_CONTROL:
 445         case WM831X_LDO4_CONTROL:
 446         case WM831X_LDO4_ON_CONTROL:
 447         case WM831X_LDO4_SLEEP_CONTROL:
 448         case WM831X_LDO5_CONTROL:
 449         case WM831X_LDO5_ON_CONTROL:
 450         case WM831X_LDO5_SLEEP_CONTROL:
 451         case WM831X_LDO6_CONTROL:
 452         case WM831X_LDO6_ON_CONTROL:
 453         case WM831X_LDO6_SLEEP_CONTROL:
 454         case WM831X_LDO7_CONTROL:
 455         case WM831X_LDO7_ON_CONTROL:
 456         case WM831X_LDO7_SLEEP_CONTROL:
 457         case WM831X_LDO8_CONTROL:
 458         case WM831X_LDO8_ON_CONTROL:
 459         case WM831X_LDO8_SLEEP_CONTROL:
 460         case WM831X_LDO9_CONTROL:
 461         case WM831X_LDO9_ON_CONTROL:
 462         case WM831X_LDO9_SLEEP_CONTROL:
 463         case WM831X_LDO10_CONTROL:
 464         case WM831X_LDO10_ON_CONTROL:
 465         case WM831X_LDO10_SLEEP_CONTROL:
 466         case WM831X_LDO11_ON_CONTROL:
 467         case WM831X_LDO11_SLEEP_CONTROL:
 468         case WM831X_POWER_GOOD_SOURCE_1:
 469         case WM831X_POWER_GOOD_SOURCE_2:
 470         case WM831X_CLOCK_CONTROL_1:
 471         case WM831X_CLOCK_CONTROL_2:
 472         case WM831X_FLL_CONTROL_1:
 473         case WM831X_FLL_CONTROL_2:
 474         case WM831X_FLL_CONTROL_3:
 475         case WM831X_FLL_CONTROL_4:
 476         case WM831X_FLL_CONTROL_5:
 477                 return true;
 478         default:
 479                 return false;
 480         }
 481 }
 482
 483 static bool wm831x_reg_volatile(struct device *dev, unsigned int reg)
 484 {
 485         switch (reg) {
 486         case WM831X_SYSTEM_STATUS:
 487         case WM831X_ON_SOURCE:
 488         case WM831X_OFF_SOURCE:
 489         case WM831X_GPIO_LEVEL:
 490         case WM831X_SYSTEM_INTERRUPTS:
 491         case WM831X_INTERRUPT_STATUS_1:
 492         case WM831X_INTERRUPT_STATUS_2:
 493         case WM831X_INTERRUPT_STATUS_3:
 494         case WM831X_INTERRUPT_STATUS_4:
 495         case WM831X_INTERRUPT_STATUS_5:
 496         case WM831X_RTC_TIME_1:
 497         case WM831X_RTC_TIME_2:
 498         case WM831X_TOUCH_DATA_X:
 499         case WM831X_TOUCH_DATA_Y:
 500         case WM831X_TOUCH_DATA_Z:
 501         case WM831X_AUXADC_DATA:
 502         case WM831X_CHARGER_STATUS:
 503         case WM831X_DCDC_STATUS:
 504         case WM831X_LDO_STATUS:
 505         case WM831X_DCDC_UV_STATUS:
 506         case WM831X_LDO_UV_STATUS:
 507                 return true;
 508         default:
 509                 return false;
 510         }
 511 }
 512
 513 /**
 514  * wm831x_reg_read: Read a single WM831x register.
 515  *
 516  * @wm831x: Device to read from.
 517  * @reg: Register to read.
 518  */
 519 int wm831x_reg_read(struct wm831x *wm831x, unsigned short reg)
 520 {
 521         unsigned int val;
 522         int ret;
 523
 524         ret = regmap_read(wm831x->regmap, reg, &val);
 525
 526         if (ret < 0)
 527                 return ret;
 528         else
 529                 return val;
 530 }
 531 EXPORT_SYMBOL_GPL(wm831x_reg_read);
 532
 533 /**
 534  * wm831x_bulk_read: Read multiple WM831x registers
 535  *
 536  * @wm831x: Device to read from
 537  * @reg: First register
 538  * @count: Number of registers
 539  * @buf: Buffer to fill.
 540  */
 541 int wm831x_bulk_read(struct wm831x *wm831x, unsigned short reg,
 542                      int count, u16 *buf)
 543 {
 544         return regmap_bulk_read(wm831x->regmap, reg, buf, count);
 545 }
 546 EXPORT_SYMBOL_GPL(wm831x_bulk_read);
 547
 548 static int wm831x_write(struct wm831x *wm831x, unsigned short reg,
 549                         int bytes, void *src)
 550 {
 551         u16 *buf = src;
 552         int i, ret;
 553
 554         BUG_ON(bytes % 2);
 555         BUG_ON(bytes <= 0);
 556
 557         for (i = 0; i < bytes / 2; i++) {
 558                 if (wm831x_reg_locked(wm831x, reg))
 559                         return -EPERM;
 560
 561                 dev_vdbg(wm831x->dev, "Write %04x to R%d(0x%x)\n",
 562                          buf[i], reg + i, reg + i);
 563                 ret = regmap_write(wm831x->regmap, reg + i, buf[i]);
 564                 if (ret != 0)
 565                         return ret;
 566         }
 567
 568         return 0;
 569 }
 570
 571 /**
 572  * wm831x_reg_write: Write a single WM831x register.
 573  *
 574  * @wm831x: Device to write to.
 575  * @reg: Register to write to.
 576  * @val: Value to write.
 577  */
 578 int wm831x_reg_write(struct wm831x *wm831x, unsigned short reg,
 579                      unsigned short val)
 580 {
 581         int ret;
 582
 583         mutex_lock(&wm831x->io_lock);
 584
 585         ret = wm831x_write(wm831x, reg, 2, &val);
 586
 587         mutex_unlock(&wm831x->io_lock);
 588
 589         return ret;
 590 }
 591 EXPORT_SYMBOL_GPL(wm831x_reg_write);
 592
 593 /**
 594  * wm831x_set_bits: Set the value of a bitfield in a WM831x register
 595  *
 596  * @wm831x: Device to write to.
 597  * @reg: Register to write to.
 598  * @mask: Mask of bits to set.
 599  * @val: Value to set (unshifted)
 600  */
 601 int wm831x_set_bits(struct wm831x *wm831x, unsigned short reg,
 602                     unsigned short mask, unsigned short val)
 603 {
 604         int ret;
 605
 606         mutex_lock(&wm831x->io_lock);
 607
 608         if (!wm831x_reg_locked(wm831x, reg))
 609                 ret = regmap_update_bits(wm831x->regmap, reg, mask, val);
 610         else
 611                 ret = -EPERM;
 612
 613         mutex_unlock(&wm831x->io_lock);
 614
 615         return ret;
 616 }
 617 EXPORT_SYMBOL_GPL(wm831x_set_bits);
 618
 619 static const struct resource wm831x_dcdc1_resources[] = {
 620         {
 621                 .start = WM831X_DC1_CONTROL_1,
 622                 .end   = WM831X_DC1_DVS_CONTROL,
 623                 .flags = IORESOURCE_REG,
 624         },
 625         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_DC1, "UV"),
 626         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_HC_DC1, "HC"),
 627 };
 628
 629
 630 static const struct resource wm831x_dcdc2_resources[] = {
 631         {
 632                 .start = WM831X_DC2_CONTROL_1,
 633                 .end   = WM831X_DC2_DVS_CONTROL,
 634                 .flags = IORESOURCE_REG,
 635         },
 636         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_DC2, "UV"),
 637         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_HC_DC2, "HC"),
 638 };
 639
 640 static const struct resource wm831x_dcdc3_resources[] = {
 641         {
 642                 .start = WM831X_DC3_CONTROL_1,
 643                 .end   = WM831X_DC3_SLEEP_CONTROL,
 644                 .flags = IORESOURCE_REG,
 645         },
 646         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_DC3, "UV"),
 647 };
 648
 649 static const struct resource wm831x_dcdc4_resources[] = {
 650         {
 651                 .start = WM831X_DC4_CONTROL,
 652                 .end   = WM831X_DC4_SLEEP_CONTROL,
 653                 .flags = IORESOURCE_REG,
 654         },
 655         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_DC4, "UV"),
 656 };
 657
 658 static const struct resource wm8320_dcdc4_buck_resources[] = {
 659         {
 660                 .start = WM831X_DC4_CONTROL,
 661                 .end   = WM832X_DC4_SLEEP_CONTROL,
 662                 .flags = IORESOURCE_REG,
 663         },
 664         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_DC4, "UV"),
 665 };
 666
 667 static const struct resource wm831x_gpio_resources[] = {
 668         {
 669                 .start = WM831X_IRQ_GPIO_1,
 670                 .end   = WM831X_IRQ_GPIO_16,
 671                 .flags = IORESOURCE_IRQ,
 672         },
 673 };
 674
 675 static const struct resource wm831x_isink1_resources[] = {
 676         {
 677                 .start = WM831X_CURRENT_SINK_1,
 678                 .end   = WM831X_CURRENT_SINK_1,
 679                 .flags = IORESOURCE_REG,
 680         },
 681         DEFINE_RES_IRQ(WM831X_IRQ_CS1),
 682 };
 683
 684 static const struct resource wm831x_isink2_resources[] = {
 685         {
 686                 .start = WM831X_CURRENT_SINK_2,
 687                 .end   = WM831X_CURRENT_SINK_2,
 688                 .flags = IORESOURCE_REG,
 689         },
 690         DEFINE_RES_IRQ(WM831X_IRQ_CS2),
 691 };
 692
 693 static const struct resource wm831x_ldo1_resources[] = {
 694         {
 695                 .start = WM831X_LDO1_CONTROL,
 696                 .end   = WM831X_LDO1_SLEEP_CONTROL,
 697                 .flags = IORESOURCE_REG,
 698         },
 699         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO1, "UV"),
 700 };
 701
 702 static const struct resource wm831x_ldo2_resources[] = {
 703         {
 704                 .start = WM831X_LDO2_CONTROL,
 705                 .end   = WM831X_LDO2_SLEEP_CONTROL,
 706                 .flags = IORESOURCE_REG,
 707         },
 708         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO2, "UV"),
 709 };
 710
 711 static const struct resource wm831x_ldo3_resources[] = {
 712         {
 713                 .start = WM831X_LDO3_CONTROL,
 714                 .end   = WM831X_LDO3_SLEEP_CONTROL,
 715                 .flags = IORESOURCE_REG,
 716         },
 717         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO3, "UV"),
 718 };
 719
 720 static const struct resource wm831x_ldo4_resources[] = {
 721         {
 722                 .start = WM831X_LDO4_CONTROL,
 723                 .end   = WM831X_LDO4_SLEEP_CONTROL,
 724                 .flags = IORESOURCE_REG,
 725         },
 726         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO4, "UV"),
 727 };
 728
 729 static const struct resource wm831x_ldo5_resources[] = {
 730         {
 731                 .start = WM831X_LDO5_CONTROL,
 732                 .end   = WM831X_LDO5_SLEEP_CONTROL,
 733                 .flags = IORESOURCE_REG,
 734         },
 735         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO5, "UV"),
 736 };
 737
 738 static const struct resource wm831x_ldo6_resources[] = {
 739         {
 740                 .start = WM831X_LDO6_CONTROL,
 741                 .end   = WM831X_LDO6_SLEEP_CONTROL,
 742                 .flags = IORESOURCE_REG,
 743         },
 744         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO6, "UV"),
 745 };
 746
 747 static const struct resource wm831x_ldo7_resources[] = {
 748         {
 749                 .start = WM831X_LDO7_CONTROL,
 750                 .end   = WM831X_LDO7_SLEEP_CONTROL,
 751                 .flags = IORESOURCE_REG,
 752         },
 753         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO7, "UV"),
 754 };
 755
 756 static const struct resource wm831x_ldo8_resources[] = {
 757         {
 758                 .start = WM831X_LDO8_CONTROL,
 759                 .end   = WM831X_LDO8_SLEEP_CONTROL,
 760                 .flags = IORESOURCE_REG,
 761         },
 762         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO8, "UV"),
 763 };
 764
 765 static const struct resource wm831x_ldo9_resources[] = {
 766         {
 767                 .start = WM831X_LDO9_CONTROL,
 768                 .end   = WM831X_LDO9_SLEEP_CONTROL,
 769                 .flags = IORESOURCE_REG,
 770         },
 771         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO9, "UV"),
 772 };
 773
 774 static const struct resource wm831x_ldo10_resources[] = {
 775         {
 776                 .start = WM831X_LDO10_CONTROL,
 777                 .end   = WM831X_LDO10_SLEEP_CONTROL,
 778                 .flags = IORESOURCE_REG,
 779         },
 780         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_UV_LDO10, "UV"),
 781 };
 782
 783 static const struct resource wm831x_ldo11_resources[] = {
 784         {
 785                 .start = WM831X_LDO11_ON_CONTROL,
 786                 .end   = WM831X_LDO11_SLEEP_CONTROL,
 787                 .flags = IORESOURCE_REG,
 788         },
 789 };
 790
 791 static const struct resource wm831x_on_resources[] = {
 792         DEFINE_RES_IRQ(WM831X_IRQ_ON),
 793 };
 794
 795
 796 static const struct resource wm831x_power_resources[] = {
 797         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_PPM_SYSLO, "SYSLO"),
 798         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_PPM_PWR_SRC, "PWR SRC"),
 799         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_PPM_USB_CURR, "USB CURR"),
 800         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_BATT_HOT, "BATT HOT"),
 801         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_BATT_COLD, "BATT COLD"),
 802         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_BATT_FAIL, "BATT FAIL"),
 803         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_OV, "OV"),
 804         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_END, "END"),
 805         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_TO, "TO"),
 806         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_MODE, "MODE"),
 807         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_CHG_START, "START"),
 808 };
 809
 810 static const struct resource wm831x_rtc_resources[] = {
 811         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_RTC_PER, "PER"),
 812         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_RTC_ALM, "ALM"),
 813 };
 814
 815 static const struct resource wm831x_status1_resources[] = {
 816         {
 817                 .start = WM831X_STATUS_LED_1,
 818                 .end   = WM831X_STATUS_LED_1,
 819                 .flags = IORESOURCE_REG,
 820         },
 821 };
 822
 823 static const struct resource wm831x_status2_resources[] = {
 824         {
 825                 .start = WM831X_STATUS_LED_2,
 826                 .end   = WM831X_STATUS_LED_2,
 827                 .flags = IORESOURCE_REG,
 828         },
 829 };
 830
 831 static const struct resource wm831x_touch_resources[] = {
 832         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_TCHPD, "TCHPD"),
 833         DEFINE_RES_IRQ_NAMED(WM831X_IRQ_TCHDATA, "TCHDATA"),
 834 };
 835
 836 static const struct resource wm831x_wdt_resources[] = {
 837         DEFINE_RES_IRQ(WM831X_IRQ_WDOG_TO),
 838 };
 839
 840 static const struct mfd_cell wm8310_devs[] = {
 841         {
 842                 .name = "wm831x-backup",
 843         },
 844         {
 845                 .name = "wm831x-buckv",
 846                 .id = 1,
 847                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
 848                 .resources = wm831x_dcdc1_resources,
 849         },
 850         {
 851                 .name = "wm831x-buckv",
 852                 .id = 2,
 853                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
 854                 .resources = wm831x_dcdc2_resources,
 855         },
 856         {
 857                 .name = "wm831x-buckp",
 858                 .id = 3,
 859                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
 860                 .resources = wm831x_dcdc3_resources,
 861         },
 862         {
 863                 .name = "wm831x-boostp",
 864                 .id = 4,
 865                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
 866                 .resources = wm831x_dcdc4_resources,
 867         },
 868         {
 869                 .name = "wm831x-clk",
 870         },
 871         {
 872                 .name = "wm831x-epe",
 873                 .id = 1,
 874         },
 875         {
 876                 .name = "wm831x-epe",
 877                 .id = 2,
 878         },
 879         {
 880                 .name = "wm831x-gpio",
 881                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
 882                 .resources = wm831x_gpio_resources,
 883         },
 884         {
 885                 .name = "wm831x-hwmon",
 886         },
 887         {
 888                 .name = "wm831x-isink",
 889                 .id = 1,
 890                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
 891                 .resources = wm831x_isink1_resources,
 892         },
 893         {
 894                 .name = "wm831x-isink",
 895                 .id = 2,
 896                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
 897                 .resources = wm831x_isink2_resources,
 898         },
 899         {
 900                 .name = "wm831x-ldo",
 901                 .id = 1,
 902                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
 903                 .resources = wm831x_ldo1_resources,
 904         },
 905         {
 906                 .name = "wm831x-ldo",
 907                 .id = 2,
 908                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
 909                 .resources = wm831x_ldo2_resources,
 910         },
 911         {
 912                 .name = "wm831x-ldo",
 913                 .id = 3,
 914                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
 915                 .resources = wm831x_ldo3_resources,
 916         },
 917         {
 918                 .name = "wm831x-ldo",
 919                 .id = 4,
 920                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
 921                 .resources = wm831x_ldo4_resources,
 922         },
 923         {
 924                 .name = "wm831x-ldo",
 925                 .id = 5,
 926                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
 927                 .resources = wm831x_ldo5_resources,
 928         },
 929         {
 930                 .name = "wm831x-ldo",
 931                 .id = 6,
 932                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
 933                 .resources = wm831x_ldo6_resources,
 934         },
 935         {
 936                 .name = "wm831x-aldo",
 937                 .id = 7,
 938                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
 939                 .resources = wm831x_ldo7_resources,
 940         },
 941         {
 942                 .name = "wm831x-aldo",
 943                 .id = 8,
 944                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
 945                 .resources = wm831x_ldo8_resources,
 946         },
 947         {
 948                 .name = "wm831x-aldo",
 949                 .id = 9,
 950                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
 951                 .resources = wm831x_ldo9_resources,
 952         },
 953         {
 954                 .name = "wm831x-aldo",
 955                 .id = 10,
 956                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
 957                 .resources = wm831x_ldo10_resources,
 958         },
 959         {
 960                 .name = "wm831x-alive-ldo",
 961                 .id = 11,
 962                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
 963                 .resources = wm831x_ldo11_resources,
 964         },
 965         {
 966                 .name = "wm831x-on",
 967                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
 968                 .resources = wm831x_on_resources,
 969         },
 970         {
 971                 .name = "wm831x-power",
 972                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
 973                 .resources = wm831x_power_resources,
 974         },
 975         {
 976                 .name = "wm831x-status",
 977                 .id = 1,
 978                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
 979                 .resources = wm831x_status1_resources,
 980         },
 981         {
 982                 .name = "wm831x-status",
 983                 .id = 2,
 984                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
 985                 .resources = wm831x_status2_resources,
 986         },
 987         {
 988                 .name = "wm831x-watchdog",
 989                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
 990                 .resources = wm831x_wdt_resources,
 991         },
 992 };
 993
 994 static const struct mfd_cell wm8311_devs[] = {
 995         {
 996                 .name = "wm831x-backup",
 997         },
 998         {
 999                 .name = "wm831x-buckv",
1000                 .id = 1,
1001                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1002                 .resources = wm831x_dcdc1_resources,
1003         },
1004         {
1005                 .name = "wm831x-buckv",
1006                 .id = 2,
1007                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1008                 .resources = wm831x_dcdc2_resources,
1009         },
1010         {
1011                 .name = "wm831x-buckp",
1012                 .id = 3,
1013                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1014                 .resources = wm831x_dcdc3_resources,
1015         },
1016         {
1017                 .name = "wm831x-boostp",
1018                 .id = 4,
1019                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
1020                 .resources = wm831x_dcdc4_resources,
1021         },
1022         {
1023                 .name = "wm831x-clk",
1024         },
1025         {
1026                 .name = "wm831x-epe",
1027                 .id = 1,
1028         },
1029         {
1030                 .name = "wm831x-epe",
1031                 .id = 2,
1032         },
1033         {
1034                 .name = "wm831x-gpio",
1035                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1036                 .resources = wm831x_gpio_resources,
1037         },
1038         {
1039                 .name = "wm831x-hwmon",
1040         },
1041         {
1042                 .name = "wm831x-isink",
1043                 .id = 1,
1044                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
1045                 .resources = wm831x_isink1_resources,
1046         },
1047         {
1048                 .name = "wm831x-isink",
1049                 .id = 2,
1050                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
1051                 .resources = wm831x_isink2_resources,
1052         },
1053         {
1054                 .name = "wm831x-ldo",
1055                 .id = 1,
1056                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1057                 .resources = wm831x_ldo1_resources,
1058         },
1059         {
1060                 .name = "wm831x-ldo",
1061                 .id = 2,
1062                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1063                 .resources = wm831x_ldo2_resources,
1064         },
1065         {
1066                 .name = "wm831x-ldo",
1067                 .id = 3,
1068                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1069                 .resources = wm831x_ldo3_resources,
1070         },
1071         {
1072                 .name = "wm831x-ldo",
1073                 .id = 4,
1074                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1075                 .resources = wm831x_ldo4_resources,
1076         },
1077         {
1078                 .name = "wm831x-ldo",
1079                 .id = 5,
1080                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1081                 .resources = wm831x_ldo5_resources,
1082         },
1083         {
1084                 .name = "wm831x-aldo",
1085                 .id = 7,
1086                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1087                 .resources = wm831x_ldo7_resources,
1088         },
1089         {
1090                 .name = "wm831x-alive-ldo",
1091                 .id = 11,
1092                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1093                 .resources = wm831x_ldo11_resources,
1094         },
1095         {
1096                 .name = "wm831x-on",
1097                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1098                 .resources = wm831x_on_resources,
1099         },
1100         {
1101                 .name = "wm831x-power",
1102                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
1103                 .resources = wm831x_power_resources,
1104         },
1105         {
1106                 .name = "wm831x-status",
1107                 .id = 1,
1108                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1109                 .resources = wm831x_status1_resources,
1110         },
1111         {
1112                 .name = "wm831x-status",
1113                 .id = 2,
1114                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1115                 .resources = wm831x_status2_resources,
1116         },
1117         {
1118                 .name = "wm831x-watchdog",
1119                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1120                 .resources = wm831x_wdt_resources,
1121         },
1122 };
1123
1124 static const struct mfd_cell wm8312_devs[] = {
1125         {
1126                 .name = "wm831x-backup",
1127         },
1128         {
1129                 .name = "wm831x-buckv",
1130                 .id = 1,
1131                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1132                 .resources = wm831x_dcdc1_resources,
1133         },
1134         {
1135                 .name = "wm831x-buckv",
1136                 .id = 2,
1137                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1138                 .resources = wm831x_dcdc2_resources,
1139         },
1140         {
1141                 .name = "wm831x-buckp",
1142                 .id = 3,
1143                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1144                 .resources = wm831x_dcdc3_resources,
1145         },
1146         {
1147                 .name = "wm831x-boostp",
1148                 .id = 4,
1149                 .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
1150                 .resources = wm831x_dcdc4_resources,
1151         },
1152         {
1153                 .name = "wm831x-clk",
1154         },
1155         {
1156                 .name = "wm831x-epe",
1157                 .id = 1,
1158         },
1159         {
1160                 .name = "wm831x-epe",
1161                 .id = 2,
1162         },
1163         {
1164                 .name = "wm831x-gpio",
1165                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1166                 .resources = wm831x_gpio_resources,
1167         },
1168         {
1169                 .name = "wm831x-hwmon",
1170         },
1171         {
1172                 .name = "wm831x-isink",
1173                 .id = 1,
1174                 .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
1175                 .resources = wm831x_isink1_resources,
1176         },
1177         {
1178                 .name = "wm831x-isink",
1179                 .id = 2,
1180                 .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
1181                 .resources = wm831x_isink2_resources,
1182         },
1183         {
1184                 .name = "wm831x-ldo",
1185                 .id = 1,
1186                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1187                 .resources = wm831x_ldo1_resources,
1188         },
1189         {
1190                 .name = "wm831x-ldo",
1191                 .id = 2,
1192                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1193                 .resources = wm831x_ldo2_resources,
1194         },
1195         {
1196                 .name = "wm831x-ldo",
1197                 .id = 3,
1198                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1199                 .resources = wm831x_ldo3_resources,
1200         },
1201         {
1202                 .name = "wm831x-ldo",
1203                 .id = 4,
1204                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1205                 .resources = wm831x_ldo4_resources,
1206         },
1207         {
1208                 .name = "wm831x-ldo",
1209                 .id = 5,
1210                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1211                 .resources = wm831x_ldo5_resources,
1212         },
1213         {
1214                 .name = "wm831x-ldo",
1215                 .id = 6,
1216                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
1217                 .resources = wm831x_ldo6_resources,
1218         },
1219         {
1220                 .name = "wm831x-aldo",
1221                 .id = 7,
1222                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1223                 .resources = wm831x_ldo7_resources,
1224         },
1225         {
1226                 .name = "wm831x-aldo",
1227                 .id = 8,
1228                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
1229                 .resources = wm831x_ldo8_resources,
1230         },
1231         {
1232                 .name = "wm831x-aldo",
1233                 .id = 9,
1234                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
1235                 .resources = wm831x_ldo9_resources,
1236         },
1237         {
1238                 .name = "wm831x-aldo",
1239                 .id = 10,
1240                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
1241                 .resources = wm831x_ldo10_resources,
1242         },
1243         {
1244                 .name = "wm831x-alive-ldo",
1245                 .id = 11,
1246                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1247                 .resources = wm831x_ldo11_resources,
1248         },
1249         {
1250                 .name = "wm831x-on",
1251                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1252                 .resources = wm831x_on_resources,
1253         },
1254         {
1255                 .name = "wm831x-power",
1256                 .num_resources = ARRAY_SIZE(wm831x_power_resources),
1257                 .resources = wm831x_power_resources,
1258         },
1259         {
1260                 .name = "wm831x-status",
1261                 .id = 1,
1262                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1263                 .resources = wm831x_status1_resources,
1264         },
1265         {
1266                 .name = "wm831x-status",
1267                 .id = 2,
1268                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1269                 .resources = wm831x_status2_resources,
1270         },
1271         {
1272                 .name = "wm831x-watchdog",
1273                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1274                 .resources = wm831x_wdt_resources,
1275         },
1276 };
1277
1278 static const struct mfd_cell wm8320_devs[] = {
1279         {
1280                 .name = "wm831x-backup",
1281         },
1282         {
1283                 .name = "wm831x-buckv",
1284                 .id = 1,
1285                 .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
1286                 .resources = wm831x_dcdc1_resources,
1287         },
1288         {
1289                 .name = "wm831x-buckv",
1290                 .id = 2,
1291                 .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
1292                 .resources = wm831x_dcdc2_resources,
1293         },
1294         {
1295                 .name = "wm831x-buckp",
1296                 .id = 3,
1297                 .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
1298                 .resources = wm831x_dcdc3_resources,
1299         },
1300         {
1301                 .name = "wm831x-buckp",
1302                 .id = 4,
1303                 .num_resources = ARRAY_SIZE(wm8320_dcdc4_buck_resources),
1304                 .resources = wm8320_dcdc4_buck_resources,
1305         },
1306         {
1307                 .name = "wm831x-clk",
1308         },
1309         {
1310                 .name = "wm831x-gpio",
1311                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
1312                 .resources = wm831x_gpio_resources,
1313         },
1314         {
1315                 .name = "wm831x-hwmon",
1316         },
1317         {
1318                 .name = "wm831x-ldo",
1319                 .id = 1,
1320                 .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
1321                 .resources = wm831x_ldo1_resources,
1322         },
1323         {
1324                 .name = "wm831x-ldo",
1325                 .id = 2,
1326                 .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
1327                 .resources = wm831x_ldo2_resources,
1328         },
1329         {
1330                 .name = "wm831x-ldo",
1331                 .id = 3,
1332                 .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
1333                 .resources = wm831x_ldo3_resources,
1334         },
1335         {
1336                 .name = "wm831x-ldo",
1337                 .id = 4,
1338                 .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
1339                 .resources = wm831x_ldo4_resources,
1340         },
1341         {
1342                 .name = "wm831x-ldo",
1343                 .id = 5,
1344                 .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
1345                 .resources = wm831x_ldo5_resources,
1346         },
1347         {
1348                 .name = "wm831x-ldo",
1349                 .id = 6,
1350                 .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
1351                 .resources = wm831x_ldo6_resources,
1352         },
1353         {
1354                 .name = "wm831x-aldo",
1355                 .id = 7,
1356                 .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
1357                 .resources = wm831x_ldo7_resources,
1358         },
1359         {
1360                 .name = "wm831x-aldo",
1361                 .id = 8,
1362                 .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
1363                 .resources = wm831x_ldo8_resources,
1364         },
1365         {
1366                 .name = "wm831x-aldo",
1367                 .id = 9,
1368                 .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
1369                 .resources = wm831x_ldo9_resources,
1370         },
1371         {
1372                 .name = "wm831x-aldo",
1373                 .id = 10,
1374                 .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
1375                 .resources = wm831x_ldo10_resources,
1376         },
1377         {
1378                 .name = "wm831x-alive-ldo",
1379                 .id = 11,
1380                 .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
1381                 .resources = wm831x_ldo11_resources,
1382         },
1383         {
1384                 .name = "wm831x-on",
1385                 .num_resources = ARRAY_SIZE(wm831x_on_resources),
1386                 .resources = wm831x_on_resources,
1387         },
1388         {
1389                 .name = "wm831x-status",
1390                 .id = 1,
1391                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
1392                 .resources = wm831x_status1_resources,
1393         },
1394         {
1395                 .name = "wm831x-status",
1396                 .id = 2,
1397                 .num_resources = ARRAY_SIZE(wm831x_status2_resources),
1398                 .resources = wm831x_status2_resources,
1399         },
1400         {
1401                 .name = "wm831x-watchdog",
1402                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
1403                 .resources = wm831x_wdt_resources,
1404         },
1405 };
1406
1407 static const struct mfd_cell touch_devs[] = {
1408         {
1409                 .name = "wm831x-touch",
1410                 .num_resources = ARRAY_SIZE(wm831x_touch_resources),
1411                 .resources = wm831x_touch_resources,
1412         },
1413 };
1414
1415 static const struct mfd_cell rtc_devs[] = {
1416         {
1417                 .name = "wm831x-rtc",
1418                 .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
1419                 .resources = wm831x_rtc_resources,
1420         },
1421 };
1422
1423 static const struct mfd_cell backlight_devs[] = {
1424         {
1425                 .name = "wm831x-backlight",
1426         },
1427 };
1428
1429 struct regmap_config wm831x_regmap_config = {
1430         .reg_bits = 16,
1431         .val_bits = 16,
1432
1433         .cache_type = REGCACHE_RBTREE,
1434
1435         .max_register = WM831X_DBE_CHECK_DATA,
1436         .readable_reg = wm831x_reg_readable,
1437         .writeable_reg = wm831x_reg_writeable,
1438         .volatile_reg = wm831x_reg_volatile,
1439 };
1440 EXPORT_SYMBOL_GPL(wm831x_regmap_config);
1441
1442 const struct of_device_id wm831x_of_match[] = {
1443         { .compatible = "wlf,wm8310", .data = (void *)WM8310 },
1444         { .compatible = "wlf,wm8311", .data = (void *)WM8311 },
1445         { .compatible = "wlf,wm8312", .data = (void *)WM8312 },
1446         { .compatible = "wlf,wm8320", .data = (void *)WM8320 },
1447         { .compatible = "wlf,wm8321", .data = (void *)WM8321 },
1448         { .compatible = "wlf,wm8325", .data = (void *)WM8325 },
1449         { .compatible = "wlf,wm8326", .data = (void *)WM8326 },
1450         { },
1451 };
1452 EXPORT_SYMBOL_GPL(wm831x_of_match);
1453
1454 /*
1455  * Instantiate the generic non-control parts of the device.
1456  */
1457 int wm831x_device_init(struct wm831x *wm831x, int irq)
1458 {
1459         struct wm831x_pdata *pdata = &wm831x->pdata;
1460         int rev, wm831x_num;
1461         enum wm831x_parent parent;
1462         int ret, i;
1463
1464         mutex_init(&wm831x->io_lock);
1465         mutex_init(&wm831x->key_lock);
1466         dev_set_drvdata(wm831x->dev, wm831x);
1467
1468         wm831x->soft_shutdown = pdata->soft_shutdown;
1469
1470         ret = wm831x_reg_read(wm831x, WM831X_PARENT_ID);
1471         if (ret < 0) {
1472                 dev_err(wm831x->dev, "Failed to read parent ID: %d\n", ret);
1473                 goto err;
1474         }
1475         switch (ret) {
1476         case 0x6204:
1477         case 0x6246:
1478                 break;
1479         default:
1480                 dev_err(wm831x->dev, "Device is not a WM831x: ID %x\n", ret);
1481                 ret = -EINVAL;
1482                 goto err;
1483         }
1484
1485         ret = wm831x_reg_read(wm831x, WM831X_REVISION);
1486         if (ret < 0) {
1487                 dev_err(wm831x->dev, "Failed to read revision: %d\n", ret);
1488                 goto err;
1489         }
1490         rev = (ret & WM831X_PARENT_REV_MASK) >> WM831X_PARENT_REV_SHIFT;
1491
1492         ret = wm831x_reg_read(wm831x, WM831X_RESET_ID);
1493         if (ret < 0) {
1494                 dev_err(wm831x->dev, "Failed to read device ID: %d\n", ret);
1495                 goto err;
1496         }
1497
1498         /* Some engineering samples do not have the ID set, rely on
1499          * the device being registered correctly.
1500          */
1501         if (ret == 0) {
1502                 dev_info(wm831x->dev, "Device is an engineering sample\n");
1503                 ret = wm831x->type;
1504         }
1505
1506         switch (ret) {
1507         case WM8310:
1508                 parent = WM8310;
1509                 wm831x->num_gpio = 16;
1510                 wm831x->charger_irq_wake = 1;
1511                 if (rev > 0) {
1512                         wm831x->has_gpio_ena = 1;
1513                         wm831x->has_cs_sts = 1;
1514                 }
1515
1516                 dev_info(wm831x->dev, "WM8310 revision %c\n", 'A' + rev);
1517                 break;
1518
1519         case WM8311:
1520                 parent = WM8311;
1521                 wm831x->num_gpio = 16;
1522                 wm831x->charger_irq_wake = 1;
1523                 if (rev > 0) {
1524                         wm831x->has_gpio_ena = 1;
1525                         wm831x->has_cs_sts = 1;
1526                 }
1527
1528                 dev_info(wm831x->dev, "WM8311 revision %c\n", 'A' + rev);
1529                 break;
1530
1531         case WM8312:
1532                 parent = WM8312;
1533                 wm831x->num_gpio = 16;
1534                 wm831x->charger_irq_wake = 1;
1535                 if (rev > 0) {
1536                         wm831x->has_gpio_ena = 1;
1537                         wm831x->has_cs_sts = 1;
1538                 }
1539
1540                 dev_info(wm831x->dev, "WM8312 revision %c\n", 'A' + rev);
1541                 break;
1542
1543         case WM8320:
1544                 parent = WM8320;
1545                 wm831x->num_gpio = 12;
1546                 dev_info(wm831x->dev, "WM8320 revision %c\n", 'A' + rev);
1547                 break;
1548
1549         case WM8321:
1550                 parent = WM8321;
1551                 wm831x->num_gpio = 12;
1552                 dev_info(wm831x->dev, "WM8321 revision %c\n", 'A' + rev);
1553                 break;
1554
1555         case WM8325:
1556                 parent = WM8325;
1557                 wm831x->num_gpio = 12;
1558                 dev_info(wm831x->dev, "WM8325 revision %c\n", 'A' + rev);
1559                 break;
1560
1561         case WM8326:
1562                 parent = WM8326;
1563                 wm831x->num_gpio = 12;
1564                 dev_info(wm831x->dev, "WM8326 revision %c\n", 'A' + rev);
1565                 break;
1566
1567         default:
1568                 dev_err(wm831x->dev, "Unknown WM831x device %04x\n", ret);
1569                 ret = -EINVAL;
1570                 goto err;
1571         }
1572
1573         /* This will need revisiting in future but is OK for all
1574          * current parts.
1575          */
1576         if (parent != wm831x->type)
1577                 dev_warn(wm831x->dev, "Device was registered as a WM%x\n",
1578                          wm831x->type);
1579
1580         /* Bootstrap the user key */
1581         ret = wm831x_reg_read(wm831x, WM831X_SECURITY_KEY);
1582         if (ret < 0) {
1583                 dev_err(wm831x->dev, "Failed to read security key: %d\n", ret);
1584                 goto err;
1585         }
1586         if (ret != 0) {
1587                 dev_warn(wm831x->dev, "Security key had non-zero value %x\n",
1588                          ret);
1589                 wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
1590         }
1591         wm831x->locked = 1;
1592
1593         if (pdata->pre_init) {
1594                 ret = pdata->pre_init(wm831x);
1595                 if (ret != 0) {
1596                         dev_err(wm831x->dev, "pre_init() failed: %d\n", ret);
1597                         goto err;
1598                 }
1599         }
1600
1601         for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
1602                 if (!pdata->gpio_defaults[i])
1603                         continue;
1604
1605                 wm831x_reg_write(wm831x,
1606                                  WM831X_GPIO1_CONTROL + i,
1607                                  pdata->gpio_defaults[i] & 0xffff);
1608         }
1609
1610         /* Multiply by 10 as we have many subdevices of the same type */
1611         if (pdata->wm831x_num)
1612                 wm831x_num = pdata->wm831x_num * 10;
1613         else
1614                 wm831x_num = -1;
1615
1616         ret = wm831x_irq_init(wm831x, irq);
1617         if (ret != 0)
1618                 goto err;
1619
1620         wm831x_auxadc_init(wm831x);
1621
1622         /* The core device is up, instantiate the subdevices. */
1623         switch (parent) {
1624         case WM8310:
1625                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1626                                       wm8310_devs, ARRAY_SIZE(wm8310_devs),
1627                                       NULL, 0, NULL);
1628                 break;
1629
1630         case WM8311:
1631                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1632                                       wm8311_devs, ARRAY_SIZE(wm8311_devs),
1633                                       NULL, 0, NULL);
1634                 if (!pdata->disable_touch)
1635                         mfd_add_devices(wm831x->dev, wm831x_num,
1636                                         touch_devs, ARRAY_SIZE(touch_devs),
1637                                         NULL, 0, NULL);
1638                 break;
1639
1640         case WM8312:
1641                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1642                                       wm8312_devs, ARRAY_SIZE(wm8312_devs),
1643                                       NULL, 0, NULL);
1644                 if (!pdata->disable_touch)
1645                         mfd_add_devices(wm831x->dev, wm831x_num,
1646                                         touch_devs, ARRAY_SIZE(touch_devs),
1647                                         NULL, 0, NULL);
1648                 break;
1649
1650         case WM8320:
1651         case WM8321:
1652         case WM8325:
1653         case WM8326:
1654                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1655                                       wm8320_devs, ARRAY_SIZE(wm8320_devs),
1656                                       NULL, 0, NULL);
1657                 break;
1658
1659         default:
1660                 /* If this happens the bus probe function is buggy */
1661                 BUG();
1662         }
1663
1664         if (ret != 0) {
1665                 dev_err(wm831x->dev, "Failed to add children\n");
1666                 goto err_irq;
1667         }
1668
1669         /* The RTC can only be used if the 32.768kHz crystal is
1670          * enabled; this can't be controlled by software at runtime.
1671          */
1672         ret = wm831x_reg_read(wm831x, WM831X_CLOCK_CONTROL_2);
1673         if (ret < 0) {
1674                 dev_err(wm831x->dev, "Failed to read clock status: %d\n", ret);
1675                 goto err_irq;
1676         }
1677
1678         if (ret & WM831X_XTAL_ENA) {
1679                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
1680                                       rtc_devs, ARRAY_SIZE(rtc_devs),
1681                                       NULL, 0, NULL);
1682                 if (ret != 0) {
1683                         dev_err(wm831x->dev, "Failed to add RTC: %d\n", ret);
1684                         goto err_irq;
1685                 }
1686         } else {
1687                 dev_info(wm831x->dev, "32.768kHz clock disabled, no RTC\n");
1688         }
1689
1690         if (pdata->backlight) {
1691                 /* Treat errors as non-critical */
1692                 ret = mfd_add_devices(wm831x->dev, wm831x_num, backlight_devs,
1693                                       ARRAY_SIZE(backlight_devs), NULL,
1694                                       0, NULL);
1695                 if (ret < 0)
1696                         dev_err(wm831x->dev, "Failed to add backlight: %d\n",
1697                                 ret);
1698         }
1699
1700         wm831x_otp_init(wm831x);
1701
1702         if (pdata->post_init) {
1703                 ret = pdata->post_init(wm831x);
1704                 if (ret != 0) {
1705                         dev_err(wm831x->dev, "post_init() failed: %d\n", ret);
1706                         goto err_irq;
1707                 }
1708         }
1709
1710         return 0;
1711
1712 err_irq:
1713         wm831x_irq_exit(wm831x);
1714 err:
1715         mfd_remove_devices(wm831x->dev);
1716         return ret;
1717 }
1718
1719 int wm831x_device_suspend(struct wm831x *wm831x)
1720 {
1721         int reg, mask;
1722
1723         /* If the charger IRQs are a wake source then make sure we ack
1724          * them even if they're not actively being used (eg, no power
1725          * driver or no IRQ line wired up) then acknowledge the
1726          * interrupts otherwise suspend won't last very long.
1727          */
1728         if (wm831x->charger_irq_wake) {
1729                 reg = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_2_MASK);
1730
1731                 mask = WM831X_CHG_BATT_HOT_EINT |
1732                         WM831X_CHG_BATT_COLD_EINT |
1733                         WM831X_CHG_BATT_FAIL_EINT |
1734                         WM831X_CHG_OV_EINT | WM831X_CHG_END_EINT |
1735                         WM831X_CHG_TO_EINT | WM831X_CHG_MODE_EINT |
1736                         WM831X_CHG_START_EINT;
1737
1738                 /* If any of the interrupts are masked read the statuses */
1739                 if (reg & mask)
1740                         reg = wm831x_reg_read(wm831x,
1741                                               WM831X_INTERRUPT_STATUS_2);
1742
1743                 if (reg & mask) {
1744                         dev_info(wm831x->dev,
1745                                  "Acknowledging masked charger IRQs: %x\n",
1746                                  reg & mask);
1747                         wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_2,
1748                                          reg & mask);
1749                 }
1750         }
1751
1752         return 0;
1753 }
1754
1755 void wm831x_device_shutdown(struct wm831x *wm831x)
1756 {
1757         if (wm831x->soft_shutdown) {
1758                 dev_info(wm831x->dev, "Initiating shutdown...\n");
1759                 wm831x_set_bits(wm831x, WM831X_POWER_STATE, WM831X_CHIP_ON, 0);
1760         }
1761 }
1762 EXPORT_SYMBOL_GPL(wm831x_device_shutdown);