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