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