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 mfd_cell wm8994_devs[] = {
 177         { .name = "wm8994-codec" },
 178         { .name = "wm8994-gpio" },
 179 };
 180
 181 /*
 182  * Supplies for the main bulk of CODEC; the LDO supplies are ignored
 183  * and should be handled via the standard regulator API supply
 184  * management.
 185  */
 186 static const char *wm8994_main_supplies[] = {
 187         "DBVDD",
 188         "DCVDD",
 189         "AVDD1",
 190         "AVDD2",
 191         "CPVDD",
 192         "SPKVDD1",
 193         "SPKVDD2",
 194 };
 195
 196 #ifdef CONFIG_PM
 197 static int wm8994_device_suspend(struct device *dev)
 198 {
 199         struct wm8994 *wm8994 = dev_get_drvdata(dev);
 200         int ret;
 201
 202         /* GPIO configuration state is saved here since we may be configuring
 203          * the GPIO alternate functions even if we're not using the gpiolib
 204          * driver for them.
 205          */
 206         ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 207                           &wm8994->gpio_regs);
 208         if (ret < 0)
 209                 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
 210
 211         /* For similar reasons we also stash the regulator states */
 212         ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 213                           &wm8994->ldo_regs);
 214         if (ret < 0)
 215                 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
 216
 217         ret = regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
 218                                      wm8994->supplies);
 219         if (ret != 0) {
 220                 dev_err(dev, "Failed to disable supplies: %d\n", ret);
 221                 return ret;
 222         }
 223
 224         return 0;
 225 }
 226
 227 static int wm8994_device_resume(struct device *dev)
 228 {
 229         struct wm8994 *wm8994 = dev_get_drvdata(dev);
 230         int ret;
 231
 232         ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies),
 233                                     wm8994->supplies);
 234         if (ret != 0) {
 235                 dev_err(dev, "Failed to enable supplies: %d\n", ret);
 236                 return ret;
 237         }
 238
 239         ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
 240                            &wm8994->ldo_regs);
 241         if (ret < 0)
 242                 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
 243
 244         ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
 245                            &wm8994->gpio_regs);
 246         if (ret < 0)
 247                 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
 248
 249         return 0;
 250 }
 251 #endif
 252
 253 #ifdef CONFIG_REGULATOR
 254 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 255 {
 256         struct wm8994_ldo_pdata *ldo_pdata;
 257
 258         if (!pdata)
 259                 return 0;
 260
 261         ldo_pdata = &pdata->ldo[ldo];
 262
 263         if (!ldo_pdata->init_data)
 264                 return 0;
 265
 266         return ldo_pdata->init_data->num_consumer_supplies != 0;
 267 }
 268 #else
 269 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 270 {
 271         return 0;
 272 }
 273 #endif
 274
 275 /*
 276  * Instantiate the generic non-control parts of the device.
 277  */
 278 static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq)
 279 {
 280         struct wm8994_pdata *pdata = wm8994->dev->platform_data;
 281         int ret, i;
 282
 283         mutex_init(&wm8994->io_lock);
 284         dev_set_drvdata(wm8994->dev, wm8994);
 285
 286         /* Add the on-chip regulators first for bootstrapping */
 287         ret = mfd_add_devices(wm8994->dev, -1,
 288                               wm8994_regulator_devs,
 289                               ARRAY_SIZE(wm8994_regulator_devs),
 290                               NULL, 0);
 291         if (ret != 0) {
 292                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 293                 goto err;
 294         }
 295
 296         wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
 297                                    ARRAY_SIZE(wm8994_main_supplies),
 298                                    GFP_KERNEL);
 299         if (!wm8994->supplies)
 300                 goto err;
 301
 302         for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
 303                 wm8994->supplies[i].supply = wm8994_main_supplies[i];
 304
 305         ret = regulator_bulk_get(wm8994->dev, ARRAY_SIZE(wm8994_main_supplies),
 306                                  wm8994->supplies);
 307         if (ret != 0) {
 308                 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
 309                 goto err_supplies;
 310         }
 311
 312         ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies),
 313                                     wm8994->supplies);
 314         if (ret != 0) {
 315                 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
 316                 goto err_get;
 317         }
 318
 319         ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
 320         if (ret < 0) {
 321                 dev_err(wm8994->dev, "Failed to read ID register\n");
 322                 goto err_enable;
 323         }
 324         if (ret != 0x8994) {
 325                 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
 326                         ret);
 327                 ret = -EINVAL;
 328                 goto err_enable;
 329         }
 330
 331         ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
 332         if (ret < 0) {
 333                 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
 334                         ret);
 335                 goto err_enable;
 336         }
 337
 338         switch (ret) {
 339         case 0:
 340         case 1:
 341                 dev_warn(wm8994->dev, "revision %c not fully supported\n",
 342                         'A' + ret);
 343                 break;
 344         default:
 345                 dev_info(wm8994->dev, "revision %c\n", 'A' + ret);
 346                 break;
 347         }
 348
 349
 350         if (pdata) {
 351                 wm8994->gpio_base = pdata->gpio_base;
 352
 353                 /* GPIO configuration is only applied if it's non-zero */
 354                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
 355                         if (pdata->gpio_defaults[i]) {
 356                                 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
 357                                                 0xffff,
 358                                                 pdata->gpio_defaults[i]);
 359                         }
 360                 }
 361         }
 362
 363         /* In some system designs where the regulators are not in use,
 364          * we can achieve a small reduction in leakage currents by
 365          * floating LDO outputs.  This bit makes no difference if the
 366          * LDOs are enabled, it only affects cases where the LDOs were
 367          * in operation and are then disabled.
 368          */
 369         for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
 370                 if (wm8994_ldo_in_use(pdata, i))
 371                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 372                                         WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
 373                 else
 374                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
 375                                         WM8994_LDO1_DISCH, 0);
 376         }
 377
 378         ret = mfd_add_devices(wm8994->dev, -1,
 379                               wm8994_devs, ARRAY_SIZE(wm8994_devs),
 380                               NULL, 0);
 381         if (ret != 0) {
 382                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
 383                 goto err_enable;
 384         }
 385
 386         return 0;
 387
 388 err_enable:
 389         regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
 390                                wm8994->supplies);
 391 err_get:
 392         regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies);
 393 err_supplies:
 394         kfree(wm8994->supplies);
 395 err:
 396         mfd_remove_devices(wm8994->dev);
 397         kfree(wm8994);
 398         return ret;
 399 }
 400
 401 static void wm8994_device_exit(struct wm8994 *wm8994)
 402 {
 403         mfd_remove_devices(wm8994->dev);
 404         regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
 405                                wm8994->supplies);
 406         regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies);
 407         kfree(wm8994->supplies);
 408         kfree(wm8994);
 409 }
 410
 411 static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
 412                                   int bytes, void *dest)
 413 {
 414         struct i2c_client *i2c = wm8994->control_data;
 415         int ret;
 416         u16 r = cpu_to_be16(reg);
 417
 418         ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
 419         if (ret < 0)
 420                 return ret;
 421         if (ret != 2)
 422                 return -EIO;
 423
 424         ret = i2c_master_recv(i2c, dest, bytes);
 425         if (ret < 0)
 426                 return ret;
 427         if (ret != bytes)
 428                 return -EIO;
 429         return 0;
 430 }
 431
 432 /* Currently we allocate the write buffer on the stack; this is OK for
 433  * small writes - if we need to do large writes this will need to be
 434  * revised.
 435  */
 436 static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
 437                                    int bytes, void *src)
 438 {
 439         struct i2c_client *i2c = wm8994->control_data;
 440         unsigned char msg[bytes + 2];
 441         int ret;
 442
 443         reg = cpu_to_be16(reg);
 444         memcpy(&msg[0], &reg, 2);
 445         memcpy(&msg[2], src, bytes);
 446
 447         ret = i2c_master_send(i2c, msg, bytes + 2);
 448         if (ret < 0)
 449                 return ret;
 450         if (ret < bytes + 2)
 451                 return -EIO;
 452
 453         return 0;
 454 }
 455
 456 static int wm8994_i2c_probe(struct i2c_client *i2c,
 457                             const struct i2c_device_id *id)
 458 {
 459         struct wm8994 *wm8994;
 460
 461         wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
 462         if (wm8994 == NULL) {
 463                 kfree(i2c);
 464                 return -ENOMEM;
 465         }
 466
 467         i2c_set_clientdata(i2c, wm8994);
 468         wm8994->dev = &i2c->dev;
 469         wm8994->control_data = i2c;
 470         wm8994->read_dev = wm8994_i2c_read_device;
 471         wm8994->write_dev = wm8994_i2c_write_device;
 472
 473         return wm8994_device_init(wm8994, id->driver_data, i2c->irq);
 474 }
 475
 476 static int wm8994_i2c_remove(struct i2c_client *i2c)
 477 {
 478         struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
 479
 480         wm8994_device_exit(wm8994);
 481
 482         return 0;
 483 }
 484
 485 #ifdef CONFIG_PM
 486 static int wm8994_i2c_suspend(struct i2c_client *i2c, pm_message_t state)
 487 {
 488         return wm8994_device_suspend(&i2c->dev);
 489 }
 490
 491 static int wm8994_i2c_resume(struct i2c_client *i2c)
 492 {
 493         return wm8994_device_resume(&i2c->dev);
 494 }
 495 #else
 496 #define wm8994_i2c_suspend NULL
 497 #define wm8994_i2c_resume NULL
 498 #endif
 499
 500 static const struct i2c_device_id wm8994_i2c_id[] = {
 501         { "wm8994", 0 },
 502         { }
 503 };
 504 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
 505
 506 static struct i2c_driver wm8994_i2c_driver = {
 507         .driver = {
 508                    .name = "wm8994",
 509                    .owner = THIS_MODULE,
 510         },
 511         .probe = wm8994_i2c_probe,
 512         .remove = wm8994_i2c_remove,
 513         .suspend = wm8994_i2c_suspend,
 514         .resume = wm8994_i2c_resume,
 515         .id_table = wm8994_i2c_id,
 516 };
 517
 518 static int __init wm8994_i2c_init(void)
 519 {
 520         int ret;
 521
 522         ret = i2c_add_driver(&wm8994_i2c_driver);
 523         if (ret != 0)
 524                 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
 525
 526         return ret;
 527 }
 528 module_init(wm8994_i2c_init);
 529
 530 static void __exit wm8994_i2c_exit(void)
 531 {
 532         i2c_del_driver(&wm8994_i2c_driver);
 533 }
 534 module_exit(wm8994_i2c_exit);
 535
 536 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
 537 MODULE_LICENSE("GPL");
 538 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");