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