drivers/mfd/tc3589x.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2010
   3  *
   4  * License Terms: GNU General Public License, version 2
   5  * Author: Hanumath Prasad <hanumath.prasad@stericsson.com> for ST-Ericsson
   6  * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/irq.h>
  12 #include <linux/slab.h>
  13 #include <linux/i2c.h>
  14 #include <linux/mfd/core.h>
  15 #include <linux/mfd/tc3589x.h>
  16
  17 #define TC3589x_CLKMODE_MODCTL_SLEEP            0x0
  18 #define TC3589x_CLKMODE_MODCTL_OPERATION        (1 << 0)
  19
  20 /**
  21  * tc3589x_reg_read() - read a single TC3589x register
  22  * @tc3589x:    Device to read from
  23  * @reg:        Register to read
  24  */
  25 int tc3589x_reg_read(struct tc3589x *tc3589x, u8 reg)
  26 {
  27         int ret;
  28
  29         ret = i2c_smbus_read_byte_data(tc3589x->i2c, reg);
  30         if (ret < 0)
  31                 dev_err(tc3589x->dev, "failed to read reg %#x: %d\n",
  32                         reg, ret);
  33
  34         return ret;
  35 }
  36 EXPORT_SYMBOL_GPL(tc3589x_reg_read);
  37
  38 /**
  39  * tc3589x_reg_read() - write a single TC3589x register
  40  * @tc3589x:    Device to write to
  41  * @reg:        Register to read
  42  * @data:       Value to write
  43  */
  44 int tc3589x_reg_write(struct tc3589x *tc3589x, u8 reg, u8 data)
  45 {
  46         int ret;
  47
  48         ret = i2c_smbus_write_byte_data(tc3589x->i2c, reg, data);
  49         if (ret < 0)
  50                 dev_err(tc3589x->dev, "failed to write reg %#x: %d\n",
  51                         reg, ret);
  52
  53         return ret;
  54 }
  55 EXPORT_SYMBOL_GPL(tc3589x_reg_write);
  56
  57 /**
  58  * tc3589x_block_read() - read multiple TC3589x registers
  59  * @tc3589x:    Device to read from
  60  * @reg:        First register
  61  * @length:     Number of registers
  62  * @values:     Buffer to write to
  63  */
  64 int tc3589x_block_read(struct tc3589x *tc3589x, u8 reg, u8 length, u8 *values)
  65 {
  66         int ret;
  67
  68         ret = i2c_smbus_read_i2c_block_data(tc3589x->i2c, reg, length, values);
  69         if (ret < 0)
  70                 dev_err(tc3589x->dev, "failed to read regs %#x: %d\n",
  71                         reg, ret);
  72
  73         return ret;
  74 }
  75 EXPORT_SYMBOL_GPL(tc3589x_block_read);
  76
  77 /**
  78  * tc3589x_block_write() - write multiple TC3589x registers
  79  * @tc3589x:    Device to write to
  80  * @reg:        First register
  81  * @length:     Number of registers
  82  * @values:     Values to write
  83  */
  84 int tc3589x_block_write(struct tc3589x *tc3589x, u8 reg, u8 length,
  85                         const u8 *values)
  86 {
  87         int ret;
  88
  89         ret = i2c_smbus_write_i2c_block_data(tc3589x->i2c, reg, length,
  90                                              values);
  91         if (ret < 0)
  92                 dev_err(tc3589x->dev, "failed to write regs %#x: %d\n",
  93                         reg, ret);
  94
  95         return ret;
  96 }
  97 EXPORT_SYMBOL_GPL(tc3589x_block_write);
  98
  99 /**
 100  * tc3589x_set_bits() - set the value of a bitfield in a TC3589x register
 101  * @tc3589x:    Device to write to
 102  * @reg:        Register to write
 103  * @mask:       Mask of bits to set
 104  * @values:     Value to set
 105  */
 106 int tc3589x_set_bits(struct tc3589x *tc3589x, u8 reg, u8 mask, u8 val)
 107 {
 108         int ret;
 109
 110         mutex_lock(&tc3589x->lock);
 111
 112         ret = tc3589x_reg_read(tc3589x, reg);
 113         if (ret < 0)
 114                 goto out;
 115
 116         ret &= ~mask;
 117         ret |= val;
 118
 119         ret = tc3589x_reg_write(tc3589x, reg, ret);
 120
 121 out:
 122         mutex_unlock(&tc3589x->lock);
 123         return ret;
 124 }
 125 EXPORT_SYMBOL_GPL(tc3589x_set_bits);
 126
 127 static struct resource gpio_resources[] = {
 128         {
 129                 .start  = TC3589x_INT_GPIIRQ,
 130                 .end    = TC3589x_INT_GPIIRQ,
 131                 .flags  = IORESOURCE_IRQ,
 132         },
 133 };
 134
 135 static struct mfd_cell tc3589x_dev_gpio[] = {
 136         {
 137                 .name           = "tc3589x-gpio",
 138                 .num_resources  = ARRAY_SIZE(gpio_resources),
 139                 .resources      = &gpio_resources[0],
 140         },
 141 };
 142
 143 static irqreturn_t tc3589x_irq(int irq, void *data)
 144 {
 145         struct tc3589x *tc3589x = data;
 146         int status;
 147
 148 again:
 149         status = tc3589x_reg_read(tc3589x, TC3589x_IRQST);
 150         if (status < 0)
 151                 return IRQ_NONE;
 152
 153         while (status) {
 154                 int bit = __ffs(status);
 155
 156                 handle_nested_irq(tc3589x->irq_base + bit);
 157                 status &= ~(1 << bit);
 158         }
 159
 160         /*
 161          * A dummy read or write (to any register) appears to be necessary to
 162          * have the last interrupt clear (for example, GPIO IC write) take
 163          * effect. In such a case, recheck for any interrupt which is still
 164          * pending.
 165          */
 166         status = tc3589x_reg_read(tc3589x, TC3589x_IRQST);
 167         if (status)
 168                 goto again;
 169
 170         return IRQ_HANDLED;
 171 }
 172
 173 static int tc3589x_irq_init(struct tc3589x *tc3589x)
 174 {
 175         int base = tc3589x->irq_base;
 176         int irq;
 177
 178         for (irq = base; irq < base + TC3589x_NR_INTERNAL_IRQS; irq++) {
 179                 set_irq_chip_data(irq, tc3589x);
 180                 set_irq_chip_and_handler(irq, &dummy_irq_chip,
 181                                          handle_edge_irq);
 182                 set_irq_nested_thread(irq, 1);
 183 #ifdef CONFIG_ARM
 184                 set_irq_flags(irq, IRQF_VALID);
 185 #else
 186                 set_irq_noprobe(irq);
 187 #endif
 188         }
 189
 190         return 0;
 191 }
 192
 193 static void tc3589x_irq_remove(struct tc3589x *tc3589x)
 194 {
 195         int base = tc3589x->irq_base;
 196         int irq;
 197
 198         for (irq = base; irq < base + TC3589x_NR_INTERNAL_IRQS; irq++) {
 199 #ifdef CONFIG_ARM
 200                 set_irq_flags(irq, 0);
 201 #endif
 202                 set_irq_chip_and_handler(irq, NULL, NULL);
 203                 set_irq_chip_data(irq, NULL);
 204         }
 205 }
 206
 207 static int tc3589x_chip_init(struct tc3589x *tc3589x)
 208 {
 209         int manf, ver, ret;
 210
 211         manf = tc3589x_reg_read(tc3589x, TC3589x_MANFCODE);
 212         if (manf < 0)
 213                 return manf;
 214
 215         ver = tc3589x_reg_read(tc3589x, TC3589x_VERSION);
 216         if (ver < 0)
 217                 return ver;
 218
 219         if (manf != TC3589x_MANFCODE_MAGIC) {
 220                 dev_err(tc3589x->dev, "unknown manufacturer: %#x\n", manf);
 221                 return -EINVAL;
 222         }
 223
 224         dev_info(tc3589x->dev, "manufacturer: %#x, version: %#x\n", manf, ver);
 225
 226         /*
 227          * Put everything except the IRQ module into reset;
 228          * also spare the GPIO module for any pin initialization
 229          * done during pre-kernel boot
 230          */
 231         ret = tc3589x_reg_write(tc3589x, TC3589x_RSTCTRL,
 232                                 TC3589x_RSTCTRL_TIMRST
 233                                 | TC3589x_RSTCTRL_ROTRST
 234                                 | TC3589x_RSTCTRL_KBDRST);
 235         if (ret < 0)
 236                 return ret;
 237
 238         /* Clear the reset interrupt. */
 239         return tc3589x_reg_write(tc3589x, TC3589x_RSTINTCLR, 0x1);
 240 }
 241
 242 static int __devinit tc3589x_device_init(struct tc3589x *tc3589x)
 243 {
 244         int ret = 0;
 245         unsigned int blocks = tc3589x->pdata->block;
 246
 247         if (blocks & TC3589x_BLOCK_GPIO) {
 248                 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_gpio,
 249                                 ARRAY_SIZE(tc3589x_dev_gpio), NULL,
 250                                 tc3589x->irq_base);
 251                 if (ret) {
 252                         dev_err(tc3589x->dev, "failed to add gpio child\n");
 253                         return ret;
 254                 }
 255                 dev_info(tc3589x->dev, "added gpio block\n");
 256         }
 257
 258         return ret;
 259
 260 }
 261
 262 static int __devinit tc3589x_probe(struct i2c_client *i2c,
 263                                    const struct i2c_device_id *id)
 264 {
 265         struct tc3589x_platform_data *pdata = i2c->dev.platform_data;
 266         struct tc3589x *tc3589x;
 267         int ret;
 268
 269         if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA
 270                                      | I2C_FUNC_SMBUS_I2C_BLOCK))
 271                 return -EIO;
 272
 273         tc3589x = kzalloc(sizeof(struct tc3589x), GFP_KERNEL);
 274         if (!tc3589x)
 275                 return -ENOMEM;
 276
 277         mutex_init(&tc3589x->lock);
 278
 279         tc3589x->dev = &i2c->dev;
 280         tc3589x->i2c = i2c;
 281         tc3589x->pdata = pdata;
 282         tc3589x->irq_base = pdata->irq_base;
 283         tc3589x->num_gpio = id->driver_data;
 284
 285         i2c_set_clientdata(i2c, tc3589x);
 286
 287         ret = tc3589x_chip_init(tc3589x);
 288         if (ret)
 289                 goto out_free;
 290
 291         ret = tc3589x_irq_init(tc3589x);
 292         if (ret)
 293                 goto out_free;
 294
 295         ret = request_threaded_irq(tc3589x->i2c->irq, NULL, tc3589x_irq,
 296                                    IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 297                                    "tc3589x", tc3589x);
 298         if (ret) {
 299                 dev_err(tc3589x->dev, "failed to request IRQ: %d\n", ret);
 300                 goto out_removeirq;
 301         }
 302
 303         ret = tc3589x_device_init(tc3589x);
 304         if (ret) {
 305                 dev_err(tc3589x->dev, "failed to add child devices\n");
 306                 goto out_freeirq;
 307         }
 308
 309         return 0;
 310
 311 out_freeirq:
 312         free_irq(tc3589x->i2c->irq, tc3589x);
 313 out_removeirq:
 314         tc3589x_irq_remove(tc3589x);
 315 out_free:
 316         kfree(tc3589x);
 317         return ret;
 318 }
 319
 320 static int __devexit tc3589x_remove(struct i2c_client *client)
 321 {
 322         struct tc3589x *tc3589x = i2c_get_clientdata(client);
 323
 324         mfd_remove_devices(tc3589x->dev);
 325
 326         free_irq(tc3589x->i2c->irq, tc3589x);
 327         tc3589x_irq_remove(tc3589x);
 328
 329         kfree(tc3589x);
 330
 331         return 0;
 332 }
 333
 334 static int tc3589x_suspend(struct device *dev)
 335 {
 336         struct tc3589x *tc3589x = dev_get_drvdata(dev);
 337         struct i2c_client *client = tc3589x->i2c;
 338         int ret = 0;
 339
 340         /* put the system to sleep mode */
 341         if (!device_may_wakeup(&client->dev))
 342                 ret = tc3589x_reg_write(tc3589x, TC3589x_CLKMODE,
 343                                 TC3589x_CLKMODE_MODCTL_SLEEP);
 344
 345         return ret;
 346 }
 347
 348 static int tc3589x_resume(struct device *dev)
 349 {
 350         struct tc3589x *tc3589x = dev_get_drvdata(dev);
 351         struct i2c_client *client = tc3589x->i2c;
 352         int ret = 0;
 353
 354         /* enable the system into operation */
 355         if (!device_may_wakeup(&client->dev))
 356                 ret = tc3589x_reg_write(tc3589x, TC3589x_CLKMODE,
 357                                 TC3589x_CLKMODE_MODCTL_OPERATION);
 358
 359         return ret;
 360 }
 361
 362 static const SIMPLE_DEV_PM_OPS(tc3589x_dev_pm_ops, tc3589x_suspend,
 363                                                 tc3589x_resume);
 364
 365 static const struct i2c_device_id tc3589x_id[] = {
 366         { "tc3589x", 24 },
 367         { }
 368 };
 369 MODULE_DEVICE_TABLE(i2c, tc3589x_id);
 370
 371 static struct i2c_driver tc3589x_driver = {
 372         .driver.name    = "tc3589x",
 373         .driver.owner   = THIS_MODULE,
 374 #ifdef CONFIG_PM
 375         .driver.pm      = &tc3589x_dev_pm_ops,
 376 #endif
 377         .probe          = tc3589x_probe,
 378         .remove         = __devexit_p(tc3589x_remove),
 379         .id_table       = tc3589x_id,
 380 };
 381
 382 static int __init tc3589x_init(void)
 383 {
 384         return i2c_add_driver(&tc3589x_driver);
 385 }
 386 subsys_initcall(tc3589x_init);
 387
 388 static void __exit tc3589x_exit(void)
 389 {
 390         i2c_del_driver(&tc3589x_driver);
 391 }
 392 module_exit(tc3589x_exit);
 393
 394 MODULE_LICENSE("GPL v2");
 395 MODULE_DESCRIPTION("TC3589x MFD core driver");
 396 MODULE_AUTHOR("Hanumath Prasad, Rabin Vincent");