Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/mfd/as3711.c

  1 /*
  2  * AS3711 PMIC MFC driver
  3  *
  4  * Copyright (C) 2012 Renesas Electronics Corporation
  5  * Author: Guennadi Liakhovetski, <g.liakhovetski@gmx.de>
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the version 2 of the GNU General Public License as
  9  * published by the Free Software Foundation
 10  */
 11 
 12 #include <linux/device.h>
 13 #include <linux/err.h>
 14 #include <linux/i2c.h>
 15 #include <linux/init.h>
 16 #include <linux/kernel.h>
 17 #include <linux/mfd/as3711.h>
 18 #include <linux/mfd/core.h>
 19 #include <linux/module.h>
 20 #include <linux/of.h>
 21 #include <linux/regmap.h>
 22 #include <linux/slab.h>
 23 
 24 enum {
 25         AS3711_REGULATOR,
 26         AS3711_BACKLIGHT,
 27 };
 28 
 29 /*
 30  * Ok to have it static: it is only used during probing and multiple I2C devices
 31  * cannot be probed simultaneously. Just make sure to avoid stale data.
 32  */
 33 static struct mfd_cell as3711_subdevs[] = {
 34         [AS3711_REGULATOR] = {.name = "as3711-regulator",},
 35         [AS3711_BACKLIGHT] = {.name = "as3711-backlight",},
 36 };
 37 
 38 static bool as3711_volatile_reg(struct device *dev, unsigned int reg)
 39 {
 40         switch (reg) {
 41         case AS3711_GPIO_SIGNAL_IN:
 42         case AS3711_INTERRUPT_STATUS_1:
 43         case AS3711_INTERRUPT_STATUS_2:
 44         case AS3711_INTERRUPT_STATUS_3:
 45         case AS3711_CHARGER_STATUS_1:
 46         case AS3711_CHARGER_STATUS_2:
 47         case AS3711_REG_STATUS:
 48                 return true;
 49         }
 50         return false;
 51 }
 52 
 53 static bool as3711_precious_reg(struct device *dev, unsigned int reg)
 54 {
 55         switch (reg) {
 56         case AS3711_INTERRUPT_STATUS_1:
 57         case AS3711_INTERRUPT_STATUS_2:
 58         case AS3711_INTERRUPT_STATUS_3:
 59                 return true;
 60         }
 61         return false;
 62 }
 63 
 64 static bool as3711_readable_reg(struct device *dev, unsigned int reg)
 65 {
 66         switch (reg) {
 67         case AS3711_SD_1_VOLTAGE:
 68         case AS3711_SD_2_VOLTAGE:
 69         case AS3711_SD_3_VOLTAGE:
 70         case AS3711_SD_4_VOLTAGE:
 71         case AS3711_LDO_1_VOLTAGE:
 72         case AS3711_LDO_2_VOLTAGE:
 73         case AS3711_LDO_3_VOLTAGE:
 74         case AS3711_LDO_4_VOLTAGE:
 75         case AS3711_LDO_5_VOLTAGE:
 76         case AS3711_LDO_6_VOLTAGE:
 77         case AS3711_LDO_7_VOLTAGE:
 78         case AS3711_LDO_8_VOLTAGE:
 79         case AS3711_SD_CONTROL:
 80         case AS3711_GPIO_SIGNAL_OUT:
 81         case AS3711_GPIO_SIGNAL_IN:
 82         case AS3711_SD_CONTROL_1:
 83         case AS3711_SD_CONTROL_2:
 84         case AS3711_CURR_CONTROL:
 85         case AS3711_CURR1_VALUE:
 86         case AS3711_CURR2_VALUE:
 87         case AS3711_CURR3_VALUE:
 88         case AS3711_STEPUP_CONTROL_1:
 89         case AS3711_STEPUP_CONTROL_2:
 90         case AS3711_STEPUP_CONTROL_4:
 91         case AS3711_STEPUP_CONTROL_5:
 92         case AS3711_REG_STATUS:
 93         case AS3711_INTERRUPT_STATUS_1:
 94         case AS3711_INTERRUPT_STATUS_2:
 95         case AS3711_INTERRUPT_STATUS_3:
 96         case AS3711_CHARGER_STATUS_1:
 97         case AS3711_CHARGER_STATUS_2:
 98         case AS3711_ASIC_ID_1:
 99         case AS3711_ASIC_ID_2:
100                 return true;
101         }
102         return false;
103 }
104 
105 static const struct regmap_config as3711_regmap_config = {
106         .reg_bits = 8,
107         .val_bits = 8,
108         .volatile_reg = as3711_volatile_reg,
109         .readable_reg = as3711_readable_reg,
110         .precious_reg = as3711_precious_reg,
111         .max_register = AS3711_MAX_REGS,
112         .num_reg_defaults_raw = AS3711_MAX_REGS,
113         .cache_type = REGCACHE_RBTREE,
114 };
115 
116 #ifdef CONFIG_OF
117 static const struct of_device_id as3711_of_match[] = {
118         {.compatible = "ams,as3711",},
119         {}
120 };
121 MODULE_DEVICE_TABLE(of, as3711_of_match);
122 #endif
123 
124 static int as3711_i2c_probe(struct i2c_client *client,
125                             const struct i2c_device_id *id)
126 {
127         struct as3711 *as3711;
128         struct as3711_platform_data *pdata;
129         unsigned int id1, id2;
130         int ret;
131 
132         if (!client->dev.of_node) {
133                 pdata = dev_get_platdata(&client->dev);
134                 if (!pdata)
135                         dev_dbg(&client->dev, "Platform data not found\n");
136         } else {
137                 pdata = devm_kzalloc(&client->dev,
138                                      sizeof(*pdata), GFP_KERNEL);
139                 if (!pdata) {
140                         dev_err(&client->dev, "Failed to allocate pdata\n");
141                         return -ENOMEM;
142                 }
143         }
144 
145         as3711 = devm_kzalloc(&client->dev, sizeof(struct as3711), GFP_KERNEL);
146         if (!as3711) {
147                 dev_err(&client->dev, "Memory allocation failed\n");
148                 return -ENOMEM;
149         }
150 
151         as3711->dev = &client->dev;
152         i2c_set_clientdata(client, as3711);
153 
154         if (client->irq)
155                 dev_notice(&client->dev, "IRQ not supported yet\n");
156 
157         as3711->regmap = devm_regmap_init_i2c(client, &as3711_regmap_config);
158         if (IS_ERR(as3711->regmap)) {
159                 ret = PTR_ERR(as3711->regmap);
160                 dev_err(&client->dev, "regmap initialization failed: %d\n", ret);
161                 return ret;
162         }
163 
164         ret = regmap_read(as3711->regmap, AS3711_ASIC_ID_1, &id1);
165         if (!ret)
166                 ret = regmap_read(as3711->regmap, AS3711_ASIC_ID_2, &id2);
167         if (ret < 0) {
168                 dev_err(&client->dev, "regmap_read() failed: %d\n", ret);
169                 return ret;
170         }
171         if (id1 != 0x8b)
172                 return -ENODEV;
173         dev_info(as3711->dev, "AS3711 detected: %x:%x\n", id1, id2);
174 
175         /* We can reuse as3711_subdevs[], it will be copied in mfd_add_devices() */
176         if (pdata) {
177                 as3711_subdevs[AS3711_REGULATOR].platform_data = &pdata->regulator;
178                 as3711_subdevs[AS3711_REGULATOR].pdata_size = sizeof(pdata->regulator);
179                 as3711_subdevs[AS3711_BACKLIGHT].platform_data = &pdata->backlight;
180                 as3711_subdevs[AS3711_BACKLIGHT].pdata_size = sizeof(pdata->backlight);
181         } else {
182                 as3711_subdevs[AS3711_REGULATOR].platform_data = NULL;
183                 as3711_subdevs[AS3711_REGULATOR].pdata_size = 0;
184                 as3711_subdevs[AS3711_BACKLIGHT].platform_data = NULL;
185                 as3711_subdevs[AS3711_BACKLIGHT].pdata_size = 0;
186         }
187 
188         ret = mfd_add_devices(as3711->dev, -1, as3711_subdevs,
189                               ARRAY_SIZE(as3711_subdevs), NULL, 0, NULL);
190         if (ret < 0)
191                 dev_err(&client->dev, "add mfd devices failed: %d\n", ret);
192 
193         return ret;
194 }
195 
196 static int as3711_i2c_remove(struct i2c_client *client)
197 {
198         struct as3711 *as3711 = i2c_get_clientdata(client);
199 
200         mfd_remove_devices(as3711->dev);
201         return 0;
202 }
203 
204 static const struct i2c_device_id as3711_i2c_id[] = {
205         {.name = "as3711", .driver_data = 0},
206         {}
207 };
208 
209 MODULE_DEVICE_TABLE(i2c, as3711_i2c_id);
210 
211 static struct i2c_driver as3711_i2c_driver = {
212         .driver = {
213                    .name = "as3711",
214                    .owner = THIS_MODULE,
215                    .of_match_table = of_match_ptr(as3711_of_match),
216         },
217         .probe = as3711_i2c_probe,
218         .remove = as3711_i2c_remove,
219         .id_table = as3711_i2c_id,
220 };
221 
222 static int __init as3711_i2c_init(void)
223 {
224         return i2c_add_driver(&as3711_i2c_driver);
225 }
226 /* Initialise early */
227 subsys_initcall(as3711_i2c_init);
228 
229 static void __exit as3711_i2c_exit(void)
230 {
231         i2c_del_driver(&as3711_i2c_driver);
232 }
233 module_exit(as3711_i2c_exit);
234 
235 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
236 MODULE_DESCRIPTION("AS3711 PMIC driver");
237 MODULE_LICENSE("GPL v2");
238 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us