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         if (base) {
 232                 tc3589x->domain = irq_domain_add_legacy(
 233                         NULL, TC3589x_NR_INTERNAL_IRQS, base,
 234                         0, &tc3589x_irq_ops, tc3589x);
 235         }
 236         else {
 237                 tc3589x->domain = irq_domain_add_linear(
 238                         np, TC3589x_NR_INTERNAL_IRQS,
 239                         &tc3589x_irq_ops, tc3589x);
 240         }
 241
 242         if (!tc3589x->domain) {
 243                 dev_err(tc3589x->dev, "Failed to create irqdomain\n");
 244                 return -ENOSYS;
 245         }
 246
 247         return 0;
 248 }
 249
 250 static int tc3589x_chip_init(struct tc3589x *tc3589x)
 251 {
 252         int manf, ver, ret;
 253
 254         manf = tc3589x_reg_read(tc3589x, TC3589x_MANFCODE);
 255         if (manf < 0)
 256                 return manf;
 257
 258         ver = tc3589x_reg_read(tc3589x, TC3589x_VERSION);
 259         if (ver < 0)
 260                 return ver;
 261
 262         if (manf != TC3589x_MANFCODE_MAGIC) {
 263                 dev_err(tc3589x->dev, "unknown manufacturer: %#x\n", manf);
 264                 return -EINVAL;
 265         }
 266
 267         dev_info(tc3589x->dev, "manufacturer: %#x, version: %#x\n", manf, ver);
 268
 269         /*
 270          * Put everything except the IRQ module into reset;
 271          * also spare the GPIO module for any pin initialization
 272          * done during pre-kernel boot
 273          */
 274         ret = tc3589x_reg_write(tc3589x, TC3589x_RSTCTRL,
 275                                 TC3589x_RSTCTRL_TIMRST
 276                                 | TC3589x_RSTCTRL_ROTRST
 277                                 | TC3589x_RSTCTRL_KBDRST);
 278         if (ret < 0)
 279                 return ret;
 280
 281         /* Clear the reset interrupt. */
 282         return tc3589x_reg_write(tc3589x, TC3589x_RSTINTCLR, 0x1);
 283 }
 284
 285 static int __devinit tc3589x_device_init(struct tc3589x *tc3589x)
 286 {
 287         int ret = 0;
 288         unsigned int blocks = tc3589x->pdata->block;
 289
 290         if (blocks & TC3589x_BLOCK_GPIO) {
 291                 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_gpio,
 292                                       ARRAY_SIZE(tc3589x_dev_gpio), NULL,
 293                                       tc3589x->irq_base, tc3589x->domain);
 294                 if (ret) {
 295                         dev_err(tc3589x->dev, "failed to add gpio child\n");
 296                         return ret;
 297                 }
 298                 dev_info(tc3589x->dev, "added gpio block\n");
 299         }
 300
 301         if (blocks & TC3589x_BLOCK_KEYPAD) {
 302                 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_keypad,
 303                                       ARRAY_SIZE(tc3589x_dev_keypad), NULL,
 304                                       tc3589x->irq_base, tc3589x->domain);
 305                 if (ret) {
 306                         dev_err(tc3589x->dev, "failed to keypad child\n");
 307                         return ret;
 308                 }
 309                 dev_info(tc3589x->dev, "added keypad block\n");
 310         }
 311
 312         return ret;
 313 }
 314
 315 static int tc3589x_of_probe(struct device_node *np,
 316                         struct tc3589x_platform_data *pdata)
 317 {
 318         struct device_node *child;
 319
 320         for_each_child_of_node(np, child) {
 321                 if (!strcmp(child->name, "tc3589x_gpio")) {
 322                         pdata->block |= TC3589x_BLOCK_GPIO;
 323                 }
 324                 if (!strcmp(child->name, "tc3589x_keypad")) {
 325                         pdata->block |= TC3589x_BLOCK_KEYPAD;
 326                 }
 327         }
 328
 329         return 0;
 330 }
 331
 332 static int __devinit tc3589x_probe(struct i2c_client *i2c,
 333                                    const struct i2c_device_id *id)
 334 {
 335         struct tc3589x_platform_data *pdata = i2c->dev.platform_data;
 336         struct device_node *np = i2c->dev.of_node;
 337         struct tc3589x *tc3589x;
 338         int ret;
 339
 340         if (!pdata) {
 341                 if (np) {
 342                         pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL);
 343                         if (!pdata)
 344                                 return -ENOMEM;
 345
 346                         ret = tc3589x_of_probe(np, pdata);
 347                         if (ret)
 348                                 return ret;
 349                 }
 350                 else {
 351                         dev_err(&i2c->dev, "No platform data or DT found\n");
 352                         return -EINVAL;
 353                 }
 354         }
 355
 356         if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA
 357                                      | I2C_FUNC_SMBUS_I2C_BLOCK))
 358                 return -EIO;
 359
 360         tc3589x = kzalloc(sizeof(struct tc3589x), GFP_KERNEL);
 361         if (!tc3589x)
 362                 return -ENOMEM;
 363
 364         mutex_init(&tc3589x->lock);
 365
 366         tc3589x->dev = &i2c->dev;
 367         tc3589x->i2c = i2c;
 368         tc3589x->pdata = pdata;
 369         tc3589x->irq_base = pdata->irq_base;
 370         tc3589x->num_gpio = id->driver_data;
 371
 372         i2c_set_clientdata(i2c, tc3589x);
 373
 374         ret = tc3589x_chip_init(tc3589x);
 375         if (ret)
 376                 goto out_free;
 377
 378         ret = tc3589x_irq_init(tc3589x, np);
 379         if (ret)
 380                 goto out_free;
 381
 382         ret = request_threaded_irq(tc3589x->i2c->irq, NULL, tc3589x_irq,
 383                                    IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 384                                    "tc3589x", tc3589x);
 385         if (ret) {
 386                 dev_err(tc3589x->dev, "failed to request IRQ: %d\n", ret);
 387                 goto out_free;
 388         }
 389
 390         ret = tc3589x_device_init(tc3589x);
 391         if (ret) {
 392                 dev_err(tc3589x->dev, "failed to add child devices\n");
 393                 goto out_freeirq;
 394         }
 395
 396         return 0;
 397
 398 out_freeirq:
 399         free_irq(tc3589x->i2c->irq, tc3589x);
 400 out_free:
 401         kfree(tc3589x);
 402         return ret;
 403 }
 404
 405 static int __devexit tc3589x_remove(struct i2c_client *client)
 406 {
 407         struct tc3589x *tc3589x = i2c_get_clientdata(client);
 408
 409         mfd_remove_devices(tc3589x->dev);
 410
 411         free_irq(tc3589x->i2c->irq, tc3589x);
 412
 413         kfree(tc3589x);
 414
 415         return 0;
 416 }
 417
 418 #ifdef CONFIG_PM_SLEEP
 419 static int tc3589x_suspend(struct device *dev)
 420 {
 421         struct tc3589x *tc3589x = dev_get_drvdata(dev);
 422         struct i2c_client *client = tc3589x->i2c;
 423         int ret = 0;
 424
 425         /* put the system to sleep mode */
 426         if (!device_may_wakeup(&client->dev))
 427                 ret = tc3589x_reg_write(tc3589x, TC3589x_CLKMODE,
 428                                 TC3589x_CLKMODE_MODCTL_SLEEP);
 429
 430         return ret;
 431 }
 432
 433 static int tc3589x_resume(struct device *dev)
 434 {
 435         struct tc3589x *tc3589x = dev_get_drvdata(dev);
 436         struct i2c_client *client = tc3589x->i2c;
 437         int ret = 0;
 438
 439         /* enable the system into operation */
 440         if (!device_may_wakeup(&client->dev))
 441                 ret = tc3589x_reg_write(tc3589x, TC3589x_CLKMODE,
 442                                 TC3589x_CLKMODE_MODCTL_OPERATION);
 443
 444         return ret;
 445 }
 446 #endif
 447
 448 static SIMPLE_DEV_PM_OPS(tc3589x_dev_pm_ops, tc3589x_suspend, tc3589x_resume);
 449
 450 static const struct i2c_device_id tc3589x_id[] = {
 451         { "tc3589x", 24 },
 452         { }
 453 };
 454 MODULE_DEVICE_TABLE(i2c, tc3589x_id);
 455
 456 static struct i2c_driver tc3589x_driver = {
 457         .driver.name    = "tc3589x",
 458         .driver.owner   = THIS_MODULE,
 459         .driver.pm      = &tc3589x_dev_pm_ops,
 460         .probe          = tc3589x_probe,
 461         .remove         = __devexit_p(tc3589x_remove),
 462         .id_table       = tc3589x_id,
 463 };
 464
 465 static int __init tc3589x_init(void)
 466 {
 467         return i2c_add_driver(&tc3589x_driver);
 468 }
 469 subsys_initcall(tc3589x_init);
 470
 471 static void __exit tc3589x_exit(void)
 472 {
 473         i2c_del_driver(&tc3589x_driver);
 474 }
 475 module_exit(tc3589x_exit);
 476
 477 MODULE_LICENSE("GPL v2");
 478 MODULE_DESCRIPTION("TC3589x MFD core driver");
 479 MODULE_AUTHOR("Hanumath Prasad, Rabin Vincent");