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