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