drivers/mfd/ab8500-core.c

   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  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/slab.h>
  11 #include <linux/init.h>
  12 #include <linux/irq.h>
  13 #include <linux/delay.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/module.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/mfd/core.h>
  18 #include <linux/mfd/ab8500.h>
  19
  20 /*
  21  * Interrupt register offsets
  22  * Bank : 0x0E
  23  */
  24 #define AB8500_IT_SOURCE1_REG           0x0E00
  25 #define AB8500_IT_SOURCE2_REG           0x0E01
  26 #define AB8500_IT_SOURCE3_REG           0x0E02
  27 #define AB8500_IT_SOURCE4_REG           0x0E03
  28 #define AB8500_IT_SOURCE5_REG           0x0E04
  29 #define AB8500_IT_SOURCE6_REG           0x0E05
  30 #define AB8500_IT_SOURCE7_REG           0x0E06
  31 #define AB8500_IT_SOURCE8_REG           0x0E07
  32 #define AB8500_IT_SOURCE19_REG          0x0E12
  33 #define AB8500_IT_SOURCE20_REG          0x0E13
  34 #define AB8500_IT_SOURCE21_REG          0x0E14
  35 #define AB8500_IT_SOURCE22_REG          0x0E15
  36 #define AB8500_IT_SOURCE23_REG          0x0E16
  37 #define AB8500_IT_SOURCE24_REG          0x0E17
  38
  39 /*
  40  * latch registers
  41  */
  42 #define AB8500_IT_LATCH1_REG            0x0E20
  43 #define AB8500_IT_LATCH2_REG            0x0E21
  44 #define AB8500_IT_LATCH3_REG            0x0E22
  45 #define AB8500_IT_LATCH4_REG            0x0E23
  46 #define AB8500_IT_LATCH5_REG            0x0E24
  47 #define AB8500_IT_LATCH6_REG            0x0E25
  48 #define AB8500_IT_LATCH7_REG            0x0E26
  49 #define AB8500_IT_LATCH8_REG            0x0E27
  50 #define AB8500_IT_LATCH9_REG            0x0E28
  51 #define AB8500_IT_LATCH10_REG           0x0E29
  52 #define AB8500_IT_LATCH19_REG           0x0E32
  53 #define AB8500_IT_LATCH20_REG           0x0E33
  54 #define AB8500_IT_LATCH21_REG           0x0E34
  55 #define AB8500_IT_LATCH22_REG           0x0E35
  56 #define AB8500_IT_LATCH23_REG           0x0E36
  57 #define AB8500_IT_LATCH24_REG           0x0E37
  58
  59 /*
  60  * mask registers
  61  */
  62
  63 #define AB8500_IT_MASK1_REG             0x0E40
  64 #define AB8500_IT_MASK2_REG             0x0E41
  65 #define AB8500_IT_MASK3_REG             0x0E42
  66 #define AB8500_IT_MASK4_REG             0x0E43
  67 #define AB8500_IT_MASK5_REG             0x0E44
  68 #define AB8500_IT_MASK6_REG             0x0E45
  69 #define AB8500_IT_MASK7_REG             0x0E46
  70 #define AB8500_IT_MASK8_REG             0x0E47
  71 #define AB8500_IT_MASK9_REG             0x0E48
  72 #define AB8500_IT_MASK10_REG            0x0E49
  73 #define AB8500_IT_MASK11_REG            0x0E4A
  74 #define AB8500_IT_MASK12_REG            0x0E4B
  75 #define AB8500_IT_MASK13_REG            0x0E4C
  76 #define AB8500_IT_MASK14_REG            0x0E4D
  77 #define AB8500_IT_MASK15_REG            0x0E4E
  78 #define AB8500_IT_MASK16_REG            0x0E4F
  79 #define AB8500_IT_MASK17_REG            0x0E50
  80 #define AB8500_IT_MASK18_REG            0x0E51
  81 #define AB8500_IT_MASK19_REG            0x0E52
  82 #define AB8500_IT_MASK20_REG            0x0E53
  83 #define AB8500_IT_MASK21_REG            0x0E54
  84 #define AB8500_IT_MASK22_REG            0x0E55
  85 #define AB8500_IT_MASK23_REG            0x0E56
  86 #define AB8500_IT_MASK24_REG            0x0E57
  87
  88 #define AB8500_REV_REG                  0x1080
  89
  90 /*
  91  * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt
  92  * numbers are indexed into this array with (num / 8).
  93  *
  94  * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at
  95  * offset 0.
  96  */
  97 static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
  98         0, 1, 2, 3, 4, 6, 7, 8, 9, 18, 19, 20, 21,
  99 };
 100
 101 static int __ab8500_write(struct ab8500 *ab8500, u16 addr, u8 data)
 102 {
 103         int ret;
 104
 105         dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);
 106
 107         ret = ab8500->write(ab8500, addr, data);
 108         if (ret < 0)
 109                 dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
 110                         addr, ret);
 111
 112         return ret;
 113 }
 114
 115 /**
 116  * ab8500_write() - write an AB8500 register
 117  * @ab8500: device to write to
 118  * @addr: address of the register
 119  * @data: value to write
 120  */
 121 int ab8500_write(struct ab8500 *ab8500, u16 addr, u8 data)
 122 {
 123         int ret;
 124
 125         mutex_lock(&ab8500->lock);
 126         ret = __ab8500_write(ab8500, addr, data);
 127         mutex_unlock(&ab8500->lock);
 128
 129         return ret;
 130 }
 131 EXPORT_SYMBOL_GPL(ab8500_write);
 132
 133 static int __ab8500_read(struct ab8500 *ab8500, u16 addr)
 134 {
 135         int ret;
 136
 137         ret = ab8500->read(ab8500, addr);
 138         if (ret < 0)
 139                 dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
 140                         addr, ret);
 141
 142         dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
 143
 144         return ret;
 145 }
 146
 147 /**
 148  * ab8500_read() - read an AB8500 register
 149  * @ab8500: device to read from
 150  * @addr: address of the register
 151  */
 152 int ab8500_read(struct ab8500 *ab8500, u16 addr)
 153 {
 154         int ret;
 155
 156         mutex_lock(&ab8500->lock);
 157         ret = __ab8500_read(ab8500, addr);
 158         mutex_unlock(&ab8500->lock);
 159
 160         return ret;
 161 }
 162 EXPORT_SYMBOL_GPL(ab8500_read);
 163
 164 /**
 165  * ab8500_set_bits() - set a bitfield in an AB8500 register
 166  * @ab8500: device to read from
 167  * @addr: address of the register
 168  * @mask: mask of the bitfield to modify
 169  * @data: value to set to the bitfield
 170  */
 171 int ab8500_set_bits(struct ab8500 *ab8500, u16 addr, u8 mask, u8 data)
 172 {
 173         int ret;
 174
 175         mutex_lock(&ab8500->lock);
 176
 177         ret = __ab8500_read(ab8500, addr);
 178         if (ret < 0)
 179                 goto out;
 180
 181         ret &= ~mask;
 182         ret |= data;
 183
 184         ret = __ab8500_write(ab8500, addr, ret);
 185
 186 out:
 187         mutex_unlock(&ab8500->lock);
 188         return ret;
 189 }
 190 EXPORT_SYMBOL_GPL(ab8500_set_bits);
 191
 192 static void ab8500_irq_lock(unsigned int irq)
 193 {
 194         struct ab8500 *ab8500 = get_irq_chip_data(irq);
 195
 196         mutex_lock(&ab8500->irq_lock);
 197 }
 198
 199 static void ab8500_irq_sync_unlock(unsigned int irq)
 200 {
 201         struct ab8500 *ab8500 = get_irq_chip_data(irq);
 202         int i;
 203
 204         for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
 205                 u8 old = ab8500->oldmask[i];
 206                 u8 new = ab8500->mask[i];
 207                 int reg;
 208
 209                 if (new == old)
 210                         continue;
 211
 212                 ab8500->oldmask[i] = new;
 213
 214                 reg = AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i];
 215                 ab8500_write(ab8500, reg, new);
 216         }
 217
 218         mutex_unlock(&ab8500->irq_lock);
 219 }
 220
 221 static void ab8500_irq_mask(unsigned int irq)
 222 {
 223         struct ab8500 *ab8500 = get_irq_chip_data(irq);
 224         int offset = irq - ab8500->irq_base;
 225         int index = offset / 8;
 226         int mask = 1 << (offset % 8);
 227
 228         ab8500->mask[index] |= mask;
 229 }
 230
 231 static void ab8500_irq_unmask(unsigned int irq)
 232 {
 233         struct ab8500 *ab8500 = get_irq_chip_data(irq);
 234         int offset = irq - ab8500->irq_base;
 235         int index = offset / 8;
 236         int mask = 1 << (offset % 8);
 237
 238         ab8500->mask[index] &= ~mask;
 239 }
 240
 241 static struct irq_chip ab8500_irq_chip = {
 242         .name                   = "ab8500",
 243         .bus_lock               = ab8500_irq_lock,
 244         .bus_sync_unlock        = ab8500_irq_sync_unlock,
 245         .mask                   = ab8500_irq_mask,
 246         .unmask                 = ab8500_irq_unmask,
 247 };
 248
 249 static irqreturn_t ab8500_irq(int irq, void *dev)
 250 {
 251         struct ab8500 *ab8500 = dev;
 252         int i;
 253
 254         dev_vdbg(ab8500->dev, "interrupt\n");
 255
 256         for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
 257                 int regoffset = ab8500_irq_regoffset[i];
 258                 int status;
 259
 260                 status = ab8500_read(ab8500, AB8500_IT_LATCH1_REG + regoffset);
 261                 if (status <= 0)
 262                         continue;
 263
 264                 do {
 265                         int bit = __ffs(status);
 266                         int line = i * 8 + bit;
 267
 268                         handle_nested_irq(ab8500->irq_base + line);
 269                         status &= ~(1 << bit);
 270                 } while (status);
 271         }
 272
 273         return IRQ_HANDLED;
 274 }
 275
 276 static int ab8500_irq_init(struct ab8500 *ab8500)
 277 {
 278         int base = ab8500->irq_base;
 279         int irq;
 280
 281         for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {
 282                 set_irq_chip_data(irq, ab8500);
 283                 set_irq_chip_and_handler(irq, &ab8500_irq_chip,
 284                                          handle_simple_irq);
 285                 set_irq_nested_thread(irq, 1);
 286 #ifdef CONFIG_ARM
 287                 set_irq_flags(irq, IRQF_VALID);
 288 #else
 289                 set_irq_noprobe(irq);
 290 #endif
 291         }
 292
 293         return 0;
 294 }
 295
 296 static void ab8500_irq_remove(struct ab8500 *ab8500)
 297 {
 298         int base = ab8500->irq_base;
 299         int irq;
 300
 301         for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {
 302 #ifdef CONFIG_ARM
 303                 set_irq_flags(irq, 0);
 304 #endif
 305                 set_irq_chip_and_handler(irq, NULL, NULL);
 306                 set_irq_chip_data(irq, NULL);
 307         }
 308 }
 309
 310 static struct resource ab8500_gpadc_resources[] = {
 311         {
 312                 .name   = "HW_CONV_END",
 313                 .start  = AB8500_INT_GP_HW_ADC_CONV_END,
 314                 .end    = AB8500_INT_GP_HW_ADC_CONV_END,
 315                 .flags  = IORESOURCE_IRQ,
 316         },
 317         {
 318                 .name   = "SW_CONV_END",
 319                 .start  = AB8500_INT_GP_SW_ADC_CONV_END,
 320                 .end    = AB8500_INT_GP_SW_ADC_CONV_END,
 321                 .flags  = IORESOURCE_IRQ,
 322         },
 323 };
 324
 325 static struct resource ab8500_rtc_resources[] = {
 326         {
 327                 .name   = "60S",
 328                 .start  = AB8500_INT_RTC_60S,
 329                 .end    = AB8500_INT_RTC_60S,
 330                 .flags  = IORESOURCE_IRQ,
 331         },
 332         {
 333                 .name   = "ALARM",
 334                 .start  = AB8500_INT_RTC_ALARM,
 335                 .end    = AB8500_INT_RTC_ALARM,
 336                 .flags  = IORESOURCE_IRQ,
 337         },
 338 };
 339
 340 static struct mfd_cell ab8500_devs[] = {
 341         {
 342                 .name = "ab8500-gpadc",
 343                 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
 344                 .resources = ab8500_gpadc_resources,
 345         },
 346         {
 347                 .name = "ab8500-rtc",
 348                 .num_resources = ARRAY_SIZE(ab8500_rtc_resources),
 349                 .resources = ab8500_rtc_resources,
 350         },
 351         { .name = "ab8500-charger", },
 352         { .name = "ab8500-audio", },
 353         { .name = "ab8500-usb", },
 354         { .name = "ab8500-pwm", },
 355 };
 356
 357 int __devinit ab8500_init(struct ab8500 *ab8500)
 358 {
 359         struct ab8500_platform_data *plat = dev_get_platdata(ab8500->dev);
 360         int ret;
 361         int i;
 362
 363         if (plat)
 364                 ab8500->irq_base = plat->irq_base;
 365
 366         mutex_init(&ab8500->lock);
 367         mutex_init(&ab8500->irq_lock);
 368
 369         ret = ab8500_read(ab8500, AB8500_REV_REG);
 370         if (ret < 0)
 371                 return ret;
 372
 373         /*
 374          * 0x0 - Early Drop
 375          * 0x10 - Cut 1.0
 376          * 0x11 - Cut 1.1
 377          */
 378         if (ret == 0x0 || ret == 0x10 || ret == 0x11) {
 379                 ab8500->revision = ret;
 380                 dev_info(ab8500->dev, "detected chip, revision: %#x\n", ret);
 381         } else {
 382                 dev_err(ab8500->dev, "unknown chip, revision: %#x\n", ret);
 383                 return -EINVAL;
 384         }
 385
 386         if (plat && plat->init)
 387                 plat->init(ab8500);
 388
 389         /* Clear and mask all interrupts */
 390         for (i = 0; i < 10; i++) {
 391                 ab8500_read(ab8500, AB8500_IT_LATCH1_REG + i);
 392                 ab8500_write(ab8500, AB8500_IT_MASK1_REG + i, 0xff);
 393         }
 394
 395         for (i = 18; i < 24; i++) {
 396                 ab8500_read(ab8500, AB8500_IT_LATCH1_REG + i);
 397                 ab8500_write(ab8500, AB8500_IT_MASK1_REG + i, 0xff);
 398         }
 399
 400         for (i = 0; i < AB8500_NUM_IRQ_REGS; i++)
 401                 ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
 402
 403         if (ab8500->irq_base) {
 404                 ret = ab8500_irq_init(ab8500);
 405                 if (ret)
 406                         return ret;
 407
 408                 ret = request_threaded_irq(ab8500->irq, NULL, ab8500_irq,
 409                                            IRQF_ONESHOT, "ab8500", ab8500);
 410                 if (ret)
 411                         goto out_removeirq;
 412         }
 413
 414         ret = mfd_add_devices(ab8500->dev, -1, ab8500_devs,
 415                               ARRAY_SIZE(ab8500_devs), NULL,
 416                               ab8500->irq_base);
 417         if (ret)
 418                 goto out_freeirq;
 419
 420         return ret;
 421
 422 out_freeirq:
 423         if (ab8500->irq_base) {
 424                 free_irq(ab8500->irq, ab8500);
 425 out_removeirq:
 426                 ab8500_irq_remove(ab8500);
 427         }
 428         return ret;
 429 }
 430
 431 int __devexit ab8500_exit(struct ab8500 *ab8500)
 432 {
 433         mfd_remove_devices(ab8500->dev);
 434         if (ab8500->irq_base) {
 435                 free_irq(ab8500->irq, ab8500);
 436                 ab8500_irq_remove(ab8500);
 437         }
 438
 439         return 0;
 440 }
 441
 442 MODULE_AUTHOR("Srinidhi Kasagar, Rabin Vincent");
 443 MODULE_DESCRIPTION("AB8500 MFD core");
 444 MODULE_LICENSE("GPL v2");