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