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