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