1 /* 2 * Copyright (C) ST-Ericsson SA 2010 3 * 4 * License Terms: GNU General Public License v2 5 * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com> 6 * Author: Rabin Vincent <rabin.vincent@stericsson.com> 7 * Author: Mattias Wallin <mattias.wallin@stericsson.com> 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/slab.h> 12 #include <linux/init.h> 13 #include <linux/irq.h> 14 #include <linux/delay.h> 15 #include <linux/interrupt.h> 16 #include <linux/module.h> 17 #include <linux/platform_device.h> 18 #include <linux/mfd/core.h> 19 #include <linux/mfd/abx500.h> 20 #include <linux/mfd/abx500/ab8500.h> 21 #include <linux/mfd/dbx500-prcmu.h> 22 #include <linux/regulator/ab8500.h> 23 #include <linux/of.h> 24 #include <linux/of_device.h> 25 26 /* 27 * Interrupt register offsets 28 * Bank : 0x0E 29 */ 30 #define AB8500_IT_SOURCE1_REG 0x00 31 #define AB8500_IT_SOURCE2_REG 0x01 32 #define AB8500_IT_SOURCE3_REG 0x02 33 #define AB8500_IT_SOURCE4_REG 0x03 34 #define AB8500_IT_SOURCE5_REG 0x04 35 #define AB8500_IT_SOURCE6_REG 0x05 36 #define AB8500_IT_SOURCE7_REG 0x06 37 #define AB8500_IT_SOURCE8_REG 0x07 38 #define AB9540_IT_SOURCE13_REG 0x0C 39 #define AB8500_IT_SOURCE19_REG 0x12 40 #define AB8500_IT_SOURCE20_REG 0x13 41 #define AB8500_IT_SOURCE21_REG 0x14 42 #define AB8500_IT_SOURCE22_REG 0x15 43 #define AB8500_IT_SOURCE23_REG 0x16 44 #define AB8500_IT_SOURCE24_REG 0x17 45 46 /* 47 * latch registers 48 */ 49 #define AB8500_IT_LATCH1_REG 0x20 50 #define AB8500_IT_LATCH2_REG 0x21 51 #define AB8500_IT_LATCH3_REG 0x22 52 #define AB8500_IT_LATCH4_REG 0x23 53 #define AB8500_IT_LATCH5_REG 0x24 54 #define AB8500_IT_LATCH6_REG 0x25 55 #define AB8500_IT_LATCH7_REG 0x26 56 #define AB8500_IT_LATCH8_REG 0x27 57 #define AB8500_IT_LATCH9_REG 0x28 58 #define AB8500_IT_LATCH10_REG 0x29 59 #define AB8500_IT_LATCH12_REG 0x2B 60 #define AB9540_IT_LATCH13_REG 0x2C 61 #define AB8500_IT_LATCH19_REG 0x32 62 #define AB8500_IT_LATCH20_REG 0x33 63 #define AB8500_IT_LATCH21_REG 0x34 64 #define AB8500_IT_LATCH22_REG 0x35 65 #define AB8500_IT_LATCH23_REG 0x36 66 #define AB8500_IT_LATCH24_REG 0x37 67 68 /* 69 * mask registers 70 */ 71 72 #define AB8500_IT_MASK1_REG 0x40 73 #define AB8500_IT_MASK2_REG 0x41 74 #define AB8500_IT_MASK3_REG 0x42 75 #define AB8500_IT_MASK4_REG 0x43 76 #define AB8500_IT_MASK5_REG 0x44 77 #define AB8500_IT_MASK6_REG 0x45 78 #define AB8500_IT_MASK7_REG 0x46 79 #define AB8500_IT_MASK8_REG 0x47 80 #define AB8500_IT_MASK9_REG 0x48 81 #define AB8500_IT_MASK10_REG 0x49 82 #define AB8500_IT_MASK11_REG 0x4A 83 #define AB8500_IT_MASK12_REG 0x4B 84 #define AB8500_IT_MASK13_REG 0x4C 85 #define AB8500_IT_MASK14_REG 0x4D 86 #define AB8500_IT_MASK15_REG 0x4E 87 #define AB8500_IT_MASK16_REG 0x4F 88 #define AB8500_IT_MASK17_REG 0x50 89 #define AB8500_IT_MASK18_REG 0x51 90 #define AB8500_IT_MASK19_REG 0x52 91 #define AB8500_IT_MASK20_REG 0x53 92 #define AB8500_IT_MASK21_REG 0x54 93 #define AB8500_IT_MASK22_REG 0x55 94 #define AB8500_IT_MASK23_REG 0x56 95 #define AB8500_IT_MASK24_REG 0x57 96 97 /* 98 * latch hierarchy registers 99 */ 100 #define AB8500_IT_LATCHHIER1_REG 0x60 101 #define AB8500_IT_LATCHHIER2_REG 0x61 102 #define AB8500_IT_LATCHHIER3_REG 0x62 103 104 #define AB8500_IT_LATCHHIER_NUM 3 105 106 #define AB8500_REV_REG 0x80 107 #define AB8500_IC_NAME_REG 0x82 108 #define AB8500_SWITCH_OFF_STATUS 0x00 109 110 #define AB8500_TURN_ON_STATUS 0x00 111 112 static bool no_bm; /* No battery management */ 113 module_param(no_bm, bool, S_IRUGO); 114 115 #define AB9540_MODEM_CTRL2_REG 0x23 116 #define AB9540_MODEM_CTRL2_SWDBBRSTN_BIT BIT(2) 117 118 /* 119 * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt 120 * numbers are indexed into this array with (num / 8). The interupts are 121 * defined in linux/mfd/ab8500.h 122 * 123 * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at 124 * offset 0. 125 */ 126 /* AB8500 support */ 127 static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = { 128 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21, 129 }; 130 131 /* AB9540 support */ 132 static const int ab9540_irq_regoffset[AB9540_NUM_IRQ_REGS] = { 133 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21, 12, 13, 24, 134 }; 135 136 static const char ab8500_version_str[][7] = { 137 [AB8500_VERSION_AB8500] = "AB8500", 138 [AB8500_VERSION_AB8505] = "AB8505", 139 [AB8500_VERSION_AB9540] = "AB9540", 140 [AB8500_VERSION_AB8540] = "AB8540", 141 }; 142 143 static int ab8500_i2c_write(struct ab8500 *ab8500, u16 addr, u8 data) 144 { 145 int ret; 146 147 ret = prcmu_abb_write((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1); 148 if (ret < 0) 149 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret); 150 return ret; 151 } 152 153 static int ab8500_i2c_write_masked(struct ab8500 *ab8500, u16 addr, u8 mask, 154 u8 data) 155 { 156 int ret; 157 158 ret = prcmu_abb_write_masked((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 159 &mask, 1); 160 if (ret < 0) 161 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret); 162 return ret; 163 } 164 165 static int ab8500_i2c_read(struct ab8500 *ab8500, u16 addr) 166 { 167 int ret; 168 u8 data; 169 170 ret = prcmu_abb_read((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1); 171 if (ret < 0) { 172 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret); 173 return ret; 174 } 175 return (int)data; 176 } 177 178 static int ab8500_get_chip_id(struct device *dev) 179 { 180 struct ab8500 *ab8500; 181 182 if (!dev) 183 return -EINVAL; 184 ab8500 = dev_get_drvdata(dev->parent); 185 return ab8500 ? (int)ab8500->chip_id : -EINVAL; 186 } 187 188 static int set_register_interruptible(struct ab8500 *ab8500, u8 bank, 189 u8 reg, u8 data) 190 { 191 int ret; 192 /* 193 * Put the u8 bank and u8 register together into a an u16. 194 * The bank on higher 8 bits and register in lower 8 bits. 195 * */ 196 u16 addr = ((u16)bank) << 8 | reg; 197 198 dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data); 199 200 mutex_lock(&ab8500->lock); 201 202 ret = ab8500->write(ab8500, addr, data); 203 if (ret < 0) 204 dev_err(ab8500->dev, "failed to write reg %#x: %d\n", 205 addr, ret); 206 mutex_unlock(&ab8500->lock); 207 208 return ret; 209 } 210 211 static int ab8500_set_register(struct device *dev, u8 bank, 212 u8 reg, u8 value) 213 { 214 int ret; 215 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent); 216 217 atomic_inc(&ab8500->transfer_ongoing); 218 ret = set_register_interruptible(ab8500, bank, reg, value); 219 atomic_dec(&ab8500->transfer_ongoing); 220 return ret; 221 } 222 223 static int get_register_interruptible(struct ab8500 *ab8500, u8 bank, 224 u8 reg, u8 *value) 225 { 226 int ret; 227 /* put the u8 bank and u8 reg together into a an u16. 228 * bank on higher 8 bits and reg in lower */ 229 u16 addr = ((u16)bank) << 8 | reg; 230 231 mutex_lock(&ab8500->lock); 232 233 ret = ab8500->read(ab8500, addr); 234 if (ret < 0) 235 dev_err(ab8500->dev, "failed to read reg %#x: %d\n", 236 addr, ret); 237 else 238 *value = ret; 239 240 mutex_unlock(&ab8500->lock); 241 dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret); 242 243 return ret; 244 } 245 246 static int ab8500_get_register(struct device *dev, u8 bank, 247 u8 reg, u8 *value) 248 { 249 int ret; 250 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent); 251 252 atomic_inc(&ab8500->transfer_ongoing); 253 ret = get_register_interruptible(ab8500, bank, reg, value); 254 atomic_dec(&ab8500->transfer_ongoing); 255 return ret; 256 } 257 258 static int mask_and_set_register_interruptible(struct ab8500 *ab8500, u8 bank, 259 u8 reg, u8 bitmask, u8 bitvalues) 260 { 261 int ret; 262 /* put the u8 bank and u8 reg together into a an u16. 263 * bank on higher 8 bits and reg in lower */ 264 u16 addr = ((u16)bank) << 8 | reg; 265 266 mutex_lock(&ab8500->lock); 267 268 if (ab8500->write_masked == NULL) { 269 u8 data; 270 271 ret = ab8500->read(ab8500, addr); 272 if (ret < 0) { 273 dev_err(ab8500->dev, "failed to read reg %#x: %d\n", 274 addr, ret); 275 goto out; 276 } 277 278 data = (u8)ret; 279 data = (~bitmask & data) | (bitmask & bitvalues); 280 281 ret = ab8500->write(ab8500, addr, data); 282 if (ret < 0) 283 dev_err(ab8500->dev, "failed to write reg %#x: %d\n", 284 addr, ret); 285 286 dev_vdbg(ab8500->dev, "mask: addr %#x => data %#x\n", addr, 287 data); 288 goto out; 289 } 290 ret = ab8500->write_masked(ab8500, addr, bitmask, bitvalues); 291 if (ret < 0) 292 dev_err(ab8500->dev, "failed to modify reg %#x: %d\n", addr, 293 ret); 294 out: 295 mutex_unlock(&ab8500->lock); 296 return ret; 297 } 298 299 static int ab8500_mask_and_set_register(struct device *dev, 300 u8 bank, u8 reg, u8 bitmask, u8 bitvalues) 301 { 302 int ret; 303 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent); 304 305 atomic_inc(&ab8500->transfer_ongoing); 306 ret= mask_and_set_register_interruptible(ab8500, bank, reg, 307 bitmask, bitvalues); 308 atomic_dec(&ab8500->transfer_ongoing); 309 return ret; 310 } 311 312 static struct abx500_ops ab8500_ops = { 313 .get_chip_id = ab8500_get_chip_id, 314 .get_register = ab8500_get_register, 315 .set_register = ab8500_set_register, 316 .get_register_page = NULL, 317 .set_register_page = NULL, 318 .mask_and_set_register = ab8500_mask_and_set_register, 319 .event_registers_startup_state_get = NULL, 320 .startup_irq_enabled = NULL, 321 }; 322 323 static void ab8500_irq_lock(struct irq_data *data) 324 { 325 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data); 326 327 mutex_lock(&ab8500->irq_lock); 328 atomic_inc(&ab8500->transfer_ongoing); 329 } 330 331 static void ab8500_irq_sync_unlock(struct irq_data *data) 332 { 333 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data); 334 int i; 335 336 for (i = 0; i < ab8500->mask_size; i++) { 337 u8 old = ab8500->oldmask[i]; 338 u8 new = ab8500->mask[i]; 339 int reg; 340 341 if (new == old) 342 continue; 343 344 /* 345 * Interrupt register 12 doesn't exist prior to AB8500 version 346 * 2.0 347 */ 348 if (ab8500->irq_reg_offset[i] == 11 && 349 is_ab8500_1p1_or_earlier(ab8500)) 350 continue; 351 352 ab8500->oldmask[i] = new; 353 354 reg = AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i]; 355 set_register_interruptible(ab8500, AB8500_INTERRUPT, reg, new); 356 } 357 atomic_dec(&ab8500->transfer_ongoing); 358 mutex_unlock(&ab8500->irq_lock); 359 } 360 361 static void ab8500_irq_mask(struct irq_data *data) 362 { 363 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data); 364 int offset = data->irq - ab8500->irq_base; 365 int index = offset / 8; 366 int mask = 1 << (offset % 8); 367 368 ab8500->mask[index] |= mask; 369 } 370 371 static void ab8500_irq_unmask(struct irq_data *data) 372 { 373 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data); 374 int offset = data->irq - ab8500->irq_base; 375 int index = offset / 8; 376 int mask = 1 << (offset % 8); 377 378 ab8500->mask[index] &= ~mask; 379 } 380 381 static struct irq_chip ab8500_irq_chip = { 382 .name = "ab8500", 383 .irq_bus_lock = ab8500_irq_lock, 384 .irq_bus_sync_unlock = ab8500_irq_sync_unlock, 385 .irq_mask = ab8500_irq_mask, 386 .irq_disable = ab8500_irq_mask, 387 .irq_unmask = ab8500_irq_unmask, 388 }; 389 390 static int ab8500_handle_hierarchical_line(struct ab8500 *ab8500, 391 int latch_offset, u8 latch_val) 392 { 393 int int_bit = __ffs(latch_val); 394 int line, i; 395 396 do { 397 int_bit = __ffs(latch_val); 398 399 for (i = 0; i < ab8500->mask_size; i++) 400 if (ab8500->irq_reg_offset[i] == latch_offset) 401 break; 402 403 if (i >= ab8500->mask_size) { 404 dev_err(ab8500->dev, "Register offset 0x%2x not declared\n", 405 latch_offset); 406 return -ENXIO; 407 } 408 409 line = (i << 3) + int_bit; 410 latch_val &= ~(1 << int_bit); 411 412 handle_nested_irq(ab8500->irq_base + line); 413 } while (latch_val); 414 415 return 0; 416 } 417 418 static int ab8500_handle_hierarchical_latch(struct ab8500 *ab8500, 419 int hier_offset, u8 hier_val) 420 { 421 int latch_bit, status; 422 u8 latch_offset, latch_val; 423 424 do { 425 latch_bit = __ffs(hier_val); 426 latch_offset = (hier_offset << 3) + latch_bit; 427 428 /* Fix inconsistent ITFromLatch25 bit mapping... */ 429 if (unlikely(latch_offset == 17)) 430 latch_offset = 24; 431 432 status = get_register_interruptible(ab8500, 433 AB8500_INTERRUPT, 434 AB8500_IT_LATCH1_REG + latch_offset, 435 &latch_val); 436 if (status < 0 || latch_val == 0) 437 goto discard; 438 439 status = ab8500_handle_hierarchical_line(ab8500, 440 latch_offset, latch_val); 441 if (status < 0) 442 return status; 443 discard: 444 hier_val &= ~(1 << latch_bit); 445 } while (hier_val); 446 447 return 0; 448 } 449 450 static irqreturn_t ab8500_hierarchical_irq(int irq, void *dev) 451 { 452 struct ab8500 *ab8500 = dev; 453 u8 i; 454 455 dev_vdbg(ab8500->dev, "interrupt\n"); 456 457 /* Hierarchical interrupt version */ 458 for (i = 0; i < AB8500_IT_LATCHHIER_NUM; i++) { 459 int status; 460 u8 hier_val; 461 462 status = get_register_interruptible(ab8500, AB8500_INTERRUPT, 463 AB8500_IT_LATCHHIER1_REG + i, &hier_val); 464 if (status < 0 || hier_val == 0) 465 continue; 466 467 status = ab8500_handle_hierarchical_latch(ab8500, i, hier_val); 468 if (status < 0) 469 break; 470 } 471 return IRQ_HANDLED; 472 } 473 474 static irqreturn_t ab8500_irq(int irq, void *dev) 475 { 476 struct ab8500 *ab8500 = dev; 477 int i; 478 479 dev_vdbg(ab8500->dev, "interrupt\n"); 480 481 atomic_inc(&ab8500->transfer_ongoing); 482 483 for (i = 0; i < ab8500->mask_size; i++) { 484 int regoffset = ab8500->irq_reg_offset[i]; 485 int status; 486 u8 value; 487 488 /* 489 * Interrupt register 12 doesn't exist prior to AB8500 version 490 * 2.0 491 */ 492 if (regoffset == 11 && is_ab8500_1p1_or_earlier(ab8500)) 493 continue; 494 495 status = get_register_interruptible(ab8500, AB8500_INTERRUPT, 496 AB8500_IT_LATCH1_REG + regoffset, &value); 497 if (status < 0 || value == 0) 498 continue; 499 500 do { 501 int bit = __ffs(value); 502 int line = i * 8 + bit; 503 504 handle_nested_irq(ab8500->irq_base + line); 505 value &= ~(1 << bit); 506 507 } while (value); 508 } 509 atomic_dec(&ab8500->transfer_ongoing); 510 return IRQ_HANDLED; 511 } 512 513 static int ab8500_irq_init(struct ab8500 *ab8500) 514 { 515 int base = ab8500->irq_base; 516 int irq; 517 int num_irqs; 518 519 if (is_ab9540(ab8500)) 520 num_irqs = AB9540_NR_IRQS; 521 else if (is_ab8505(ab8500)) 522 num_irqs = AB8505_NR_IRQS; 523 else 524 num_irqs = AB8500_NR_IRQS; 525 526 for (irq = base; irq < base + num_irqs; irq++) { 527 irq_set_chip_data(irq, ab8500); 528 irq_set_chip_and_handler(irq, &ab8500_irq_chip, 529 handle_simple_irq); 530 irq_set_nested_thread(irq, 1); 531 #ifdef CONFIG_ARM 532 set_irq_flags(irq, IRQF_VALID); 533 #else 534 irq_set_noprobe(irq); 535 #endif 536 } 537 538 return 0; 539 } 540 541 static void ab8500_irq_remove(struct ab8500 *ab8500) 542 { 543 int base = ab8500->irq_base; 544 int irq; 545 int num_irqs; 546 547 if (is_ab9540(ab8500)) 548 num_irqs = AB9540_NR_IRQS; 549 else if (is_ab8505(ab8500)) 550 num_irqs = AB8505_NR_IRQS; 551 else 552 num_irqs = AB8500_NR_IRQS; 553 554 for (irq = base; irq < base + num_irqs; irq++) { 555 #ifdef CONFIG_ARM 556 set_irq_flags(irq, 0); 557 #endif 558 irq_set_chip_and_handler(irq, NULL, NULL); 559 irq_set_chip_data(irq, NULL); 560 } 561 } 562 563 int ab8500_suspend(struct ab8500 *ab8500) 564 { 565 if (atomic_read(&ab8500->transfer_ongoing)) 566 return -EINVAL; 567 else 568 return 0; 569 } 570 571 /* AB8500 GPIO Resources */ 572 static struct resource __devinitdata ab8500_gpio_resources[] = { 573 { 574 .name = "GPIO_INT6", 575 .start = AB8500_INT_GPIO6R, 576 .end = AB8500_INT_GPIO41F, 577 .flags = IORESOURCE_IRQ, 578 } 579 }; 580 581 /* AB9540 GPIO Resources */ 582 static struct resource __devinitdata ab9540_gpio_resources[] = { 583 { 584 .name = "GPIO_INT6", 585 .start = AB8500_INT_GPIO6R, 586 .end = AB8500_INT_GPIO41F, 587 .flags = IORESOURCE_IRQ, 588 }, 589 { 590 .name = "GPIO_INT14", 591 .start = AB9540_INT_GPIO50R, 592 .end = AB9540_INT_GPIO54R, 593 .flags = IORESOURCE_IRQ, 594 }, 595 { 596 .name = "GPIO_INT15", 597 .start = AB9540_INT_GPIO50F, 598 .end = AB9540_INT_GPIO54F, 599 .flags = IORESOURCE_IRQ, 600 } 601 }; 602 603 static struct resource __devinitdata ab8500_gpadc_resources[] = { 604 { 605 .name = "HW_CONV_END", 606 .start = AB8500_INT_GP_HW_ADC_CONV_END, 607 .end = AB8500_INT_GP_HW_ADC_CONV_END, 608 .flags = IORESOURCE_IRQ, 609 }, 610 { 611 .name = "SW_CONV_END", 612 .start = AB8500_INT_GP_SW_ADC_CONV_END, 613 .end = AB8500_INT_GP_SW_ADC_CONV_END, 614 .flags = IORESOURCE_IRQ, 615 }, 616 }; 617 618 static struct resource __devinitdata ab8500_rtc_resources[] = { 619 { 620 .name = "60S", 621 .start = AB8500_INT_RTC_60S, 622 .end = AB8500_INT_RTC_60S, 623 .flags = IORESOURCE_IRQ, 624 }, 625 { 626 .name = "ALARM", 627 .start = AB8500_INT_RTC_ALARM, 628 .end = AB8500_INT_RTC_ALARM, 629 .flags = IORESOURCE_IRQ, 630 }, 631 }; 632 633 static struct resource __devinitdata ab8500_poweronkey_db_resources[] = { 634 { 635 .name = "ONKEY_DBF", 636 .start = AB8500_INT_PON_KEY1DB_F, 637 .end = AB8500_INT_PON_KEY1DB_F, 638 .flags = IORESOURCE_IRQ, 639 }, 640 { 641 .name = "ONKEY_DBR", 642 .start = AB8500_INT_PON_KEY1DB_R, 643 .end = AB8500_INT_PON_KEY1DB_R, 644 .flags = IORESOURCE_IRQ, 645 }, 646 }; 647 648 static struct resource __devinitdata ab8500_av_acc_detect_resources[] = { 649 { 650 .name = "ACC_DETECT_1DB_F", 651 .start = AB8500_INT_ACC_DETECT_1DB_F, 652 .end = AB8500_INT_ACC_DETECT_1DB_F, 653 .flags = IORESOURCE_IRQ, 654 }, 655 { 656 .name = "ACC_DETECT_1DB_R", 657 .start = AB8500_INT_ACC_DETECT_1DB_R, 658 .end = AB8500_INT_ACC_DETECT_1DB_R, 659 .flags = IORESOURCE_IRQ, 660 }, 661 { 662 .name = "ACC_DETECT_21DB_F", 663 .start = AB8500_INT_ACC_DETECT_21DB_F, 664 .end = AB8500_INT_ACC_DETECT_21DB_F, 665 .flags = IORESOURCE_IRQ, 666 }, 667 { 668 .name = "ACC_DETECT_21DB_R", 669 .start = AB8500_INT_ACC_DETECT_21DB_R, 670 .end = AB8500_INT_ACC_DETECT_21DB_R, 671 .flags = IORESOURCE_IRQ, 672 }, 673 { 674 .name = "ACC_DETECT_22DB_F", 675 .start = AB8500_INT_ACC_DETECT_22DB_F, 676 .end = AB8500_INT_ACC_DETECT_22DB_F, 677 .flags = IORESOURCE_IRQ, 678 }, 679 { 680 .name = "ACC_DETECT_22DB_R", 681 .start = AB8500_INT_ACC_DETECT_22DB_R, 682 .end = AB8500_INT_ACC_DETECT_22DB_R, 683 .flags = IORESOURCE_IRQ, 684 }, 685 }; 686 687 static struct resource __devinitdata ab8500_charger_resources[] = { 688 { 689 .name = "MAIN_CH_UNPLUG_DET", 690 .start = AB8500_INT_MAIN_CH_UNPLUG_DET, 691 .end = AB8500_INT_MAIN_CH_UNPLUG_DET, 692 .flags = IORESOURCE_IRQ, 693 }, 694 { 695 .name = "MAIN_CHARGE_PLUG_DET", 696 .start = AB8500_INT_MAIN_CH_PLUG_DET, 697 .end = AB8500_INT_MAIN_CH_PLUG_DET, 698 .flags = IORESOURCE_IRQ, 699 }, 700 { 701 .name = "VBUS_DET_R", 702 .start = AB8500_INT_VBUS_DET_R, 703 .end = AB8500_INT_VBUS_DET_R, 704 .flags = IORESOURCE_IRQ, 705 }, 706 { 707 .name = "VBUS_DET_F", 708 .start = AB8500_INT_VBUS_DET_F, 709 .end = AB8500_INT_VBUS_DET_F, 710 .flags = IORESOURCE_IRQ, 711 }, 712 { 713 .name = "USB_LINK_STATUS", 714 .start = AB8500_INT_USB_LINK_STATUS, 715 .end = AB8500_INT_USB_LINK_STATUS, 716 .flags = IORESOURCE_IRQ, 717 }, 718 { 719 .name = "VBUS_OVV", 720 .start = AB8500_INT_VBUS_OVV, 721 .end = AB8500_INT_VBUS_OVV, 722 .flags = IORESOURCE_IRQ, 723 }, 724 { 725 .name = "USB_CH_TH_PROT_R", 726 .start = AB8500_INT_USB_CH_TH_PROT_R, 727 .end = AB8500_INT_USB_CH_TH_PROT_R, 728 .flags = IORESOURCE_IRQ, 729 }, 730 { 731 .name = "USB_CH_TH_PROT_F", 732 .start = AB8500_INT_USB_CH_TH_PROT_F, 733 .end = AB8500_INT_USB_CH_TH_PROT_F, 734 .flags = IORESOURCE_IRQ, 735 }, 736 { 737 .name = "MAIN_EXT_CH_NOT_OK", 738 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK, 739 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK, 740 .flags = IORESOURCE_IRQ, 741 }, 742 { 743 .name = "MAIN_CH_TH_PROT_R", 744 .start = AB8500_INT_MAIN_CH_TH_PROT_R, 745 .end = AB8500_INT_MAIN_CH_TH_PROT_R, 746 .flags = IORESOURCE_IRQ, 747 }, 748 { 749 .name = "MAIN_CH_TH_PROT_F", 750 .start = AB8500_INT_MAIN_CH_TH_PROT_F, 751 .end = AB8500_INT_MAIN_CH_TH_PROT_F, 752 .flags = IORESOURCE_IRQ, 753 }, 754 { 755 .name = "USB_CHARGER_NOT_OKR", 756 .start = AB8500_INT_USB_CHARGER_NOT_OKR, 757 .end = AB8500_INT_USB_CHARGER_NOT_OKR, 758 .flags = IORESOURCE_IRQ, 759 }, 760 { 761 .name = "CH_WD_EXP", 762 .start = AB8500_INT_CH_WD_EXP, 763 .end = AB8500_INT_CH_WD_EXP, 764 .flags = IORESOURCE_IRQ, 765 }, 766 }; 767 768 static struct resource __devinitdata ab8500_btemp_resources[] = { 769 { 770 .name = "BAT_CTRL_INDB", 771 .start = AB8500_INT_BAT_CTRL_INDB, 772 .end = AB8500_INT_BAT_CTRL_INDB, 773 .flags = IORESOURCE_IRQ, 774 }, 775 { 776 .name = "BTEMP_LOW", 777 .start = AB8500_INT_BTEMP_LOW, 778 .end = AB8500_INT_BTEMP_LOW, 779 .flags = IORESOURCE_IRQ, 780 }, 781 { 782 .name = "BTEMP_HIGH", 783 .start = AB8500_INT_BTEMP_HIGH, 784 .end = AB8500_INT_BTEMP_HIGH, 785 .flags = IORESOURCE_IRQ, 786 }, 787 { 788 .name = "BTEMP_LOW_MEDIUM", 789 .start = AB8500_INT_BTEMP_LOW_MEDIUM, 790 .end = AB8500_INT_BTEMP_LOW_MEDIUM, 791 .flags = IORESOURCE_IRQ, 792 }, 793 { 794 .name = "BTEMP_MEDIUM_HIGH", 795 .start = AB8500_INT_BTEMP_MEDIUM_HIGH, 796 .end = AB8500_INT_BTEMP_MEDIUM_HIGH, 797 .flags = IORESOURCE_IRQ, 798 }, 799 }; 800 801 static struct resource __devinitdata ab8500_fg_resources[] = { 802 { 803 .name = "NCONV_ACCU", 804 .start = AB8500_INT_CCN_CONV_ACC, 805 .end = AB8500_INT_CCN_CONV_ACC, 806 .flags = IORESOURCE_IRQ, 807 }, 808 { 809 .name = "BATT_OVV", 810 .start = AB8500_INT_BATT_OVV, 811 .end = AB8500_INT_BATT_OVV, 812 .flags = IORESOURCE_IRQ, 813 }, 814 { 815 .name = "LOW_BAT_F", 816 .start = AB8500_INT_LOW_BAT_F, 817 .end = AB8500_INT_LOW_BAT_F, 818 .flags = IORESOURCE_IRQ, 819 }, 820 { 821 .name = "LOW_BAT_R", 822 .start = AB8500_INT_LOW_BAT_R, 823 .end = AB8500_INT_LOW_BAT_R, 824 .flags = IORESOURCE_IRQ, 825 }, 826 { 827 .name = "CC_INT_CALIB", 828 .start = AB8500_INT_CC_INT_CALIB, 829 .end = AB8500_INT_CC_INT_CALIB, 830 .flags = IORESOURCE_IRQ, 831 }, 832 { 833 .name = "CCEOC", 834 .start = AB8500_INT_CCEOC, 835 .end = AB8500_INT_CCEOC, 836 .flags = IORESOURCE_IRQ, 837 }, 838 }; 839 840 static struct resource __devinitdata ab8500_chargalg_resources[] = {}; 841 842 #ifdef CONFIG_DEBUG_FS 843 static struct resource __devinitdata ab8500_debug_resources[] = { 844 { 845 .name = "IRQ_FIRST", 846 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK, 847 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK, 848 .flags = IORESOURCE_IRQ, 849 }, 850 { 851 .name = "IRQ_LAST", 852 .start = AB8500_INT_XTAL32K_KO, 853 .end = AB8500_INT_XTAL32K_KO, 854 .flags = IORESOURCE_IRQ, 855 }, 856 }; 857 #endif 858 859 static struct resource __devinitdata ab8500_usb_resources[] = { 860 { 861 .name = "ID_WAKEUP_R", 862 .start = AB8500_INT_ID_WAKEUP_R, 863 .end = AB8500_INT_ID_WAKEUP_R, 864 .flags = IORESOURCE_IRQ, 865 }, 866 { 867 .name = "ID_WAKEUP_F", 868 .start = AB8500_INT_ID_WAKEUP_F, 869 .end = AB8500_INT_ID_WAKEUP_F, 870 .flags = IORESOURCE_IRQ, 871 }, 872 { 873 .name = "VBUS_DET_F", 874 .start = AB8500_INT_VBUS_DET_F, 875 .end = AB8500_INT_VBUS_DET_F, 876 .flags = IORESOURCE_IRQ, 877 }, 878 { 879 .name = "VBUS_DET_R", 880 .start = AB8500_INT_VBUS_DET_R, 881 .end = AB8500_INT_VBUS_DET_R, 882 .flags = IORESOURCE_IRQ, 883 }, 884 { 885 .name = "USB_LINK_STATUS", 886 .start = AB8500_INT_USB_LINK_STATUS, 887 .end = AB8500_INT_USB_LINK_STATUS, 888 .flags = IORESOURCE_IRQ, 889 }, 890 { 891 .name = "USB_ADP_PROBE_PLUG", 892 .start = AB8500_INT_ADP_PROBE_PLUG, 893 .end = AB8500_INT_ADP_PROBE_PLUG, 894 .flags = IORESOURCE_IRQ, 895 }, 896 { 897 .name = "USB_ADP_PROBE_UNPLUG", 898 .start = AB8500_INT_ADP_PROBE_UNPLUG, 899 .end = AB8500_INT_ADP_PROBE_UNPLUG, 900 .flags = IORESOURCE_IRQ, 901 }, 902 }; 903 904 static struct resource __devinitdata ab8505_iddet_resources[] = { 905 { 906 .name = "KeyDeglitch", 907 .start = AB8505_INT_KEYDEGLITCH, 908 .end = AB8505_INT_KEYDEGLITCH, 909 .flags = IORESOURCE_IRQ, 910 }, 911 { 912 .name = "KP", 913 .start = AB8505_INT_KP, 914 .end = AB8505_INT_KP, 915 .flags = IORESOURCE_IRQ, 916 }, 917 { 918 .name = "IKP", 919 .start = AB8505_INT_IKP, 920 .end = AB8505_INT_IKP, 921 .flags = IORESOURCE_IRQ, 922 }, 923 { 924 .name = "IKR", 925 .start = AB8505_INT_IKR, 926 .end = AB8505_INT_IKR, 927 .flags = IORESOURCE_IRQ, 928 }, 929 { 930 .name = "KeyStuck", 931 .start = AB8505_INT_KEYSTUCK, 932 .end = AB8505_INT_KEYSTUCK, 933 .flags = IORESOURCE_IRQ, 934 }, 935 }; 936 937 static struct resource __devinitdata ab8500_temp_resources[] = { 938 { 939 .name = "AB8500_TEMP_WARM", 940 .start = AB8500_INT_TEMP_WARM, 941 .end = AB8500_INT_TEMP_WARM, 942 .flags = IORESOURCE_IRQ, 943 }, 944 }; 945 946 static struct mfd_cell __devinitdata abx500_common_devs[] = { 947 #ifdef CONFIG_DEBUG_FS 948 { 949 .name = "ab8500-debug", 950 .num_resources = ARRAY_SIZE(ab8500_debug_resources), 951 .resources = ab8500_debug_resources, 952 }, 953 #endif 954 { 955 .name = "ab8500-sysctrl", 956 }, 957 { 958 .name = "ab8500-regulator", 959 }, 960 { 961 .name = "ab8500-gpadc", 962 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources), 963 .resources = ab8500_gpadc_resources, 964 }, 965 { 966 .name = "ab8500-rtc", 967 .num_resources = ARRAY_SIZE(ab8500_rtc_resources), 968 .resources = ab8500_rtc_resources, 969 }, 970 { 971 .name = "ab8500-acc-det", 972 .num_resources = ARRAY_SIZE(ab8500_av_acc_detect_resources), 973 .resources = ab8500_av_acc_detect_resources, 974 }, 975 { 976 .name = "ab8500-poweron-key", 977 .num_resources = ARRAY_SIZE(ab8500_poweronkey_db_resources), 978 .resources = ab8500_poweronkey_db_resources, 979 }, 980 { 981 .name = "ab8500-pwm", 982 .id = 1, 983 }, 984 { 985 .name = "ab8500-pwm", 986 .id = 2, 987 }, 988 { 989 .name = "ab8500-pwm", 990 .id = 3, 991 }, 992 { .name = "ab8500-leds", }, 993 { 994 .name = "ab8500-denc", 995 }, 996 { 997 .name = "ab8500-temp", 998 .num_resources = ARRAY_SIZE(ab8500_temp_resources), 999 .resources = ab8500_temp_resources, 1000 }, 1001 }; 1002 1003 static struct mfd_cell __devinitdata ab8500_bm_devs[] = { 1004 { 1005 .name = "ab8500-charger", 1006 .num_resources = ARRAY_SIZE(ab8500_charger_resources), 1007 .resources = ab8500_charger_resources, 1008 }, 1009 { 1010 .name = "ab8500-btemp", 1011 .num_resources = ARRAY_SIZE(ab8500_btemp_resources), 1012 .resources = ab8500_btemp_resources, 1013 }, 1014 { 1015 .name = "ab8500-fg", 1016 .num_resources = ARRAY_SIZE(ab8500_fg_resources), 1017 .resources = ab8500_fg_resources, 1018 }, 1019 { 1020 .name = "ab8500-chargalg", 1021 .num_resources = ARRAY_SIZE(ab8500_chargalg_resources), 1022 .resources = ab8500_chargalg_resources, 1023 }, 1024 }; 1025 1026 static struct mfd_cell __devinitdata ab8500_devs[] = { 1027 { 1028 .name = "ab8500-gpio", 1029 .num_resources = ARRAY_SIZE(ab8500_gpio_resources), 1030 .resources = ab8500_gpio_resources, 1031 }, 1032 { 1033 .name = "ab8500-usb", 1034 .num_resources = ARRAY_SIZE(ab8500_usb_resources), 1035 .resources = ab8500_usb_resources, 1036 }, 1037 { 1038 .name = "ab8500-codec", 1039 }, 1040 }; 1041 1042 static struct mfd_cell __devinitdata ab9540_devs[] = { 1043 { 1044 .name = "ab8500-gpio", 1045 .num_resources = ARRAY_SIZE(ab9540_gpio_resources), 1046 .resources = ab9540_gpio_resources, 1047 }, 1048 { 1049 .name = "ab9540-usb", 1050 .num_resources = ARRAY_SIZE(ab8500_usb_resources), 1051 .resources = ab8500_usb_resources, 1052 }, 1053 { 1054 .name = "ab9540-codec", 1055 }, 1056 }; 1057 1058 /* Device list common to ab9540 and ab8505 */ 1059 static struct mfd_cell __devinitdata ab9540_ab8505_devs[] = { 1060 { 1061 .name = "ab-iddet", 1062 .num_resources = ARRAY_SIZE(ab8505_iddet_resources), 1063 .resources = ab8505_iddet_resources, 1064 }, 1065 }; 1066 1067 static ssize_t show_chip_id(struct device *dev, 1068 struct device_attribute *attr, char *buf) 1069 { 1070 struct ab8500 *ab8500; 1071 1072 ab8500 = dev_get_drvdata(dev); 1073 return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL); 1074 } 1075 1076 /* 1077 * ab8500 has switched off due to (SWITCH_OFF_STATUS): 1078 * 0x01 Swoff bit programming 1079 * 0x02 Thermal protection activation 1080 * 0x04 Vbat lower then BattOk falling threshold 1081 * 0x08 Watchdog expired 1082 * 0x10 Non presence of 32kHz clock 1083 * 0x20 Battery level lower than power on reset threshold 1084 * 0x40 Power on key 1 pressed longer than 10 seconds 1085 * 0x80 DB8500 thermal shutdown 1086 */ 1087 static ssize_t show_switch_off_status(struct device *dev, 1088 struct device_attribute *attr, char *buf) 1089 { 1090 int ret; 1091 u8 value; 1092 struct ab8500 *ab8500; 1093 1094 ab8500 = dev_get_drvdata(dev); 1095 ret = get_register_interruptible(ab8500, AB8500_RTC, 1096 AB8500_SWITCH_OFF_STATUS, &value); 1097 if (ret < 0) 1098 return ret; 1099 return sprintf(buf, "%#x\n", value); 1100 } 1101 1102 /* 1103 * ab8500 has turned on due to (TURN_ON_STATUS): 1104 * 0x01 PORnVbat 1105 * 0x02 PonKey1dbF 1106 * 0x04 PonKey2dbF 1107 * 0x08 RTCAlarm 1108 * 0x10 MainChDet 1109 * 0x20 VbusDet 1110 * 0x40 UsbIDDetect 1111 * 0x80 Reserved 1112 */ 1113 static ssize_t show_turn_on_status(struct device *dev, 1114 struct device_attribute *attr, char *buf) 1115 { 1116 int ret; 1117 u8 value; 1118 struct ab8500 *ab8500; 1119 1120 ab8500 = dev_get_drvdata(dev); 1121 ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK, 1122 AB8500_TURN_ON_STATUS, &value); 1123 if (ret < 0) 1124 return ret; 1125 return sprintf(buf, "%#x\n", value); 1126 } 1127 1128 static ssize_t show_ab9540_dbbrstn(struct device *dev, 1129 struct device_attribute *attr, char *buf) 1130 { 1131 struct ab8500 *ab8500; 1132 int ret; 1133 u8 value; 1134 1135 ab8500 = dev_get_drvdata(dev); 1136 1137 ret = get_register_interruptible(ab8500, AB8500_REGU_CTRL2, 1138 AB9540_MODEM_CTRL2_REG, &value); 1139 if (ret < 0) 1140 return ret; 1141 1142 return sprintf(buf, "%d\n", 1143 (value & AB9540_MODEM_CTRL2_SWDBBRSTN_BIT) ? 1 : 0); 1144 } 1145 1146 static ssize_t store_ab9540_dbbrstn(struct device *dev, 1147 struct device_attribute *attr, const char *buf, size_t count) 1148 { 1149 struct ab8500 *ab8500; 1150 int ret = count; 1151 int err; 1152 u8 bitvalues; 1153 1154 ab8500 = dev_get_drvdata(dev); 1155 1156 if (count > 0) { 1157 switch (buf[0]) { 1158 case '0': 1159 bitvalues = 0; 1160 break; 1161 case '1': 1162 bitvalues = AB9540_MODEM_CTRL2_SWDBBRSTN_BIT; 1163 break; 1164 default: 1165 goto exit; 1166 } 1167 1168 err = mask_and_set_register_interruptible(ab8500, 1169 AB8500_REGU_CTRL2, AB9540_MODEM_CTRL2_REG, 1170 AB9540_MODEM_CTRL2_SWDBBRSTN_BIT, bitvalues); 1171 if (err) 1172 dev_info(ab8500->dev, 1173 "Failed to set DBBRSTN %c, err %#x\n", 1174 buf[0], err); 1175 } 1176 1177 exit: 1178 return ret; 1179 } 1180 1181 static DEVICE_ATTR(chip_id, S_IRUGO, show_chip_id, NULL); 1182 static DEVICE_ATTR(switch_off_status, S_IRUGO, show_switch_off_status, NULL); 1183 static DEVICE_ATTR(turn_on_status, S_IRUGO, show_turn_on_status, NULL); 1184 static DEVICE_ATTR(dbbrstn, S_IRUGO | S_IWUSR, 1185 show_ab9540_dbbrstn, store_ab9540_dbbrstn); 1186 1187 static struct attribute *ab8500_sysfs_entries[] = { 1188 &dev_attr_chip_id.attr, 1189 &dev_attr_switch_off_status.attr, 1190 &dev_attr_turn_on_status.attr, 1191 NULL, 1192 }; 1193 1194 static struct attribute *ab9540_sysfs_entries[] = { 1195 &dev_attr_chip_id.attr, 1196 &dev_attr_switch_off_status.attr, 1197 &dev_attr_turn_on_status.attr, 1198 &dev_attr_dbbrstn.attr, 1199 NULL, 1200 }; 1201 1202 static struct attribute_group ab8500_attr_group = { 1203 .attrs = ab8500_sysfs_entries, 1204 }; 1205 1206 static struct attribute_group ab9540_attr_group = { 1207 .attrs = ab9540_sysfs_entries, 1208 }; 1209 1210 static const struct of_device_id ab8500_match[] = { 1211 { 1212 .compatible = "stericsson,ab8500", 1213 .data = (void *)AB8500_VERSION_AB8500, 1214 }, 1215 {}, 1216 }; 1217 1218 static int __devinit ab8500_probe(struct platform_device *pdev) 1219 { 1220 struct ab8500_platform_data *plat = dev_get_platdata(&pdev->dev); 1221 const struct platform_device_id *platid = platform_get_device_id(pdev); 1222 enum ab8500_version version = AB8500_VERSION_UNDEFINED; 1223 struct device_node *np = pdev->dev.of_node; 1224 struct ab8500 *ab8500; 1225 struct resource *resource; 1226 int ret; 1227 int i; 1228 u8 value; 1229 1230 ab8500 = kzalloc(sizeof *ab8500, GFP_KERNEL); 1231 if (!ab8500) 1232 return -ENOMEM; 1233 1234 if (plat) 1235 ab8500->irq_base = plat->irq_base; 1236 else if (np) 1237 ret = of_property_read_u32(np, "stericsson,irq-base", &ab8500->irq_base); 1238 1239 if (!ab8500->irq_base) { 1240 dev_info(&pdev->dev, "couldn't find irq-base\n"); 1241 ret = -EINVAL; 1242 goto out_free_ab8500; 1243 } 1244 1245 ab8500->dev = &pdev->dev; 1246 1247 resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 1248 if (!resource) { 1249 ret = -ENODEV; 1250 goto out_free_ab8500; 1251 } 1252 1253 ab8500->irq = resource->start; 1254 1255 ab8500->read = ab8500_i2c_read; 1256 ab8500->write = ab8500_i2c_write; 1257 ab8500->write_masked = ab8500_i2c_write_masked; 1258 1259 mutex_init(&ab8500->lock); 1260 mutex_init(&ab8500->irq_lock); 1261 atomic_set(&ab8500->transfer_ongoing, 0); 1262 1263 platform_set_drvdata(pdev, ab8500); 1264 1265 if (platid) 1266 version = platid->driver_data; 1267 else if (np) 1268 version = (unsigned int) 1269 of_match_device(ab8500_match, &pdev->dev)->data; 1270 1271 if (version != AB8500_VERSION_UNDEFINED) 1272 ab8500->version = version; 1273 else { 1274 ret = get_register_interruptible(ab8500, AB8500_MISC, 1275 AB8500_IC_NAME_REG, &value); 1276 if (ret < 0) 1277 goto out_free_ab8500; 1278 1279 ab8500->version = value; 1280 } 1281 1282 ret = get_register_interruptible(ab8500, AB8500_MISC, 1283 AB8500_REV_REG, &value); 1284 if (ret < 0) 1285 goto out_free_ab8500; 1286 1287 ab8500->chip_id = value; 1288 1289 dev_info(ab8500->dev, "detected chip, %s rev. %1x.%1x\n", 1290 ab8500_version_str[ab8500->version], 1291 ab8500->chip_id >> 4, 1292 ab8500->chip_id & 0x0F); 1293 1294 /* Configure AB8500 or AB9540 IRQ */ 1295 if (is_ab9540(ab8500) || is_ab8505(ab8500)) { 1296 ab8500->mask_size = AB9540_NUM_IRQ_REGS; 1297 ab8500->irq_reg_offset = ab9540_irq_regoffset; 1298 } else { 1299 ab8500->mask_size = AB8500_NUM_IRQ_REGS; 1300 ab8500->irq_reg_offset = ab8500_irq_regoffset; 1301 } 1302 ab8500->mask = kzalloc(ab8500->mask_size, GFP_KERNEL); 1303 if (!ab8500->mask) 1304 return -ENOMEM; 1305 ab8500->oldmask = kzalloc(ab8500->mask_size, GFP_KERNEL); 1306 if (!ab8500->oldmask) { 1307 ret = -ENOMEM; 1308 goto out_freemask; 1309 } 1310 /* 1311 * ab8500 has switched off due to (SWITCH_OFF_STATUS): 1312 * 0x01 Swoff bit programming 1313 * 0x02 Thermal protection activation 1314 * 0x04 Vbat lower then BattOk falling threshold 1315 * 0x08 Watchdog expired 1316 * 0x10 Non presence of 32kHz clock 1317 * 0x20 Battery level lower than power on reset threshold 1318 * 0x40 Power on key 1 pressed longer than 10 seconds 1319 * 0x80 DB8500 thermal shutdown 1320 */ 1321 1322 ret = get_register_interruptible(ab8500, AB8500_RTC, 1323 AB8500_SWITCH_OFF_STATUS, &value); 1324 if (ret < 0) 1325 return ret; 1326 dev_info(ab8500->dev, "switch off status: %#x", value); 1327 1328 if (plat && plat->init) 1329 plat->init(ab8500); 1330 1331 /* Clear and mask all interrupts */ 1332 for (i = 0; i < ab8500->mask_size; i++) { 1333 /* 1334 * Interrupt register 12 doesn't exist prior to AB8500 version 1335 * 2.0 1336 */ 1337 if (ab8500->irq_reg_offset[i] == 11 && 1338 is_ab8500_1p1_or_earlier(ab8500)) 1339 continue; 1340 1341 get_register_interruptible(ab8500, AB8500_INTERRUPT, 1342 AB8500_IT_LATCH1_REG + ab8500->irq_reg_offset[i], 1343 &value); 1344 set_register_interruptible(ab8500, AB8500_INTERRUPT, 1345 AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i], 0xff); 1346 } 1347 1348 ret = abx500_register_ops(ab8500->dev, &ab8500_ops); 1349 if (ret) 1350 goto out_freeoldmask; 1351 1352 for (i = 0; i < ab8500->mask_size; i++) 1353 ab8500->mask[i] = ab8500->oldmask[i] = 0xff; 1354 1355 if (ab8500->irq_base) { 1356 ret = ab8500_irq_init(ab8500); 1357 if (ret) 1358 goto out_freeoldmask; 1359 1360 /* Activate this feature only in ab9540 */ 1361 /* till tests are done on ab8500 1p2 or later*/ 1362 if (is_ab9540(ab8500)) 1363 ret = request_threaded_irq(ab8500->irq, NULL, 1364 ab8500_hierarchical_irq, 1365 IRQF_ONESHOT | IRQF_NO_SUSPEND, 1366 "ab8500", ab8500); 1367 else 1368 ret = request_threaded_irq(ab8500->irq, NULL, 1369 ab8500_irq, 1370 IRQF_ONESHOT | IRQF_NO_SUSPEND, 1371 "ab8500", ab8500); 1372 if (ret) 1373 goto out_removeirq; 1374 } 1375 1376 if (!np) { 1377 ret = mfd_add_devices(ab8500->dev, 0, abx500_common_devs, 1378 ARRAY_SIZE(abx500_common_devs), NULL, 1379 ab8500->irq_base); 1380 1381 if (ret) 1382 goto out_freeirq; 1383 1384 if (is_ab9540(ab8500)) 1385 ret = mfd_add_devices(ab8500->dev, 0, ab9540_devs, 1386 ARRAY_SIZE(ab9540_devs), NULL, 1387 ab8500->irq_base); 1388 else 1389 ret = mfd_add_devices(ab8500->dev, 0, ab8500_devs, 1390 ARRAY_SIZE(ab8500_devs), NULL, 1391 ab8500->irq_base); 1392 if (ret) 1393 goto out_freeirq; 1394 1395 if (is_ab9540(ab8500) || is_ab8505(ab8500)) 1396 ret = mfd_add_devices(ab8500->dev, 0, ab9540_ab8505_devs, 1397 ARRAY_SIZE(ab9540_ab8505_devs), NULL, 1398 ab8500->irq_base); 1399 if (ret) 1400 goto out_freeirq; 1401 } 1402 1403 if (!no_bm) { 1404 /* Add battery management devices */ 1405 ret = mfd_add_devices(ab8500->dev, 0, ab8500_bm_devs, 1406 ARRAY_SIZE(ab8500_bm_devs), NULL, 1407 ab8500->irq_base); 1408 if (ret) 1409 dev_err(ab8500->dev, "error adding bm devices\n"); 1410 } 1411 1412 if (is_ab9540(ab8500)) 1413 ret = sysfs_create_group(&ab8500->dev->kobj, 1414 &ab9540_attr_group); 1415 else 1416 ret = sysfs_create_group(&ab8500->dev->kobj, 1417 &ab8500_attr_group); 1418 if (ret) 1419 dev_err(ab8500->dev, "error creating sysfs entries\n"); 1420 else 1421 return ret; 1422 1423 out_freeirq: 1424 if (ab8500->irq_base) 1425 free_irq(ab8500->irq, ab8500); 1426 out_removeirq: 1427 if (ab8500->irq_base) 1428 ab8500_irq_remove(ab8500); 1429 out_freeoldmask: 1430 kfree(ab8500->oldmask); 1431 out_freemask: 1432 kfree(ab8500->mask); 1433 out_free_ab8500: 1434 kfree(ab8500); 1435 1436 return ret; 1437 } 1438 1439 static int __devexit ab8500_remove(struct platform_device *pdev) 1440 { 1441 struct ab8500 *ab8500 = platform_get_drvdata(pdev); 1442 1443 if (is_ab9540(ab8500)) 1444 sysfs_remove_group(&ab8500->dev->kobj, &ab9540_attr_group); 1445 else 1446 sysfs_remove_group(&ab8500->dev->kobj, &ab8500_attr_group); 1447 mfd_remove_devices(ab8500->dev); 1448 if (ab8500->irq_base) { 1449 free_irq(ab8500->irq, ab8500); 1450 ab8500_irq_remove(ab8500); 1451 } 1452 kfree(ab8500->oldmask); 1453 kfree(ab8500->mask); 1454 kfree(ab8500); 1455 1456 return 0; 1457 } 1458 1459 static const struct platform_device_id ab8500_id[] = { 1460 { "ab8500-core", AB8500_VERSION_AB8500 }, 1461 { "ab8505-i2c", AB8500_VERSION_AB8505 }, 1462 { "ab9540-i2c", AB8500_VERSION_AB9540 }, 1463 { "ab8540-i2c", AB8500_VERSION_AB8540 }, 1464 { } 1465 }; 1466 1467 static struct platform_driver ab8500_core_driver = { 1468 .driver = { 1469 .name = "ab8500-core", 1470 .owner = THIS_MODULE, 1471 .of_match_table = ab8500_match, 1472 }, 1473 .probe = ab8500_probe, 1474 .remove = __devexit_p(ab8500_remove), 1475 .id_table = ab8500_id, 1476 }; 1477 1478 static int __init ab8500_core_init(void) 1479 { 1480 return platform_driver_register(&ab8500_core_driver); 1481 } 1482 1483 static void __exit ab8500_core_exit(void) 1484 { 1485 platform_driver_unregister(&ab8500_core_driver); 1486 } 1487 arch_initcall(ab8500_core_init); 1488 module_exit(ab8500_core_exit); 1489 1490 MODULE_AUTHOR("Mattias Wallin, Srinidhi Kasagar, Rabin Vincent"); 1491 MODULE_DESCRIPTION("AB8500 MFD core"); 1492 MODULE_LICENSE("GPL v2"); 1493