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