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 22 #define DA9030_CHIP_ID 0x00 23 #define DA9030_EVENT_A 0x01 24 #define DA9030_EVENT_B 0x02 25 #define DA9030_EVENT_C 0x03 26 #define DA9030_STATUS 0x04 27 #define DA9030_IRQ_MASK_A 0x05 28 #define DA9030_IRQ_MASK_B 0x06 29 #define DA9030_IRQ_MASK_C 0x07 30 #define DA9030_SYS_CTRL_A 0x08 31 #define DA9030_SYS_CTRL_B 0x09 32 #define DA9030_FAULT_LOG 0x0a 33 34 #define DA9034_CHIP_ID 0x00 35 #define DA9034_EVENT_A 0x01 36 #define DA9034_EVENT_B 0x02 37 #define DA9034_EVENT_C 0x03 38 #define DA9034_EVENT_D 0x04 39 #define DA9034_STATUS_A 0x05 40 #define DA9034_STATUS_B 0x06 41 #define DA9034_IRQ_MASK_A 0x07 42 #define DA9034_IRQ_MASK_B 0x08 43 #define DA9034_IRQ_MASK_C 0x09 44 #define DA9034_IRQ_MASK_D 0x0a 45 #define DA9034_SYS_CTRL_A 0x0b 46 #define DA9034_SYS_CTRL_B 0x0c 47 #define DA9034_FAULT_LOG 0x0d 48 49 struct da903x_chip; 50 51 struct da903x_chip_ops { 52 int (*init_chip)(struct da903x_chip *); 53 int (*unmask_events)(struct da903x_chip *, unsigned int events); 54 int (*mask_events)(struct da903x_chip *, unsigned int events); 55 int (*read_events)(struct da903x_chip *, unsigned int *events); 56 int (*read_status)(struct da903x_chip *, unsigned int *status); 57 }; 58 59 struct da903x_chip { 60 struct i2c_client *client; 61 struct device *dev; 62 struct da903x_chip_ops *ops; 63 64 int type; 65 uint32_t events_mask; 66 67 struct mutex lock; 68 struct work_struct irq_work; 69 70 struct blocking_notifier_head notifier_list; 71 }; 72 73 static inline int __da903x_read(struct i2c_client *client, 74 int reg, uint8_t *val) 75 { 76 int ret; 77 78 ret = i2c_smbus_read_byte_data(client, reg); 79 if (ret < 0) { 80 dev_err(&client->dev, "failed reading at 0x%02x\n", reg); 81 return ret; 82 } 83 84 *val = (uint8_t)ret; 85 return 0; 86 } 87 88 static inline int __da903x_reads(struct i2c_client *client, int reg, 89 int len, uint8_t *val) 90 { 91 int ret; 92 93 ret = i2c_smbus_read_i2c_block_data(client, reg, len, val); 94 if (ret < 0) { 95 dev_err(&client->dev, "failed reading from 0x%02x\n", reg); 96 return ret; 97 } 98 return 0; 99 } 100 101 static inline int __da903x_write(struct i2c_client *client, 102 int reg, uint8_t val) 103 { 104 int ret; 105 106 ret = i2c_smbus_write_byte_data(client, reg, val); 107 if (ret < 0) { 108 dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n", 109 val, reg); 110 return ret; 111 } 112 return 0; 113 } 114 115 static inline int __da903x_writes(struct i2c_client *client, int reg, 116 int len, uint8_t *val) 117 { 118 int ret; 119 120 ret = i2c_smbus_write_i2c_block_data(client, reg, len, val); 121 if (ret < 0) { 122 dev_err(&client->dev, "failed writings to 0x%02x\n", reg); 123 return ret; 124 } 125 return 0; 126 } 127 128 int da903x_register_notifier(struct device *dev, struct notifier_block *nb, 129 unsigned int events) 130 { 131 struct da903x_chip *chip = dev_get_drvdata(dev); 132 133 chip->ops->unmask_events(chip, events); 134 return blocking_notifier_chain_register(&chip->notifier_list, nb); 135 } 136 EXPORT_SYMBOL_GPL(da903x_register_notifier); 137 138 int da903x_unregister_notifier(struct device *dev, struct notifier_block *nb, 139 unsigned int events) 140 { 141 struct da903x_chip *chip = dev_get_drvdata(dev); 142 143 chip->ops->mask_events(chip, events); 144 return blocking_notifier_chain_unregister(&chip->notifier_list, nb); 145 } 146 EXPORT_SYMBOL_GPL(da903x_unregister_notifier); 147 148 int da903x_write(struct device *dev, int reg, uint8_t val) 149 { 150 return __da903x_write(to_i2c_client(dev), reg, val); 151 } 152 EXPORT_SYMBOL_GPL(da903x_write); 153 154 int da903x_writes(struct device *dev, int reg, int len, uint8_t *val) 155 { 156 return __da903x_writes(to_i2c_client(dev), reg, len, val); 157 } 158 EXPORT_SYMBOL_GPL(da903x_writes); 159 160 int da903x_read(struct device *dev, int reg, uint8_t *val) 161 { 162 return __da903x_read(to_i2c_client(dev), reg, val); 163 } 164 EXPORT_SYMBOL_GPL(da903x_read); 165 166 int da903x_reads(struct device *dev, int reg, int len, uint8_t *val) 167 { 168 return __da903x_reads(to_i2c_client(dev), reg, len, val); 169 } 170 EXPORT_SYMBOL_GPL(da903x_reads); 171 172 int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask) 173 { 174 struct da903x_chip *chip = dev_get_drvdata(dev); 175 uint8_t reg_val; 176 int ret = 0; 177 178 mutex_lock(&chip->lock); 179 180 ret = __da903x_read(chip->client, reg, ®_val); 181 if (ret) 182 goto out; 183 184 if ((reg_val & bit_mask) == 0) { 185 reg_val |= bit_mask; 186 ret = __da903x_write(chip->client, reg, reg_val); 187 } 188 out: 189 mutex_unlock(&chip->lock); 190 return ret; 191 } 192 EXPORT_SYMBOL_GPL(da903x_set_bits); 193 194 int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask) 195 { 196 struct da903x_chip *chip = dev_get_drvdata(dev); 197 uint8_t reg_val; 198 int ret = 0; 199 200 mutex_lock(&chip->lock); 201 202 ret = __da903x_read(chip->client, reg, ®_val); 203 if (ret) 204 goto out; 205 206 if (reg_val & bit_mask) { 207 reg_val &= ~bit_mask; 208 ret = __da903x_write(chip->client, reg, reg_val); 209 } 210 out: 211 mutex_unlock(&chip->lock); 212 return ret; 213 } 214 EXPORT_SYMBOL_GPL(da903x_clr_bits); 215 216 int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask) 217 { 218 struct da903x_chip *chip = dev_get_drvdata(dev); 219 uint8_t reg_val; 220 int ret = 0; 221 222 mutex_lock(&chip->lock); 223 224 ret = __da903x_read(chip->client, reg, ®_val); 225 if (ret) 226 goto out; 227 228 if ((reg_val & mask) != val) { 229 reg_val = (reg_val & ~mask) | val; 230 ret = __da903x_write(chip->client, reg, reg_val); 231 } 232 out: 233 mutex_unlock(&chip->lock); 234 return ret; 235 } 236 EXPORT_SYMBOL_GPL(da903x_update); 237 238 int da903x_query_status(struct device *dev, unsigned int sbits) 239 { 240 struct da903x_chip *chip = dev_get_drvdata(dev); 241 unsigned int status = 0; 242 243 chip->ops->read_status(chip, &status); 244 return ((status & sbits) == sbits); 245 } 246 EXPORT_SYMBOL(da903x_query_status); 247 248 static int __devinit da9030_init_chip(struct da903x_chip *chip) 249 { 250 uint8_t chip_id; 251 int err; 252 253 err = __da903x_read(chip->client, DA9030_CHIP_ID, &chip_id); 254 if (err) 255 return err; 256 257 err = __da903x_write(chip->client, DA9030_SYS_CTRL_A, 0xE8); 258 if (err) 259 return err; 260 261 dev_info(chip->dev, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id); 262 return 0; 263 } 264 265 static int da9030_unmask_events(struct da903x_chip *chip, unsigned int events) 266 { 267 uint8_t v[3]; 268 269 chip->events_mask &= ~events; 270 271 v[0] = (chip->events_mask & 0xff); 272 v[1] = (chip->events_mask >> 8) & 0xff; 273 v[2] = (chip->events_mask >> 16) & 0xff; 274 275 return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v); 276 } 277 278 static int da9030_mask_events(struct da903x_chip *chip, unsigned int events) 279 { 280 uint8_t v[3]; 281 282 chip->events_mask |= events; 283 284 v[0] = (chip->events_mask & 0xff); 285 v[1] = (chip->events_mask >> 8) & 0xff; 286 v[2] = (chip->events_mask >> 16) & 0xff; 287 288 return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v); 289 } 290 291 static int da9030_read_events(struct da903x_chip *chip, unsigned int *events) 292 { 293 uint8_t v[3] = {0, 0, 0}; 294 int ret; 295 296 ret = __da903x_reads(chip->client, DA9030_EVENT_A, 3, v); 297 if (ret < 0) 298 return ret; 299 300 *events = (v[2] << 16) | (v[1] << 8) | v[0]; 301 return 0; 302 } 303 304 static int da9030_read_status(struct da903x_chip *chip, unsigned int *status) 305 { 306 return __da903x_read(chip->client, DA9030_STATUS, (uint8_t *)status); 307 } 308 309 static int da9034_init_chip(struct da903x_chip *chip) 310 { 311 uint8_t chip_id; 312 int err; 313 314 err = __da903x_read(chip->client, DA9034_CHIP_ID, &chip_id); 315 if (err) 316 return err; 317 318 err = __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0xE8); 319 if (err) 320 return err; 321 322 /* avoid SRAM power off during sleep*/ 323 __da903x_write(chip->client, 0x10, 0x07); 324 __da903x_write(chip->client, 0x11, 0xff); 325 __da903x_write(chip->client, 0x12, 0xff); 326 327 /* Enable the ONKEY power down functionality */ 328 __da903x_write(chip->client, DA9034_SYS_CTRL_B, 0x20); 329 __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0x60); 330 331 /* workaround to make LEDs work */ 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 342 static 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 356 static 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 370 static 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 383 static 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 396 static 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 416 static 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 426 static 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 443 static const struct i2c_device_id da903x_id_table[] = { 444 { "da9030", 0 }, 445 { "da9034", 1 }, 446 { }, 447 }; 448 MODULE_DEVICE_TABLE(i2c, da903x_id_table); 449 450 static int __remove_subdev(struct device *dev, void *unused) 451 { 452 platform_device_unregister(to_platform_device(dev)); 453 return 0; 454 } 455 456 static int da903x_remove_subdevs(struct da903x_chip *chip) 457 { 458 return device_for_each_child(chip->dev, NULL, __remove_subdev); 459 } 460 461 static 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 482 failed: 483 da903x_remove_subdevs(chip); 484 return ret; 485 } 486 487 static 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 533 out_free_irq: 534 free_irq(client->irq, chip); 535 out_free_chip: 536 i2c_set_clientdata(client, NULL); 537 kfree(chip); 538 return ret; 539 } 540 541 static int __devexit da903x_remove(struct i2c_client *client) 542 { 543 struct da903x_chip *chip = i2c_get_clientdata(client); 544 545 da903x_remove_subdevs(chip); 546 kfree(chip); 547 return 0; 548 } 549 550 static struct i2c_driver da903x_driver = { 551 .driver = { 552 .name = "da903x", 553 .owner = THIS_MODULE, 554 }, 555 .probe = da903x_probe, 556 .remove = __devexit_p(da903x_remove), 557 .id_table = da903x_id_table, 558 }; 559 560 static int __init da903x_init(void) 561 { 562 return i2c_add_driver(&da903x_driver); 563 } 564 module_init(da903x_init); 565 566 static void __exit da903x_exit(void) 567 { 568 i2c_del_driver(&da903x_driver); 569 } 570 module_exit(da903x_exit); 571 572 MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034"); 573 MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>" 574 "Mike Rapoport <mike@compulab.co.il>"); 575 MODULE_LICENSE("GPL"); 576