1/* 2 * Base driver for Dialog Semiconductor DA9030/DA9034 3 * 4 * Copyright (C) 2008 Compulab, Ltd. 5 * Mike Rapoport <mike@compulab.co.il> 6 * 7 * Copyright (C) 2006-2008 Marvell International Ltd. 8 * Eric Miao <eric.miao@marvell.com> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 */ 14 15#include <linux/kernel.h> 16#include <linux/module.h> 17#include <linux/interrupt.h> 18#include <linux/platform_device.h> 19#include <linux/i2c.h> 20#include <linux/mfd/da903x.h> 21#include <linux/slab.h> 22 23#define DA9030_CHIP_ID 0x00 24#define DA9030_EVENT_A 0x01 25#define DA9030_EVENT_B 0x02 26#define DA9030_EVENT_C 0x03 27#define DA9030_STATUS 0x04 28#define DA9030_IRQ_MASK_A 0x05 29#define DA9030_IRQ_MASK_B 0x06 30#define DA9030_IRQ_MASK_C 0x07 31#define DA9030_SYS_CTRL_A 0x08 32#define DA9030_SYS_CTRL_B 0x09 33#define DA9030_FAULT_LOG 0x0a 34 35#define DA9034_CHIP_ID 0x00 36#define DA9034_EVENT_A 0x01 37#define DA9034_EVENT_B 0x02 38#define DA9034_EVENT_C 0x03 39#define DA9034_EVENT_D 0x04 40#define DA9034_STATUS_A 0x05 41#define DA9034_STATUS_B 0x06 42#define DA9034_IRQ_MASK_A 0x07 43#define DA9034_IRQ_MASK_B 0x08 44#define DA9034_IRQ_MASK_C 0x09 45#define DA9034_IRQ_MASK_D 0x0a 46#define DA9034_SYS_CTRL_A 0x0b 47#define DA9034_SYS_CTRL_B 0x0c 48#define DA9034_FAULT_LOG 0x0d 49 50struct da903x_chip; 51 52struct da903x_chip_ops { 53 int (*init_chip)(struct da903x_chip *); 54 int (*unmask_events)(struct da903x_chip *, unsigned int events); 55 int (*mask_events)(struct da903x_chip *, unsigned int events); 56 int (*read_events)(struct da903x_chip *, unsigned int *events); 57 int (*read_status)(struct da903x_chip *, unsigned int *status); 58}; 59 60struct da903x_chip { 61 struct i2c_client *client; 62 struct device *dev; 63 struct da903x_chip_ops *ops; 64 65 int type; 66 uint32_t events_mask; 67 68 struct mutex lock; 69 struct work_struct irq_work; 70 71 struct blocking_notifier_head notifier_list; 72}; 73 74static inline int __da903x_read(struct i2c_client *client, 75 int reg, uint8_t *val) 76{ 77 int ret; 78 79 ret = i2c_smbus_read_byte_data(client, reg); 80 if (ret < 0) { 81 dev_err(&client->dev, "failed reading at 0x%02x\n", reg); 82 return ret; 83 } 84 85 *val = (uint8_t)ret; 86 return 0; 87} 88 89static inline int __da903x_reads(struct i2c_client *client, int reg, 90 int len, uint8_t *val) 91{ 92 int ret; 93 94 ret = i2c_smbus_read_i2c_block_data(client, reg, len, val); 95 if (ret < 0) { 96 dev_err(&client->dev, "failed reading from 0x%02x\n", reg); 97 return ret; 98 } 99 return 0; 100} 101 102static inline int __da903x_write(struct i2c_client *client, 103 int reg, uint8_t val) 104{ 105 int ret; 106 107 ret = i2c_smbus_write_byte_data(client, reg, val); 108 if (ret < 0) { 109 dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n", 110 val, reg); 111 return ret; 112 } 113 return 0; 114} 115 116static inline int __da903x_writes(struct i2c_client *client, int reg, 117 int len, uint8_t *val) 118{ 119 int ret; 120 121 ret = i2c_smbus_write_i2c_block_data(client, reg, len, val); 122 if (ret < 0) { 123 dev_err(&client->dev, "failed writings to 0x%02x\n", reg); 124 return ret; 125 } 126 return 0; 127} 128 129int da903x_register_notifier(struct device *dev, struct notifier_block *nb, 130 unsigned int events) 131{ 132 struct da903x_chip *chip = dev_get_drvdata(dev); 133 134 chip->ops->unmask_events(chip, events); 135 return blocking_notifier_chain_register(&chip->notifier_list, nb); 136} 137EXPORT_SYMBOL_GPL(da903x_register_notifier); 138 139int da903x_unregister_notifier(struct device *dev, struct notifier_block *nb, 140 unsigned int events) 141{ 142 struct da903x_chip *chip = dev_get_drvdata(dev); 143 144 chip->ops->mask_events(chip, events); 145 return blocking_notifier_chain_unregister(&chip->notifier_list, nb); 146} 147EXPORT_SYMBOL_GPL(da903x_unregister_notifier); 148 149int da903x_write(struct device *dev, int reg, uint8_t val) 150{ 151 return __da903x_write(to_i2c_client(dev), reg, val); 152} 153EXPORT_SYMBOL_GPL(da903x_write); 154 155int da903x_writes(struct device *dev, int reg, int len, uint8_t *val) 156{ 157 return __da903x_writes(to_i2c_client(dev), reg, len, val); 158} 159EXPORT_SYMBOL_GPL(da903x_writes); 160 161int da903x_read(struct device *dev, int reg, uint8_t *val) 162{ 163 return __da903x_read(to_i2c_client(dev), reg, val); 164} 165EXPORT_SYMBOL_GPL(da903x_read); 166 167int da903x_reads(struct device *dev, int reg, int len, uint8_t *val) 168{ 169 return __da903x_reads(to_i2c_client(dev), reg, len, val); 170} 171EXPORT_SYMBOL_GPL(da903x_reads); 172 173int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask) 174{ 175 struct da903x_chip *chip = dev_get_drvdata(dev); 176 uint8_t reg_val; 177 int ret = 0; 178 179 mutex_lock(&chip->lock); 180 181 ret = __da903x_read(chip->client, reg, ®_val); 182 if (ret) 183 goto out; 184 185 if ((reg_val & bit_mask) == 0) { 186 reg_val |= bit_mask; 187 ret = __da903x_write(chip->client, reg, reg_val); 188 } 189out: 190 mutex_unlock(&chip->lock); 191 return ret; 192} 193EXPORT_SYMBOL_GPL(da903x_set_bits); 194 195int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask) 196{ 197 struct da903x_chip *chip = dev_get_drvdata(dev); 198 uint8_t reg_val; 199 int ret = 0; 200 201 mutex_lock(&chip->lock); 202 203 ret = __da903x_read(chip->client, reg, ®_val); 204 if (ret) 205 goto out; 206 207 if (reg_val & bit_mask) { 208 reg_val &= ~bit_mask; 209 ret = __da903x_write(chip->client, reg, reg_val); 210 } 211out: 212 mutex_unlock(&chip->lock); 213 return ret; 214} 215EXPORT_SYMBOL_GPL(da903x_clr_bits); 216 217int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask) 218{ 219 struct da903x_chip *chip = dev_get_drvdata(dev); 220 uint8_t reg_val; 221 int ret = 0; 222 223 mutex_lock(&chip->lock); 224 225 ret = __da903x_read(chip->client, reg, ®_val); 226 if (ret) 227 goto out; 228 229 if ((reg_val & mask) != val) { 230 reg_val = (reg_val & ~mask) | val; 231 ret = __da903x_write(chip->client, reg, reg_val); 232 } 233out: 234 mutex_unlock(&chip->lock); 235 return ret; 236} 237EXPORT_SYMBOL_GPL(da903x_update); 238 239int da903x_query_status(struct device *dev, unsigned int sbits) 240{ 241 struct da903x_chip *chip = dev_get_drvdata(dev); 242 unsigned int status = 0; 243 244 chip->ops->read_status(chip, &status); 245 return ((status & sbits) == sbits); 246} 247EXPORT_SYMBOL(da903x_query_status); 248 249static int __devinit da9030_init_chip(struct da903x_chip *chip) 250{ 251 uint8_t chip_id; 252 int err; 253 254 err = __da903x_read(chip->client, DA9030_CHIP_ID, &chip_id); 255 if (err) 256 return err; 257 258 err = __da903x_write(chip->client, DA9030_SYS_CTRL_A, 0xE8); 259 if (err) 260 return err; 261 262 dev_info(chip->dev, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id); 263 return 0; 264} 265 266static int da9030_unmask_events(struct da903x_chip *chip, unsigned int events) 267{ 268 uint8_t v[3]; 269 270 chip->events_mask &= ~events; 271 272 v[0] = (chip->events_mask & 0xff); 273 v[1] = (chip->events_mask >> 8) & 0xff; 274 v[2] = (chip->events_mask >> 16) & 0xff; 275 276 return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v); 277} 278 279static int da9030_mask_events(struct da903x_chip *chip, unsigned int events) 280{ 281 uint8_t v[3]; 282 283 chip->events_mask |= events; 284 285 v[0] = (chip->events_mask & 0xff); 286 v[1] = (chip->events_mask >> 8) & 0xff; 287 v[2] = (chip->events_mask >> 16) & 0xff; 288 289 return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v); 290} 291 292static int da9030_read_events(struct da903x_chip *chip, unsigned int *events) 293{ 294 uint8_t v[3] = {0, 0, 0}; 295 int ret; 296 297 ret = __da903x_reads(chip->client, DA9030_EVENT_A, 3, v); 298 if (ret < 0) 299 return ret; 300 301 *events = (v[2] << 16) | (v[1] << 8) | v[0]; 302 return 0; 303} 304 305static int da9030_read_status(struct da903x_chip *chip, unsigned int *status) 306{ 307 return __da903x_read(chip->client, DA9030_STATUS, (uint8_t *)status); 308} 309 310static int da9034_init_chip(struct da903x_chip *chip) 311{ 312 uint8_t chip_id; 313 int err; 314 315 err = __da903x_read(chip->client, DA9034_CHIP_ID, &chip_id); 316 if (err) 317 return err; 318 319 err = __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0xE8); 320 if (err) 321 return err; 322 323 /* avoid SRAM power off during sleep*/ 324 __da903x_write(chip->client, 0x10, 0x07); 325 __da903x_write(chip->client, 0x11, 0xff); 326 __da903x_write(chip->client, 0x12, 0xff); 327 328 /* Enable the ONKEY power down functionality */ 329 __da903x_write(chip->client, DA9034_SYS_CTRL_B, 0x20); 330 __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0x60); 331 332 __da903x_write(chip->client, 0x90, 0x01); 333 __da903x_write(chip->client, 0xB0, 0x08); 334 335 /* make ADTV1 and SDTV1 effective */ 336 __da903x_write(chip->client, 0x20, 0x00); 337 338 dev_info(chip->dev, "DA9034 (CHIP ID: 0x%02x) detected\n", chip_id); 339 return 0; 340} 341 342static int da9034_unmask_events(struct da903x_chip *chip, unsigned int events) 343{ 344 uint8_t v[4]; 345 346 chip->events_mask &= ~events; 347 348 v[0] = (chip->events_mask & 0xff); 349 v[1] = (chip->events_mask >> 8) & 0xff; 350 v[2] = (chip->events_mask >> 16) & 0xff; 351 v[3] = (chip->events_mask >> 24) & 0xff; 352 353 return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v); 354} 355 356static int da9034_mask_events(struct da903x_chip *chip, unsigned int events) 357{ 358 uint8_t v[4]; 359 360 chip->events_mask |= events; 361 362 v[0] = (chip->events_mask & 0xff); 363 v[1] = (chip->events_mask >> 8) & 0xff; 364 v[2] = (chip->events_mask >> 16) & 0xff; 365 v[3] = (chip->events_mask >> 24) & 0xff; 366 367 return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v); 368} 369 370static int da9034_read_events(struct da903x_chip *chip, unsigned int *events) 371{ 372 uint8_t v[4] = {0, 0, 0, 0}; 373 int ret; 374 375 ret = __da903x_reads(chip->client, DA9034_EVENT_A, 4, v); 376 if (ret < 0) 377 return ret; 378 379 *events = (v[3] << 24) | (v[2] << 16) | (v[1] << 8) | v[0]; 380 return 0; 381} 382 383static int da9034_read_status(struct da903x_chip *chip, unsigned int *status) 384{ 385 uint8_t v[2] = {0, 0}; 386 int ret = 0; 387 388 ret = __da903x_reads(chip->client, DA9034_STATUS_A, 2, v); 389 if (ret) 390 return ret; 391 392 *status = (v[1] << 8) | v[0]; 393 return 0; 394} 395 396static void da903x_irq_work(struct work_struct *work) 397{ 398 struct da903x_chip *chip = 399 container_of(work, struct da903x_chip, irq_work); 400 unsigned int events = 0; 401 402 while (1) { 403 if (chip->ops->read_events(chip, &events)) 404 break; 405 406 events &= ~chip->events_mask; 407 if (events == 0) 408 break; 409 410 blocking_notifier_call_chain( 411 &chip->notifier_list, events, NULL); 412 } 413 enable_irq(chip->client->irq); 414} 415 416static irqreturn_t da903x_irq_handler(int irq, void *data) 417{ 418 struct da903x_chip *chip = data; 419 420 disable_irq_nosync(irq); 421 (void)schedule_work(&chip->irq_work); 422 423 return IRQ_HANDLED; 424} 425 426static struct da903x_chip_ops da903x_ops[] = { 427 [0] = { 428 .init_chip = da9030_init_chip, 429 .unmask_events = da9030_unmask_events, 430 .mask_events = da9030_mask_events, 431 .read_events = da9030_read_events, 432 .read_status = da9030_read_status, 433 }, 434 [1] = { 435 .init_chip = da9034_init_chip, 436 .unmask_events = da9034_unmask_events, 437 .mask_events = da9034_mask_events, 438 .read_events = da9034_read_events, 439 .read_status = da9034_read_status, 440 } 441}; 442 443static const struct i2c_device_id da903x_id_table[] = { 444 { "da9030", 0 }, 445 { "da9034", 1 }, 446 { }, 447}; 448MODULE_DEVICE_TABLE(i2c, da903x_id_table); 449 450static int __remove_subdev(struct device *dev, void *unused) 451{ 452 platform_device_unregister(to_platform_device(dev)); 453 return 0; 454} 455 456static int da903x_remove_subdevs(struct da903x_chip *chip) 457{ 458 return device_for_each_child(chip->dev, NULL, __remove_subdev); 459} 460 461static int __devinit da903x_add_subdevs(struct da903x_chip *chip, 462 struct da903x_platform_data *pdata) 463{ 464 struct da903x_subdev_info *subdev; 465 struct platform_device *pdev; 466 int i, ret = 0; 467 468 for (i = 0; i < pdata->num_subdevs; i++) { 469 subdev = &pdata->subdevs[i]; 470 471 pdev = platform_device_alloc(subdev->name, subdev->id); 472 473 pdev->dev.parent = chip->dev; 474 pdev->dev.platform_data = subdev->platform_data; 475 476 ret = platform_device_add(pdev); 477 if (ret) 478 goto failed; 479 } 480 return 0; 481 482failed: 483 da903x_remove_subdevs(chip); 484 return ret; 485} 486 487static int __devinit da903x_probe(struct i2c_client *client, 488 const struct i2c_device_id *id) 489{ 490 struct da903x_platform_data *pdata = client->dev.platform_data; 491 struct da903x_chip *chip; 492 unsigned int tmp; 493 int ret; 494 495 chip = kzalloc(sizeof(struct da903x_chip), GFP_KERNEL); 496 if (chip == NULL) 497 return -ENOMEM; 498 499 chip->client = client; 500 chip->dev = &client->dev; 501 chip->ops = &da903x_ops[id->driver_data]; 502 503 mutex_init(&chip->lock); 504 INIT_WORK(&chip->irq_work, da903x_irq_work); 505 BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list); 506 507 i2c_set_clientdata(client, chip); 508 509 ret = chip->ops->init_chip(chip); 510 if (ret) 511 goto out_free_chip; 512 513 /* mask and clear all IRQs */ 514 chip->events_mask = 0xffffffff; 515 chip->ops->mask_events(chip, chip->events_mask); 516 chip->ops->read_events(chip, &tmp); 517 518 ret = request_irq(client->irq, da903x_irq_handler, 519 IRQF_DISABLED | IRQF_TRIGGER_FALLING, 520 "da903x", chip); 521 if (ret) { 522 dev_err(&client->dev, "failed to request irq %d\n", 523 client->irq); 524 goto out_free_chip; 525 } 526 527 ret = da903x_add_subdevs(chip, pdata); 528 if (ret) 529 goto out_free_irq; 530 531 return 0; 532 533out_free_irq: 534 free_irq(client->irq, chip); 535out_free_chip: 536 kfree(chip); 537 return ret; 538} 539 540static int __devexit da903x_remove(struct i2c_client *client) 541{ 542 struct da903x_chip *chip = i2c_get_clientdata(client); 543 544 da903x_remove_subdevs(chip); 545 kfree(chip); 546 return 0; 547} 548 549static struct i2c_driver da903x_driver = { 550 .driver = { 551 .name = "da903x", 552 .owner = THIS_MODULE, 553 }, 554 .probe = da903x_probe, 555 .remove = __devexit_p(da903x_remove), 556 .id_table = da903x_id_table, 557}; 558 559static int __init da903x_init(void) 560{ 561 return i2c_add_driver(&da903x_driver); 562} 563subsys_initcall(da903x_init); 564 565static void __exit da903x_exit(void) 566{ 567 i2c_del_driver(&da903x_driver); 568} 569module_exit(da903x_exit); 570 571MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034"); 572MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>" 573 "Mike Rapoport <mike@compulab.co.il>"); 574MODULE_LICENSE("GPL"); 575