drivers/mfd/pcf50633-core.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /* NXP PCF50633 Power Management Unit (PMU) driver
0003  *
0004  * (C) 2006-2008 by Openmoko, Inc.
0005  * Author: Harald Welte <laforge@openmoko.org>
0006  *     Balaji Rao <balajirrao@openmoko.org>
0007  * All rights reserved.
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/device.h>
0012 #include <linux/sysfs.h>
0013 #include <linux/module.h>
0014 #include <linux/types.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/workqueue.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/i2c.h>
0019 #include <linux/pm.h>
0020 #include <linux/slab.h>
0021 #include <linux/regmap.h>
0022 #include <linux/err.h>
0023
0024 #include <linux/mfd/pcf50633/core.h>
0025
0026 /* Read a block of up to 32 regs  */
0027 int pcf50633_read_block(struct pcf50633 *pcf, u8 reg,
0028                     int nr_regs, u8 *data)
0029 {
0030     int ret;
0031
0032     ret = regmap_raw_read(pcf->regmap, reg, data, nr_regs);
0033     if (ret != 0)
0034         return ret;
0035
0036     return nr_regs;
0037 }
0038 EXPORT_SYMBOL_GPL(pcf50633_read_block);
0039
0040 /* Write a block of up to 32 regs  */
0041 int pcf50633_write_block(struct pcf50633 *pcf , u8 reg,
0042                     int nr_regs, u8 *data)
0043 {
0044     return regmap_raw_write(pcf->regmap, reg, data, nr_regs);
0045 }
0046 EXPORT_SYMBOL_GPL(pcf50633_write_block);
0047
0048 u8 pcf50633_reg_read(struct pcf50633 *pcf, u8 reg)
0049 {
0050     unsigned int val;
0051     int ret;
0052
0053     ret = regmap_read(pcf->regmap, reg, &val);
0054     if (ret < 0)
0055         return -1;
0056
0057     return val;
0058 }
0059 EXPORT_SYMBOL_GPL(pcf50633_reg_read);
0060
0061 int pcf50633_reg_write(struct pcf50633 *pcf, u8 reg, u8 val)
0062 {
0063     return regmap_write(pcf->regmap, reg, val);
0064 }
0065 EXPORT_SYMBOL_GPL(pcf50633_reg_write);
0066
0067 int pcf50633_reg_set_bit_mask(struct pcf50633 *pcf, u8 reg, u8 mask, u8 val)
0068 {
0069     return regmap_update_bits(pcf->regmap, reg, mask, val);
0070 }
0071 EXPORT_SYMBOL_GPL(pcf50633_reg_set_bit_mask);
0072
0073 int pcf50633_reg_clear_bits(struct pcf50633 *pcf, u8 reg, u8 val)
0074 {
0075     return regmap_update_bits(pcf->regmap, reg, val, 0);
0076 }
0077 EXPORT_SYMBOL_GPL(pcf50633_reg_clear_bits);
0078
0079 /* sysfs attributes */
0080 static ssize_t dump_regs_show(struct device *dev,
0081                   struct device_attribute *attr, char *buf)
0082 {
0083     struct pcf50633 *pcf = dev_get_drvdata(dev);
0084     u8 dump[16];
0085     int n, n1, idx = 0;
0086     char *buf1 = buf;
0087     static u8 address_no_read[] = { /* must be ascending */
0088         PCF50633_REG_INT1,
0089         PCF50633_REG_INT2,
0090         PCF50633_REG_INT3,
0091         PCF50633_REG_INT4,
0092         PCF50633_REG_INT5,
0093         0 /* terminator */
0094     };
0095
0096     for (n = 0; n < 256; n += sizeof(dump)) {
0097         for (n1 = 0; n1 < sizeof(dump); n1++)
0098             if (n == address_no_read[idx]) {
0099                 idx++;
0100                 dump[n1] = 0x00;
0101             } else
0102                 dump[n1] = pcf50633_reg_read(pcf, n + n1);
0103
0104         buf1 += sprintf(buf1, "%*ph\n", (int)sizeof(dump), dump);
0105     }
0106
0107     return buf1 - buf;
0108 }
0109 static DEVICE_ATTR_ADMIN_RO(dump_regs);
0110
0111 static ssize_t resume_reason_show(struct device *dev,
0112                   struct device_attribute *attr, char *buf)
0113 {
0114     struct pcf50633 *pcf = dev_get_drvdata(dev);
0115     int n;
0116
0117     n = sprintf(buf, "%02x%02x%02x%02x%02x\n",
0118                 pcf->resume_reason[0],
0119                 pcf->resume_reason[1],
0120                 pcf->resume_reason[2],
0121                 pcf->resume_reason[3],
0122                 pcf->resume_reason[4]);
0123
0124     return n;
0125 }
0126 static DEVICE_ATTR_ADMIN_RO(resume_reason);
0127
0128 static struct attribute *pcf_sysfs_entries[] = {
0129     &dev_attr_dump_regs.attr,
0130     &dev_attr_resume_reason.attr,
0131     NULL,
0132 };
0133
0134 static struct attribute_group pcf_attr_group = {
0135     .name   = NULL,         /* put in device directory */
0136     .attrs  = pcf_sysfs_entries,
0137 };
0138
0139 static void
0140 pcf50633_client_dev_register(struct pcf50633 *pcf, const char *name,
0141                         struct platform_device **pdev)
0142 {
0143     int ret;
0144
0145     *pdev = platform_device_alloc(name, -1);
0146     if (!*pdev) {
0147         dev_err(pcf->dev, "Failed to allocate %s\n", name);
0148         return;
0149     }
0150
0151     (*pdev)->dev.parent = pcf->dev;
0152
0153     ret = platform_device_add(*pdev);
0154     if (ret) {
0155         dev_err(pcf->dev, "Failed to register %s: %d\n", name, ret);
0156         platform_device_put(*pdev);
0157         *pdev = NULL;
0158     }
0159 }
0160
0161 #ifdef CONFIG_PM_SLEEP
0162 static int pcf50633_suspend(struct device *dev)
0163 {
0164     struct i2c_client *client = to_i2c_client(dev);
0165     struct pcf50633 *pcf = i2c_get_clientdata(client);
0166
0167     return pcf50633_irq_suspend(pcf);
0168 }
0169
0170 static int pcf50633_resume(struct device *dev)
0171 {
0172     struct i2c_client *client = to_i2c_client(dev);
0173     struct pcf50633 *pcf = i2c_get_clientdata(client);
0174
0175     return pcf50633_irq_resume(pcf);
0176 }
0177 #endif
0178
0179 static SIMPLE_DEV_PM_OPS(pcf50633_pm, pcf50633_suspend, pcf50633_resume);
0180
0181 static const struct regmap_config pcf50633_regmap_config = {
0182     .reg_bits = 8,
0183     .val_bits = 8,
0184 };
0185
0186 static int pcf50633_probe(struct i2c_client *client,
0187                 const struct i2c_device_id *ids)
0188 {
0189     struct pcf50633 *pcf;
0190     struct platform_device *pdev;
0191     struct pcf50633_platform_data *pdata = dev_get_platdata(&client->dev);
0192     int i, j, ret;
0193     int version, variant;
0194
0195     if (!client->irq) {
0196         dev_err(&client->dev, "Missing IRQ\n");
0197         return -ENOENT;
0198     }
0199
0200     pcf = devm_kzalloc(&client->dev, sizeof(*pcf), GFP_KERNEL);
0201     if (!pcf)
0202         return -ENOMEM;
0203
0204     i2c_set_clientdata(client, pcf);
0205     pcf->dev = &client->dev;
0206     pcf->pdata = pdata;
0207
0208     mutex_init(&pcf->lock);
0209
0210     pcf->regmap = devm_regmap_init_i2c(client, &pcf50633_regmap_config);
0211     if (IS_ERR(pcf->regmap)) {
0212         ret = PTR_ERR(pcf->regmap);
0213         dev_err(pcf->dev, "Failed to allocate register map: %d\n", ret);
0214         return ret;
0215     }
0216
0217     version = pcf50633_reg_read(pcf, 0);
0218     variant = pcf50633_reg_read(pcf, 1);
0219     if (version < 0 || variant < 0) {
0220         dev_err(pcf->dev, "Unable to probe pcf50633\n");
0221         ret = -ENODEV;
0222         return ret;
0223     }
0224
0225     dev_info(pcf->dev, "Probed device version %d variant %d\n",
0226                             version, variant);
0227
0228     pcf50633_irq_init(pcf, client->irq);
0229
0230     /* Create sub devices */
0231     pcf50633_client_dev_register(pcf, "pcf50633-input", &pcf->input_pdev);
0232     pcf50633_client_dev_register(pcf, "pcf50633-rtc", &pcf->rtc_pdev);
0233     pcf50633_client_dev_register(pcf, "pcf50633-mbc", &pcf->mbc_pdev);
0234     pcf50633_client_dev_register(pcf, "pcf50633-adc", &pcf->adc_pdev);
0235     pcf50633_client_dev_register(pcf, "pcf50633-backlight", &pcf->bl_pdev);
0236
0237
0238     for (i = 0; i < PCF50633_NUM_REGULATORS; i++) {
0239         pdev = platform_device_alloc("pcf50633-regulator", i);
0240         if (!pdev) {
0241             ret = -ENOMEM;
0242             goto err2;
0243         }
0244
0245         pdev->dev.parent = pcf->dev;
0246         ret = platform_device_add_data(pdev, &pdata->reg_init_data[i],
0247                            sizeof(pdata->reg_init_data[i]));
0248         if (ret)
0249             goto err;
0250
0251         ret = platform_device_add(pdev);
0252         if (ret)
0253             goto err;
0254
0255         pcf->regulator_pdev[i] = pdev;
0256     }
0257
0258     ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group);
0259     if (ret)
0260         dev_warn(pcf->dev, "error creating sysfs entries\n");
0261
0262     if (pdata->probe_done)
0263         pdata->probe_done(pcf);
0264
0265     return 0;
0266
0267 err:
0268     platform_device_put(pdev);
0269 err2:
0270     for (j = 0; j < i; j++)
0271         platform_device_put(pcf->regulator_pdev[j]);
0272
0273     return ret;
0274 }
0275
0276 static int pcf50633_remove(struct i2c_client *client)
0277 {
0278     struct pcf50633 *pcf = i2c_get_clientdata(client);
0279     int i;
0280
0281     sysfs_remove_group(&client->dev.kobj, &pcf_attr_group);
0282     pcf50633_irq_free(pcf);
0283
0284     platform_device_unregister(pcf->input_pdev);
0285     platform_device_unregister(pcf->rtc_pdev);
0286     platform_device_unregister(pcf->mbc_pdev);
0287     platform_device_unregister(pcf->adc_pdev);
0288     platform_device_unregister(pcf->bl_pdev);
0289
0290     for (i = 0; i < PCF50633_NUM_REGULATORS; i++)
0291         platform_device_unregister(pcf->regulator_pdev[i]);
0292
0293     return 0;
0294 }
0295
0296 static const struct i2c_device_id pcf50633_id_table[] = {
0297     {"pcf50633", 0x73},
0298     {/* end of list */}
0299 };
0300 MODULE_DEVICE_TABLE(i2c, pcf50633_id_table);
0301
0302 static struct i2c_driver pcf50633_driver = {
0303     .driver = {
0304         .name   = "pcf50633",
0305         .pm = &pcf50633_pm,
0306     },
0307     .id_table = pcf50633_id_table,
0308     .probe = pcf50633_probe,
0309     .remove = pcf50633_remove,
0310 };
0311
0312 static int __init pcf50633_init(void)
0313 {
0314     return i2c_add_driver(&pcf50633_driver);
0315 }
0316
0317 static void __exit pcf50633_exit(void)
0318 {
0319     i2c_del_driver(&pcf50633_driver);
0320 }
0321
0322 MODULE_DESCRIPTION("I2C chip driver for NXP PCF50633 PMU");
0323 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
0324 MODULE_LICENSE("GPL");
0325
0326 subsys_initcall(pcf50633_init);
0327 module_exit(pcf50633_exit);