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         /* Explicitly put the device into reset in case regulators
 275          * don't get disabled in order to ensure consistent restart.
 276          */
 277         wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
 278
 279         wm8994->suspended = true;
 280
 281         ret = regulator_bulk_disable(wm8994->num_supplies,
 282                                      wm8994->supplies);
 283         if (ret != 0) {
 284                 dev_err(dev, "Failed to disable supplies: %d\n", ret);
 285                 return ret;
 286         }
 287
 288         return 0;
 289 }
 290
 291 static int wm8994_resume(struct device *dev)
 292 {
 293         struct wm8994 *wm8994 = dev_get_drvdata(dev);
 294         int ret;
 295
 296         /* We may have lied to the PM core about suspending */
 297         if (!wm8994->suspended)
 298                 return 0;
 299
 300         ret = regulator_bulk_enable(wm8994->num_supplies,
 301                                     wm8994->supplies);
 302         if (ret != 0) {
 303                 dev_err(dev, "Failed to enable supplies: %d\n", ret);
 304                 return ret;
 305         }
 306
 307         ret = wm8994_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK,
 308                            WM8994_NUM_IRQ_REGS * 2, &wm8994->irq_masks_cur);
 309         if (ret < 0)
 310                 dev_err(dev, "Failed to restore interrupt masks: %d\n", ret);
 311
 312         ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 313                            &wm8994->ldo_regs);
 314         if (ret < 0)
 315                 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
 316
 317         ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 318                            &wm8994->gpio_regs);
 319         if (ret < 0)
 320                 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
 321
 322         wm8994->suspended = false;
 323
 324         return 0;
 325 }
 326 #endif
 327
 328 #ifdef CONFIG_REGULATOR
 329 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 330 {
 331         struct wm8994_ldo_pdata *ldo_pdata;
 332
 333         if (!pdata)
 334                 return 0;
 335
 336         ldo_pdata = &pdata->ldo[ldo];
 337
 338         if (!ldo_pdata->init_data)
 339                 return 0;
 340
 341         return ldo_pdata->init_data->num_consumer_supplies != 0;
 342 }
 343 #else
 344 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 345 {
 346         return 0;
 347 }
 348 #endif
 349
 350 /*
 351  * Instantiate the generic non-control parts of the device.
 352  */
 353 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
 354 {
 355         struct wm8994_pdata *pdata = wm8994->dev->platform_data;
 356         const char *devname;
 357         int ret, i;
 358
 359         mutex_init(&wm8994->io_lock);
 360         dev_set_drvdata(wm8994->dev, wm8994);
 361
 362         /* Add the on-chip regulators first for bootstrapping */
 363         ret = mfd_add_devices(wm8994->dev, -1,
 364                               wm8994_regulator_devs,
 365                               ARRAY_SIZE(wm8994_regulator_devs),
 366                               NULL, 0);
 367         if (ret != 0) {
 368                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 369                 goto err;
 370         }
 371
 372         switch (wm8994->type) {
 373         case WM8994:
 374                 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
 375                 break;
 376         case WM8958:
 377                 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
 378                 break;
 379         default:
 380                 BUG();
 381                 return -EINVAL;
 382         }
 383
 384         wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
 385                                    wm8994->num_supplies,
 386                                    GFP_KERNEL);
 387         if (!wm8994->supplies) {
 388                 ret = -ENOMEM;
 389                 goto err;
 390         }
 391
 392         switch (wm8994->type) {
 393         case WM8994:
 394                 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
 395                         wm8994->supplies[i].supply = wm8994_main_supplies[i];
 396                 break;
 397         case WM8958:
 398                 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
 399                         wm8994->supplies[i].supply = wm8958_main_supplies[i];
 400                 break;
 401         default:
 402                 BUG();
 403                 return -EINVAL;
 404         }
 405
 406         ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
 407                                  wm8994->supplies);
 408         if (ret != 0) {
 409                 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
 410                 goto err_supplies;
 411         }
 412
 413         ret = regulator_bulk_enable(wm8994->num_supplies,
 414                                     wm8994->supplies);
 415         if (ret != 0) {
 416                 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
 417                 goto err_get;
 418         }
 419
 420         ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
 421         if (ret < 0) {
 422                 dev_err(wm8994->dev, "Failed to read ID register\n");
 423                 goto err_enable;
 424         }
 425         switch (ret) {
 426         case 0x8994:
 427                 devname = "WM8994";
 428                 if (wm8994->type != WM8994)
 429                         dev_warn(wm8994->dev, "Device registered as type %d\n",
 430                                  wm8994->type);
 431                 wm8994->type = WM8994;
 432                 break;
 433         case 0x8958:
 434                 devname = "WM8958";
 435                 if (wm8994->type != WM8958)
 436                         dev_warn(wm8994->dev, "Device registered as type %d\n",
 437                                  wm8994->type);
 438                 wm8994->type = WM8958;
 439                 break;
 440         default:
 441                 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
 442                         ret);
 443                 ret = -EINVAL;
 444                 goto err_enable;
 445         }
 446
 447         ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
 448         if (ret < 0) {
 449                 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
 450                         ret);
 451                 goto err_enable;
 452         }
 453
 454         switch (ret) {
 455         case 0:
 456         case 1:
 457                 if (wm8994->type == WM8994)
 458                         dev_warn(wm8994->dev,
 459                                  "revision %c not fully supported\n",
 460                                  'A' + ret);
 461                 break;
 462         default:
 463                 break;
 464         }
 465
 466         dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
 467
 468         if (pdata) {
 469                 wm8994->irq_base = pdata->irq_base;
 470                 wm8994->gpio_base = pdata->gpio_base;
 471
 472                 /* GPIO configuration is only applied if it's non-zero */
 473                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 474                         if (pdata->gpio_defaults[i]) {
 475                                 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
 476                                                 0xffff,
 477                                                 pdata->gpio_defaults[i]);
 478                         }
 479                 }
 480         }
 481
 482         /* In some system designs where the regulators are not in use,
 483          * we can achieve a small reduction in leakage currents by
 484          * floating LDO outputs.  This bit makes no difference if the
 485          * LDOs are enabled, it only affects cases where the LDOs were
 486          * in operation and are then disabled.
 487          */
 488         for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
 489                 if (wm8994_ldo_in_use(pdata, i))
 490                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 491                                         WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
 492                 else
 493                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 494                                         WM8994_LDO1_DISCH, 0);
 495         }
 496
 497         wm8994_irq_init(wm8994);
 498
 499         ret = mfd_add_devices(wm8994->dev, -1,
 500                               wm8994_devs, ARRAY_SIZE(wm8994_devs),
 501                               NULL, 0);
 502         if (ret != 0) {
 503                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 504                 goto err_irq;
 505         }
 506
 507         pm_runtime_enable(wm8994->dev);
 508         pm_runtime_resume(wm8994->dev);
 509
 510         return 0;
 511
 512 err_irq:
 513         wm8994_irq_exit(wm8994);
 514 err_enable:
 515         regulator_bulk_disable(wm8994->num_supplies,
 516                                wm8994->supplies);
 517 err_get:
 518         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 519 err_supplies:
 520         kfree(wm8994->supplies);
 521 err:
 522         mfd_remove_devices(wm8994->dev);
 523         kfree(wm8994);
 524         return ret;
 525 }
 526
 527 static void wm8994_device_exit(struct wm8994 *wm8994)
 528 {
 529         pm_runtime_disable(wm8994->dev);
 530         mfd_remove_devices(wm8994->dev);
 531         wm8994_irq_exit(wm8994);
 532         regulator_bulk_disable(wm8994->num_supplies,
 533                                wm8994->supplies);
 534         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
 535         kfree(wm8994->supplies);
 536         kfree(wm8994);
 537 }
 538
 539 static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
 540                                   int bytes, void *dest)
 541 {
 542         struct i2c_client *i2c = wm8994->control_data;
 543         int ret;
 544         u16 r = cpu_to_be16(reg);
 545
 546         ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
 547         if (ret < 0)
 548                 return ret;
 549         if (ret != 2)
 550                 return -EIO;
 551
 552         ret = i2c_master_recv(i2c, dest, bytes);
 553         if (ret < 0)
 554                 return ret;
 555         if (ret != bytes)
 556                 return -EIO;
 557         return 0;
 558 }
 559
 560 /* Currently we allocate the write buffer on the stack; this is OK for
 561  * small writes - if we need to do large writes this will need to be
 562  * revised.
 563  */
 564 static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
 565                                    int bytes, void *src)
 566 {
 567         struct i2c_client *i2c = wm8994->control_data;
 568         unsigned char msg[bytes + 2];
 569         int ret;
 570
 571         reg = cpu_to_be16(reg);
 572         memcpy(&msg[0], &reg, 2);
 573         memcpy(&msg[2], src, bytes);
 574
 575         ret = i2c_master_send(i2c, msg, bytes + 2);
 576         if (ret < 0)
 577                 return ret;
 578         if (ret < bytes + 2)
 579                 return -EIO;
 580
 581         return 0;
 582 }
 583
 584 static int wm8994_i2c_probe(struct i2c_client *i2c,
 585                             const struct i2c_device_id *id)
 586 {
 587         struct wm8994 *wm8994;
 588
 589         wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
 590         if (wm8994 == NULL)
 591                 return -ENOMEM;
 592
 593         i2c_set_clientdata(i2c, wm8994);
 594         wm8994->dev = &i2c->dev;
 595         wm8994->control_data = i2c;
 596         wm8994->read_dev = wm8994_i2c_read_device;
 597         wm8994->write_dev = wm8994_i2c_write_device;
 598         wm8994->irq = i2c->irq;
 599         wm8994->type = id->driver_data;
 600
 601         return wm8994_device_init(wm8994, i2c->irq);
 602 }
 603
 604 static int wm8994_i2c_remove(struct i2c_client *i2c)
 605 {
 606         struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
 607
 608         wm8994_device_exit(wm8994);
 609
 610         return 0;
 611 }
 612
 613 static const struct i2c_device_id wm8994_i2c_id[] = {
 614         { "wm8994", WM8994 },
 615         { "wm8958", WM8958 },
 616         { }
 617 };
 618 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
 619
 620 UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume, NULL);
 621
 622 static struct i2c_driver wm8994_i2c_driver = {
 623         .driver = {
 624                 .name = "wm8994",
 625                 .owner = THIS_MODULE,
 626                 .pm = &wm8994_pm_ops,
 627         },
 628         .probe = wm8994_i2c_probe,
 629         .remove = wm8994_i2c_remove,
 630         .id_table = wm8994_i2c_id,
 631 };
 632
 633 static int __init wm8994_i2c_init(void)
 634 {
 635         int ret;
 636
 637         ret = i2c_add_driver(&wm8994_i2c_driver);
 638         if (ret != 0)
 639                 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
 640
 641         return ret;
 642 }
 643 module_init(wm8994_i2c_init);
 644
 645 static void __exit wm8994_i2c_exit(void)
 646 {
 647         i2c_del_driver(&wm8994_i2c_driver);
 648 }
 649 module_exit(wm8994_i2c_exit);
 650
 651 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
 652 MODULE_LICENSE("GPL");
 653 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");