drivers/mfd/da9055-core.c

   1 /*
   2  * Device access for Dialog DA9055 PMICs.
   3  *
   4  * Copyright(c) 2012 Dialog Semiconductor Ltd.
   5  *
   6  * Author: David Dajun Chen <dchen@diasemi.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 #include <linux/module.h>
  15 #include <linux/device.h>
  16 #include <linux/input.h>
  17 #include <linux/irq.h>
  18 #include <linux/mutex.h>
  19
  20 #include <linux/mfd/core.h>
  21 #include <linux/mfd/da9055/core.h>
  22 #include <linux/mfd/da9055/pdata.h>
  23 #include <linux/mfd/da9055/reg.h>
  24
  25 #define DA9055_IRQ_NONKEY_MASK          0x01
  26 #define DA9055_IRQ_ALM_MASK             0x02
  27 #define DA9055_IRQ_TICK_MASK            0x04
  28 #define DA9055_IRQ_ADC_MASK             0x08
  29 #define DA9055_IRQ_BUCK_ILIM_MASK       0x08
  30
  31 static bool da9055_register_readable(struct device *dev, unsigned int reg)
  32 {
  33         switch (reg) {
  34         case DA9055_REG_STATUS_A:
  35         case DA9055_REG_STATUS_B:
  36         case DA9055_REG_EVENT_A:
  37         case DA9055_REG_EVENT_B:
  38         case DA9055_REG_EVENT_C:
  39         case DA9055_REG_IRQ_MASK_A:
  40         case DA9055_REG_IRQ_MASK_B:
  41         case DA9055_REG_IRQ_MASK_C:
  42
  43         case DA9055_REG_CONTROL_A:
  44         case DA9055_REG_CONTROL_B:
  45         case DA9055_REG_CONTROL_C:
  46         case DA9055_REG_CONTROL_D:
  47         case DA9055_REG_CONTROL_E:
  48
  49         case DA9055_REG_ADC_MAN:
  50         case DA9055_REG_ADC_CONT:
  51         case DA9055_REG_VSYS_MON:
  52         case DA9055_REG_ADC_RES_L:
  53         case DA9055_REG_ADC_RES_H:
  54         case DA9055_REG_VSYS_RES:
  55         case DA9055_REG_ADCIN1_RES:
  56         case DA9055_REG_ADCIN2_RES:
  57         case DA9055_REG_ADCIN3_RES:
  58
  59         case DA9055_REG_COUNT_S:
  60         case DA9055_REG_COUNT_MI:
  61         case DA9055_REG_COUNT_H:
  62         case DA9055_REG_COUNT_D:
  63         case DA9055_REG_COUNT_MO:
  64         case DA9055_REG_COUNT_Y:
  65         case DA9055_REG_ALARM_H:
  66         case DA9055_REG_ALARM_D:
  67         case DA9055_REG_ALARM_MI:
  68         case DA9055_REG_ALARM_MO:
  69         case DA9055_REG_ALARM_Y:
  70
  71         case DA9055_REG_GPIO0_1:
  72         case DA9055_REG_GPIO2:
  73         case DA9055_REG_GPIO_MODE0_2:
  74
  75         case DA9055_REG_BCORE_CONT:
  76         case DA9055_REG_BMEM_CONT:
  77         case DA9055_REG_LDO1_CONT:
  78         case DA9055_REG_LDO2_CONT:
  79         case DA9055_REG_LDO3_CONT:
  80         case DA9055_REG_LDO4_CONT:
  81         case DA9055_REG_LDO5_CONT:
  82         case DA9055_REG_LDO6_CONT:
  83         case DA9055_REG_BUCK_LIM:
  84         case DA9055_REG_BCORE_MODE:
  85         case DA9055_REG_VBCORE_A:
  86         case DA9055_REG_VBMEM_A:
  87         case DA9055_REG_VLDO1_A:
  88         case DA9055_REG_VLDO2_A:
  89         case DA9055_REG_VLDO3_A:
  90         case DA9055_REG_VLDO4_A:
  91         case DA9055_REG_VLDO5_A:
  92         case DA9055_REG_VLDO6_A:
  93         case DA9055_REG_VBCORE_B:
  94         case DA9055_REG_VBMEM_B:
  95         case DA9055_REG_VLDO1_B:
  96         case DA9055_REG_VLDO2_B:
  97         case DA9055_REG_VLDO3_B:
  98         case DA9055_REG_VLDO4_B:
  99         case DA9055_REG_VLDO5_B:
 100         case DA9055_REG_VLDO6_B:
 101                 return true;
 102         default:
 103                 return false;
 104         }
 105 }
 106
 107 static bool da9055_register_writeable(struct device *dev, unsigned int reg)
 108 {
 109         switch (reg) {
 110         case DA9055_REG_STATUS_A:
 111         case DA9055_REG_STATUS_B:
 112         case DA9055_REG_EVENT_A:
 113         case DA9055_REG_EVENT_B:
 114         case DA9055_REG_EVENT_C:
 115         case DA9055_REG_IRQ_MASK_A:
 116         case DA9055_REG_IRQ_MASK_B:
 117         case DA9055_REG_IRQ_MASK_C:
 118
 119         case DA9055_REG_CONTROL_A:
 120         case DA9055_REG_CONTROL_B:
 121         case DA9055_REG_CONTROL_C:
 122         case DA9055_REG_CONTROL_D:
 123         case DA9055_REG_CONTROL_E:
 124
 125         case DA9055_REG_ADC_MAN:
 126         case DA9055_REG_ADC_CONT:
 127         case DA9055_REG_VSYS_MON:
 128         case DA9055_REG_ADC_RES_L:
 129         case DA9055_REG_ADC_RES_H:
 130         case DA9055_REG_VSYS_RES:
 131         case DA9055_REG_ADCIN1_RES:
 132         case DA9055_REG_ADCIN2_RES:
 133         case DA9055_REG_ADCIN3_RES:
 134
 135         case DA9055_REG_COUNT_S:
 136         case DA9055_REG_COUNT_MI:
 137         case DA9055_REG_COUNT_H:
 138         case DA9055_REG_COUNT_D:
 139         case DA9055_REG_COUNT_MO:
 140         case DA9055_REG_COUNT_Y:
 141         case DA9055_REG_ALARM_H:
 142         case DA9055_REG_ALARM_D:
 143         case DA9055_REG_ALARM_MI:
 144         case DA9055_REG_ALARM_MO:
 145         case DA9055_REG_ALARM_Y:
 146
 147         case DA9055_REG_GPIO0_1:
 148         case DA9055_REG_GPIO2:
 149         case DA9055_REG_GPIO_MODE0_2:
 150
 151         case DA9055_REG_BCORE_CONT:
 152         case DA9055_REG_BMEM_CONT:
 153         case DA9055_REG_LDO1_CONT:
 154         case DA9055_REG_LDO2_CONT:
 155         case DA9055_REG_LDO3_CONT:
 156         case DA9055_REG_LDO4_CONT:
 157         case DA9055_REG_LDO5_CONT:
 158         case DA9055_REG_LDO6_CONT:
 159         case DA9055_REG_BUCK_LIM:
 160         case DA9055_REG_BCORE_MODE:
 161         case DA9055_REG_VBCORE_A:
 162         case DA9055_REG_VBMEM_A:
 163         case DA9055_REG_VLDO1_A:
 164         case DA9055_REG_VLDO2_A:
 165         case DA9055_REG_VLDO3_A:
 166         case DA9055_REG_VLDO4_A:
 167         case DA9055_REG_VLDO5_A:
 168         case DA9055_REG_VLDO6_A:
 169         case DA9055_REG_VBCORE_B:
 170         case DA9055_REG_VBMEM_B:
 171         case DA9055_REG_VLDO1_B:
 172         case DA9055_REG_VLDO2_B:
 173         case DA9055_REG_VLDO3_B:
 174         case DA9055_REG_VLDO4_B:
 175         case DA9055_REG_VLDO5_B:
 176         case DA9055_REG_VLDO6_B:
 177                 return true;
 178         default:
 179                 return false;
 180         }
 181 }
 182
 183 static bool da9055_register_volatile(struct device *dev, unsigned int reg)
 184 {
 185         switch (reg) {
 186         case DA9055_REG_STATUS_A:
 187         case DA9055_REG_STATUS_B:
 188         case DA9055_REG_EVENT_A:
 189         case DA9055_REG_EVENT_B:
 190         case DA9055_REG_EVENT_C:
 191
 192         case DA9055_REG_CONTROL_A:
 193         case DA9055_REG_CONTROL_E:
 194
 195         case DA9055_REG_ADC_MAN:
 196         case DA9055_REG_ADC_RES_L:
 197         case DA9055_REG_ADC_RES_H:
 198         case DA9055_REG_VSYS_RES:
 199         case DA9055_REG_ADCIN1_RES:
 200         case DA9055_REG_ADCIN2_RES:
 201         case DA9055_REG_ADCIN3_RES:
 202
 203         case DA9055_REG_COUNT_S:
 204         case DA9055_REG_COUNT_MI:
 205         case DA9055_REG_COUNT_H:
 206         case DA9055_REG_COUNT_D:
 207         case DA9055_REG_COUNT_MO:
 208         case DA9055_REG_COUNT_Y:
 209         case DA9055_REG_ALARM_MI:
 210
 211         case DA9055_REG_BCORE_CONT:
 212         case DA9055_REG_BMEM_CONT:
 213         case DA9055_REG_LDO1_CONT:
 214         case DA9055_REG_LDO2_CONT:
 215         case DA9055_REG_LDO3_CONT:
 216         case DA9055_REG_LDO4_CONT:
 217         case DA9055_REG_LDO5_CONT:
 218         case DA9055_REG_LDO6_CONT:
 219                 return true;
 220         default:
 221                 return false;
 222         }
 223 }
 224
 225 static const struct regmap_irq da9055_irqs[] = {
 226         [DA9055_IRQ_NONKEY] = {
 227                 .reg_offset = 0,
 228                 .mask = DA9055_IRQ_NONKEY_MASK,
 229         },
 230         [DA9055_IRQ_ALARM] = {
 231                 .reg_offset = 0,
 232                 .mask = DA9055_IRQ_ALM_MASK,
 233         },
 234         [DA9055_IRQ_TICK] = {
 235                 .reg_offset = 0,
 236                 .mask = DA9055_IRQ_TICK_MASK,
 237         },
 238         [DA9055_IRQ_HWMON] = {
 239                 .reg_offset = 0,
 240                 .mask = DA9055_IRQ_ADC_MASK,
 241         },
 242         [DA9055_IRQ_REGULATOR] = {
 243                 .reg_offset = 1,
 244                 .mask = DA9055_IRQ_BUCK_ILIM_MASK,
 245         },
 246 };
 247
 248 const struct regmap_config da9055_regmap_config = {
 249         .reg_bits = 8,
 250         .val_bits = 8,
 251
 252         .cache_type = REGCACHE_RBTREE,
 253
 254         .max_register = DA9055_MAX_REGISTER_CNT,
 255         .readable_reg = da9055_register_readable,
 256         .writeable_reg = da9055_register_writeable,
 257         .volatile_reg = da9055_register_volatile,
 258 };
 259 EXPORT_SYMBOL_GPL(da9055_regmap_config);
 260
 261 static struct resource da9055_onkey_resource = {
 262         .name = "ONKEY",
 263         .start = DA9055_IRQ_NONKEY,
 264         .end   = DA9055_IRQ_NONKEY,
 265         .flags = IORESOURCE_IRQ,
 266 };
 267
 268 static struct resource da9055_rtc_resource[] = {
 269         {
 270                 .name = "ALM",
 271                 .start = DA9055_IRQ_ALARM,
 272                 .end   = DA9055_IRQ_ALARM,
 273                 .flags = IORESOURCE_IRQ,
 274         },
 275         {
 276                 .name = "TICK",
 277                 .start = DA9055_IRQ_TICK,
 278                 .end   = DA9055_IRQ_TICK,
 279                 .flags = IORESOURCE_IRQ,
 280         },
 281 };
 282
 283 static struct resource da9055_hwmon_resource = {
 284         .name = "HWMON",
 285         .start = DA9055_IRQ_HWMON,
 286         .end   = DA9055_IRQ_HWMON,
 287         .flags = IORESOURCE_IRQ,
 288 };
 289
 290 static struct resource da9055_ld05_6_resource = {
 291         .name = "REGULATOR",
 292         .start = DA9055_IRQ_REGULATOR,
 293         .end   = DA9055_IRQ_REGULATOR,
 294         .flags = IORESOURCE_IRQ,
 295 };
 296
 297 static const struct mfd_cell da9055_devs[] = {
 298         {
 299                 .of_compatible = "dlg,da9055-gpio",
 300                 .name = "da9055-gpio",
 301         },
 302         {
 303                 .of_compatible = "dlg,da9055-regulator",
 304                 .name = "da9055-regulator",
 305                 .id = 1,
 306         },
 307         {
 308                 .of_compatible = "dlg,da9055-regulator",
 309                 .name = "da9055-regulator",
 310                 .id = 2,
 311         },
 312         {
 313                 .of_compatible = "dlg,da9055-regulator",
 314                 .name = "da9055-regulator",
 315                 .id = 3,
 316         },
 317         {
 318                 .of_compatible = "dlg,da9055-regulator",
 319                 .name = "da9055-regulator",
 320                 .id = 4,
 321         },
 322         {
 323                 .of_compatible = "dlg,da9055-regulator",
 324                 .name = "da9055-regulator",
 325                 .id = 5,
 326         },
 327         {
 328                 .of_compatible = "dlg,da9055-regulator",
 329                 .name = "da9055-regulator",
 330                 .id = 6,
 331         },
 332         {
 333                 .of_compatible = "dlg,da9055-regulator",
 334                 .name = "da9055-regulator",
 335                 .id = 7,
 336                 .resources = &da9055_ld05_6_resource,
 337                 .num_resources = 1,
 338         },
 339         {
 340                 .of_compatible = "dlg,da9055-regulator",
 341                 .name = "da9055-regulator",
 342                 .resources = &da9055_ld05_6_resource,
 343                 .num_resources = 1,
 344                 .id = 8,
 345         },
 346         {
 347                 .of_compatible = "dlg,da9055-onkey",
 348                 .name = "da9055-onkey",
 349                 .resources = &da9055_onkey_resource,
 350                 .num_resources = 1,
 351         },
 352         {
 353                 .of_compatible = "dlg,da9055-rtc",
 354                 .name = "da9055-rtc",
 355                 .resources = da9055_rtc_resource,
 356                 .num_resources = ARRAY_SIZE(da9055_rtc_resource),
 357         },
 358         {
 359                 .of_compatible = "dlg,da9055-hwmon",
 360                 .name = "da9055-hwmon",
 361                 .resources = &da9055_hwmon_resource,
 362                 .num_resources = 1,
 363         },
 364         {
 365                 .of_compatible = "dlg,da9055-watchdog",
 366                 .name = "da9055-watchdog",
 367         },
 368 };
 369
 370 static const struct regmap_irq_chip da9055_regmap_irq_chip = {
 371         .name = "da9055_irq",
 372         .status_base = DA9055_REG_EVENT_A,
 373         .mask_base = DA9055_REG_IRQ_MASK_A,
 374         .ack_base = DA9055_REG_EVENT_A,
 375         .num_regs = 3,
 376         .irqs = da9055_irqs,
 377         .num_irqs = ARRAY_SIZE(da9055_irqs),
 378 };
 379
 380 int da9055_device_init(struct da9055 *da9055)
 381 {
 382         struct da9055_pdata *pdata = dev_get_platdata(da9055->dev);
 383         int ret;
 384         uint8_t clear_events[3] = {0xFF, 0xFF, 0xFF};
 385
 386         if (pdata && pdata->init != NULL)
 387                 pdata->init(da9055);
 388
 389         if (!pdata || !pdata->irq_base)
 390                 da9055->irq_base = -1;
 391         else
 392                 da9055->irq_base = pdata->irq_base;
 393
 394         ret = da9055_group_write(da9055, DA9055_REG_EVENT_A, 3, clear_events);
 395         if (ret < 0)
 396                 return ret;
 397
 398         ret = regmap_add_irq_chip(da9055->regmap, da9055->chip_irq,
 399                                   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 400                                   da9055->irq_base, &da9055_regmap_irq_chip,
 401                                   &da9055->irq_data);
 402         if (ret < 0)
 403                 return ret;
 404
 405         da9055->irq_base = regmap_irq_chip_get_base(da9055->irq_data);
 406
 407         ret = mfd_add_devices(da9055->dev, -1,
 408                               da9055_devs, ARRAY_SIZE(da9055_devs),
 409                               NULL, da9055->irq_base, NULL);
 410         if (ret)
 411                 goto err;
 412
 413         return 0;
 414
 415 err:
 416         mfd_remove_devices(da9055->dev);
 417         return ret;
 418 }
 419
 420 void da9055_device_exit(struct da9055 *da9055)
 421 {
 422         regmap_del_irq_chip(da9055->chip_irq, da9055->irq_data);
 423         mfd_remove_devices(da9055->dev);
 424 }
 425
 426 MODULE_DESCRIPTION("Core support for the DA9055 PMIC");
 427 MODULE_LICENSE("GPL");
 428 MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");