1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (C) 2007-2010 ST-Ericsson 4 * Low-level core for exclusive access to the AB3100 IC on the I2C bus 5 * and some basic chip-configuration. 6 * Author: Linus Walleij <linus.walleij@stericsson.com> 7 */ 8 9#include <linux/i2c.h> 10#include <linux/mutex.h> 11#include <linux/list.h> 12#include <linux/notifier.h> 13#include <linux/slab.h> 14#include <linux/err.h> 15#include <linux/init.h> 16#include <linux/platform_device.h> 17#include <linux/device.h> 18#include <linux/interrupt.h> 19#include <linux/random.h> 20#include <linux/debugfs.h> 21#include <linux/seq_file.h> 22#include <linux/uaccess.h> 23#include <linux/mfd/core.h> 24#include <linux/mfd/ab3100.h> 25#include <linux/mfd/abx500.h> 26 27/* These are the only registers inside AB3100 used in this main file */ 28 29/* Interrupt event registers */ 30#define AB3100_EVENTA1 0x21 31#define AB3100_EVENTA2 0x22 32#define AB3100_EVENTA3 0x23 33 34/* AB3100 DAC converter registers */ 35#define AB3100_DIS 0x00 36#define AB3100_D0C 0x01 37#define AB3100_D1C 0x02 38#define AB3100_D2C 0x03 39#define AB3100_D3C 0x04 40 41/* Chip ID register */ 42#define AB3100_CID 0x20 43 44/* AB3100 interrupt registers */ 45#define AB3100_IMRA1 0x24 46#define AB3100_IMRA2 0x25 47#define AB3100_IMRA3 0x26 48#define AB3100_IMRB1 0x2B 49#define AB3100_IMRB2 0x2C 50#define AB3100_IMRB3 0x2D 51 52/* System Power Monitoring and control registers */ 53#define AB3100_MCA 0x2E 54#define AB3100_MCB 0x2F 55 56/* SIM power up */ 57#define AB3100_SUP 0x50 58 59/* 60 * I2C communication 61 * 62 * The AB3100 is usually assigned address 0x48 (7-bit) 63 * The chip is defined in the platform i2c_board_data section. 64 */ 65static int ab3100_get_chip_id(struct device *dev) 66{ 67 struct ab3100 *ab3100 = dev_get_drvdata(dev->parent); 68 69 return (int)ab3100->chip_id; 70} 71 72static int ab3100_set_register_interruptible(struct ab3100 *ab3100, 73 u8 reg, u8 regval) 74{ 75 u8 regandval[2] = {reg, regval}; 76 int err; 77 78 err = mutex_lock_interruptible(&ab3100->access_mutex); 79 if (err) 80 return err; 81 82 /* 83 * A two-byte write message with the first byte containing the register 84 * number and the second byte containing the value to be written 85 * effectively sets a register in the AB3100. 86 */ 87 err = i2c_master_send(ab3100->i2c_client, regandval, 2); 88 if (err < 0) { 89 dev_err(ab3100->dev, 90 "write error (write register): %d\n", 91 err); 92 } else if (err != 2) { 93 dev_err(ab3100->dev, 94 "write error (write register)\n" 95 " %d bytes transferred (expected 2)\n", 96 err); 97 err = -EIO; 98 } else { 99 /* All is well */ 100 err = 0; 101 } 102 mutex_unlock(&ab3100->access_mutex); 103 return err; 104} 105 106static int set_register_interruptible(struct device *dev, 107 u8 bank, u8 reg, u8 value) 108{ 109 struct ab3100 *ab3100 = dev_get_drvdata(dev->parent); 110 111 return ab3100_set_register_interruptible(ab3100, reg, value); 112} 113 114/* 115 * The test registers exist at an I2C bus address up one 116 * from the ordinary base. They are not supposed to be used 117 * in production code, but sometimes you have to do that 118 * anyway. It's currently only used from this file so declare 119 * it static and do not export. 120 */ 121static int ab3100_set_test_register_interruptible(struct ab3100 *ab3100, 122 u8 reg, u8 regval) 123{ 124 u8 regandval[2] = {reg, regval}; 125 int err; 126 127 err = mutex_lock_interruptible(&ab3100->access_mutex); 128 if (err) 129 return err; 130 131 err = i2c_master_send(ab3100->testreg_client, regandval, 2); 132 if (err < 0) { 133 dev_err(ab3100->dev, 134 "write error (write test register): %d\n", 135 err); 136 } else if (err != 2) { 137 dev_err(ab3100->dev, 138 "write error (write test register)\n" 139 " %d bytes transferred (expected 2)\n", 140 err); 141 err = -EIO; 142 } else { 143 /* All is well */ 144 err = 0; 145 } 146 mutex_unlock(&ab3100->access_mutex); 147 148 return err; 149} 150 151static int ab3100_get_register_interruptible(struct ab3100 *ab3100, 152 u8 reg, u8 *regval) 153{ 154 int err; 155 156 err = mutex_lock_interruptible(&ab3100->access_mutex); 157 if (err) 158 return err; 159 160 /* 161 * AB3100 require an I2C "stop" command between each message, else 162 * it will not work. The only way of achieveing this with the 163 * message transport layer is to send the read and write messages 164 * separately. 165 */ 166 err = i2c_master_send(ab3100->i2c_client, ®, 1); 167 if (err < 0) { 168 dev_err(ab3100->dev, 169 "write error (send register address): %d\n", 170 err); 171 goto get_reg_out_unlock; 172 } else if (err != 1) { 173 dev_err(ab3100->dev, 174 "write error (send register address)\n" 175 " %d bytes transferred (expected 1)\n", 176 err); 177 err = -EIO; 178 goto get_reg_out_unlock; 179 } else { 180 /* All is well */ 181 err = 0; 182 } 183 184 err = i2c_master_recv(ab3100->i2c_client, regval, 1); 185 if (err < 0) { 186 dev_err(ab3100->dev, 187 "write error (read register): %d\n", 188 err); 189 goto get_reg_out_unlock; 190 } else if (err != 1) { 191 dev_err(ab3100->dev, 192 "write error (read register)\n" 193 " %d bytes transferred (expected 1)\n", 194 err); 195 err = -EIO; 196 goto get_reg_out_unlock; 197 } else { 198 /* All is well */ 199 err = 0; 200 } 201 202 get_reg_out_unlock: 203 mutex_unlock(&ab3100->access_mutex); 204 return err; 205} 206 207static int get_register_interruptible(struct device *dev, u8 bank, u8 reg, 208 u8 *value) 209{ 210 struct ab3100 *ab3100 = dev_get_drvdata(dev->parent); 211 212 return ab3100_get_register_interruptible(ab3100, reg, value); 213} 214 215static int ab3100_get_register_page_interruptible(struct ab3100 *ab3100, 216 u8 first_reg, u8 *regvals, u8 numregs) 217{ 218 int err; 219 220 if (ab3100->chip_id == 0xa0 || 221 ab3100->chip_id == 0xa1) 222 /* These don't support paged reads */ 223 return -EIO; 224 225 err = mutex_lock_interruptible(&ab3100->access_mutex); 226 if (err) 227 return err; 228 229 /* 230 * Paged read also require an I2C "stop" command. 231 */ 232 err = i2c_master_send(ab3100->i2c_client, &first_reg, 1); 233 if (err < 0) { 234 dev_err(ab3100->dev, 235 "write error (send first register address): %d\n", 236 err); 237 goto get_reg_page_out_unlock; 238 } else if (err != 1) { 239 dev_err(ab3100->dev, 240 "write error (send first register address)\n" 241 " %d bytes transferred (expected 1)\n", 242 err); 243 err = -EIO; 244 goto get_reg_page_out_unlock; 245 } 246 247 err = i2c_master_recv(ab3100->i2c_client, regvals, numregs); 248 if (err < 0) { 249 dev_err(ab3100->dev, 250 "write error (read register page): %d\n", 251 err); 252 goto get_reg_page_out_unlock; 253 } else if (err != numregs) { 254 dev_err(ab3100->dev, 255 "write error (read register page)\n" 256 " %d bytes transferred (expected %d)\n", 257 err, numregs); 258 err = -EIO; 259 goto get_reg_page_out_unlock; 260 } 261 262 /* All is well */ 263 err = 0; 264 265 get_reg_page_out_unlock: 266 mutex_unlock(&ab3100->access_mutex); 267 return err; 268} 269 270static int get_register_page_interruptible(struct device *dev, u8 bank, 271 u8 first_reg, u8 *regvals, u8 numregs) 272{ 273 struct ab3100 *ab3100 = dev_get_drvdata(dev->parent); 274 275 return ab3100_get_register_page_interruptible(ab3100, 276 first_reg, regvals, numregs); 277} 278 279static int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100, 280 u8 reg, u8 andmask, u8 ormask) 281{ 282 u8 regandval[2] = {reg, 0}; 283 int err; 284 285 err = mutex_lock_interruptible(&ab3100->access_mutex); 286 if (err) 287 return err; 288 289 /* First read out the target register */ 290 err = i2c_master_send(ab3100->i2c_client, ®, 1); 291 if (err < 0) { 292 dev_err(ab3100->dev, 293 "write error (maskset send address): %d\n", 294 err); 295 goto get_maskset_unlock; 296 } else if (err != 1) { 297 dev_err(ab3100->dev, 298 "write error (maskset send address)\n" 299 " %d bytes transferred (expected 1)\n", 300 err); 301 err = -EIO; 302 goto get_maskset_unlock; 303 } 304 305 err = i2c_master_recv(ab3100->i2c_client, ®andval[1], 1); 306 if (err < 0) { 307 dev_err(ab3100->dev, 308 "write error (maskset read register): %d\n", 309 err); 310 goto get_maskset_unlock; 311 } else if (err != 1) { 312 dev_err(ab3100->dev, 313 "write error (maskset read register)\n" 314 " %d bytes transferred (expected 1)\n", 315 err); 316 err = -EIO; 317 goto get_maskset_unlock; 318 } 319 320 /* Modify the register */ 321 regandval[1] &= andmask; 322 regandval[1] |= ormask; 323 324 /* Write the register */ 325 err = i2c_master_send(ab3100->i2c_client, regandval, 2); 326 if (err < 0) { 327 dev_err(ab3100->dev, 328 "write error (write register): %d\n", 329 err); 330 goto get_maskset_unlock; 331 } else if (err != 2) { 332 dev_err(ab3100->dev, 333 "write error (write register)\n" 334 " %d bytes transferred (expected 2)\n", 335 err); 336 err = -EIO; 337 goto get_maskset_unlock; 338 } 339 340 /* All is well */ 341 err = 0; 342 343 get_maskset_unlock: 344 mutex_unlock(&ab3100->access_mutex); 345 return err; 346} 347 348static int mask_and_set_register_interruptible(struct device *dev, u8 bank, 349 u8 reg, u8 bitmask, u8 bitvalues) 350{ 351 struct ab3100 *ab3100 = dev_get_drvdata(dev->parent); 352 353 return ab3100_mask_and_set_register_interruptible(ab3100, 354 reg, bitmask, (bitmask & bitvalues)); 355} 356 357/* 358 * Register a simple callback for handling any AB3100 events. 359 */ 360int ab3100_event_register(struct ab3100 *ab3100, 361 struct notifier_block *nb) 362{ 363 return blocking_notifier_chain_register(&ab3100->event_subscribers, 364 nb); 365} 366EXPORT_SYMBOL(ab3100_event_register); 367 368/* 369 * Remove a previously registered callback. 370 */ 371int ab3100_event_unregister(struct ab3100 *ab3100, 372 struct notifier_block *nb) 373{ 374 return blocking_notifier_chain_unregister(&ab3100->event_subscribers, 375 nb); 376} 377EXPORT_SYMBOL(ab3100_event_unregister); 378 379 380static int ab3100_event_registers_startup_state_get(struct device *dev, 381 u8 *event) 382{ 383 struct ab3100 *ab3100 = dev_get_drvdata(dev->parent); 384 385 if (!ab3100->startup_events_read) 386 return -EAGAIN; /* Try again later */ 387 memcpy(event, ab3100->startup_events, 3); 388 389 return 0; 390} 391 392static struct abx500_ops ab3100_ops = { 393 .get_chip_id = ab3100_get_chip_id, 394 .set_register = set_register_interruptible, 395 .get_register = get_register_interruptible, 396 .get_register_page = get_register_page_interruptible, 397 .set_register_page = NULL, 398 .mask_and_set_register = mask_and_set_register_interruptible, 399 .event_registers_startup_state_get = 400 ab3100_event_registers_startup_state_get, 401 .startup_irq_enabled = NULL, 402}; 403 404/* 405 * This is a threaded interrupt handler so we can make some 406 * I2C calls etc. 407 */ 408static irqreturn_t ab3100_irq_handler(int irq, void *data) 409{ 410 struct ab3100 *ab3100 = data; 411 u8 event_regs[3]; 412 u32 fatevent; 413 int err; 414 415 err = ab3100_get_register_page_interruptible(ab3100, AB3100_EVENTA1, 416 event_regs, 3); 417 if (err) 418 goto err_event; 419 420 fatevent = (event_regs[0] << 16) | 421 (event_regs[1] << 8) | 422 event_regs[2]; 423 424 if (!ab3100->startup_events_read) { 425 ab3100->startup_events[0] = event_regs[0]; 426 ab3100->startup_events[1] = event_regs[1]; 427 ab3100->startup_events[2] = event_regs[2]; 428 ab3100->startup_events_read = true; 429 } 430 /* 431 * The notified parties will have to mask out the events 432 * they're interested in and react to them. They will be 433 * notified on all events, then they use the fatevent value 434 * to determine if they're interested. 435 */ 436 blocking_notifier_call_chain(&ab3100->event_subscribers, 437 fatevent, NULL); 438 439 dev_dbg(ab3100->dev, 440 "IRQ Event: 0x%08x\n", fatevent); 441 442 return IRQ_HANDLED; 443 444 err_event: 445 dev_dbg(ab3100->dev, 446 "error reading event status\n"); 447 return IRQ_HANDLED; 448} 449 450#ifdef CONFIG_DEBUG_FS 451/* 452 * Some debugfs entries only exposed if we're using debug 453 */ 454static int ab3100_registers_print(struct seq_file *s, void *p) 455{ 456 struct ab3100 *ab3100 = s->private; 457 u8 value; 458 u8 reg; 459 460 seq_puts(s, "AB3100 registers:\n"); 461 462 for (reg = 0; reg < 0xff; reg++) { 463 ab3100_get_register_interruptible(ab3100, reg, &value); 464 seq_printf(s, "[0x%x]: 0x%x\n", reg, value); 465 } 466 return 0; 467} 468 469static int ab3100_registers_open(struct inode *inode, struct file *file) 470{ 471 return single_open(file, ab3100_registers_print, inode->i_private); 472} 473 474static const struct file_operations ab3100_registers_fops = { 475 .open = ab3100_registers_open, 476 .read = seq_read, 477 .llseek = seq_lseek, 478 .release = single_release, 479 .owner = THIS_MODULE, 480}; 481 482struct ab3100_get_set_reg_priv { 483 struct ab3100 *ab3100; 484 bool mode; 485}; 486 487static ssize_t ab3100_get_set_reg(struct file *file, 488 const char __user *user_buf, 489 size_t count, loff_t *ppos) 490{ 491 struct ab3100_get_set_reg_priv *priv = file->private_data; 492 struct ab3100 *ab3100 = priv->ab3100; 493 char buf[32]; 494 ssize_t buf_size; 495 int regp; 496 u8 user_reg; 497 int err; 498 int i = 0; 499 500 /* Get userspace string and assure termination */ 501 buf_size = min((ssize_t)count, (ssize_t)(sizeof(buf)-1)); 502 if (copy_from_user(buf, user_buf, buf_size)) 503 return -EFAULT; 504 buf[buf_size] = 0; 505 506 /* 507 * The idea is here to parse a string which is either 508 * "0xnn" for reading a register, or "0xaa 0xbb" for 509 * writing 0xbb to the register 0xaa. First move past 510 * whitespace and then begin to parse the register. 511 */ 512 while ((i < buf_size) && (buf[i] == ' ')) 513 i++; 514 regp = i; 515 516 /* 517 * Advance pointer to end of string then terminate 518 * the register string. This is needed to satisfy 519 * the kstrtou8() function. 520 */ 521 while ((i < buf_size) && (buf[i] != ' ')) 522 i++; 523 buf[i] = '\0'; 524 525 err = kstrtou8(&buf[regp], 16, &user_reg); 526 if (err) 527 return err; 528 529 /* Either we read or we write a register here */ 530 if (!priv->mode) { 531 /* Reading */ 532 u8 regvalue; 533 534 ab3100_get_register_interruptible(ab3100, user_reg, ®value); 535 536 dev_info(ab3100->dev, 537 "debug read AB3100 reg[0x%02x]: 0x%02x\n", 538 user_reg, regvalue); 539 } else { 540 int valp; 541 u8 user_value; 542 u8 regvalue; 543 544 /* 545 * Writing, we need some value to write to 546 * the register so keep parsing the string 547 * from userspace. 548 */ 549 i++; 550 while ((i < buf_size) && (buf[i] == ' ')) 551 i++; 552 valp = i; 553 while ((i < buf_size) && (buf[i] != ' ')) 554 i++; 555 buf[i] = '\0'; 556 557 err = kstrtou8(&buf[valp], 16, &user_value); 558 if (err) 559 return err; 560 561 ab3100_set_register_interruptible(ab3100, user_reg, user_value); 562 ab3100_get_register_interruptible(ab3100, user_reg, ®value); 563 564 dev_info(ab3100->dev, 565 "debug write reg[0x%02x]\n" 566 " with 0x%02x, after readback: 0x%02x\n", 567 user_reg, user_value, regvalue); 568 } 569 return buf_size; 570} 571 572static const struct file_operations ab3100_get_set_reg_fops = { 573 .open = simple_open, 574 .write = ab3100_get_set_reg, 575 .llseek = noop_llseek, 576}; 577 578static struct ab3100_get_set_reg_priv ab3100_get_priv; 579static struct ab3100_get_set_reg_priv ab3100_set_priv; 580 581static void ab3100_setup_debugfs(struct ab3100 *ab3100) 582{ 583 struct dentry *ab3100_dir; 584 585 ab3100_dir = debugfs_create_dir("ab3100", NULL); 586 587 debugfs_create_file("registers", S_IRUGO, ab3100_dir, ab3100, 588 &ab3100_registers_fops); 589 590 ab3100_get_priv.ab3100 = ab3100; 591 ab3100_get_priv.mode = false; 592 debugfs_create_file("get_reg", S_IWUSR, ab3100_dir, &ab3100_get_priv, 593 &ab3100_get_set_reg_fops); 594 595 ab3100_set_priv.ab3100 = ab3100; 596 ab3100_set_priv.mode = true; 597 debugfs_create_file("set_reg", S_IWUSR, ab3100_dir, &ab3100_set_priv, 598 &ab3100_get_set_reg_fops); 599} 600#else 601static inline void ab3100_setup_debugfs(struct ab3100 *ab3100) 602{ 603} 604#endif 605 606/* 607 * Basic set-up, datastructure creation/destruction and I2C interface. 608 * This sets up a default config in the AB3100 chip so that it 609 * will work as expected. 610 */ 611 612struct ab3100_init_setting { 613 u8 abreg; 614 u8 setting; 615}; 616 617static const struct ab3100_init_setting ab3100_init_settings[] = { 618 { 619 .abreg = AB3100_MCA, 620 .setting = 0x01 621 }, { 622 .abreg = AB3100_MCB, 623 .setting = 0x30 624 }, { 625 .abreg = AB3100_IMRA1, 626 .setting = 0x00 627 }, { 628 .abreg = AB3100_IMRA2, 629 .setting = 0xFF 630 }, { 631 .abreg = AB3100_IMRA3, 632 .setting = 0x01 633 }, { 634 .abreg = AB3100_IMRB1, 635 .setting = 0xBF 636 }, { 637 .abreg = AB3100_IMRB2, 638 .setting = 0xFF 639 }, { 640 .abreg = AB3100_IMRB3, 641 .setting = 0xFF 642 }, { 643 .abreg = AB3100_SUP, 644 .setting = 0x00 645 }, { 646 .abreg = AB3100_DIS, 647 .setting = 0xF0 648 }, { 649 .abreg = AB3100_D0C, 650 .setting = 0x00 651 }, { 652 .abreg = AB3100_D1C, 653 .setting = 0x00 654 }, { 655 .abreg = AB3100_D2C, 656 .setting = 0x00 657 }, { 658 .abreg = AB3100_D3C, 659 .setting = 0x00 660 }, 661}; 662 663static int ab3100_setup(struct ab3100 *ab3100) 664{ 665 int err = 0; 666 int i; 667 668 for (i = 0; i < ARRAY_SIZE(ab3100_init_settings); i++) { 669 err = ab3100_set_register_interruptible(ab3100, 670 ab3100_init_settings[i].abreg, 671 ab3100_init_settings[i].setting); 672 if (err) 673 goto exit_no_setup; 674 } 675 676 /* 677 * Special trick to make the AB3100 use the 32kHz clock (RTC) 678 * bit 3 in test register 0x02 is a special, undocumented test 679 * register bit that only exist in AB3100 P1E 680 */ 681 if (ab3100->chip_id == 0xc4) { 682 dev_warn(ab3100->dev, 683 "AB3100 P1E variant detected forcing chip to 32KHz\n"); 684 err = ab3100_set_test_register_interruptible(ab3100, 685 0x02, 0x08); 686 } 687 688 exit_no_setup: 689 return err; 690} 691 692/* The subdevices of the AB3100 */ 693static struct mfd_cell ab3100_devs[] = { 694 { 695 .name = "ab3100-dac", 696 .id = -1, 697 }, 698 { 699 .name = "ab3100-leds", 700 .id = -1, 701 }, 702 { 703 .name = "ab3100-power", 704 .id = -1, 705 }, 706 { 707 .name = "ab3100-regulators", 708 .of_compatible = "stericsson,ab3100-regulators", 709 .id = -1, 710 }, 711 { 712 .name = "ab3100-sim", 713 .id = -1, 714 }, 715 { 716 .name = "ab3100-uart", 717 .id = -1, 718 }, 719 { 720 .name = "ab3100-rtc", 721 .id = -1, 722 }, 723 { 724 .name = "ab3100-charger", 725 .id = -1, 726 }, 727 { 728 .name = "ab3100-boost", 729 .id = -1, 730 }, 731 { 732 .name = "ab3100-adc", 733 .id = -1, 734 }, 735 { 736 .name = "ab3100-fuelgauge", 737 .id = -1, 738 }, 739 { 740 .name = "ab3100-vibrator", 741 .id = -1, 742 }, 743 { 744 .name = "ab3100-otp", 745 .id = -1, 746 }, 747 { 748 .name = "ab3100-codec", 749 .id = -1, 750 }, 751}; 752 753struct ab_family_id { 754 u8 id; 755 char *name; 756}; 757 758static const struct ab_family_id ids[] = { 759 /* AB3100 */ 760 { 761 .id = 0xc0, 762 .name = "P1A" 763 }, { 764 .id = 0xc1, 765 .name = "P1B" 766 }, { 767 .id = 0xc2, 768 .name = "P1C" 769 }, { 770 .id = 0xc3, 771 .name = "P1D" 772 }, { 773 .id = 0xc4, 774 .name = "P1E" 775 }, { 776 .id = 0xc5, 777 .name = "P1F/R1A" 778 }, { 779 .id = 0xc6, 780 .name = "P1G/R1A" 781 }, { 782 .id = 0xc7, 783 .name = "P2A/R2A" 784 }, { 785 .id = 0xc8, 786 .name = "P2B/R2B" 787 }, 788 /* AB3000 variants, not supported */ 789 { 790 .id = 0xa0 791 }, { 792 .id = 0xa1 793 }, { 794 .id = 0xa2 795 }, { 796 .id = 0xa3 797 }, { 798 .id = 0xa4 799 }, { 800 .id = 0xa5 801 }, { 802 .id = 0xa6 803 }, { 804 .id = 0xa7 805 }, 806 /* Terminator */ 807 { 808 .id = 0x00, 809 }, 810}; 811 812static int ab3100_probe(struct i2c_client *client, 813 const struct i2c_device_id *id) 814{ 815 struct ab3100 *ab3100; 816 struct ab3100_platform_data *ab3100_plf_data = 817 dev_get_platdata(&client->dev); 818 int err; 819 int i; 820 821 ab3100 = devm_kzalloc(&client->dev, sizeof(struct ab3100), GFP_KERNEL); 822 if (!ab3100) 823 return -ENOMEM; 824 825 /* Initialize data structure */ 826 mutex_init(&ab3100->access_mutex); 827 BLOCKING_INIT_NOTIFIER_HEAD(&ab3100->event_subscribers); 828 829 ab3100->i2c_client = client; 830 ab3100->dev = &ab3100->i2c_client->dev; 831 832 i2c_set_clientdata(client, ab3100); 833 834 /* Read chip ID register */ 835 err = ab3100_get_register_interruptible(ab3100, AB3100_CID, 836 &ab3100->chip_id); 837 if (err) { 838 dev_err(&client->dev, 839 "failed to communicate with AB3100 chip\n"); 840 goto exit_no_detect; 841 } 842 843 for (i = 0; ids[i].id != 0x0; i++) { 844 if (ids[i].id == ab3100->chip_id) { 845 if (ids[i].name) 846 break; 847 848 dev_err(&client->dev, "AB3000 is not supported\n"); 849 goto exit_no_detect; 850 } 851 } 852 853 snprintf(&ab3100->chip_name[0], 854 sizeof(ab3100->chip_name) - 1, "AB3100 %s", ids[i].name); 855 856 if (ids[i].id == 0x0) { 857 dev_err(&client->dev, "unknown analog baseband chip id: 0x%x\n", 858 ab3100->chip_id); 859 dev_err(&client->dev, 860 "accepting it anyway. Please update the driver.\n"); 861 goto exit_no_detect; 862 } 863 864 dev_info(&client->dev, "Detected chip: %s\n", 865 &ab3100->chip_name[0]); 866 867 /* Attach a second dummy i2c_client to the test register address */ 868 ab3100->testreg_client = i2c_new_dummy_device(client->adapter, 869 client->addr + 1); 870 if (IS_ERR(ab3100->testreg_client)) { 871 err = PTR_ERR(ab3100->testreg_client); 872 goto exit_no_testreg_client; 873 } 874 875 err = ab3100_setup(ab3100); 876 if (err) 877 goto exit_no_setup; 878 879 err = devm_request_threaded_irq(&client->dev, 880 client->irq, NULL, ab3100_irq_handler, 881 IRQF_ONESHOT, "ab3100-core", ab3100); 882 if (err) 883 goto exit_no_irq; 884 885 err = abx500_register_ops(&client->dev, &ab3100_ops); 886 if (err) 887 goto exit_no_ops; 888 889 /* Set up and register the platform devices. */ 890 for (i = 0; i < ARRAY_SIZE(ab3100_devs); i++) { 891 ab3100_devs[i].platform_data = ab3100_plf_data; 892 ab3100_devs[i].pdata_size = sizeof(struct ab3100_platform_data); 893 } 894 895 err = mfd_add_devices(&client->dev, 0, ab3100_devs, 896 ARRAY_SIZE(ab3100_devs), NULL, 0, NULL); 897 898 ab3100_setup_debugfs(ab3100); 899 900 return 0; 901 902 exit_no_ops: 903 exit_no_irq: 904 exit_no_setup: 905 i2c_unregister_device(ab3100->testreg_client); 906 exit_no_testreg_client: 907 exit_no_detect: 908 return err; 909} 910 911static const struct i2c_device_id ab3100_id[] = { 912 { "ab3100", 0 }, 913 { } 914}; 915 916static struct i2c_driver ab3100_driver = { 917 .driver = { 918 .name = "ab3100", 919 .suppress_bind_attrs = true, 920 }, 921 .id_table = ab3100_id, 922 .probe = ab3100_probe, 923}; 924 925static int __init ab3100_i2c_init(void) 926{ 927 return i2c_add_driver(&ab3100_driver); 928} 929subsys_initcall(ab3100_i2c_init); 930