| 1 | |
| 2 | |
| 3 | * Base driver for Maxim MAX8925
|
| 4 | *
|
| 5 | * Copyright (C) 2009-2010 Marvell International Ltd.
|
| 6 | * Haojian Zhuang <[email protected]>
|
| 7 |
|
| 8 |
|
| 9 | #include <linux/kernel.h>
|
| 10 | #include <linux/init.h>
|
| 11 | #include <linux/i2c.h>
|
| 12 | #include <linux/irq.h>
|
| 13 | #include <linux/interrupt.h>
|
| 14 | #include <linux/irqdomain.h>
|
| 15 | #include <linux/platform_device.h>
|
| 16 | #include <linux/regulator/machine.h>
|
| 17 | #include <linux/mfd/core.h>
|
| 18 | #include <linux/mfd/max8925.h>
|
| 19 | #include <linux/of.h>
|
| 20 |
|
| 21 | static const struct resource bk_resources[] = {
|
| 22 | { 0x84, 0x84, "mode control", IORESOURCE_REG, },
|
| 23 | { 0x85, 0x85, "control", IORESOURCE_REG, },
|
| 24 | };
|
| 25 |
|
| 26 | static struct mfd_cell bk_devs[] = {
|
| 27 | {
|
| 28 | .name = "max8925-backlight",
|
| 29 | .num_resources = ARRAY_SIZE(bk_resources),
|
| 30 | .resources = &bk_resources[0],
|
| 31 | .id = -1,
|
| 32 | },
|
| 33 | };
|
| 34 |
|
| 35 | static const struct resource touch_resources[] = {
|
| 36 | {
|
| 37 | .name = "max8925-tsc",
|
| 38 | .start = MAX8925_TSC_IRQ,
|
| 39 | .end = MAX8925_ADC_RES_END,
|
| 40 | .flags = IORESOURCE_REG,
|
| 41 | },
|
| 42 | };
|
| 43 |
|
| 44 | static const struct mfd_cell touch_devs[] = {
|
| 45 | {
|
| 46 | .name = "max8925-touch",
|
| 47 | .num_resources = 1,
|
| 48 | .resources = &touch_resources[0],
|
| 49 | .id = -1,
|
| 50 | },
|
| 51 | };
|
| 52 |
|
| 53 | static const struct resource power_supply_resources[] = {
|
| 54 | {
|
| 55 | .name = "max8925-power",
|
| 56 | .start = MAX8925_CHG_IRQ1,
|
| 57 | .end = MAX8925_CHG_IRQ1_MASK,
|
| 58 | .flags = IORESOURCE_REG,
|
| 59 | },
|
| 60 | };
|
| 61 |
|
| 62 | static const struct mfd_cell power_devs[] = {
|
| 63 | {
|
| 64 | .name = "max8925-power",
|
| 65 | .num_resources = 1,
|
| 66 | .resources = &power_supply_resources[0],
|
| 67 | .id = -1,
|
| 68 | },
|
| 69 | };
|
| 70 |
|
| 71 | static const struct resource rtc_resources[] = {
|
| 72 | {
|
| 73 | .name = "max8925-rtc",
|
| 74 | .start = MAX8925_IRQ_RTC_ALARM0,
|
| 75 | .end = MAX8925_IRQ_RTC_ALARM0,
|
| 76 | .flags = IORESOURCE_IRQ,
|
| 77 | },
|
| 78 | };
|
| 79 |
|
| 80 | static const struct mfd_cell rtc_devs[] = {
|
| 81 | {
|
| 82 | .name = "max8925-rtc",
|
| 83 | .num_resources = 1,
|
| 84 | .resources = &rtc_resources[0],
|
| 85 | .id = -1,
|
| 86 | },
|
| 87 | };
|
| 88 |
|
| 89 | static const struct resource onkey_resources[] = {
|
| 90 | {
|
| 91 | .name = "max8925-onkey",
|
| 92 | .start = MAX8925_IRQ_GPM_SW_R,
|
| 93 | .end = MAX8925_IRQ_GPM_SW_R,
|
| 94 | .flags = IORESOURCE_IRQ,
|
| 95 | }, {
|
| 96 | .name = "max8925-onkey",
|
| 97 | .start = MAX8925_IRQ_GPM_SW_F,
|
| 98 | .end = MAX8925_IRQ_GPM_SW_F,
|
| 99 | .flags = IORESOURCE_IRQ,
|
| 100 | },
|
| 101 | };
|
| 102 |
|
| 103 | static const struct mfd_cell onkey_devs[] = {
|
| 104 | {
|
| 105 | .name = "max8925-onkey",
|
| 106 | .num_resources = 2,
|
| 107 | .resources = &onkey_resources[0],
|
| 108 | .id = -1,
|
| 109 | },
|
| 110 | };
|
| 111 |
|
| 112 | static const struct resource sd1_resources[] = {
|
| 113 | {0x06, 0x06, "sdv", IORESOURCE_REG, },
|
| 114 | };
|
| 115 |
|
| 116 | static const struct resource sd2_resources[] = {
|
| 117 | {0x09, 0x09, "sdv", IORESOURCE_REG, },
|
| 118 | };
|
| 119 |
|
| 120 | static const struct resource sd3_resources[] = {
|
| 121 | {0x0c, 0x0c, "sdv", IORESOURCE_REG, },
|
| 122 | };
|
| 123 |
|
| 124 | static const struct resource ldo1_resources[] = {
|
| 125 | {0x1a, 0x1a, "ldov", IORESOURCE_REG, },
|
| 126 | };
|
| 127 |
|
| 128 | static const struct resource ldo2_resources[] = {
|
| 129 | {0x1e, 0x1e, "ldov", IORESOURCE_REG, },
|
| 130 | };
|
| 131 |
|
| 132 | static const struct resource ldo3_resources[] = {
|
| 133 | {0x22, 0x22, "ldov", IORESOURCE_REG, },
|
| 134 | };
|
| 135 |
|
| 136 | static const struct resource ldo4_resources[] = {
|
| 137 | {0x26, 0x26, "ldov", IORESOURCE_REG, },
|
| 138 | };
|
| 139 |
|
| 140 | static const struct resource ldo5_resources[] = {
|
| 141 | {0x2a, 0x2a, "ldov", IORESOURCE_REG, },
|
| 142 | };
|
| 143 |
|
| 144 | static const struct resource ldo6_resources[] = {
|
| 145 | {0x2e, 0x2e, "ldov", IORESOURCE_REG, },
|
| 146 | };
|
| 147 |
|
| 148 | static const struct resource ldo7_resources[] = {
|
| 149 | {0x32, 0x32, "ldov", IORESOURCE_REG, },
|
| 150 | };
|
| 151 |
|
| 152 | static const struct resource ldo8_resources[] = {
|
| 153 | {0x36, 0x36, "ldov", IORESOURCE_REG, },
|
| 154 | };
|
| 155 |
|
| 156 | static const struct resource ldo9_resources[] = {
|
| 157 | {0x3a, 0x3a, "ldov", IORESOURCE_REG, },
|
| 158 | };
|
| 159 |
|
| 160 | static const struct resource ldo10_resources[] = {
|
| 161 | {0x3e, 0x3e, "ldov", IORESOURCE_REG, },
|
| 162 | };
|
| 163 |
|
| 164 | static const struct resource ldo11_resources[] = {
|
| 165 | {0x42, 0x42, "ldov", IORESOURCE_REG, },
|
| 166 | };
|
| 167 |
|
| 168 | static const struct resource ldo12_resources[] = {
|
| 169 | {0x46, 0x46, "ldov", IORESOURCE_REG, },
|
| 170 | };
|
| 171 |
|
| 172 | static const struct resource ldo13_resources[] = {
|
| 173 | {0x4a, 0x4a, "ldov", IORESOURCE_REG, },
|
| 174 | };
|
| 175 |
|
| 176 | static const struct resource ldo14_resources[] = {
|
| 177 | {0x4e, 0x4e, "ldov", IORESOURCE_REG, },
|
| 178 | };
|
| 179 |
|
| 180 | static const struct resource ldo15_resources[] = {
|
| 181 | {0x52, 0x52, "ldov", IORESOURCE_REG, },
|
| 182 | };
|
| 183 |
|
| 184 | static const struct resource ldo16_resources[] = {
|
| 185 | {0x12, 0x12, "ldov", IORESOURCE_REG, },
|
| 186 | };
|
| 187 |
|
| 188 | static const struct resource ldo17_resources[] = {
|
| 189 | {0x16, 0x16, "ldov", IORESOURCE_REG, },
|
| 190 | };
|
| 191 |
|
| 192 | static const struct resource ldo18_resources[] = {
|
| 193 | {0x74, 0x74, "ldov", IORESOURCE_REG, },
|
| 194 | };
|
| 195 |
|
| 196 | static const struct resource ldo19_resources[] = {
|
| 197 | {0x5e, 0x5e, "ldov", IORESOURCE_REG, },
|
| 198 | };
|
| 199 |
|
| 200 | static const struct resource ldo20_resources[] = {
|
| 201 | {0x9e, 0x9e, "ldov", IORESOURCE_REG, },
|
| 202 | };
|
| 203 |
|
| 204 | static struct mfd_cell reg_devs[] = {
|
| 205 | {
|
| 206 | .name = "max8925-regulator",
|
| 207 | .id = 0,
|
| 208 | .num_resources = ARRAY_SIZE(sd1_resources),
|
| 209 | .resources = sd1_resources,
|
| 210 | }, {
|
| 211 | .name = "max8925-regulator",
|
| 212 | .id = 1,
|
| 213 | .num_resources = ARRAY_SIZE(sd2_resources),
|
| 214 | .resources = sd2_resources,
|
| 215 | }, {
|
| 216 | .name = "max8925-regulator",
|
| 217 | .id = 2,
|
| 218 | .num_resources = ARRAY_SIZE(sd3_resources),
|
| 219 | .resources = sd3_resources,
|
| 220 | }, {
|
| 221 | .name = "max8925-regulator",
|
| 222 | .id = 3,
|
| 223 | .num_resources = ARRAY_SIZE(ldo1_resources),
|
| 224 | .resources = ldo1_resources,
|
| 225 | }, {
|
| 226 | .name = "max8925-regulator",
|
| 227 | .id = 4,
|
| 228 | .num_resources = ARRAY_SIZE(ldo2_resources),
|
| 229 | .resources = ldo2_resources,
|
| 230 | }, {
|
| 231 | .name = "max8925-regulator",
|
| 232 | .id = 5,
|
| 233 | .num_resources = ARRAY_SIZE(ldo3_resources),
|
| 234 | .resources = ldo3_resources,
|
| 235 | }, {
|
| 236 | .name = "max8925-regulator",
|
| 237 | .id = 6,
|
| 238 | .num_resources = ARRAY_SIZE(ldo4_resources),
|
| 239 | .resources = ldo4_resources,
|
| 240 | }, {
|
| 241 | .name = "max8925-regulator",
|
| 242 | .id = 7,
|
| 243 | .num_resources = ARRAY_SIZE(ldo5_resources),
|
| 244 | .resources = ldo5_resources,
|
| 245 | }, {
|
| 246 | .name = "max8925-regulator",
|
| 247 | .id = 8,
|
| 248 | .num_resources = ARRAY_SIZE(ldo6_resources),
|
| 249 | .resources = ldo6_resources,
|
| 250 | }, {
|
| 251 | .name = "max8925-regulator",
|
| 252 | .id = 9,
|
| 253 | .num_resources = ARRAY_SIZE(ldo7_resources),
|
| 254 | .resources = ldo7_resources,
|
| 255 | }, {
|
| 256 | .name = "max8925-regulator",
|
| 257 | .id = 10,
|
| 258 | .num_resources = ARRAY_SIZE(ldo8_resources),
|
| 259 | .resources = ldo8_resources,
|
| 260 | }, {
|
| 261 | .name = "max8925-regulator",
|
| 262 | .id = 11,
|
| 263 | .num_resources = ARRAY_SIZE(ldo9_resources),
|
| 264 | .resources = ldo9_resources,
|
| 265 | }, {
|
| 266 | .name = "max8925-regulator",
|
| 267 | .id = 12,
|
| 268 | .num_resources = ARRAY_SIZE(ldo10_resources),
|
| 269 | .resources = ldo10_resources,
|
| 270 | }, {
|
| 271 | .name = "max8925-regulator",
|
| 272 | .id = 13,
|
| 273 | .num_resources = ARRAY_SIZE(ldo11_resources),
|
| 274 | .resources = ldo11_resources,
|
| 275 | }, {
|
| 276 | .name = "max8925-regulator",
|
| 277 | .id = 14,
|
| 278 | .num_resources = ARRAY_SIZE(ldo12_resources),
|
| 279 | .resources = ldo12_resources,
|
| 280 | }, {
|
| 281 | .name = "max8925-regulator",
|
| 282 | .id = 15,
|
| 283 | .num_resources = ARRAY_SIZE(ldo13_resources),
|
| 284 | .resources = ldo13_resources,
|
| 285 | }, {
|
| 286 | .name = "max8925-regulator",
|
| 287 | .id = 16,
|
| 288 | .num_resources = ARRAY_SIZE(ldo14_resources),
|
| 289 | .resources = ldo14_resources,
|
| 290 | }, {
|
| 291 | .name = "max8925-regulator",
|
| 292 | .id = 17,
|
| 293 | .num_resources = ARRAY_SIZE(ldo15_resources),
|
| 294 | .resources = ldo15_resources,
|
| 295 | }, {
|
| 296 | .name = "max8925-regulator",
|
| 297 | .id = 18,
|
| 298 | .num_resources = ARRAY_SIZE(ldo16_resources),
|
| 299 | .resources = ldo16_resources,
|
| 300 | }, {
|
| 301 | .name = "max8925-regulator",
|
| 302 | .id = 19,
|
| 303 | .num_resources = ARRAY_SIZE(ldo17_resources),
|
| 304 | .resources = ldo17_resources,
|
| 305 | }, {
|
| 306 | .name = "max8925-regulator",
|
| 307 | .id = 20,
|
| 308 | .num_resources = ARRAY_SIZE(ldo18_resources),
|
| 309 | .resources = ldo18_resources,
|
| 310 | }, {
|
| 311 | .name = "max8925-regulator",
|
| 312 | .id = 21,
|
| 313 | .num_resources = ARRAY_SIZE(ldo19_resources),
|
| 314 | .resources = ldo19_resources,
|
| 315 | }, {
|
| 316 | .name = "max8925-regulator",
|
| 317 | .id = 22,
|
| 318 | .num_resources = ARRAY_SIZE(ldo20_resources),
|
| 319 | .resources = ldo20_resources,
|
| 320 | },
|
| 321 | };
|
| 322 |
|
| 323 | enum {
|
| 324 | FLAGS_ADC = 1,
|
| 325 | FLAGS_RTC,
|
| 326 | };
|
| 327 |
|
| 328 | struct max8925_irq_data {
|
| 329 | int reg;
|
| 330 | int mask_reg;
|
| 331 | int enable;
|
| 332 | int offs;
|
| 333 | int flags;
|
| 334 | int tsc_irq;
|
| 335 | };
|
| 336 |
|
| 337 | static struct max8925_irq_data max8925_irqs[] = {
|
| 338 | [MAX8925_IRQ_VCHG_DC_OVP] = {
|
| 339 | .reg = MAX8925_CHG_IRQ1,
|
| 340 | .mask_reg = MAX8925_CHG_IRQ1_MASK,
|
| 341 | .offs = 1 << 0,
|
| 342 | },
|
| 343 | [MAX8925_IRQ_VCHG_DC_F] = {
|
| 344 | .reg = MAX8925_CHG_IRQ1,
|
| 345 | .mask_reg = MAX8925_CHG_IRQ1_MASK,
|
| 346 | .offs = 1 << 1,
|
| 347 | },
|
| 348 | [MAX8925_IRQ_VCHG_DC_R] = {
|
| 349 | .reg = MAX8925_CHG_IRQ1,
|
| 350 | .mask_reg = MAX8925_CHG_IRQ1_MASK,
|
| 351 | .offs = 1 << 2,
|
| 352 | },
|
| 353 | [MAX8925_IRQ_VCHG_THM_OK_R] = {
|
| 354 | .reg = MAX8925_CHG_IRQ2,
|
| 355 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 356 | .offs = 1 << 0,
|
| 357 | },
|
| 358 | [MAX8925_IRQ_VCHG_THM_OK_F] = {
|
| 359 | .reg = MAX8925_CHG_IRQ2,
|
| 360 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 361 | .offs = 1 << 1,
|
| 362 | },
|
| 363 | [MAX8925_IRQ_VCHG_SYSLOW_F] = {
|
| 364 | .reg = MAX8925_CHG_IRQ2,
|
| 365 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 366 | .offs = 1 << 2,
|
| 367 | },
|
| 368 | [MAX8925_IRQ_VCHG_SYSLOW_R] = {
|
| 369 | .reg = MAX8925_CHG_IRQ2,
|
| 370 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 371 | .offs = 1 << 3,
|
| 372 | },
|
| 373 | [MAX8925_IRQ_VCHG_RST] = {
|
| 374 | .reg = MAX8925_CHG_IRQ2,
|
| 375 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 376 | .offs = 1 << 4,
|
| 377 | },
|
| 378 | [MAX8925_IRQ_VCHG_DONE] = {
|
| 379 | .reg = MAX8925_CHG_IRQ2,
|
| 380 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 381 | .offs = 1 << 5,
|
| 382 | },
|
| 383 | [MAX8925_IRQ_VCHG_TOPOFF] = {
|
| 384 | .reg = MAX8925_CHG_IRQ2,
|
| 385 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 386 | .offs = 1 << 6,
|
| 387 | },
|
| 388 | [MAX8925_IRQ_VCHG_TMR_FAULT] = {
|
| 389 | .reg = MAX8925_CHG_IRQ2,
|
| 390 | .mask_reg = MAX8925_CHG_IRQ2_MASK,
|
| 391 | .offs = 1 << 7,
|
| 392 | },
|
| 393 | [MAX8925_IRQ_GPM_RSTIN] = {
|
| 394 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 395 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 396 | .offs = 1 << 0,
|
| 397 | },
|
| 398 | [MAX8925_IRQ_GPM_MPL] = {
|
| 399 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 400 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 401 | .offs = 1 << 1,
|
| 402 | },
|
| 403 | [MAX8925_IRQ_GPM_SW_3SEC] = {
|
| 404 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 405 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 406 | .offs = 1 << 2,
|
| 407 | },
|
| 408 | [MAX8925_IRQ_GPM_EXTON_F] = {
|
| 409 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 410 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 411 | .offs = 1 << 3,
|
| 412 | },
|
| 413 | [MAX8925_IRQ_GPM_EXTON_R] = {
|
| 414 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 415 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 416 | .offs = 1 << 4,
|
| 417 | },
|
| 418 | [MAX8925_IRQ_GPM_SW_1SEC] = {
|
| 419 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 420 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 421 | .offs = 1 << 5,
|
| 422 | },
|
| 423 | [MAX8925_IRQ_GPM_SW_F] = {
|
| 424 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 425 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 426 | .offs = 1 << 6,
|
| 427 | },
|
| 428 | [MAX8925_IRQ_GPM_SW_R] = {
|
| 429 | .reg = MAX8925_ON_OFF_IRQ1,
|
| 430 | .mask_reg = MAX8925_ON_OFF_IRQ1_MASK,
|
| 431 | .offs = 1 << 7,
|
| 432 | },
|
| 433 | [MAX8925_IRQ_GPM_SYSCKEN_F] = {
|
| 434 | .reg = MAX8925_ON_OFF_IRQ2,
|
| 435 | .mask_reg = MAX8925_ON_OFF_IRQ2_MASK,
|
| 436 | .offs = 1 << 0,
|
| 437 | },
|
| 438 | [MAX8925_IRQ_GPM_SYSCKEN_R] = {
|
| 439 | .reg = MAX8925_ON_OFF_IRQ2,
|
| 440 | .mask_reg = MAX8925_ON_OFF_IRQ2_MASK,
|
| 441 | .offs = 1 << 1,
|
| 442 | },
|
| 443 | [MAX8925_IRQ_RTC_ALARM1] = {
|
| 444 | .reg = MAX8925_RTC_IRQ,
|
| 445 | .mask_reg = MAX8925_RTC_IRQ_MASK,
|
| 446 | .offs = 1 << 2,
|
| 447 | .flags = FLAGS_RTC,
|
| 448 | },
|
| 449 | [MAX8925_IRQ_RTC_ALARM0] = {
|
| 450 | .reg = MAX8925_RTC_IRQ,
|
| 451 | .mask_reg = MAX8925_RTC_IRQ_MASK,
|
| 452 | .offs = 1 << 3,
|
| 453 | .flags = FLAGS_RTC,
|
| 454 | },
|
| 455 | [MAX8925_IRQ_TSC_STICK] = {
|
| 456 | .reg = MAX8925_TSC_IRQ,
|
| 457 | .mask_reg = MAX8925_TSC_IRQ_MASK,
|
| 458 | .offs = 1 << 0,
|
| 459 | .flags = FLAGS_ADC,
|
| 460 | .tsc_irq = 1,
|
| 461 | },
|
| 462 | [MAX8925_IRQ_TSC_NSTICK] = {
|
| 463 | .reg = MAX8925_TSC_IRQ,
|
| 464 | .mask_reg = MAX8925_TSC_IRQ_MASK,
|
| 465 | .offs = 1 << 1,
|
| 466 | .flags = FLAGS_ADC,
|
| 467 | .tsc_irq = 1,
|
| 468 | },
|
| 469 | };
|
| 470 |
|
| 471 | static irqreturn_t max8925_irq(int irq, void *data)
|
| 472 | {
|
| 473 | struct max8925_chip *chip = data;
|
| 474 | struct max8925_irq_data *irq_data;
|
| 475 | struct i2c_client *i2c;
|
| 476 | int read_reg = -1, value = 0;
|
| 477 | int i;
|
| 478 |
|
| 479 | for (i = 0; i < ARRAY_SIZE(max8925_irqs); i++) {
|
| 480 | irq_data = &max8925_irqs[i];
|
| 481 |
|
| 482 | if (irq_data->tsc_irq)
|
| 483 | continue;
|
| 484 | if (irq_data->flags == FLAGS_RTC)
|
| 485 | i2c = chip->rtc;
|
| 486 | else if (irq_data->flags == FLAGS_ADC)
|
| 487 | i2c = chip->adc;
|
| 488 | else
|
| 489 | i2c = chip->i2c;
|
| 490 | if (read_reg != irq_data->reg) {
|
| 491 | read_reg = irq_data->reg;
|
| 492 | value = max8925_reg_read(i2c, irq_data->reg);
|
| 493 | }
|
| 494 | if (value & irq_data->enable)
|
| 495 | handle_nested_irq(chip->irq_base + i);
|
| 496 | }
|
| 497 | return IRQ_HANDLED;
|
| 498 | }
|
| 499 |
|
| 500 | static irqreturn_t max8925_tsc_irq(int irq, void *data)
|
| 501 | {
|
| 502 | struct max8925_chip *chip = data;
|
| 503 | struct max8925_irq_data *irq_data;
|
| 504 | struct i2c_client *i2c;
|
| 505 | int read_reg = -1, value = 0;
|
| 506 | int i;
|
| 507 |
|
| 508 | for (i = 0; i < ARRAY_SIZE(max8925_irqs); i++) {
|
| 509 | irq_data = &max8925_irqs[i];
|
| 510 |
|
| 511 | if (!irq_data->tsc_irq)
|
| 512 | continue;
|
| 513 | if (irq_data->flags == FLAGS_RTC)
|
| 514 | i2c = chip->rtc;
|
| 515 | else if (irq_data->flags == FLAGS_ADC)
|
| 516 | i2c = chip->adc;
|
| 517 | else
|
| 518 | i2c = chip->i2c;
|
| 519 | if (read_reg != irq_data->reg) {
|
| 520 | read_reg = irq_data->reg;
|
| 521 | value = max8925_reg_read(i2c, irq_data->reg);
|
| 522 | }
|
| 523 | if (value & irq_data->enable)
|
| 524 | handle_nested_irq(chip->irq_base + i);
|
| 525 | }
|
| 526 | return IRQ_HANDLED;
|
| 527 | }
|
| 528 |
|
| 529 | static void max8925_irq_lock(struct irq_data *data)
|
| 530 | {
|
| 531 | struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
|
| 532 |
|
| 533 | mutex_lock(&chip->irq_lock);
|
| 534 | }
|
| 535 |
|
| 536 | static void max8925_irq_sync_unlock(struct irq_data *data)
|
| 537 | {
|
| 538 | struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
|
| 539 | struct max8925_irq_data *irq_data;
|
| 540 | static unsigned char cache_chg[2] = {0xff, 0xff};
|
| 541 | static unsigned char cache_on[2] = {0xff, 0xff};
|
| 542 | static unsigned char cache_rtc = 0xff, cache_tsc = 0xff;
|
| 543 | unsigned char irq_chg[2], irq_on[2];
|
| 544 | unsigned char irq_rtc, irq_tsc;
|
| 545 | int i;
|
| 546 |
|
| 547 |
|
| 548 | irq_chg[0] = cache_chg[0];
|
| 549 | irq_chg[1] = cache_chg[1];
|
| 550 | irq_on[0] = cache_on[0];
|
| 551 | irq_on[1] = cache_on[1];
|
| 552 | irq_rtc = cache_rtc;
|
| 553 | irq_tsc = cache_tsc;
|
| 554 | for (i = 0; i < ARRAY_SIZE(max8925_irqs); i++) {
|
| 555 | irq_data = &max8925_irqs[i];
|
| 556 |
|
| 557 | switch (irq_data->mask_reg) {
|
| 558 | case MAX8925_CHG_IRQ1_MASK:
|
| 559 | irq_chg[0] &= ~irq_data->enable;
|
| 560 | break;
|
| 561 | case MAX8925_CHG_IRQ2_MASK:
|
| 562 | irq_chg[1] &= ~irq_data->enable;
|
| 563 | break;
|
| 564 | case MAX8925_ON_OFF_IRQ1_MASK:
|
| 565 | irq_on[0] &= ~irq_data->enable;
|
| 566 | break;
|
| 567 | case MAX8925_ON_OFF_IRQ2_MASK:
|
| 568 | irq_on[1] &= ~irq_data->enable;
|
| 569 | break;
|
| 570 | case MAX8925_RTC_IRQ_MASK:
|
| 571 | irq_rtc &= ~irq_data->enable;
|
| 572 | break;
|
| 573 | case MAX8925_TSC_IRQ_MASK:
|
| 574 | irq_tsc &= ~irq_data->enable;
|
| 575 | break;
|
| 576 | default:
|
| 577 | dev_err(chip->dev, "wrong IRQ\n");
|
| 578 | break;
|
| 579 | }
|
| 580 | }
|
| 581 |
|
| 582 | if (cache_chg[0] != irq_chg[0]) {
|
| 583 | cache_chg[0] = irq_chg[0];
|
| 584 | max8925_reg_write(chip->i2c, MAX8925_CHG_IRQ1_MASK,
|
| 585 | irq_chg[0]);
|
| 586 | }
|
| 587 | if (cache_chg[1] != irq_chg[1]) {
|
| 588 | cache_chg[1] = irq_chg[1];
|
| 589 | max8925_reg_write(chip->i2c, MAX8925_CHG_IRQ2_MASK,
|
| 590 | irq_chg[1]);
|
| 591 | }
|
| 592 | if (cache_on[0] != irq_on[0]) {
|
| 593 | cache_on[0] = irq_on[0];
|
| 594 | max8925_reg_write(chip->i2c, MAX8925_ON_OFF_IRQ1_MASK,
|
| 595 | irq_on[0]);
|
| 596 | }
|
| 597 | if (cache_on[1] != irq_on[1]) {
|
| 598 | cache_on[1] = irq_on[1];
|
| 599 | max8925_reg_write(chip->i2c, MAX8925_ON_OFF_IRQ2_MASK,
|
| 600 | irq_on[1]);
|
| 601 | }
|
| 602 | if (cache_rtc != irq_rtc) {
|
| 603 | cache_rtc = irq_rtc;
|
| 604 | max8925_reg_write(chip->rtc, MAX8925_RTC_IRQ_MASK, irq_rtc);
|
| 605 | }
|
| 606 | if (cache_tsc != irq_tsc) {
|
| 607 | cache_tsc = irq_tsc;
|
| 608 | max8925_reg_write(chip->adc, MAX8925_TSC_IRQ_MASK, irq_tsc);
|
| 609 | }
|
| 610 |
|
| 611 | mutex_unlock(&chip->irq_lock);
|
| 612 | }
|
| 613 |
|
| 614 | static void max8925_irq_enable(struct irq_data *data)
|
| 615 | {
|
| 616 | struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
|
| 617 |
|
| 618 | max8925_irqs[data->irq - chip->irq_base].enable
|
| 619 | = max8925_irqs[data->irq - chip->irq_base].offs;
|
| 620 | }
|
| 621 |
|
| 622 | static void max8925_irq_disable(struct irq_data *data)
|
| 623 | {
|
| 624 | struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
|
| 625 |
|
| 626 | max8925_irqs[data->irq - chip->irq_base].enable = 0;
|
| 627 | }
|
| 628 |
|
| 629 | static struct irq_chip max8925_irq_chip = {
|
| 630 | .name = "max8925",
|
| 631 | .irq_bus_lock = max8925_irq_lock,
|
| 632 | .irq_bus_sync_unlock = max8925_irq_sync_unlock,
|
| 633 | .irq_enable = max8925_irq_enable,
|
| 634 | .irq_disable = max8925_irq_disable,
|
| 635 | };
|
| 636 |
|
| 637 | static int max8925_irq_domain_map(struct irq_domain *d, unsigned int virq,
|
| 638 | irq_hw_number_t hw)
|
| 639 | {
|
| 640 | irq_set_chip_data(virq, d->host_data);
|
| 641 | irq_set_chip_and_handler(virq, &max8925_irq_chip, handle_edge_irq);
|
| 642 | irq_set_nested_thread(virq, 1);
|
| 643 | irq_set_noprobe(virq);
|
| 644 |
|
| 645 | return 0;
|
| 646 | }
|
| 647 |
|
| 648 | static const struct irq_domain_ops max8925_irq_domain_ops = {
|
| 649 | .map = max8925_irq_domain_map,
|
| 650 | .xlate = irq_domain_xlate_onetwocell,
|
| 651 | };
|
| 652 |
|
| 653 |
|
| 654 | static int max8925_irq_init(struct max8925_chip *chip, int irq,
|
| 655 | struct max8925_platform_data *pdata)
|
| 656 | {
|
| 657 | unsigned long flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
|
| 658 | int ret;
|
| 659 |
|
| 660 |
|
| 661 | max8925_reg_read(chip->i2c, MAX8925_CHG_IRQ1);
|
| 662 | max8925_reg_read(chip->i2c, MAX8925_CHG_IRQ2);
|
| 663 | max8925_reg_read(chip->i2c, MAX8925_ON_OFF_IRQ1);
|
| 664 | max8925_reg_read(chip->i2c, MAX8925_ON_OFF_IRQ2);
|
| 665 | max8925_reg_read(chip->rtc, MAX8925_RTC_IRQ);
|
| 666 | max8925_reg_read(chip->adc, MAX8925_TSC_IRQ);
|
| 667 |
|
| 668 | max8925_reg_write(chip->rtc, MAX8925_ALARM0_CNTL, 0);
|
| 669 | max8925_reg_write(chip->rtc, MAX8925_ALARM1_CNTL, 0);
|
| 670 | max8925_reg_write(chip->i2c, MAX8925_CHG_IRQ1_MASK, 0xff);
|
| 671 | max8925_reg_write(chip->i2c, MAX8925_CHG_IRQ2_MASK, 0xff);
|
| 672 | max8925_reg_write(chip->i2c, MAX8925_ON_OFF_IRQ1_MASK, 0xff);
|
| 673 | max8925_reg_write(chip->i2c, MAX8925_ON_OFF_IRQ2_MASK, 0xff);
|
| 674 | max8925_reg_write(chip->rtc, MAX8925_RTC_IRQ_MASK, 0xff);
|
| 675 |
|
| 676 | mutex_init(&chip->irq_lock);
|
| 677 | chip->irq_base = irq_alloc_descs(-1, 0, MAX8925_NR_IRQS, 0);
|
| 678 | if (chip->irq_base < 0) {
|
| 679 | dev_err(chip->dev, "Failed to allocate interrupts, ret:%d\n",
|
| 680 | chip->irq_base);
|
| 681 | return -EBUSY;
|
| 682 | }
|
| 683 |
|
| 684 | irq_domain_create_legacy(dev_fwnode(chip->dev), MAX8925_NR_IRQS,
|
| 685 | chip->irq_base, 0, &max8925_irq_domain_ops,
|
| 686 | chip);
|
| 687 |
|
| 688 |
|
| 689 | chip->core_irq = irq;
|
| 690 | if (!chip->core_irq)
|
| 691 | return -EBUSY;
|
| 692 | ret = request_threaded_irq(irq, NULL, max8925_irq, flags | IRQF_ONESHOT,
|
| 693 | "max8925", chip);
|
| 694 | if (ret) {
|
| 695 | dev_err(chip->dev, "Failed to request core IRQ: %d\n", ret);
|
| 696 | chip->core_irq = 0;
|
| 697 | return -EBUSY;
|
| 698 | }
|
| 699 |
|
| 700 |
|
| 701 |
|
| 702 |
|
| 703 | max8925_reg_write(chip->adc, MAX8925_TSC_IRQ_MASK, 0x0f);
|
| 704 |
|
| 705 | if (!pdata->tsc_irq) {
|
| 706 | dev_warn(chip->dev, "No interrupt support on TSC IRQ\n");
|
| 707 | return 0;
|
| 708 | }
|
| 709 | chip->tsc_irq = pdata->tsc_irq;
|
| 710 | ret = request_threaded_irq(chip->tsc_irq, NULL, max8925_tsc_irq,
|
| 711 | flags | IRQF_ONESHOT, "max8925-tsc", chip);
|
| 712 | if (ret) {
|
| 713 | dev_err(chip->dev, "Failed to request TSC IRQ: %d\n", ret);
|
| 714 | chip->tsc_irq = 0;
|
| 715 | }
|
| 716 | return 0;
|
| 717 | }
|
| 718 |
|
| 719 | static void init_regulator(struct max8925_chip *chip,
|
| 720 | struct max8925_platform_data *pdata)
|
| 721 | {
|
| 722 | int ret;
|
| 723 |
|
| 724 | if (!pdata)
|
| 725 | return;
|
| 726 | if (pdata->sd1) {
|
| 727 | reg_devs[0].platform_data = pdata->sd1;
|
| 728 | reg_devs[0].pdata_size = sizeof(struct regulator_init_data);
|
| 729 | }
|
| 730 | if (pdata->sd2) {
|
| 731 | reg_devs[1].platform_data = pdata->sd2;
|
| 732 | reg_devs[1].pdata_size = sizeof(struct regulator_init_data);
|
| 733 | }
|
| 734 | if (pdata->sd3) {
|
| 735 | reg_devs[2].platform_data = pdata->sd3;
|
| 736 | reg_devs[2].pdata_size = sizeof(struct regulator_init_data);
|
| 737 | }
|
| 738 | if (pdata->ldo1) {
|
| 739 | reg_devs[3].platform_data = pdata->ldo1;
|
| 740 | reg_devs[3].pdata_size = sizeof(struct regulator_init_data);
|
| 741 | }
|
| 742 | if (pdata->ldo2) {
|
| 743 | reg_devs[4].platform_data = pdata->ldo2;
|
| 744 | reg_devs[4].pdata_size = sizeof(struct regulator_init_data);
|
| 745 | }
|
| 746 | if (pdata->ldo3) {
|
| 747 | reg_devs[5].platform_data = pdata->ldo3;
|
| 748 | reg_devs[5].pdata_size = sizeof(struct regulator_init_data);
|
| 749 | }
|
| 750 | if (pdata->ldo4) {
|
| 751 | reg_devs[6].platform_data = pdata->ldo4;
|
| 752 | reg_devs[6].pdata_size = sizeof(struct regulator_init_data);
|
| 753 | }
|
| 754 | if (pdata->ldo5) {
|
| 755 | reg_devs[7].platform_data = pdata->ldo5;
|
| 756 | reg_devs[7].pdata_size = sizeof(struct regulator_init_data);
|
| 757 | }
|
| 758 | if (pdata->ldo6) {
|
| 759 | reg_devs[8].platform_data = pdata->ldo6;
|
| 760 | reg_devs[8].pdata_size = sizeof(struct regulator_init_data);
|
| 761 | }
|
| 762 | if (pdata->ldo7) {
|
| 763 | reg_devs[9].platform_data = pdata->ldo7;
|
| 764 | reg_devs[9].pdata_size = sizeof(struct regulator_init_data);
|
| 765 | }
|
| 766 | if (pdata->ldo8) {
|
| 767 | reg_devs[10].platform_data = pdata->ldo8;
|
| 768 | reg_devs[10].pdata_size = sizeof(struct regulator_init_data);
|
| 769 | }
|
| 770 | if (pdata->ldo9) {
|
| 771 | reg_devs[11].platform_data = pdata->ldo9;
|
| 772 | reg_devs[11].pdata_size = sizeof(struct regulator_init_data);
|
| 773 | }
|
| 774 | if (pdata->ldo10) {
|
| 775 | reg_devs[12].platform_data = pdata->ldo10;
|
| 776 | reg_devs[12].pdata_size = sizeof(struct regulator_init_data);
|
| 777 | }
|
| 778 | if (pdata->ldo11) {
|
| 779 | reg_devs[13].platform_data = pdata->ldo11;
|
| 780 | reg_devs[13].pdata_size = sizeof(struct regulator_init_data);
|
| 781 | }
|
| 782 | if (pdata->ldo12) {
|
| 783 | reg_devs[14].platform_data = pdata->ldo12;
|
| 784 | reg_devs[14].pdata_size = sizeof(struct regulator_init_data);
|
| 785 | }
|
| 786 | if (pdata->ldo13) {
|
| 787 | reg_devs[15].platform_data = pdata->ldo13;
|
| 788 | reg_devs[15].pdata_size = sizeof(struct regulator_init_data);
|
| 789 | }
|
| 790 | if (pdata->ldo14) {
|
| 791 | reg_devs[16].platform_data = pdata->ldo14;
|
| 792 | reg_devs[16].pdata_size = sizeof(struct regulator_init_data);
|
| 793 | }
|
| 794 | if (pdata->ldo15) {
|
| 795 | reg_devs[17].platform_data = pdata->ldo15;
|
| 796 | reg_devs[17].pdata_size = sizeof(struct regulator_init_data);
|
| 797 | }
|
| 798 | if (pdata->ldo16) {
|
| 799 | reg_devs[18].platform_data = pdata->ldo16;
|
| 800 | reg_devs[18].pdata_size = sizeof(struct regulator_init_data);
|
| 801 | }
|
| 802 | if (pdata->ldo17) {
|
| 803 | reg_devs[19].platform_data = pdata->ldo17;
|
| 804 | reg_devs[19].pdata_size = sizeof(struct regulator_init_data);
|
| 805 | }
|
| 806 | if (pdata->ldo18) {
|
| 807 | reg_devs[20].platform_data = pdata->ldo18;
|
| 808 | reg_devs[20].pdata_size = sizeof(struct regulator_init_data);
|
| 809 | }
|
| 810 | if (pdata->ldo19) {
|
| 811 | reg_devs[21].platform_data = pdata->ldo19;
|
| 812 | reg_devs[21].pdata_size = sizeof(struct regulator_init_data);
|
| 813 | }
|
| 814 | if (pdata->ldo20) {
|
| 815 | reg_devs[22].platform_data = pdata->ldo20;
|
| 816 | reg_devs[22].pdata_size = sizeof(struct regulator_init_data);
|
| 817 | }
|
| 818 | ret = mfd_add_devices(chip->dev, 0, reg_devs, ARRAY_SIZE(reg_devs),
|
| 819 | NULL, 0, NULL);
|
| 820 | if (ret < 0) {
|
| 821 | dev_err(chip->dev, "Failed to add regulator subdev\n");
|
| 822 | return;
|
| 823 | }
|
| 824 | }
|
| 825 |
|
| 826 | int max8925_device_init(struct max8925_chip *chip,
|
| 827 | struct max8925_platform_data *pdata)
|
| 828 | {
|
| 829 | int ret;
|
| 830 |
|
| 831 | max8925_irq_init(chip, chip->i2c->irq, pdata);
|
| 832 |
|
| 833 | if (pdata && (pdata->power || pdata->touch)) {
|
| 834 |
|
| 835 | max8925_set_bits(chip->i2c, MAX8925_RESET_CNFG, 1, 1);
|
| 836 |
|
| 837 | max8925_set_bits(chip->adc, MAX8925_TSC_CNFG1, 3, 2);
|
| 838 |
|
| 839 | do {
|
| 840 | ret = max8925_reg_read(chip->adc, MAX8925_TSC_IRQ);
|
| 841 | } while (ret & MAX8925_NREF_OK);
|
| 842 |
|
| 843 | max8925_set_bits(chip->adc, MAX8925_ADC_SCHED, 3, 2);
|
| 844 | }
|
| 845 |
|
| 846 |
|
| 847 | max8925_set_bits(chip->rtc, MAX8925_MPL_CNTL, 1 << 4, 1 << 4);
|
| 848 |
|
| 849 | ret = mfd_add_devices(chip->dev, 0, &rtc_devs[0],
|
| 850 | ARRAY_SIZE(rtc_devs),
|
| 851 | NULL, chip->irq_base, NULL);
|
| 852 | if (ret < 0) {
|
| 853 | dev_err(chip->dev, "Failed to add rtc subdev\n");
|
| 854 | goto out;
|
| 855 | }
|
| 856 |
|
| 857 | ret = mfd_add_devices(chip->dev, 0, &onkey_devs[0],
|
| 858 | ARRAY_SIZE(onkey_devs),
|
| 859 | NULL, chip->irq_base, NULL);
|
| 860 | if (ret < 0) {
|
| 861 | dev_err(chip->dev, "Failed to add onkey subdev\n");
|
| 862 | goto out_dev;
|
| 863 | }
|
| 864 |
|
| 865 | init_regulator(chip, pdata);
|
| 866 |
|
| 867 | if (pdata && pdata->backlight) {
|
| 868 | bk_devs[0].platform_data = &pdata->backlight;
|
| 869 | bk_devs[0].pdata_size = sizeof(struct max8925_backlight_pdata);
|
| 870 | }
|
| 871 | ret = mfd_add_devices(chip->dev, 0, bk_devs, ARRAY_SIZE(bk_devs),
|
| 872 | NULL, 0, NULL);
|
| 873 | if (ret < 0) {
|
| 874 | dev_err(chip->dev, "Failed to add backlight subdev\n");
|
| 875 | goto out_dev;
|
| 876 | }
|
| 877 |
|
| 878 | ret = mfd_add_devices(chip->dev, 0, &power_devs[0],
|
| 879 | ARRAY_SIZE(power_devs),
|
| 880 | NULL, 0, NULL);
|
| 881 | if (ret < 0) {
|
| 882 | dev_err(chip->dev,
|
| 883 | "Failed to add power supply subdev, err = %d\n", ret);
|
| 884 | goto out_dev;
|
| 885 | }
|
| 886 |
|
| 887 | if (pdata && pdata->touch) {
|
| 888 | ret = mfd_add_devices(chip->dev, 0, &touch_devs[0],
|
| 889 | ARRAY_SIZE(touch_devs),
|
| 890 | NULL, chip->tsc_irq, NULL);
|
| 891 | if (ret < 0) {
|
| 892 | dev_err(chip->dev, "Failed to add touch subdev\n");
|
| 893 | goto out_dev;
|
| 894 | }
|
| 895 | }
|
| 896 |
|
| 897 | return 0;
|
| 898 | out_dev:
|
| 899 | mfd_remove_devices(chip->dev);
|
| 900 | out:
|
| 901 | return ret;
|
| 902 | }
|
| 903 |
|
| 904 | void max8925_device_exit(struct max8925_chip *chip)
|
| 905 | {
|
| 906 | if (chip->core_irq)
|
| 907 | free_irq(chip->core_irq, chip);
|
| 908 | if (chip->tsc_irq)
|
| 909 | free_irq(chip->tsc_irq, chip);
|
| 910 | mfd_remove_devices(chip->dev);
|
| 911 | }
|