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