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