drivers/mfd/wm831x-core.c

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

DEFINITIONS
