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