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                 goto err;
 331
 332         for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
 333                 wm8994->supplies[i].supply = wm8994_main_supplies[i];
 334
 335         ret = regulator_bulk_get(wm8994->dev, ARRAY_SIZE(wm8994_main_supplies),
 336                                  wm8994->supplies);
 337         if (ret != 0) {
 338                 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
 339                 goto err_supplies;
 340         }
 341
 342         ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies),
 343                                     wm8994->supplies);
 344         if (ret != 0) {
 345                 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
 346                 goto err_get;
 347         }
 348
 349         ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
 350         if (ret < 0) {
 351                 dev_err(wm8994->dev, "Failed to read ID register\n");
 352                 goto err_enable;
 353         }
 354         if (ret != 0x8994) {
 355                 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
 356                         ret);
 357                 ret = -EINVAL;
 358                 goto err_enable;
 359         }
 360
 361         ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
 362         if (ret < 0) {
 363                 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
 364                         ret);
 365                 goto err_enable;
 366         }
 367
 368         switch (ret) {
 369         case 0:
 370         case 1:
 371                 dev_warn(wm8994->dev, "revision %c not fully supported\n",
 372                         'A' + ret);
 373                 break;
 374         default:
 375                 dev_info(wm8994->dev, "revision %c\n", 'A' + ret);
 376                 break;
 377         }
 378
 379
 380         if (pdata) {
 381                 wm8994->irq_base = pdata->irq_base;
 382                 wm8994->gpio_base = pdata->gpio_base;
 383
 384                 /* GPIO configuration is only applied if it's non-zero */
 385                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 386                         if (pdata->gpio_defaults[i]) {
 387                                 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
 388                                                 0xffff,
 389                                                 pdata->gpio_defaults[i]);
 390                         }
 391                 }
 392         }
 393
 394         /* In some system designs where the regulators are not in use,
 395          * we can achieve a small reduction in leakage currents by
 396          * floating LDO outputs.  This bit makes no difference if the
 397          * LDOs are enabled, it only affects cases where the LDOs were
 398          * in operation and are then disabled.
 399          */
 400         for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
 401                 if (wm8994_ldo_in_use(pdata, i))
 402                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 403                                         WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
 404                 else
 405                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 406                                         WM8994_LDO1_DISCH, 0);
 407         }
 408
 409         wm8994_irq_init(wm8994);
 410
 411         ret = mfd_add_devices(wm8994->dev, -1,
 412                               wm8994_devs, ARRAY_SIZE(wm8994_devs),
 413                               NULL, 0);
 414         if (ret != 0) {
 415                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 416                 goto err_irq;
 417         }
 418
 419         return 0;
 420
 421 err_irq:
 422         wm8994_irq_exit(wm8994);
 423 err_enable:
 424         regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
 425                                wm8994->supplies);
 426 err_get:
 427         regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies);
 428 err_supplies:
 429         kfree(wm8994->supplies);
 430 err:
 431         mfd_remove_devices(wm8994->dev);
 432         kfree(wm8994);
 433         return ret;
 434 }
 435
 436 static void wm8994_device_exit(struct wm8994 *wm8994)
 437 {
 438         mfd_remove_devices(wm8994->dev);
 439         wm8994_irq_exit(wm8994);
 440         regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
 441                                wm8994->supplies);
 442         regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies);
 443         kfree(wm8994->supplies);
 444         kfree(wm8994);
 445 }
 446
 447 static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
 448                                   int bytes, void *dest)
 449 {
 450         struct i2c_client *i2c = wm8994->control_data;
 451         int ret;
 452         u16 r = cpu_to_be16(reg);
 453
 454         ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
 455         if (ret < 0)
 456                 return ret;
 457         if (ret != 2)
 458                 return -EIO;
 459
 460         ret = i2c_master_recv(i2c, dest, bytes);
 461         if (ret < 0)
 462                 return ret;
 463         if (ret != bytes)
 464                 return -EIO;
 465         return 0;
 466 }
 467
 468 /* Currently we allocate the write buffer on the stack; this is OK for
 469  * small writes - if we need to do large writes this will need to be
 470  * revised.
 471  */
 472 static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
 473                                    int bytes, void *src)
 474 {
 475         struct i2c_client *i2c = wm8994->control_data;
 476         unsigned char msg[bytes + 2];
 477         int ret;
 478
 479         reg = cpu_to_be16(reg);
 480         memcpy(&msg[0], &reg, 2);
 481         memcpy(&msg[2], src, bytes);
 482
 483         ret = i2c_master_send(i2c, msg, bytes + 2);
 484         if (ret < 0)
 485                 return ret;
 486         if (ret < bytes + 2)
 487                 return -EIO;
 488
 489         return 0;
 490 }
 491
 492 static int wm8994_i2c_probe(struct i2c_client *i2c,
 493                             const struct i2c_device_id *id)
 494 {
 495         struct wm8994 *wm8994;
 496
 497         wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
 498         if (wm8994 == NULL) {
 499                 kfree(i2c);
 500                 return -ENOMEM;
 501         }
 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>");