drivers/mfd/wm8994-core.c

   1 /*
   2  * wm8994-core.c  --  Device access for Wolfson WM8994
   3  *
   4  * Copyright 2009 Wolfson Microelectronics PLC.
   5  *
   6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  *
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/i2c.h>
  19 #include <linux/delay.h>
  20 #include <linux/mfd/core.h>
  21 #include <linux/regulator/consumer.h>
  22 #include <linux/regulator/machine.h>
  23
  24 #include <linux/mfd/wm8994/core.h>
  25 #include <linux/mfd/wm8994/pdata.h>
  26 #include <linux/mfd/wm8994/registers.h>
  27
  28 static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
  29                        int bytes, void *dest)
  30 {
  31         int ret, i;
  32         u16 *buf = dest;
  33
  34         BUG_ON(bytes % 2);
  35         BUG_ON(bytes <= 0);
  36
  37         ret = wm8994->read_dev(wm8994, reg, bytes, dest);
  38         if (ret < 0)
  39                 return ret;
  40
  41         for (i = 0; i < bytes / 2; i++) {
  42                 buf[i] = be16_to_cpu(buf[i]);
  43
  44                 dev_vdbg(wm8994->dev, "Read %04x from R%d(0x%x)\n",
  45                          buf[i], reg + i, reg + i);
  46         }
  47
  48         return 0;
  49 }
  50
  51 /**
  52  * wm8994_reg_read: Read a single WM8994 register.
  53  *
  54  * @wm8994: Device to read from.
  55  * @reg: Register to read.
  56  */
  57 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
  58 {
  59         unsigned short val;
  60         int ret;
  61
  62         mutex_lock(&wm8994->io_lock);
  63
  64         ret = wm8994_read(wm8994, reg, 2, &val);
  65
  66         mutex_unlock(&wm8994->io_lock);
  67
  68         if (ret < 0)
  69                 return ret;
  70         else
  71                 return val;
  72 }
  73 EXPORT_SYMBOL_GPL(wm8994_reg_read);
  74
  75 /**
  76  * wm8994_bulk_read: Read multiple WM8994 registers
  77  *
  78  * @wm8994: Device to read from
  79  * @reg: First register
  80  * @count: Number of registers
  81  * @buf: Buffer to fill.
  82  */
  83 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
  84                      int count, u16 *buf)
  85 {
  86         int ret;
  87
  88         mutex_lock(&wm8994->io_lock);
  89
  90         ret = wm8994_read(wm8994, reg, count * 2, buf);
  91
  92         mutex_unlock(&wm8994->io_lock);
  93
  94         return ret;
  95 }
  96 EXPORT_SYMBOL_GPL(wm8994_bulk_read);
  97
  98 static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
  99                         int bytes, void *src)
 100 {
 101         u16 *buf = src;
 102         int i;
 103
 104         BUG_ON(bytes % 2);
 105         BUG_ON(bytes <= 0);
 106
 107         for (i = 0; i < bytes / 2; i++) {
 108                 dev_vdbg(wm8994->dev, "Write %04x to R%d(0x%x)\n",
 109                          buf[i], reg + i, reg + i);
 110
 111                 buf[i] = cpu_to_be16(buf[i]);
 112         }
 113
 114         return wm8994->write_dev(wm8994, reg, bytes, src);
 115 }
 116
 117 /**
 118  * wm8994_reg_write: Write a single WM8994 register.
 119  *
 120  * @wm8994: Device to write to.
 121  * @reg: Register to write to.
 122  * @val: Value to write.
 123  */
 124 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
 125                      unsigned short val)
 126 {
 127         int ret;
 128
 129         mutex_lock(&wm8994->io_lock);
 130
 131         ret = wm8994_write(wm8994, reg, 2, &val);
 132
 133         mutex_unlock(&wm8994->io_lock);
 134
 135         return ret;
 136 }
 137 EXPORT_SYMBOL_GPL(wm8994_reg_write);
 138
 139 /**
 140  * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
 141  *
 142  * @wm8994: Device to write to.
 143  * @reg: Register to write to.
 144  * @mask: Mask of bits to set.
 145  * @val: Value to set (unshifted)
 146  */
 147 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
 148                     unsigned short mask, unsigned short val)
 149 {
 150         int ret;
 151         u16 r;
 152
 153         mutex_lock(&wm8994->io_lock);
 154
 155         ret = wm8994_read(wm8994, reg, 2, &r);
 156         if (ret < 0)
 157                 goto out;
 158
 159         r &= ~mask;
 160         r |= val;
 161
 162         ret = wm8994_write(wm8994, reg, 2, &r);
 163
 164 out:
 165         mutex_unlock(&wm8994->io_lock);
 166
 167         return ret;
 168 }
 169 EXPORT_SYMBOL_GPL(wm8994_set_bits);
 170
 171 static struct mfd_cell wm8994_regulator_devs[] = {
 172         { .name = "wm8994-ldo", .id = 1 },
 173         { .name = "wm8994-ldo", .id = 2 },
 174 };
 175
 176 static struct resource wm8994_codec_resources[] = {
 177         {
 178                 .start = WM8994_IRQ_TEMP_SHUT,
 179                 .end   = WM8994_IRQ_TEMP_WARN,
 180                 .flags = IORESOURCE_IRQ,
 181         },
 182 };
 183
 184 static struct resource wm8994_gpio_resources[] = {
 185         {
 186                 .start = WM8994_IRQ_GPIO(1),
 187                 .end   = WM8994_IRQ_GPIO(11),
 188                 .flags = IORESOURCE_IRQ,
 189         },
 190 };
 191
 192 static struct mfd_cell wm8994_devs[] = {
 193         {
 194                 .name = "wm8994-codec",
 195                 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
 196                 .resources = wm8994_codec_resources,
 197         },
 198
 199         {
 200                 .name = "wm8994-gpio",
 201                 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
 202                 .resources = wm8994_gpio_resources,
 203         },
 204 };
 205
 206 /*
 207  * Supplies for the main bulk of CODEC; the LDO supplies are ignored
 208  * and should be handled via the standard regulator API supply
 209  * management.
 210  */
 211 static const char *wm8994_main_supplies[] = {
 212         "DBVDD",
 213         "DCVDD",
 214         "AVDD1",
 215         "AVDD2",
 216         "CPVDD",
 217         "SPKVDD1",
 218         "SPKVDD2",
 219 };
 220
 221 static const char *wm8958_main_supplies[] = {
 222         "DBVDD1",
 223         "DBVDD2",
 224         "DBVDD3",
 225         "DCVDD",
 226         "AVDD1",
 227         "AVDD2",
 228         "CPVDD",
 229         "SPKVDD1",
 230         "SPKVDD2",
 231 };
 232
 233 #ifdef CONFIG_PM
 234 static int wm8994_device_suspend(struct device *dev)
 235 {
 236         struct wm8994 *wm8994 = dev_get_drvdata(dev);
 237         int ret;
 238
 239         /* GPIO configuration state is saved here since we may be configuring
 240          * the GPIO alternate functions even if we're not using the gpiolib
 241          * driver for them.
 242          */
 243         ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 244                           &wm8994->gpio_regs);
 245         if (ret < 0)
 246                 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
 247
 248         /* For similar reasons we also stash the regulator states */
 249         ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 250                           &wm8994->ldo_regs);
 251         if (ret < 0)
 252                 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
 253
 254         ret = regulator_bulk_disable(wm8994->num_supplies,
 255                                      wm8994->supplies);
 256         if (ret != 0) {
 257                 dev_err(dev, "Failed to disable supplies: %d\n", ret);
 258                 return ret;
 259         }
 260
 261         return 0;
 262 }
 263
 264 static int wm8994_device_resume(struct device *dev)
 265 {
 266         struct wm8994 *wm8994 = dev_get_drvdata(dev);
 267         int ret;
 268
 269         ret = regulator_bulk_enable(wm8994->num_supplies,
 270                                     wm8994->supplies);
 271         if (ret != 0) {
 272                 dev_err(dev, "Failed to enable supplies: %d\n", ret);
 273                 return ret;
 274         }
 275
 276         ret = wm8994_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK,
 277                            WM8994_NUM_IRQ_REGS * 2, &wm8994->irq_masks_cur);
 278         if (ret < 0)
 279                 dev_err(dev, "Failed to restore interrupt masks: %d\n", ret);
 280
 281         ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 282                            &wm8994->ldo_regs);
 283         if (ret < 0)
 284                 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
 285
 286         ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 287                            &wm8994->gpio_regs);
 288         if (ret < 0)
 289                 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
 290
 291         return 0;
 292 }
 293 #endif
 294
 295 #ifdef CONFIG_REGULATOR
 296 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 297 {
 298         struct wm8994_ldo_pdata *ldo_pdata;
 299
 300         if (!pdata)
 301                 return 0;
 302
 303         ldo_pdata = &pdata->ldo[ldo];
 304
 305         if (!ldo_pdata->init_data)
 306                 return 0;
 307
 308         return ldo_pdata->init_data->num_consumer_supplies != 0;
 309 }
 310 #else
 311 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 312 {
 313         return 0;
 314 }
 315 #endif
 316
 317 /*
 318  * Instantiate the generic non-control parts of the device.
 319  */
 320 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
 321 {
 322         struct wm8994_pdata *pdata = wm8994->dev->platform_data;
 323         const char *devname;
 324         int ret, i;
 325
 326         mutex_init(&wm8994->io_lock);
 327         dev_set_drvdata(wm8994->dev, wm8994);
 328
 329         /* Add the on-chip regulators first for bootstrapping */
 330         ret = mfd_add_devices(wm8994->dev, -1,
 331                               wm8994_regulator_devs,
 332                               ARRAY_SIZE(wm8994_regulator_devs),
 333                               NULL, 0);
 334         if (ret != 0) {
 335                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 336                 goto err;
 337         }
 338
 339         switch (wm8994->type) {
 340         case WM8994:
 341                 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
 342                 break;
 343         case WM8958:
 344                 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
 345                 break;
 346         default:
 347                 BUG();
 348                 return -EINVAL;
 349         }
 350
 351         wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
 352                                    wm8994->num_supplies,
 353                                    GFP_KERNEL);
 354         if (!wm8994->supplies) {
 355                 ret = -ENOMEM;
 356                 goto err;
 357         }
 358
 359         switch (wm8994->type) {
 360         case WM8994:
 361                 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
 362                         wm8994->supplies[i].supply = wm8994_main_supplies[i];
 363                 break;
 364         case WM8958:
 365                 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
 366                         wm8994->supplies[i].supply = wm8958_main_supplies[i];
 367                 break;
 368         default:
 369                 BUG();
 370                 return -EINVAL;
 371         }
 372
 373         ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
 374                                  wm8994->supplies);
 375         if (ret != 0) {
 376                 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
 377                 goto err_supplies;
 378         }
 379
 380         ret = regulator_bulk_enable(wm8994->num_supplies,
 381                                     wm8994->supplies);
 382         if (ret != 0) {
 383                 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
 384                 goto err_get;
 385         }
 386
 387         ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
 388         if (ret < 0) {
 389                 dev_err(wm8994->dev, "Failed to read ID register\n");
 390                 goto err_enable;
 391         }
 392         switch (ret) {
 393         case 0x8994:
 394                 devname = "WM8994";
 395                 if (wm8994->type != WM8994)
 396                         dev_warn(wm8994->dev, "Device registered as type %d\n",
 397                                  wm8994->type);
 398                 wm8994->type = WM8994;
 399                 break;
 400         case 0x8958:
 401                 devname = "WM8958";
 402                 if (wm8994->type != WM8958)
 403                         dev_warn(wm8994->dev, "Device registered as type %d\n",
 404                                  wm8994->type);
 405                 wm8994->type = WM8958;
 406                 break;
 407         default:
 408                 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
 409                         ret);
 410                 ret = -EINVAL;
 411                 goto err_enable;
 412         }
 413
 414         ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
 415         if (ret < 0) {
 416                 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
 417                         ret);
 418                 goto err_enable;
 419         }
 420
 421         switch (ret) {
 422         case 0:
 423         case 1:
 424                 if (wm8994->type == WM8994)
 425                         dev_warn(wm8994->dev,
 426                                  "revision %c not fully supported\n",
 427                                  'A' + ret);
 428                 break;
 429         default:
 430                 break;
 431         }
 432
 433         dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
 434
 435         if (pdata) {
 436                 wm8994->irq_base = pdata->irq_base;
 437                 wm8994->gpio_base = pdata->gpio_base;
 438
 439                 /* GPIO configuration is only applied if it's non-zero */
 440                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 441                         if (pdata->gpio_defaults[i]) {
 442                                 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
 443                                                 0xffff,
 444                                                 pdata->gpio_defaults[i]);
 445                         }
 446                 }
 447         }
 448
 449         /* In some system designs where the regulators are not in use,
 450          * we can achieve a small reduction in leakage currents by
 451          * floating LDO outputs.  This bit makes no difference if the
 452          * LDOs are enabled, it only affects cases where the LDOs were
 453          * in operation and are then disabled.
 454          */
 455         for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
 456                 if (wm8994_ldo_in_use(pdata, i))
 457                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 458                                         WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
 459                 else
 460                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 461                                         WM8994_LDO1_DISCH, 0);
 462         }
 463
 464         wm8994_irq_init(wm8994);
 465
 466         ret = mfd_add_devices(wm8994->dev, -1,
 467                               wm8994_devs, ARRAY_SIZE(wm8994_devs),
 468                               NULL, 0);
 469         if (ret != 0) {
 470                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 471                 goto err_irq;
 472         }
 473
 474         return 0;
 475
 476 err_irq:
 477         wm8994_irq_exit(wm8994);
 478 err_enable:
 479         regulator_bulk_disable(wm8994->num_supplies,
 480                                wm8994->supplies);
 481 err_get:
 482         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 483 err_supplies:
 484         kfree(wm8994->supplies);
 485 err:
 486         mfd_remove_devices(wm8994->dev);
 487         kfree(wm8994);
 488         return ret;
 489 }
 490
 491 static void wm8994_device_exit(struct wm8994 *wm8994)
 492 {
 493         mfd_remove_devices(wm8994->dev);
 494         wm8994_irq_exit(wm8994);
 495         regulator_bulk_disable(wm8994->num_supplies,
 496                                wm8994->supplies);
 497         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 498         kfree(wm8994->supplies);
 499         kfree(wm8994);
 500 }
 501
 502 static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
 503                                   int bytes, void *dest)
 504 {
 505         struct i2c_client *i2c = wm8994->control_data;
 506         int ret;
 507         u16 r = cpu_to_be16(reg);
 508
 509         ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
 510         if (ret < 0)
 511                 return ret;
 512         if (ret != 2)
 513                 return -EIO;
 514
 515         ret = i2c_master_recv(i2c, dest, bytes);
 516         if (ret < 0)
 517                 return ret;
 518         if (ret != bytes)
 519                 return -EIO;
 520         return 0;
 521 }
 522
 523 /* Currently we allocate the write buffer on the stack; this is OK for
 524  * small writes - if we need to do large writes this will need to be
 525  * revised.
 526  */
 527 static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
 528                                    int bytes, void *src)
 529 {
 530         struct i2c_client *i2c = wm8994->control_data;
 531         unsigned char msg[bytes + 2];
 532         int ret;
 533
 534         reg = cpu_to_be16(reg);
 535         memcpy(&msg[0], &reg, 2);
 536         memcpy(&msg[2], src, bytes);
 537
 538         ret = i2c_master_send(i2c, msg, bytes + 2);
 539         if (ret < 0)
 540                 return ret;
 541         if (ret < bytes + 2)
 542                 return -EIO;
 543
 544         return 0;
 545 }
 546
 547 static int wm8994_i2c_probe(struct i2c_client *i2c,
 548                             const struct i2c_device_id *id)
 549 {
 550         struct wm8994 *wm8994;
 551
 552         wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
 553         if (wm8994 == NULL)
 554                 return -ENOMEM;
 555
 556         i2c_set_clientdata(i2c, wm8994);
 557         wm8994->dev = &i2c->dev;
 558         wm8994->control_data = i2c;
 559         wm8994->read_dev = wm8994_i2c_read_device;
 560         wm8994->write_dev = wm8994_i2c_write_device;
 561         wm8994->irq = i2c->irq;
 562         wm8994->type = id->driver_data;
 563
 564         return wm8994_device_init(wm8994, i2c->irq);
 565 }
 566
 567 static int wm8994_i2c_remove(struct i2c_client *i2c)
 568 {
 569         struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
 570
 571         wm8994_device_exit(wm8994);
 572
 573         return 0;
 574 }
 575
 576 #ifdef CONFIG_PM
 577 static int wm8994_i2c_suspend(struct i2c_client *i2c, pm_message_t state)
 578 {
 579         return wm8994_device_suspend(&i2c->dev);
 580 }
 581
 582 static int wm8994_i2c_resume(struct i2c_client *i2c)
 583 {
 584         return wm8994_device_resume(&i2c->dev);
 585 }
 586 #else
 587 #define wm8994_i2c_suspend NULL
 588 #define wm8994_i2c_resume NULL
 589 #endif
 590
 591 static const struct i2c_device_id wm8994_i2c_id[] = {
 592         { "wm8994", WM8994 },
 593         { "wm8958", WM8958 },
 594         { }
 595 };
 596 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
 597
 598 static struct i2c_driver wm8994_i2c_driver = {
 599         .driver = {
 600                    .name = "wm8994",
 601                    .owner = THIS_MODULE,
 602         },
 603         .probe = wm8994_i2c_probe,
 604         .remove = wm8994_i2c_remove,
 605         .suspend = wm8994_i2c_suspend,
 606         .resume = wm8994_i2c_resume,
 607         .id_table = wm8994_i2c_id,
 608 };
 609
 610 static int __init wm8994_i2c_init(void)
 611 {
 612         int ret;
 613
 614         ret = i2c_add_driver(&wm8994_i2c_driver);
 615         if (ret != 0)
 616                 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
 617
 618         return ret;
 619 }
 620 module_init(wm8994_i2c_init);
 621
 622 static void __exit wm8994_i2c_exit(void)
 623 {
 624         i2c_del_driver(&wm8994_i2c_driver);
 625 }
 626 module_exit(wm8994_i2c_exit);
 627
 628 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
 629 MODULE_LICENSE("GPL");
 630 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");