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