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], ®, 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>"); 576