Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) ST-Ericsson SA 2010
0004  *
0005  * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
0006  * Author: Rabin Vincent <rabin.vincent@stericsson.com>
0007  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/slab.h>
0012 #include <linux/init.h>
0013 #include <linux/irq.h>
0014 #include <linux/irqdomain.h>
0015 #include <linux/delay.h>
0016 #include <linux/interrupt.h>
0017 #include <linux/moduleparam.h>
0018 #include <linux/platform_device.h>
0019 #include <linux/mfd/core.h>
0020 #include <linux/mfd/abx500.h>
0021 #include <linux/mfd/abx500/ab8500.h>
0022 #include <linux/mfd/dbx500-prcmu.h>
0023 #include <linux/of.h>
0024 #include <linux/of_device.h>
0025 
0026 /*
0027  * Interrupt register offsets
0028  * Bank : 0x0E
0029  */
0030 #define AB8500_IT_SOURCE1_REG       0x00
0031 #define AB8500_IT_SOURCE2_REG       0x01
0032 #define AB8500_IT_SOURCE3_REG       0x02
0033 #define AB8500_IT_SOURCE4_REG       0x03
0034 #define AB8500_IT_SOURCE5_REG       0x04
0035 #define AB8500_IT_SOURCE6_REG       0x05
0036 #define AB8500_IT_SOURCE7_REG       0x06
0037 #define AB8500_IT_SOURCE8_REG       0x07
0038 #define AB9540_IT_SOURCE13_REG      0x0C
0039 #define AB8500_IT_SOURCE19_REG      0x12
0040 #define AB8500_IT_SOURCE20_REG      0x13
0041 #define AB8500_IT_SOURCE21_REG      0x14
0042 #define AB8500_IT_SOURCE22_REG      0x15
0043 #define AB8500_IT_SOURCE23_REG      0x16
0044 #define AB8500_IT_SOURCE24_REG      0x17
0045 
0046 /*
0047  * latch registers
0048  */
0049 #define AB8500_IT_LATCH1_REG        0x20
0050 #define AB8500_IT_LATCH2_REG        0x21
0051 #define AB8500_IT_LATCH3_REG        0x22
0052 #define AB8500_IT_LATCH4_REG        0x23
0053 #define AB8500_IT_LATCH5_REG        0x24
0054 #define AB8500_IT_LATCH6_REG        0x25
0055 #define AB8500_IT_LATCH7_REG        0x26
0056 #define AB8500_IT_LATCH8_REG        0x27
0057 #define AB8500_IT_LATCH9_REG        0x28
0058 #define AB8500_IT_LATCH10_REG       0x29
0059 #define AB8500_IT_LATCH12_REG       0x2B
0060 #define AB9540_IT_LATCH13_REG       0x2C
0061 #define AB8500_IT_LATCH19_REG       0x32
0062 #define AB8500_IT_LATCH20_REG       0x33
0063 #define AB8500_IT_LATCH21_REG       0x34
0064 #define AB8500_IT_LATCH22_REG       0x35
0065 #define AB8500_IT_LATCH23_REG       0x36
0066 #define AB8500_IT_LATCH24_REG       0x37
0067 
0068 /*
0069  * mask registers
0070  */
0071 
0072 #define AB8500_IT_MASK1_REG     0x40
0073 #define AB8500_IT_MASK2_REG     0x41
0074 #define AB8500_IT_MASK3_REG     0x42
0075 #define AB8500_IT_MASK4_REG     0x43
0076 #define AB8500_IT_MASK5_REG     0x44
0077 #define AB8500_IT_MASK6_REG     0x45
0078 #define AB8500_IT_MASK7_REG     0x46
0079 #define AB8500_IT_MASK8_REG     0x47
0080 #define AB8500_IT_MASK9_REG     0x48
0081 #define AB8500_IT_MASK10_REG        0x49
0082 #define AB8500_IT_MASK11_REG        0x4A
0083 #define AB8500_IT_MASK12_REG        0x4B
0084 #define AB8500_IT_MASK13_REG        0x4C
0085 #define AB8500_IT_MASK14_REG        0x4D
0086 #define AB8500_IT_MASK15_REG        0x4E
0087 #define AB8500_IT_MASK16_REG        0x4F
0088 #define AB8500_IT_MASK17_REG        0x50
0089 #define AB8500_IT_MASK18_REG        0x51
0090 #define AB8500_IT_MASK19_REG        0x52
0091 #define AB8500_IT_MASK20_REG        0x53
0092 #define AB8500_IT_MASK21_REG        0x54
0093 #define AB8500_IT_MASK22_REG        0x55
0094 #define AB8500_IT_MASK23_REG        0x56
0095 #define AB8500_IT_MASK24_REG        0x57
0096 #define AB8500_IT_MASK25_REG        0x58
0097 
0098 /*
0099  * latch hierarchy registers
0100  */
0101 #define AB8500_IT_LATCHHIER1_REG    0x60
0102 #define AB8500_IT_LATCHHIER2_REG    0x61
0103 #define AB8500_IT_LATCHHIER3_REG    0x62
0104 #define AB8540_IT_LATCHHIER4_REG    0x63
0105 
0106 #define AB8500_IT_LATCHHIER_NUM     3
0107 #define AB8540_IT_LATCHHIER_NUM     4
0108 
0109 #define AB8500_REV_REG          0x80
0110 #define AB8500_IC_NAME_REG      0x82
0111 #define AB8500_SWITCH_OFF_STATUS    0x00
0112 
0113 #define AB8500_TURN_ON_STATUS       0x00
0114 #define AB8505_TURN_ON_STATUS_2     0x04
0115 
0116 #define AB8500_CH_USBCH_STAT1_REG   0x02
0117 #define VBUS_DET_DBNC100        0x02
0118 #define VBUS_DET_DBNC1          0x01
0119 
0120 static DEFINE_SPINLOCK(on_stat_lock);
0121 static u8 turn_on_stat_mask = 0xFF;
0122 static u8 turn_on_stat_set;
0123 
0124 #define AB9540_MODEM_CTRL2_REG          0x23
0125 #define AB9540_MODEM_CTRL2_SWDBBRSTN_BIT    BIT(2)
0126 
0127 /*
0128  * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt
0129  * numbers are indexed into this array with (num / 8). The interupts are
0130  * defined in linux/mfd/ab8500.h
0131  *
0132  * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at
0133  * offset 0.
0134  */
0135 /* AB8500 support */
0136 static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
0137     0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21,
0138 };
0139 
0140 /* AB9540 / AB8505 support */
0141 static const int ab9540_irq_regoffset[AB9540_NUM_IRQ_REGS] = {
0142     0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21, 12, 13, 24, 5, 22, 23
0143 };
0144 
0145 /* AB8540 support */
0146 static const int ab8540_irq_regoffset[AB8540_NUM_IRQ_REGS] = {
0147     0, 1, 2, 3, 4, -1, -1, -1, -1, 11, 18, 19, 20, 21, 12, 13, 24, 5, 22,
0148     23, 25, 26, 27, 28, 29, 30, 31,
0149 };
0150 
0151 static const char ab8500_version_str[][7] = {
0152     [AB8500_VERSION_AB8500] = "AB8500",
0153     [AB8500_VERSION_AB8505] = "AB8505",
0154     [AB8500_VERSION_AB9540] = "AB9540",
0155     [AB8500_VERSION_AB8540] = "AB8540",
0156 };
0157 
0158 static int ab8500_prcmu_write(struct ab8500 *ab8500, u16 addr, u8 data)
0159 {
0160     int ret;
0161 
0162     ret = prcmu_abb_write((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
0163     if (ret < 0)
0164         dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
0165     return ret;
0166 }
0167 
0168 static int ab8500_prcmu_write_masked(struct ab8500 *ab8500, u16 addr, u8 mask,
0169     u8 data)
0170 {
0171     int ret;
0172 
0173     ret = prcmu_abb_write_masked((u8)(addr >> 8), (u8)(addr & 0xFF), &data,
0174         &mask, 1);
0175     if (ret < 0)
0176         dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
0177     return ret;
0178 }
0179 
0180 static int ab8500_prcmu_read(struct ab8500 *ab8500, u16 addr)
0181 {
0182     int ret;
0183     u8 data;
0184 
0185     ret = prcmu_abb_read((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
0186     if (ret < 0) {
0187         dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
0188         return ret;
0189     }
0190     return (int)data;
0191 }
0192 
0193 static int ab8500_get_chip_id(struct device *dev)
0194 {
0195     struct ab8500 *ab8500;
0196 
0197     if (!dev)
0198         return -EINVAL;
0199     ab8500 = dev_get_drvdata(dev->parent);
0200     return ab8500 ? (int)ab8500->chip_id : -EINVAL;
0201 }
0202 
0203 static int set_register_interruptible(struct ab8500 *ab8500, u8 bank,
0204     u8 reg, u8 data)
0205 {
0206     int ret;
0207     /*
0208      * Put the u8 bank and u8 register together into a an u16.
0209      * The bank on higher 8 bits and register in lower 8 bits.
0210      */
0211     u16 addr = ((u16)bank) << 8 | reg;
0212 
0213     dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);
0214 
0215     mutex_lock(&ab8500->lock);
0216 
0217     ret = ab8500->write(ab8500, addr, data);
0218     if (ret < 0)
0219         dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
0220             addr, ret);
0221     mutex_unlock(&ab8500->lock);
0222 
0223     return ret;
0224 }
0225 
0226 static int ab8500_set_register(struct device *dev, u8 bank,
0227     u8 reg, u8 value)
0228 {
0229     int ret;
0230     struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
0231 
0232     atomic_inc(&ab8500->transfer_ongoing);
0233     ret = set_register_interruptible(ab8500, bank, reg, value);
0234     atomic_dec(&ab8500->transfer_ongoing);
0235     return ret;
0236 }
0237 
0238 static int get_register_interruptible(struct ab8500 *ab8500, u8 bank,
0239     u8 reg, u8 *value)
0240 {
0241     int ret;
0242     u16 addr = ((u16)bank) << 8 | reg;
0243 
0244     mutex_lock(&ab8500->lock);
0245 
0246     ret = ab8500->read(ab8500, addr);
0247     if (ret < 0)
0248         dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
0249             addr, ret);
0250     else
0251         *value = ret;
0252 
0253     mutex_unlock(&ab8500->lock);
0254     dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
0255 
0256     return (ret < 0) ? ret : 0;
0257 }
0258 
0259 static int ab8500_get_register(struct device *dev, u8 bank,
0260     u8 reg, u8 *value)
0261 {
0262     int ret;
0263     struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
0264 
0265     atomic_inc(&ab8500->transfer_ongoing);
0266     ret = get_register_interruptible(ab8500, bank, reg, value);
0267     atomic_dec(&ab8500->transfer_ongoing);
0268     return ret;
0269 }
0270 
0271 static int mask_and_set_register_interruptible(struct ab8500 *ab8500, u8 bank,
0272     u8 reg, u8 bitmask, u8 bitvalues)
0273 {
0274     int ret;
0275     u16 addr = ((u16)bank) << 8 | reg;
0276 
0277     mutex_lock(&ab8500->lock);
0278 
0279     if (ab8500->write_masked == NULL) {
0280         u8 data;
0281 
0282         ret = ab8500->read(ab8500, addr);
0283         if (ret < 0) {
0284             dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
0285                 addr, ret);
0286             goto out;
0287         }
0288 
0289         data = (u8)ret;
0290         data = (~bitmask & data) | (bitmask & bitvalues);
0291 
0292         ret = ab8500->write(ab8500, addr, data);
0293         if (ret < 0)
0294             dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
0295                 addr, ret);
0296 
0297         dev_vdbg(ab8500->dev, "mask: addr %#x => data %#x\n", addr,
0298             data);
0299         goto out;
0300     }
0301     ret = ab8500->write_masked(ab8500, addr, bitmask, bitvalues);
0302     if (ret < 0)
0303         dev_err(ab8500->dev, "failed to modify reg %#x: %d\n", addr,
0304             ret);
0305 out:
0306     mutex_unlock(&ab8500->lock);
0307     return ret;
0308 }
0309 
0310 static int ab8500_mask_and_set_register(struct device *dev,
0311     u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
0312 {
0313     int ret;
0314     struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
0315 
0316     atomic_inc(&ab8500->transfer_ongoing);
0317     ret = mask_and_set_register_interruptible(ab8500, bank, reg,
0318                          bitmask, bitvalues);
0319     atomic_dec(&ab8500->transfer_ongoing);
0320     return ret;
0321 }
0322 
0323 static struct abx500_ops ab8500_ops = {
0324     .get_chip_id = ab8500_get_chip_id,
0325     .get_register = ab8500_get_register,
0326     .set_register = ab8500_set_register,
0327     .get_register_page = NULL,
0328     .set_register_page = NULL,
0329     .mask_and_set_register = ab8500_mask_and_set_register,
0330     .event_registers_startup_state_get = NULL,
0331     .startup_irq_enabled = NULL,
0332     .dump_all_banks = ab8500_dump_all_banks,
0333 };
0334 
0335 static void ab8500_irq_lock(struct irq_data *data)
0336 {
0337     struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
0338 
0339     mutex_lock(&ab8500->irq_lock);
0340     atomic_inc(&ab8500->transfer_ongoing);
0341 }
0342 
0343 static void ab8500_irq_sync_unlock(struct irq_data *data)
0344 {
0345     struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
0346     int i;
0347 
0348     for (i = 0; i < ab8500->mask_size; i++) {
0349         u8 old = ab8500->oldmask[i];
0350         u8 new = ab8500->mask[i];
0351         int reg;
0352 
0353         if (new == old)
0354             continue;
0355 
0356         /*
0357          * Interrupt register 12 doesn't exist prior to AB8500 version
0358          * 2.0
0359          */
0360         if (ab8500->irq_reg_offset[i] == 11 &&
0361             is_ab8500_1p1_or_earlier(ab8500))
0362             continue;
0363 
0364         if (ab8500->irq_reg_offset[i] < 0)
0365             continue;
0366 
0367         ab8500->oldmask[i] = new;
0368 
0369         reg = AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i];
0370         set_register_interruptible(ab8500, AB8500_INTERRUPT, reg, new);
0371     }
0372     atomic_dec(&ab8500->transfer_ongoing);
0373     mutex_unlock(&ab8500->irq_lock);
0374 }
0375 
0376 static void ab8500_irq_mask(struct irq_data *data)
0377 {
0378     struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
0379     int offset = data->hwirq;
0380     int index = offset / 8;
0381     int mask = 1 << (offset % 8);
0382 
0383     ab8500->mask[index] |= mask;
0384 
0385     /* The AB8500 GPIOs have two interrupts each (rising & falling). */
0386     if (offset >= AB8500_INT_GPIO6R && offset <= AB8500_INT_GPIO41R)
0387         ab8500->mask[index + 2] |= mask;
0388     if (offset >= AB9540_INT_GPIO50R && offset <= AB9540_INT_GPIO54R)
0389         ab8500->mask[index + 1] |= mask;
0390     if (offset == AB8540_INT_GPIO43R || offset == AB8540_INT_GPIO44R)
0391         /* Here the falling IRQ is one bit lower */
0392         ab8500->mask[index] |= (mask << 1);
0393 }
0394 
0395 static void ab8500_irq_unmask(struct irq_data *data)
0396 {
0397     struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
0398     unsigned int type = irqd_get_trigger_type(data);
0399     int offset = data->hwirq;
0400     int index = offset / 8;
0401     int mask = 1 << (offset % 8);
0402 
0403     if (type & IRQ_TYPE_EDGE_RISING)
0404         ab8500->mask[index] &= ~mask;
0405 
0406     /* The AB8500 GPIOs have two interrupts each (rising & falling). */
0407     if (type & IRQ_TYPE_EDGE_FALLING) {
0408         if (offset >= AB8500_INT_GPIO6R && offset <= AB8500_INT_GPIO41R)
0409             ab8500->mask[index + 2] &= ~mask;
0410         else if (offset >= AB9540_INT_GPIO50R &&
0411              offset <= AB9540_INT_GPIO54R)
0412             ab8500->mask[index + 1] &= ~mask;
0413         else if (offset == AB8540_INT_GPIO43R ||
0414              offset == AB8540_INT_GPIO44R)
0415             /* Here the falling IRQ is one bit lower */
0416             ab8500->mask[index] &= ~(mask << 1);
0417         else
0418             ab8500->mask[index] &= ~mask;
0419     } else {
0420         /* Satisfies the case where type is not set. */
0421         ab8500->mask[index] &= ~mask;
0422     }
0423 }
0424 
0425 static int ab8500_irq_set_type(struct irq_data *data, unsigned int type)
0426 {
0427     return 0;
0428 }
0429 
0430 static struct irq_chip ab8500_irq_chip = {
0431     .name           = "ab8500",
0432     .irq_bus_lock       = ab8500_irq_lock,
0433     .irq_bus_sync_unlock    = ab8500_irq_sync_unlock,
0434     .irq_mask       = ab8500_irq_mask,
0435     .irq_disable        = ab8500_irq_mask,
0436     .irq_unmask     = ab8500_irq_unmask,
0437     .irq_set_type       = ab8500_irq_set_type,
0438 };
0439 
0440 static void update_latch_offset(u8 *offset, int i)
0441 {
0442     /* Fix inconsistent ITFromLatch25 bit mapping... */
0443     if (unlikely(*offset == 17))
0444         *offset = 24;
0445     /* Fix inconsistent ab8540 bit mapping... */
0446     if (unlikely(*offset == 16))
0447         *offset = 25;
0448     if ((i == 3) && (*offset >= 24))
0449         *offset += 2;
0450 }
0451 
0452 static int ab8500_handle_hierarchical_line(struct ab8500 *ab8500,
0453                     int latch_offset, u8 latch_val)
0454 {
0455     int int_bit, line, i;
0456 
0457     for (i = 0; i < ab8500->mask_size; i++)
0458         if (ab8500->irq_reg_offset[i] == latch_offset)
0459             break;
0460 
0461     if (i >= ab8500->mask_size) {
0462         dev_err(ab8500->dev, "Register offset 0x%2x not declared\n",
0463                 latch_offset);
0464         return -ENXIO;
0465     }
0466 
0467     /* ignore masked out interrupts */
0468     latch_val &= ~ab8500->mask[i];
0469 
0470     while (latch_val) {
0471         int_bit = __ffs(latch_val);
0472         line = (i << 3) + int_bit;
0473         latch_val &= ~(1 << int_bit);
0474 
0475         /*
0476          * This handles the falling edge hwirqs from the GPIO
0477          * lines. Route them back to the line registered for the
0478          * rising IRQ, as this is merely a flag for the same IRQ
0479          * in linux terms.
0480          */
0481         if (line >= AB8500_INT_GPIO6F && line <= AB8500_INT_GPIO41F)
0482             line -= 16;
0483         if (line >= AB9540_INT_GPIO50F && line <= AB9540_INT_GPIO54F)
0484             line -= 8;
0485         if (line == AB8540_INT_GPIO43F || line == AB8540_INT_GPIO44F)
0486             line += 1;
0487 
0488         handle_nested_irq(irq_find_mapping(ab8500->domain, line));
0489     }
0490 
0491     return 0;
0492 }
0493 
0494 static int ab8500_handle_hierarchical_latch(struct ab8500 *ab8500,
0495                     int hier_offset, u8 hier_val)
0496 {
0497     int latch_bit, status;
0498     u8 latch_offset, latch_val;
0499 
0500     do {
0501         latch_bit = __ffs(hier_val);
0502         latch_offset = (hier_offset << 3) + latch_bit;
0503 
0504         update_latch_offset(&latch_offset, hier_offset);
0505 
0506         status = get_register_interruptible(ab8500,
0507                 AB8500_INTERRUPT,
0508                 AB8500_IT_LATCH1_REG + latch_offset,
0509                 &latch_val);
0510         if (status < 0 || latch_val == 0)
0511             goto discard;
0512 
0513         status = ab8500_handle_hierarchical_line(ab8500,
0514                 latch_offset, latch_val);
0515         if (status < 0)
0516             return status;
0517 discard:
0518         hier_val &= ~(1 << latch_bit);
0519     } while (hier_val);
0520 
0521     return 0;
0522 }
0523 
0524 static irqreturn_t ab8500_hierarchical_irq(int irq, void *dev)
0525 {
0526     struct ab8500 *ab8500 = dev;
0527     u8 i;
0528 
0529     dev_vdbg(ab8500->dev, "interrupt\n");
0530 
0531     /*  Hierarchical interrupt version */
0532     for (i = 0; i < (ab8500->it_latchhier_num); i++) {
0533         int status;
0534         u8 hier_val;
0535 
0536         status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
0537             AB8500_IT_LATCHHIER1_REG + i, &hier_val);
0538         if (status < 0 || hier_val == 0)
0539             continue;
0540 
0541         status = ab8500_handle_hierarchical_latch(ab8500, i, hier_val);
0542         if (status < 0)
0543             break;
0544     }
0545     return IRQ_HANDLED;
0546 }
0547 
0548 static int ab8500_irq_map(struct irq_domain *d, unsigned int virq,
0549                 irq_hw_number_t hwirq)
0550 {
0551     struct ab8500 *ab8500 = d->host_data;
0552 
0553     if (!ab8500)
0554         return -EINVAL;
0555 
0556     irq_set_chip_data(virq, ab8500);
0557     irq_set_chip_and_handler(virq, &ab8500_irq_chip,
0558                 handle_simple_irq);
0559     irq_set_nested_thread(virq, 1);
0560     irq_set_noprobe(virq);
0561 
0562     return 0;
0563 }
0564 
0565 static const struct irq_domain_ops ab8500_irq_ops = {
0566     .map    = ab8500_irq_map,
0567     .xlate  = irq_domain_xlate_twocell,
0568 };
0569 
0570 static int ab8500_irq_init(struct ab8500 *ab8500, struct device_node *np)
0571 {
0572     int num_irqs;
0573 
0574     if (is_ab8540(ab8500))
0575         num_irqs = AB8540_NR_IRQS;
0576     else if (is_ab9540(ab8500))
0577         num_irqs = AB9540_NR_IRQS;
0578     else if (is_ab8505(ab8500))
0579         num_irqs = AB8505_NR_IRQS;
0580     else
0581         num_irqs = AB8500_NR_IRQS;
0582 
0583     /* If ->irq_base is zero this will give a linear mapping */
0584     ab8500->domain = irq_domain_add_simple(ab8500->dev->of_node,
0585                            num_irqs, 0,
0586                            &ab8500_irq_ops, ab8500);
0587 
0588     if (!ab8500->domain) {
0589         dev_err(ab8500->dev, "Failed to create irqdomain\n");
0590         return -ENODEV;
0591     }
0592 
0593     return 0;
0594 }
0595 
0596 int ab8500_suspend(struct ab8500 *ab8500)
0597 {
0598     if (atomic_read(&ab8500->transfer_ongoing))
0599         return -EINVAL;
0600 
0601     return 0;
0602 }
0603 
0604 static const struct mfd_cell ab8500_bm_devs[] = {
0605     MFD_CELL_OF("ab8500-charger", NULL, NULL, 0, 0,
0606             "stericsson,ab8500-charger"),
0607     MFD_CELL_OF("ab8500-btemp", NULL, NULL, 0, 0,
0608             "stericsson,ab8500-btemp"),
0609     MFD_CELL_OF("ab8500-fg", NULL, NULL, 0, 0,
0610             "stericsson,ab8500-fg"),
0611     MFD_CELL_OF("ab8500-chargalg", NULL, NULL, 0, 0,
0612             "stericsson,ab8500-chargalg"),
0613 };
0614 
0615 static const struct mfd_cell ab8500_devs[] = {
0616     MFD_CELL_OF("ab8500-sysctrl",
0617             NULL, NULL, 0, 0, "stericsson,ab8500-sysctrl"),
0618     MFD_CELL_OF("ab8500-ext-regulator",
0619             NULL, NULL, 0, 0, "stericsson,ab8500-ext-regulator"),
0620     MFD_CELL_OF("ab8500-regulator",
0621             NULL, NULL, 0, 0, "stericsson,ab8500-regulator"),
0622     MFD_CELL_OF("ab8500-clk",
0623             NULL, NULL, 0, 0, "stericsson,ab8500-clk"),
0624     MFD_CELL_OF("ab8500-gpadc",
0625             NULL, NULL, 0, 0, "stericsson,ab8500-gpadc"),
0626     MFD_CELL_OF("ab8500-rtc",
0627             NULL, NULL, 0, 0, "stericsson,ab8500-rtc"),
0628     MFD_CELL_OF("ab8500-acc-det",
0629             NULL, NULL, 0, 0, "stericsson,ab8500-acc-det"),
0630     MFD_CELL_OF("ab8500-poweron-key",
0631             NULL, NULL, 0, 0, "stericsson,ab8500-poweron-key"),
0632     MFD_CELL_OF("ab8500-pwm",
0633             NULL, NULL, 0, 1, "stericsson,ab8500-pwm"),
0634     MFD_CELL_OF("ab8500-pwm",
0635             NULL, NULL, 0, 2, "stericsson,ab8500-pwm"),
0636     MFD_CELL_OF("ab8500-pwm",
0637             NULL, NULL, 0, 3, "stericsson,ab8500-pwm"),
0638     MFD_CELL_OF("ab8500-denc",
0639             NULL, NULL, 0, 0, "stericsson,ab8500-denc"),
0640     MFD_CELL_OF("pinctrl-ab8500",
0641             NULL, NULL, 0, 0, "stericsson,ab8500-gpio"),
0642     MFD_CELL_OF("abx500-temp",
0643             NULL, NULL, 0, 0, "stericsson,abx500-temp"),
0644     MFD_CELL_OF("ab8500-usb",
0645             NULL, NULL, 0, 0, "stericsson,ab8500-usb"),
0646     MFD_CELL_OF("ab8500-codec",
0647             NULL, NULL, 0, 0, "stericsson,ab8500-codec"),
0648 };
0649 
0650 static const struct mfd_cell ab9540_devs[] = {
0651     {
0652         .name = "ab8500-sysctrl",
0653     },
0654     {
0655         .name = "ab8500-ext-regulator",
0656     },
0657     {
0658         .name = "ab8500-regulator",
0659     },
0660     {
0661         .name = "abx500-clk",
0662         .of_compatible = "stericsson,abx500-clk",
0663     },
0664     {
0665         .name = "ab8500-gpadc",
0666         .of_compatible = "stericsson,ab8500-gpadc",
0667     },
0668     {
0669         .name = "ab8500-rtc",
0670     },
0671     {
0672         .name = "ab8500-acc-det",
0673     },
0674     {
0675         .name = "ab8500-poweron-key",
0676     },
0677     {
0678         .name = "ab8500-pwm",
0679         .id = 1,
0680     },
0681     {
0682         .name = "abx500-temp",
0683     },
0684     {
0685         .name = "pinctrl-ab9540",
0686         .of_compatible = "stericsson,ab9540-gpio",
0687     },
0688     {
0689         .name = "ab9540-usb",
0690     },
0691     {
0692         .name = "ab9540-codec",
0693     },
0694     {
0695         .name = "ab-iddet",
0696     },
0697 };
0698 
0699 /* Device list for ab8505  */
0700 static const struct mfd_cell ab8505_devs[] = {
0701     {
0702         .name = "ab8500-sysctrl",
0703         .of_compatible = "stericsson,ab8500-sysctrl",
0704     },
0705     {
0706         .name = "ab8500-regulator",
0707         .of_compatible = "stericsson,ab8505-regulator",
0708     },
0709     {
0710         .name = "abx500-clk",
0711         .of_compatible = "stericsson,ab8500-clk",
0712     },
0713     {
0714         .name = "ab8500-gpadc",
0715         .of_compatible = "stericsson,ab8500-gpadc",
0716     },
0717     {
0718         .name = "ab8500-rtc",
0719         .of_compatible = "stericsson,ab8500-rtc",
0720     },
0721     {
0722         .name = "ab8500-acc-det",
0723         .of_compatible = "stericsson,ab8500-acc-det",
0724     },
0725     {
0726         .name = "ab8500-poweron-key",
0727         .of_compatible = "stericsson,ab8500-poweron-key",
0728     },
0729     {
0730         .name = "ab8500-pwm",
0731         .of_compatible = "stericsson,ab8500-pwm",
0732         .id = 1,
0733     },
0734     {
0735         .name = "pinctrl-ab8505",
0736         .of_compatible = "stericsson,ab8505-gpio",
0737     },
0738     {
0739         .name = "ab8500-usb",
0740         .of_compatible = "stericsson,ab8500-usb",
0741     },
0742     {
0743         .name = "ab8500-codec",
0744         .of_compatible = "stericsson,ab8500-codec",
0745     },
0746     {
0747         .name = "ab-iddet",
0748     },
0749 };
0750 
0751 static const struct mfd_cell ab8540_devs[] = {
0752     {
0753         .name = "ab8500-sysctrl",
0754     },
0755     {
0756         .name = "ab8500-ext-regulator",
0757     },
0758     {
0759         .name = "ab8500-regulator",
0760     },
0761     {
0762         .name = "abx500-clk",
0763         .of_compatible = "stericsson,abx500-clk",
0764     },
0765     {
0766         .name = "ab8500-gpadc",
0767         .of_compatible = "stericsson,ab8500-gpadc",
0768     },
0769     {
0770         .name = "ab8500-acc-det",
0771     },
0772     {
0773         .name = "ab8500-poweron-key",
0774     },
0775     {
0776         .name = "ab8500-pwm",
0777         .id = 1,
0778     },
0779     {
0780         .name = "abx500-temp",
0781     },
0782     {
0783         .name = "pinctrl-ab8540",
0784     },
0785     {
0786         .name = "ab8540-usb",
0787     },
0788     {
0789         .name = "ab8540-codec",
0790     },
0791     {
0792         .name = "ab-iddet",
0793     },
0794 };
0795 
0796 static const struct mfd_cell ab8540_cut1_devs[] = {
0797     {
0798         .name = "ab8500-rtc",
0799         .of_compatible = "stericsson,ab8500-rtc",
0800     },
0801 };
0802 
0803 static const struct mfd_cell ab8540_cut2_devs[] = {
0804     {
0805         .name = "ab8540-rtc",
0806         .of_compatible = "stericsson,ab8540-rtc",
0807     },
0808 };
0809 
0810 static ssize_t chip_id_show(struct device *dev,
0811                 struct device_attribute *attr, char *buf)
0812 {
0813     struct ab8500 *ab8500;
0814 
0815     ab8500 = dev_get_drvdata(dev);
0816 
0817     return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL);
0818 }
0819 
0820 /*
0821  * ab8500 has switched off due to (SWITCH_OFF_STATUS):
0822  * 0x01 Swoff bit programming
0823  * 0x02 Thermal protection activation
0824  * 0x04 Vbat lower then BattOk falling threshold
0825  * 0x08 Watchdog expired
0826  * 0x10 Non presence of 32kHz clock
0827  * 0x20 Battery level lower than power on reset threshold
0828  * 0x40 Power on key 1 pressed longer than 10 seconds
0829  * 0x80 DB8500 thermal shutdown
0830  */
0831 static ssize_t switch_off_status_show(struct device *dev,
0832                       struct device_attribute *attr, char *buf)
0833 {
0834     int ret;
0835     u8 value;
0836     struct ab8500 *ab8500;
0837 
0838     ab8500 = dev_get_drvdata(dev);
0839     ret = get_register_interruptible(ab8500, AB8500_RTC,
0840         AB8500_SWITCH_OFF_STATUS, &value);
0841     if (ret < 0)
0842         return ret;
0843     return sprintf(buf, "%#x\n", value);
0844 }
0845 
0846 /* use mask and set to override the register turn_on_stat value */
0847 void ab8500_override_turn_on_stat(u8 mask, u8 set)
0848 {
0849     spin_lock(&on_stat_lock);
0850     turn_on_stat_mask = mask;
0851     turn_on_stat_set = set;
0852     spin_unlock(&on_stat_lock);
0853 }
0854 
0855 /*
0856  * ab8500 has turned on due to (TURN_ON_STATUS):
0857  * 0x01 PORnVbat
0858  * 0x02 PonKey1dbF
0859  * 0x04 PonKey2dbF
0860  * 0x08 RTCAlarm
0861  * 0x10 MainChDet
0862  * 0x20 VbusDet
0863  * 0x40 UsbIDDetect
0864  * 0x80 Reserved
0865  */
0866 static ssize_t turn_on_status_show(struct device *dev,
0867                    struct device_attribute *attr, char *buf)
0868 {
0869     int ret;
0870     u8 value;
0871     struct ab8500 *ab8500;
0872 
0873     ab8500 = dev_get_drvdata(dev);
0874     ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
0875         AB8500_TURN_ON_STATUS, &value);
0876     if (ret < 0)
0877         return ret;
0878 
0879     /*
0880      * In L9540, turn_on_status register is not updated correctly if
0881      * the device is rebooted with AC/USB charger connected. Due to
0882      * this, the device boots android instead of entering into charge
0883      * only mode. Read the AC/USB status register to detect the charger
0884      * presence and update the turn on status manually.
0885      */
0886     if (is_ab9540(ab8500)) {
0887         spin_lock(&on_stat_lock);
0888         value = (value & turn_on_stat_mask) | turn_on_stat_set;
0889         spin_unlock(&on_stat_lock);
0890     }
0891 
0892     return sprintf(buf, "%#x\n", value);
0893 }
0894 
0895 static ssize_t turn_on_status_2_show(struct device *dev,
0896                      struct device_attribute *attr, char *buf)
0897 {
0898     int ret;
0899     u8 value;
0900     struct ab8500 *ab8500;
0901 
0902     ab8500 = dev_get_drvdata(dev);
0903     ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
0904         AB8505_TURN_ON_STATUS_2, &value);
0905     if (ret < 0)
0906         return ret;
0907     return sprintf(buf, "%#x\n", (value & 0x1));
0908 }
0909 
0910 static ssize_t dbbrstn_show(struct device *dev,
0911                 struct device_attribute *attr, char *buf)
0912 {
0913     struct ab8500 *ab8500;
0914     int ret;
0915     u8 value;
0916 
0917     ab8500 = dev_get_drvdata(dev);
0918 
0919     ret = get_register_interruptible(ab8500, AB8500_REGU_CTRL2,
0920         AB9540_MODEM_CTRL2_REG, &value);
0921     if (ret < 0)
0922         return ret;
0923 
0924     return sprintf(buf, "%d\n",
0925             (value & AB9540_MODEM_CTRL2_SWDBBRSTN_BIT) ? 1 : 0);
0926 }
0927 
0928 static ssize_t dbbrstn_store(struct device *dev,
0929     struct device_attribute *attr, const char *buf, size_t count)
0930 {
0931     struct ab8500 *ab8500;
0932     int ret = count;
0933     int err;
0934     u8 bitvalues;
0935 
0936     ab8500 = dev_get_drvdata(dev);
0937 
0938     if (count > 0) {
0939         switch (buf[0]) {
0940         case '0':
0941             bitvalues = 0;
0942             break;
0943         case '1':
0944             bitvalues = AB9540_MODEM_CTRL2_SWDBBRSTN_BIT;
0945             break;
0946         default:
0947             goto exit;
0948         }
0949 
0950         err = mask_and_set_register_interruptible(ab8500,
0951             AB8500_REGU_CTRL2, AB9540_MODEM_CTRL2_REG,
0952             AB9540_MODEM_CTRL2_SWDBBRSTN_BIT, bitvalues);
0953         if (err)
0954             dev_info(ab8500->dev,
0955                 "Failed to set DBBRSTN %c, err %#x\n",
0956                 buf[0], err);
0957     }
0958 
0959 exit:
0960     return ret;
0961 }
0962 
0963 static DEVICE_ATTR_RO(chip_id);
0964 static DEVICE_ATTR_RO(switch_off_status);
0965 static DEVICE_ATTR_RO(turn_on_status);
0966 static DEVICE_ATTR_RO(turn_on_status_2);
0967 static DEVICE_ATTR_RW(dbbrstn);
0968 
0969 static struct attribute *ab8500_sysfs_entries[] = {
0970     &dev_attr_chip_id.attr,
0971     &dev_attr_switch_off_status.attr,
0972     &dev_attr_turn_on_status.attr,
0973     NULL,
0974 };
0975 
0976 static struct attribute *ab8505_sysfs_entries[] = {
0977     &dev_attr_turn_on_status_2.attr,
0978     NULL,
0979 };
0980 
0981 static struct attribute *ab9540_sysfs_entries[] = {
0982     &dev_attr_chip_id.attr,
0983     &dev_attr_switch_off_status.attr,
0984     &dev_attr_turn_on_status.attr,
0985     &dev_attr_dbbrstn.attr,
0986     NULL,
0987 };
0988 
0989 static const struct attribute_group ab8500_attr_group = {
0990     .attrs  = ab8500_sysfs_entries,
0991 };
0992 
0993 static const struct attribute_group ab8505_attr_group = {
0994     .attrs  = ab8505_sysfs_entries,
0995 };
0996 
0997 static const struct attribute_group ab9540_attr_group = {
0998     .attrs  = ab9540_sysfs_entries,
0999 };
1000 
1001 static int ab8500_probe(struct platform_device *pdev)
1002 {
1003     static const char * const switch_off_status[] = {
1004         "Swoff bit programming",
1005         "Thermal protection activation",
1006         "Vbat lower then BattOk falling threshold",
1007         "Watchdog expired",
1008         "Non presence of 32kHz clock",
1009         "Battery level lower than power on reset threshold",
1010         "Power on key 1 pressed longer than 10 seconds",
1011         "DB8500 thermal shutdown"};
1012     static const char * const turn_on_status[] = {
1013         "Battery rising (Vbat)",
1014         "Power On Key 1 dbF",
1015         "Power On Key 2 dbF",
1016         "RTC Alarm",
1017         "Main Charger Detect",
1018         "Vbus Detect (USB)",
1019         "USB ID Detect",
1020         "UART Factory Mode Detect"};
1021     const struct platform_device_id *platid = platform_get_device_id(pdev);
1022     enum ab8500_version version = AB8500_VERSION_UNDEFINED;
1023     struct device_node *np = pdev->dev.of_node;
1024     struct ab8500 *ab8500;
1025     int ret;
1026     int i;
1027     int irq;
1028     u8 value;
1029 
1030     ab8500 = devm_kzalloc(&pdev->dev, sizeof(*ab8500), GFP_KERNEL);
1031     if (!ab8500)
1032         return -ENOMEM;
1033 
1034     ab8500->dev = &pdev->dev;
1035 
1036     irq = platform_get_irq(pdev, 0);
1037     if (irq < 0)
1038         return irq;
1039 
1040     ab8500->irq = irq;
1041 
1042     ab8500->read = ab8500_prcmu_read;
1043     ab8500->write = ab8500_prcmu_write;
1044     ab8500->write_masked = ab8500_prcmu_write_masked;
1045 
1046     mutex_init(&ab8500->lock);
1047     mutex_init(&ab8500->irq_lock);
1048     atomic_set(&ab8500->transfer_ongoing, 0);
1049 
1050     platform_set_drvdata(pdev, ab8500);
1051 
1052     if (platid)
1053         version = platid->driver_data;
1054 
1055     if (version != AB8500_VERSION_UNDEFINED)
1056         ab8500->version = version;
1057     else {
1058         ret = get_register_interruptible(ab8500, AB8500_MISC,
1059             AB8500_IC_NAME_REG, &value);
1060         if (ret < 0) {
1061             dev_err(&pdev->dev, "could not probe HW\n");
1062             return ret;
1063         }
1064 
1065         ab8500->version = value;
1066     }
1067 
1068     ret = get_register_interruptible(ab8500, AB8500_MISC,
1069         AB8500_REV_REG, &value);
1070     if (ret < 0)
1071         return ret;
1072 
1073     ab8500->chip_id = value;
1074 
1075     dev_info(ab8500->dev, "detected chip, %s rev. %1x.%1x\n",
1076             ab8500_version_str[ab8500->version],
1077             ab8500->chip_id >> 4,
1078             ab8500->chip_id & 0x0F);
1079 
1080     /* Configure AB8540 */
1081     if (is_ab8540(ab8500)) {
1082         ab8500->mask_size = AB8540_NUM_IRQ_REGS;
1083         ab8500->irq_reg_offset = ab8540_irq_regoffset;
1084         ab8500->it_latchhier_num = AB8540_IT_LATCHHIER_NUM;
1085     } /* Configure AB8500 or AB9540 IRQ */
1086     else if (is_ab9540(ab8500) || is_ab8505(ab8500)) {
1087         ab8500->mask_size = AB9540_NUM_IRQ_REGS;
1088         ab8500->irq_reg_offset = ab9540_irq_regoffset;
1089         ab8500->it_latchhier_num = AB8500_IT_LATCHHIER_NUM;
1090     } else {
1091         ab8500->mask_size = AB8500_NUM_IRQ_REGS;
1092         ab8500->irq_reg_offset = ab8500_irq_regoffset;
1093         ab8500->it_latchhier_num = AB8500_IT_LATCHHIER_NUM;
1094     }
1095     ab8500->mask = devm_kzalloc(&pdev->dev, ab8500->mask_size,
1096                     GFP_KERNEL);
1097     if (!ab8500->mask)
1098         return -ENOMEM;
1099     ab8500->oldmask = devm_kzalloc(&pdev->dev, ab8500->mask_size,
1100                        GFP_KERNEL);
1101     if (!ab8500->oldmask)
1102         return -ENOMEM;
1103 
1104     /*
1105      * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1106      * 0x01 Swoff bit programming
1107      * 0x02 Thermal protection activation
1108      * 0x04 Vbat lower then BattOk falling threshold
1109      * 0x08 Watchdog expired
1110      * 0x10 Non presence of 32kHz clock
1111      * 0x20 Battery level lower than power on reset threshold
1112      * 0x40 Power on key 1 pressed longer than 10 seconds
1113      * 0x80 DB8500 thermal shutdown
1114      */
1115 
1116     ret = get_register_interruptible(ab8500, AB8500_RTC,
1117         AB8500_SWITCH_OFF_STATUS, &value);
1118     if (ret < 0)
1119         return ret;
1120     dev_info(ab8500->dev, "switch off cause(s) (%#x): ", value);
1121 
1122     if (value) {
1123         for (i = 0; i < ARRAY_SIZE(switch_off_status); i++) {
1124             if (value & 1)
1125                 pr_cont(" \"%s\"", switch_off_status[i]);
1126             value = value >> 1;
1127 
1128         }
1129         pr_cont("\n");
1130     } else {
1131         pr_cont(" None\n");
1132     }
1133     ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
1134         AB8500_TURN_ON_STATUS, &value);
1135     if (ret < 0)
1136         return ret;
1137     dev_info(ab8500->dev, "turn on reason(s) (%#x): ", value);
1138 
1139     if (value) {
1140         for (i = 0; i < ARRAY_SIZE(turn_on_status); i++) {
1141             if (value & 1)
1142                 pr_cont("\"%s\" ", turn_on_status[i]);
1143             value = value >> 1;
1144         }
1145         pr_cont("\n");
1146     } else {
1147         pr_cont("None\n");
1148     }
1149 
1150     if (is_ab9540(ab8500)) {
1151         ret = get_register_interruptible(ab8500, AB8500_CHARGER,
1152             AB8500_CH_USBCH_STAT1_REG, &value);
1153         if (ret < 0)
1154             return ret;
1155         if ((value & VBUS_DET_DBNC1) && (value & VBUS_DET_DBNC100))
1156             ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON,
1157                              AB8500_VBUS_DET);
1158     }
1159 
1160     /* Clear and mask all interrupts */
1161     for (i = 0; i < ab8500->mask_size; i++) {
1162         /*
1163          * Interrupt register 12 doesn't exist prior to AB8500 version
1164          * 2.0
1165          */
1166         if (ab8500->irq_reg_offset[i] == 11 &&
1167                 is_ab8500_1p1_or_earlier(ab8500))
1168             continue;
1169 
1170         if (ab8500->irq_reg_offset[i] < 0)
1171             continue;
1172 
1173         get_register_interruptible(ab8500, AB8500_INTERRUPT,
1174             AB8500_IT_LATCH1_REG + ab8500->irq_reg_offset[i],
1175             &value);
1176         set_register_interruptible(ab8500, AB8500_INTERRUPT,
1177             AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i], 0xff);
1178     }
1179 
1180     ret = abx500_register_ops(ab8500->dev, &ab8500_ops);
1181     if (ret)
1182         return ret;
1183 
1184     for (i = 0; i < ab8500->mask_size; i++)
1185         ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
1186 
1187     ret = ab8500_irq_init(ab8500, np);
1188     if (ret)
1189         return ret;
1190 
1191     ret = devm_request_threaded_irq(&pdev->dev, ab8500->irq, NULL,
1192             ab8500_hierarchical_irq,
1193             IRQF_ONESHOT | IRQF_NO_SUSPEND,
1194             "ab8500", ab8500);
1195     if (ret)
1196         return ret;
1197 
1198     if (is_ab9540(ab8500))
1199         ret = mfd_add_devices(ab8500->dev, 0, ab9540_devs,
1200                 ARRAY_SIZE(ab9540_devs), NULL,
1201                 0, ab8500->domain);
1202     else if (is_ab8540(ab8500)) {
1203         ret = mfd_add_devices(ab8500->dev, 0, ab8540_devs,
1204                   ARRAY_SIZE(ab8540_devs), NULL,
1205                   0, ab8500->domain);
1206         if (ret)
1207             return ret;
1208 
1209         if (is_ab8540_1p2_or_earlier(ab8500))
1210             ret = mfd_add_devices(ab8500->dev, 0, ab8540_cut1_devs,
1211                   ARRAY_SIZE(ab8540_cut1_devs), NULL,
1212                   0, ab8500->domain);
1213         else /* ab8540 >= cut2 */
1214             ret = mfd_add_devices(ab8500->dev, 0, ab8540_cut2_devs,
1215                   ARRAY_SIZE(ab8540_cut2_devs), NULL,
1216                   0, ab8500->domain);
1217     } else if (is_ab8505(ab8500))
1218         ret = mfd_add_devices(ab8500->dev, 0, ab8505_devs,
1219                   ARRAY_SIZE(ab8505_devs), NULL,
1220                   0, ab8500->domain);
1221     else
1222         ret = mfd_add_devices(ab8500->dev, 0, ab8500_devs,
1223                 ARRAY_SIZE(ab8500_devs), NULL,
1224                 0, ab8500->domain);
1225     if (ret)
1226         return ret;
1227 
1228     /* Add battery management devices */
1229     ret = mfd_add_devices(ab8500->dev, 0, ab8500_bm_devs,
1230                   ARRAY_SIZE(ab8500_bm_devs), NULL,
1231                   0, ab8500->domain);
1232     if (ret)
1233         dev_err(ab8500->dev, "error adding bm devices\n");
1234 
1235     if (((is_ab8505(ab8500) || is_ab9540(ab8500)) &&
1236             ab8500->chip_id >= AB8500_CUT2P0) || is_ab8540(ab8500))
1237         ret = sysfs_create_group(&ab8500->dev->kobj,
1238                     &ab9540_attr_group);
1239     else
1240         ret = sysfs_create_group(&ab8500->dev->kobj,
1241                     &ab8500_attr_group);
1242 
1243     if ((is_ab8505(ab8500) || is_ab9540(ab8500)) &&
1244             ab8500->chip_id >= AB8500_CUT2P0)
1245         ret = sysfs_create_group(&ab8500->dev->kobj,
1246                      &ab8505_attr_group);
1247 
1248     if (ret)
1249         dev_err(ab8500->dev, "error creating sysfs entries\n");
1250 
1251     return ret;
1252 }
1253 
1254 static const struct platform_device_id ab8500_id[] = {
1255     { "ab8500-core", AB8500_VERSION_AB8500 },
1256     { "ab8505-core", AB8500_VERSION_AB8505 },
1257     { "ab9540-i2c", AB8500_VERSION_AB9540 },
1258     { "ab8540-i2c", AB8500_VERSION_AB8540 },
1259     { }
1260 };
1261 
1262 static struct platform_driver ab8500_core_driver = {
1263     .driver = {
1264         .name = "ab8500-core",
1265         .suppress_bind_attrs = true,
1266     },
1267     .probe  = ab8500_probe,
1268     .id_table = ab8500_id,
1269 };
1270 
1271 static int __init ab8500_core_init(void)
1272 {
1273     return platform_driver_register(&ab8500_core_driver);
1274 }
1275 core_initcall(ab8500_core_init);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!