Doug / smarc-fsl-linux-kernel

Download as
Browse Code »

Commit 168755ebb11e8bc17f2c12c42534adaf003a7d7e

Authored by Dan Carpenter
Committed by Samuel Ortiz
1 parent 10bbc48d7a
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

mfd: Silence an lm3533 gcc warning 

This is supposed to be umode_t.  It causes a GCC warning:
drivers/mfd/lm3533-core.c:440:2: warning: initialization from incompatible pointer type [enabled by default]
drivers/mfd/lm3533-core.c:440:2: warning: (near initialization for ‘lm3533_attribute_group.is_visible’) [enabled by default]

Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

drivers/mfd/lm3533-core.c
Diff comments   View file @ 168755e
1 /* 1 /*
2 * lm3533-core.c -- LM3533 Core 2 * lm3533-core.c -- LM3533 Core
3 * 3 *
4 * Copyright (C) 2011-2012 Texas Instruments 4 * Copyright (C) 2011-2012 Texas Instruments
5 * 5 *
6 * Author: Johan Hovold <jhovold@gmail.com> 6 * Author: Johan Hovold <jhovold@gmail.com>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify it 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 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 10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
12 */ 12 */
13 13
14 #include <linux/module.h> 14 #include <linux/module.h>
15 #include <linux/init.h> 15 #include <linux/init.h>
16 #include <linux/kernel.h> 16 #include <linux/kernel.h>
17 #include <linux/err.h> 17 #include <linux/err.h>
18 #include <linux/gpio.h> 18 #include <linux/gpio.h>
19 #include <linux/i2c.h> 19 #include <linux/i2c.h>
20 #include <linux/mfd/core.h> 20 #include <linux/mfd/core.h>
21 #include <linux/regmap.h> 21 #include <linux/regmap.h>
22 #include <linux/seq_file.h> 22 #include <linux/seq_file.h>
23 #include <linux/slab.h> 23 #include <linux/slab.h>
24 #include <linux/uaccess.h> 24 #include <linux/uaccess.h>
25 25
26 #include <linux/mfd/lm3533.h> 26 #include <linux/mfd/lm3533.h>
27 27
28 28
29 #define LM3533_BOOST_OVP_MASK 0x06 29 #define LM3533_BOOST_OVP_MASK 0x06
30 #define LM3533_BOOST_OVP_SHIFT 1 30 #define LM3533_BOOST_OVP_SHIFT 1
31 31
32 #define LM3533_BOOST_FREQ_MASK 0x01 32 #define LM3533_BOOST_FREQ_MASK 0x01
33 #define LM3533_BOOST_FREQ_SHIFT 0 33 #define LM3533_BOOST_FREQ_SHIFT 0
34 34
35 #define LM3533_BL_ID_MASK 1 35 #define LM3533_BL_ID_MASK 1
36 #define LM3533_LED_ID_MASK 3 36 #define LM3533_LED_ID_MASK 3
37 #define LM3533_BL_ID_MAX 1 37 #define LM3533_BL_ID_MAX 1
38 #define LM3533_LED_ID_MAX 3 38 #define LM3533_LED_ID_MAX 3
39 39
40 #define LM3533_HVLED_ID_MAX 2 40 #define LM3533_HVLED_ID_MAX 2
41 #define LM3533_LVLED_ID_MAX 5 41 #define LM3533_LVLED_ID_MAX 5
42 42
43 #define LM3533_REG_OUTPUT_CONF1 0x10 43 #define LM3533_REG_OUTPUT_CONF1 0x10
44 #define LM3533_REG_OUTPUT_CONF2 0x11 44 #define LM3533_REG_OUTPUT_CONF2 0x11
45 #define LM3533_REG_BOOST_PWM 0x2c 45 #define LM3533_REG_BOOST_PWM 0x2c
46 46
47 #define LM3533_REG_MAX 0xb2 47 #define LM3533_REG_MAX 0xb2
48 48
49 49
50 static struct mfd_cell lm3533_als_devs[] = { 50 static struct mfd_cell lm3533_als_devs[] = {
51 { 51 {
52 .name = "lm3533-als", 52 .name = "lm3533-als",
53 .id = -1, 53 .id = -1,
54 }, 54 },
55 }; 55 };
56 56
57 static struct mfd_cell lm3533_bl_devs[] = { 57 static struct mfd_cell lm3533_bl_devs[] = {
58 { 58 {
59 .name = "lm3533-backlight", 59 .name = "lm3533-backlight",
60 .id = 0, 60 .id = 0,
61 }, 61 },
62 { 62 {
63 .name = "lm3533-backlight", 63 .name = "lm3533-backlight",
64 .id = 1, 64 .id = 1,
65 }, 65 },
66 }; 66 };
67 67
68 static struct mfd_cell lm3533_led_devs[] = { 68 static struct mfd_cell lm3533_led_devs[] = {
69 { 69 {
70 .name = "lm3533-leds", 70 .name = "lm3533-leds",
71 .id = 0, 71 .id = 0,
72 }, 72 },
73 { 73 {
74 .name = "lm3533-leds", 74 .name = "lm3533-leds",
75 .id = 1, 75 .id = 1,
76 }, 76 },
77 { 77 {
78 .name = "lm3533-leds", 78 .name = "lm3533-leds",
79 .id = 2, 79 .id = 2,
80 }, 80 },
81 { 81 {
82 .name = "lm3533-leds", 82 .name = "lm3533-leds",
83 .id = 3, 83 .id = 3,
84 }, 84 },
85 }; 85 };
86 86
87 int lm3533_read(struct lm3533 *lm3533, u8 reg, u8 *val) 87 int lm3533_read(struct lm3533 *lm3533, u8 reg, u8 *val)
88 { 88 {
89 int tmp; 89 int tmp;
90 int ret; 90 int ret;
91 91
92 ret = regmap_read(lm3533->regmap, reg, &tmp); 92 ret = regmap_read(lm3533->regmap, reg, &tmp);
93 if (ret < 0) { 93 if (ret < 0) {
94 dev_err(lm3533->dev, "failed to read register %02x: %d\n", 94 dev_err(lm3533->dev, "failed to read register %02x: %d\n",
95 reg, ret); 95 reg, ret);
96 return ret; 96 return ret;
97 } 97 }
98 98
99 *val = tmp; 99 *val = tmp;
100 100
101 dev_dbg(lm3533->dev, "read [%02x]: %02x\n", reg, *val); 101 dev_dbg(lm3533->dev, "read [%02x]: %02x\n", reg, *val);
102 102
103 return ret; 103 return ret;
104 } 104 }
105 EXPORT_SYMBOL_GPL(lm3533_read); 105 EXPORT_SYMBOL_GPL(lm3533_read);
106 106
107 int lm3533_write(struct lm3533 *lm3533, u8 reg, u8 val) 107 int lm3533_write(struct lm3533 *lm3533, u8 reg, u8 val)
108 { 108 {
109 int ret; 109 int ret;
110 110
111 dev_dbg(lm3533->dev, "write [%02x]: %02x\n", reg, val); 111 dev_dbg(lm3533->dev, "write [%02x]: %02x\n", reg, val);
112 112
113 ret = regmap_write(lm3533->regmap, reg, val); 113 ret = regmap_write(lm3533->regmap, reg, val);
114 if (ret < 0) { 114 if (ret < 0) {
115 dev_err(lm3533->dev, "failed to write register %02x: %d\n", 115 dev_err(lm3533->dev, "failed to write register %02x: %d\n",
116 reg, ret); 116 reg, ret);
117 } 117 }
118 118
119 return ret; 119 return ret;
120 } 120 }
121 EXPORT_SYMBOL_GPL(lm3533_write); 121 EXPORT_SYMBOL_GPL(lm3533_write);
122 122
123 int lm3533_update(struct lm3533 *lm3533, u8 reg, u8 val, u8 mask) 123 int lm3533_update(struct lm3533 *lm3533, u8 reg, u8 val, u8 mask)
124 { 124 {
125 int ret; 125 int ret;
126 126
127 dev_dbg(lm3533->dev, "update [%02x]: %02x/%02x\n", reg, val, mask); 127 dev_dbg(lm3533->dev, "update [%02x]: %02x/%02x\n", reg, val, mask);
128 128
129 ret = regmap_update_bits(lm3533->regmap, reg, mask, val); 129 ret = regmap_update_bits(lm3533->regmap, reg, mask, val);
130 if (ret < 0) { 130 if (ret < 0) {
131 dev_err(lm3533->dev, "failed to update register %02x: %d\n", 131 dev_err(lm3533->dev, "failed to update register %02x: %d\n",
132 reg, ret); 132 reg, ret);
133 } 133 }
134 134
135 return ret; 135 return ret;
136 } 136 }
137 EXPORT_SYMBOL_GPL(lm3533_update); 137 EXPORT_SYMBOL_GPL(lm3533_update);
138 138
139 static int lm3533_set_boost_freq(struct lm3533 *lm3533, 139 static int lm3533_set_boost_freq(struct lm3533 *lm3533,
140 enum lm3533_boost_freq freq) 140 enum lm3533_boost_freq freq)
141 { 141 {
142 int ret; 142 int ret;
143 143
144 ret = lm3533_update(lm3533, LM3533_REG_BOOST_PWM, 144 ret = lm3533_update(lm3533, LM3533_REG_BOOST_PWM,
145 freq << LM3533_BOOST_FREQ_SHIFT, 145 freq << LM3533_BOOST_FREQ_SHIFT,
146 LM3533_BOOST_FREQ_MASK); 146 LM3533_BOOST_FREQ_MASK);
147 if (ret) 147 if (ret)
148 dev_err(lm3533->dev, "failed to set boost frequency\n"); 148 dev_err(lm3533->dev, "failed to set boost frequency\n");
149 149
150 return ret; 150 return ret;
151 } 151 }
152 152
153 153
154 static int lm3533_set_boost_ovp(struct lm3533 *lm3533, 154 static int lm3533_set_boost_ovp(struct lm3533 *lm3533,
155 enum lm3533_boost_ovp ovp) 155 enum lm3533_boost_ovp ovp)
156 { 156 {
157 int ret; 157 int ret;
158 158
159 ret = lm3533_update(lm3533, LM3533_REG_BOOST_PWM, 159 ret = lm3533_update(lm3533, LM3533_REG_BOOST_PWM,
160 ovp << LM3533_BOOST_OVP_SHIFT, 160 ovp << LM3533_BOOST_OVP_SHIFT,
161 LM3533_BOOST_OVP_MASK); 161 LM3533_BOOST_OVP_MASK);
162 if (ret) 162 if (ret)
163 dev_err(lm3533->dev, "failed to set boost ovp\n"); 163 dev_err(lm3533->dev, "failed to set boost ovp\n");
164 164
165 return ret; 165 return ret;
166 } 166 }
167 167
168 /* 168 /*
169 * HVLED output config -- output hvled controlled by backlight bl 169 * HVLED output config -- output hvled controlled by backlight bl
170 */ 170 */
171 static int lm3533_set_hvled_config(struct lm3533 *lm3533, u8 hvled, u8 bl) 171 static int lm3533_set_hvled_config(struct lm3533 *lm3533, u8 hvled, u8 bl)
172 { 172 {
173 u8 val; 173 u8 val;
174 u8 mask; 174 u8 mask;
175 int shift; 175 int shift;
176 int ret; 176 int ret;
177 177
178 if (hvled == 0 || hvled > LM3533_HVLED_ID_MAX) 178 if (hvled == 0 || hvled > LM3533_HVLED_ID_MAX)
179 return -EINVAL; 179 return -EINVAL;
180 180
181 if (bl > LM3533_BL_ID_MAX) 181 if (bl > LM3533_BL_ID_MAX)
182 return -EINVAL; 182 return -EINVAL;
183 183
184 shift = hvled - 1; 184 shift = hvled - 1;
185 mask = LM3533_BL_ID_MASK << shift; 185 mask = LM3533_BL_ID_MASK << shift;
186 val = bl << shift; 186 val = bl << shift;
187 187
188 ret = lm3533_update(lm3533, LM3533_REG_OUTPUT_CONF1, val, mask); 188 ret = lm3533_update(lm3533, LM3533_REG_OUTPUT_CONF1, val, mask);
189 if (ret) 189 if (ret)
190 dev_err(lm3533->dev, "failed to set hvled config\n"); 190 dev_err(lm3533->dev, "failed to set hvled config\n");
191 191
192 return ret; 192 return ret;
193 } 193 }
194 194
195 /* 195 /*
196 * LVLED output config -- output lvled controlled by LED led 196 * LVLED output config -- output lvled controlled by LED led
197 */ 197 */
198 static int lm3533_set_lvled_config(struct lm3533 *lm3533, u8 lvled, u8 led) 198 static int lm3533_set_lvled_config(struct lm3533 *lm3533, u8 lvled, u8 led)
199 { 199 {
200 u8 reg; 200 u8 reg;
201 u8 val; 201 u8 val;
202 u8 mask; 202 u8 mask;
203 int shift; 203 int shift;
204 int ret; 204 int ret;
205 205
206 if (lvled == 0 || lvled > LM3533_LVLED_ID_MAX) 206 if (lvled == 0 || lvled > LM3533_LVLED_ID_MAX)
207 return -EINVAL; 207 return -EINVAL;
208 208
209 if (led > LM3533_LED_ID_MAX) 209 if (led > LM3533_LED_ID_MAX)
210 return -EINVAL; 210 return -EINVAL;
211 211
212 if (lvled < 4) { 212 if (lvled < 4) {
213 reg = LM3533_REG_OUTPUT_CONF1; 213 reg = LM3533_REG_OUTPUT_CONF1;
214 shift = 2 * lvled; 214 shift = 2 * lvled;
215 } else { 215 } else {
216 reg = LM3533_REG_OUTPUT_CONF2; 216 reg = LM3533_REG_OUTPUT_CONF2;
217 shift = 2 * (lvled - 4); 217 shift = 2 * (lvled - 4);
218 } 218 }
219 219
220 mask = LM3533_LED_ID_MASK << shift; 220 mask = LM3533_LED_ID_MASK << shift;
221 val = led << shift; 221 val = led << shift;
222 222
223 ret = lm3533_update(lm3533, reg, val, mask); 223 ret = lm3533_update(lm3533, reg, val, mask);
224 if (ret) 224 if (ret)
225 dev_err(lm3533->dev, "failed to set lvled config\n"); 225 dev_err(lm3533->dev, "failed to set lvled config\n");
226 226
227 return ret; 227 return ret;
228 } 228 }
229 229
230 static void lm3533_enable(struct lm3533 *lm3533) 230 static void lm3533_enable(struct lm3533 *lm3533)
231 { 231 {
232 if (gpio_is_valid(lm3533->gpio_hwen)) 232 if (gpio_is_valid(lm3533->gpio_hwen))
233 gpio_set_value(lm3533->gpio_hwen, 1); 233 gpio_set_value(lm3533->gpio_hwen, 1);
234 } 234 }
235 235
236 static void lm3533_disable(struct lm3533 *lm3533) 236 static void lm3533_disable(struct lm3533 *lm3533)
237 { 237 {
238 if (gpio_is_valid(lm3533->gpio_hwen)) 238 if (gpio_is_valid(lm3533->gpio_hwen))
239 gpio_set_value(lm3533->gpio_hwen, 0); 239 gpio_set_value(lm3533->gpio_hwen, 0);
240 } 240 }
241 241
242 enum lm3533_attribute_type { 242 enum lm3533_attribute_type {
243 LM3533_ATTR_TYPE_BACKLIGHT, 243 LM3533_ATTR_TYPE_BACKLIGHT,
244 LM3533_ATTR_TYPE_LED, 244 LM3533_ATTR_TYPE_LED,
245 }; 245 };
246 246
247 struct lm3533_device_attribute { 247 struct lm3533_device_attribute {
248 struct device_attribute dev_attr; 248 struct device_attribute dev_attr;
249 enum lm3533_attribute_type type; 249 enum lm3533_attribute_type type;
250 union { 250 union {
251 struct { 251 struct {
252 u8 id; 252 u8 id;
253 } output; 253 } output;
254 } u; 254 } u;
255 }; 255 };
256 256
257 #define to_lm3533_dev_attr(_attr) \ 257 #define to_lm3533_dev_attr(_attr) \
258 container_of(_attr, struct lm3533_device_attribute, dev_attr) 258 container_of(_attr, struct lm3533_device_attribute, dev_attr)
259 259
260 static ssize_t show_output(struct device *dev, 260 static ssize_t show_output(struct device *dev,
261 struct device_attribute *attr, char *buf) 261 struct device_attribute *attr, char *buf)
262 { 262 {
263 struct lm3533 *lm3533 = dev_get_drvdata(dev); 263 struct lm3533 *lm3533 = dev_get_drvdata(dev);
264 struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(attr); 264 struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(attr);
265 int id = lattr->u.output.id; 265 int id = lattr->u.output.id;
266 u8 reg; 266 u8 reg;
267 u8 val; 267 u8 val;
268 u8 mask; 268 u8 mask;
269 int shift; 269 int shift;
270 int ret; 270 int ret;
271 271
272 if (lattr->type == LM3533_ATTR_TYPE_BACKLIGHT) { 272 if (lattr->type == LM3533_ATTR_TYPE_BACKLIGHT) {
273 reg = LM3533_REG_OUTPUT_CONF1; 273 reg = LM3533_REG_OUTPUT_CONF1;
274 shift = id - 1; 274 shift = id - 1;
275 mask = LM3533_BL_ID_MASK << shift; 275 mask = LM3533_BL_ID_MASK << shift;
276 } else { 276 } else {
277 if (id < 4) { 277 if (id < 4) {
278 reg = LM3533_REG_OUTPUT_CONF1; 278 reg = LM3533_REG_OUTPUT_CONF1;
279 shift = 2 * id; 279 shift = 2 * id;
280 } else { 280 } else {
281 reg = LM3533_REG_OUTPUT_CONF2; 281 reg = LM3533_REG_OUTPUT_CONF2;
282 shift = 2 * (id - 4); 282 shift = 2 * (id - 4);
283 } 283 }
284 mask = LM3533_LED_ID_MASK << shift; 284 mask = LM3533_LED_ID_MASK << shift;
285 } 285 }
286 286
287 ret = lm3533_read(lm3533, reg, &val); 287 ret = lm3533_read(lm3533, reg, &val);
288 if (ret) 288 if (ret)
289 return ret; 289 return ret;
290 290
291 val = (val & mask) >> shift; 291 val = (val & mask) >> shift;
292 292
293 return scnprintf(buf, PAGE_SIZE, "%u\n", val); 293 return scnprintf(buf, PAGE_SIZE, "%u\n", val);
294 } 294 }
295 295
296 static ssize_t store_output(struct device *dev, 296 static ssize_t store_output(struct device *dev,
297 struct device_attribute *attr, 297 struct device_attribute *attr,
298 const char *buf, size_t len) 298 const char *buf, size_t len)
299 { 299 {
300 struct lm3533 *lm3533 = dev_get_drvdata(dev); 300 struct lm3533 *lm3533 = dev_get_drvdata(dev);
301 struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(attr); 301 struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(attr);
302 int id = lattr->u.output.id; 302 int id = lattr->u.output.id;
303 u8 val; 303 u8 val;
304 int ret; 304 int ret;
305 305
306 if (kstrtou8(buf, 0, &val)) 306 if (kstrtou8(buf, 0, &val))
307 return -EINVAL; 307 return -EINVAL;
308 308
309 if (lattr->type == LM3533_ATTR_TYPE_BACKLIGHT) 309 if (lattr->type == LM3533_ATTR_TYPE_BACKLIGHT)
310 ret = lm3533_set_hvled_config(lm3533, id, val); 310 ret = lm3533_set_hvled_config(lm3533, id, val);
311 else 311 else
312 ret = lm3533_set_lvled_config(lm3533, id, val); 312 ret = lm3533_set_lvled_config(lm3533, id, val);
313 313
314 if (ret) 314 if (ret)
315 return ret; 315 return ret;
316 316
317 return len; 317 return len;
318 } 318 }
319 319
320 #define LM3533_OUTPUT_ATTR(_name, _mode, _show, _store, _type, _id) \ 320 #define LM3533_OUTPUT_ATTR(_name, _mode, _show, _store, _type, _id) \
321 struct lm3533_device_attribute lm3533_dev_attr_##_name = \ 321 struct lm3533_device_attribute lm3533_dev_attr_##_name = \
322 { .dev_attr = __ATTR(_name, _mode, _show, _store), \ 322 { .dev_attr = __ATTR(_name, _mode, _show, _store), \
323 .type = _type, \ 323 .type = _type, \
324 .u.output = { .id = _id }, } 324 .u.output = { .id = _id }, }
325 325
326 #define LM3533_OUTPUT_ATTR_RW(_name, _type, _id) \ 326 #define LM3533_OUTPUT_ATTR_RW(_name, _type, _id) \
327 LM3533_OUTPUT_ATTR(output_##_name, S_IRUGO | S_IWUSR, \ 327 LM3533_OUTPUT_ATTR(output_##_name, S_IRUGO | S_IWUSR, \
328 show_output, store_output, _type, _id) 328 show_output, store_output, _type, _id)
329 329
330 #define LM3533_OUTPUT_HVLED_ATTR_RW(_nr) \ 330 #define LM3533_OUTPUT_HVLED_ATTR_RW(_nr) \
331 LM3533_OUTPUT_ATTR_RW(hvled##_nr, LM3533_ATTR_TYPE_BACKLIGHT, _nr) 331 LM3533_OUTPUT_ATTR_RW(hvled##_nr, LM3533_ATTR_TYPE_BACKLIGHT, _nr)
332 #define LM3533_OUTPUT_LVLED_ATTR_RW(_nr) \ 332 #define LM3533_OUTPUT_LVLED_ATTR_RW(_nr) \
333 LM3533_OUTPUT_ATTR_RW(lvled##_nr, LM3533_ATTR_TYPE_LED, _nr) 333 LM3533_OUTPUT_ATTR_RW(lvled##_nr, LM3533_ATTR_TYPE_LED, _nr)
334 /* 334 /*
335 * Output config: 335 * Output config:
336 * 336 *
337 * output_hvled<nr> 0-1 337 * output_hvled<nr> 0-1
338 * output_lvled<nr> 0-3 338 * output_lvled<nr> 0-3
339 */ 339 */
340 static LM3533_OUTPUT_HVLED_ATTR_RW(1); 340 static LM3533_OUTPUT_HVLED_ATTR_RW(1);
341 static LM3533_OUTPUT_HVLED_ATTR_RW(2); 341 static LM3533_OUTPUT_HVLED_ATTR_RW(2);
342 static LM3533_OUTPUT_LVLED_ATTR_RW(1); 342 static LM3533_OUTPUT_LVLED_ATTR_RW(1);
343 static LM3533_OUTPUT_LVLED_ATTR_RW(2); 343 static LM3533_OUTPUT_LVLED_ATTR_RW(2);
344 static LM3533_OUTPUT_LVLED_ATTR_RW(3); 344 static LM3533_OUTPUT_LVLED_ATTR_RW(3);
345 static LM3533_OUTPUT_LVLED_ATTR_RW(4); 345 static LM3533_OUTPUT_LVLED_ATTR_RW(4);
346 static LM3533_OUTPUT_LVLED_ATTR_RW(5); 346 static LM3533_OUTPUT_LVLED_ATTR_RW(5);
347 347
348 static struct attribute *lm3533_attributes[] = { 348 static struct attribute *lm3533_attributes[] = {
349 &lm3533_dev_attr_output_hvled1.dev_attr.attr, 349 &lm3533_dev_attr_output_hvled1.dev_attr.attr,
350 &lm3533_dev_attr_output_hvled2.dev_attr.attr, 350 &lm3533_dev_attr_output_hvled2.dev_attr.attr,
351 &lm3533_dev_attr_output_lvled1.dev_attr.attr, 351 &lm3533_dev_attr_output_lvled1.dev_attr.attr,
352 &lm3533_dev_attr_output_lvled2.dev_attr.attr, 352 &lm3533_dev_attr_output_lvled2.dev_attr.attr,
353 &lm3533_dev_attr_output_lvled3.dev_attr.attr, 353 &lm3533_dev_attr_output_lvled3.dev_attr.attr,
354 &lm3533_dev_attr_output_lvled4.dev_attr.attr, 354 &lm3533_dev_attr_output_lvled4.dev_attr.attr,
355 &lm3533_dev_attr_output_lvled5.dev_attr.attr, 355 &lm3533_dev_attr_output_lvled5.dev_attr.attr,
356 NULL, 356 NULL,
357 }; 357 };
358 358
359 #define to_dev_attr(_attr) \ 359 #define to_dev_attr(_attr) \
360 container_of(_attr, struct device_attribute, attr) 360 container_of(_attr, struct device_attribute, attr)
361 361
362 static mode_t lm3533_attr_is_visible(struct kobject *kobj, 362 static umode_t lm3533_attr_is_visible(struct kobject *kobj,
363 struct attribute *attr, int n) 363 struct attribute *attr, int n)
364 { 364 {
365 struct device *dev = container_of(kobj, struct device, kobj); 365 struct device *dev = container_of(kobj, struct device, kobj);
366 struct lm3533 *lm3533 = dev_get_drvdata(dev); 366 struct lm3533 *lm3533 = dev_get_drvdata(dev);
367 struct device_attribute *dattr = to_dev_attr(attr); 367 struct device_attribute *dattr = to_dev_attr(attr);
368 struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(dattr); 368 struct lm3533_device_attribute *lattr = to_lm3533_dev_attr(dattr);
369 enum lm3533_attribute_type type = lattr->type; 369 enum lm3533_attribute_type type = lattr->type;
370 mode_t mode = attr->mode; 370 mode_t mode = attr->mode;
371 371
372 if (!lm3533->have_backlights && type == LM3533_ATTR_TYPE_BACKLIGHT) 372 if (!lm3533->have_backlights && type == LM3533_ATTR_TYPE_BACKLIGHT)
373 mode = 0; 373 mode = 0;
374 else if (!lm3533->have_leds && type == LM3533_ATTR_TYPE_LED) 374 else if (!lm3533->have_leds && type == LM3533_ATTR_TYPE_LED)
375 mode = 0; 375 mode = 0;
376 376
377 return mode; 377 return mode;
378 }; 378 };
379 379
380 static struct attribute_group lm3533_attribute_group = { 380 static struct attribute_group lm3533_attribute_group = {
381 .is_visible = lm3533_attr_is_visible, 381 .is_visible = lm3533_attr_is_visible,
382 .attrs = lm3533_attributes 382 .attrs = lm3533_attributes
383 }; 383 };
384 384
385 static int __devinit lm3533_device_als_init(struct lm3533 *lm3533) 385 static int __devinit lm3533_device_als_init(struct lm3533 *lm3533)
386 { 386 {
387 struct lm3533_platform_data *pdata = lm3533->dev->platform_data; 387 struct lm3533_platform_data *pdata = lm3533->dev->platform_data;
388 int ret; 388 int ret;
389 389
390 if (!pdata->als) 390 if (!pdata->als)
391 return 0; 391 return 0;
392 392
393 lm3533_als_devs[0].platform_data = pdata->als; 393 lm3533_als_devs[0].platform_data = pdata->als;
394 lm3533_als_devs[0].pdata_size = sizeof(*pdata->als); 394 lm3533_als_devs[0].pdata_size = sizeof(*pdata->als);
395 395
396 ret = mfd_add_devices(lm3533->dev, 0, lm3533_als_devs, 1, NULL, 0); 396 ret = mfd_add_devices(lm3533->dev, 0, lm3533_als_devs, 1, NULL, 0);
397 if (ret) { 397 if (ret) {
398 dev_err(lm3533->dev, "failed to add ALS device\n"); 398 dev_err(lm3533->dev, "failed to add ALS device\n");
399 return ret; 399 return ret;
400 } 400 }
401 401
402 lm3533->have_als = 1; 402 lm3533->have_als = 1;
403 403
404 return 0; 404 return 0;
405 } 405 }
406 406
407 static int __devinit lm3533_device_bl_init(struct lm3533 *lm3533) 407 static int __devinit lm3533_device_bl_init(struct lm3533 *lm3533)
408 { 408 {
409 struct lm3533_platform_data *pdata = lm3533->dev->platform_data; 409 struct lm3533_platform_data *pdata = lm3533->dev->platform_data;
410 int i; 410 int i;
411 int ret; 411 int ret;
412 412
413 if (!pdata->backlights || pdata->num_backlights == 0) 413 if (!pdata->backlights || pdata->num_backlights == 0)
414 return 0; 414 return 0;
415 415
416 if (pdata->num_backlights > ARRAY_SIZE(lm3533_bl_devs)) 416 if (pdata->num_backlights > ARRAY_SIZE(lm3533_bl_devs))
417 pdata->num_backlights = ARRAY_SIZE(lm3533_bl_devs); 417 pdata->num_backlights = ARRAY_SIZE(lm3533_bl_devs);
418 418
419 for (i = 0; i < pdata->num_backlights; ++i) { 419 for (i = 0; i < pdata->num_backlights; ++i) {
420 lm3533_bl_devs[i].platform_data = &pdata->backlights[i]; 420 lm3533_bl_devs[i].platform_data = &pdata->backlights[i];
421 lm3533_bl_devs[i].pdata_size = sizeof(pdata->backlights[i]); 421 lm3533_bl_devs[i].pdata_size = sizeof(pdata->backlights[i]);
422 } 422 }
423 423
424 ret = mfd_add_devices(lm3533->dev, 0, lm3533_bl_devs, 424 ret = mfd_add_devices(lm3533->dev, 0, lm3533_bl_devs,
425 pdata->num_backlights, NULL, 0); 425 pdata->num_backlights, NULL, 0);
426 if (ret) { 426 if (ret) {
427 dev_err(lm3533->dev, "failed to add backlight devices\n"); 427 dev_err(lm3533->dev, "failed to add backlight devices\n");
428 return ret; 428 return ret;
429 } 429 }
430 430
431 lm3533->have_backlights = 1; 431 lm3533->have_backlights = 1;
432 432
433 return 0; 433 return 0;
434 } 434 }
435 435
436 static int __devinit lm3533_device_led_init(struct lm3533 *lm3533) 436 static int __devinit lm3533_device_led_init(struct lm3533 *lm3533)
437 { 437 {
438 struct lm3533_platform_data *pdata = lm3533->dev->platform_data; 438 struct lm3533_platform_data *pdata = lm3533->dev->platform_data;
439 int i; 439 int i;
440 int ret; 440 int ret;
441 441
442 if (!pdata->leds || pdata->num_leds == 0) 442 if (!pdata->leds || pdata->num_leds == 0)
443 return 0; 443 return 0;
444 444
445 if (pdata->num_leds > ARRAY_SIZE(lm3533_led_devs)) 445 if (pdata->num_leds > ARRAY_SIZE(lm3533_led_devs))
446 pdata->num_leds = ARRAY_SIZE(lm3533_led_devs); 446 pdata->num_leds = ARRAY_SIZE(lm3533_led_devs);
447 447
448 for (i = 0; i < pdata->num_leds; ++i) { 448 for (i = 0; i < pdata->num_leds; ++i) {
449 lm3533_led_devs[i].platform_data = &pdata->leds[i]; 449 lm3533_led_devs[i].platform_data = &pdata->leds[i];
450 lm3533_led_devs[i].pdata_size = sizeof(pdata->leds[i]); 450 lm3533_led_devs[i].pdata_size = sizeof(pdata->leds[i]);
451 } 451 }
452 452
453 ret = mfd_add_devices(lm3533->dev, 0, lm3533_led_devs, 453 ret = mfd_add_devices(lm3533->dev, 0, lm3533_led_devs,
454 pdata->num_leds, NULL, 0); 454 pdata->num_leds, NULL, 0);
455 if (ret) { 455 if (ret) {
456 dev_err(lm3533->dev, "failed to add LED devices\n"); 456 dev_err(lm3533->dev, "failed to add LED devices\n");
457 return ret; 457 return ret;
458 } 458 }
459 459
460 lm3533->have_leds = 1; 460 lm3533->have_leds = 1;
461 461
462 return 0; 462 return 0;
463 } 463 }
464 464
465 static int __devinit lm3533_device_setup(struct lm3533 *lm3533, 465 static int __devinit lm3533_device_setup(struct lm3533 *lm3533,
466 struct lm3533_platform_data *pdata) 466 struct lm3533_platform_data *pdata)
467 { 467 {
468 int ret; 468 int ret;
469 469
470 ret = lm3533_set_boost_freq(lm3533, pdata->boost_freq); 470 ret = lm3533_set_boost_freq(lm3533, pdata->boost_freq);
471 if (ret) 471 if (ret)
472 return ret; 472 return ret;
473 473
474 ret = lm3533_set_boost_ovp(lm3533, pdata->boost_ovp); 474 ret = lm3533_set_boost_ovp(lm3533, pdata->boost_ovp);
475 if (ret) 475 if (ret)
476 return ret; 476 return ret;
477 477
478 return 0; 478 return 0;
479 } 479 }
480 480
481 static int __devinit lm3533_device_init(struct lm3533 *lm3533) 481 static int __devinit lm3533_device_init(struct lm3533 *lm3533)
482 { 482 {
483 struct lm3533_platform_data *pdata = lm3533->dev->platform_data; 483 struct lm3533_platform_data *pdata = lm3533->dev->platform_data;
484 int ret; 484 int ret;
485 485
486 dev_dbg(lm3533->dev, "%s\n", __func__); 486 dev_dbg(lm3533->dev, "%s\n", __func__);
487 487
488 if (!pdata) { 488 if (!pdata) {
489 dev_err(lm3533->dev, "no platform data\n"); 489 dev_err(lm3533->dev, "no platform data\n");
490 return -EINVAL; 490 return -EINVAL;
491 } 491 }
492 492
493 lm3533->gpio_hwen = pdata->gpio_hwen; 493 lm3533->gpio_hwen = pdata->gpio_hwen;
494 494
495 dev_set_drvdata(lm3533->dev, lm3533); 495 dev_set_drvdata(lm3533->dev, lm3533);
496 496
497 if (gpio_is_valid(lm3533->gpio_hwen)) { 497 if (gpio_is_valid(lm3533->gpio_hwen)) {
498 ret = gpio_request_one(lm3533->gpio_hwen, GPIOF_OUT_INIT_LOW, 498 ret = gpio_request_one(lm3533->gpio_hwen, GPIOF_OUT_INIT_LOW,
499 "lm3533-hwen"); 499 "lm3533-hwen");
500 if (ret < 0) { 500 if (ret < 0) {
501 dev_err(lm3533->dev, 501 dev_err(lm3533->dev,
502 "failed to request HWEN GPIO %d\n", 502 "failed to request HWEN GPIO %d\n",
503 lm3533->gpio_hwen); 503 lm3533->gpio_hwen);
504 return ret; 504 return ret;
505 } 505 }
506 } 506 }
507 507
508 lm3533_enable(lm3533); 508 lm3533_enable(lm3533);
509 509
510 ret = lm3533_device_setup(lm3533, pdata); 510 ret = lm3533_device_setup(lm3533, pdata);
511 if (ret) 511 if (ret)
512 goto err_disable; 512 goto err_disable;
513 513
514 lm3533_device_als_init(lm3533); 514 lm3533_device_als_init(lm3533);
515 lm3533_device_bl_init(lm3533); 515 lm3533_device_bl_init(lm3533);
516 lm3533_device_led_init(lm3533); 516 lm3533_device_led_init(lm3533);
517 517
518 ret = sysfs_create_group(&lm3533->dev->kobj, &lm3533_attribute_group); 518 ret = sysfs_create_group(&lm3533->dev->kobj, &lm3533_attribute_group);
519 if (ret < 0) { 519 if (ret < 0) {
520 dev_err(lm3533->dev, "failed to create sysfs attributes\n"); 520 dev_err(lm3533->dev, "failed to create sysfs attributes\n");
521 goto err_unregister; 521 goto err_unregister;
522 } 522 }
523 523
524 return 0; 524 return 0;
525 525
526 err_unregister: 526 err_unregister:
527 mfd_remove_devices(lm3533->dev); 527 mfd_remove_devices(lm3533->dev);
528 err_disable: 528 err_disable:
529 lm3533_disable(lm3533); 529 lm3533_disable(lm3533);
530 if (gpio_is_valid(lm3533->gpio_hwen)) 530 if (gpio_is_valid(lm3533->gpio_hwen))
531 gpio_free(lm3533->gpio_hwen); 531 gpio_free(lm3533->gpio_hwen);
532 532
533 return ret; 533 return ret;
534 } 534 }
535 535
536 static void __devexit lm3533_device_exit(struct lm3533 *lm3533) 536 static void __devexit lm3533_device_exit(struct lm3533 *lm3533)
537 { 537 {
538 dev_dbg(lm3533->dev, "%s\n", __func__); 538 dev_dbg(lm3533->dev, "%s\n", __func__);
539 539
540 sysfs_remove_group(&lm3533->dev->kobj, &lm3533_attribute_group); 540 sysfs_remove_group(&lm3533->dev->kobj, &lm3533_attribute_group);
541 541
542 mfd_remove_devices(lm3533->dev); 542 mfd_remove_devices(lm3533->dev);
543 lm3533_disable(lm3533); 543 lm3533_disable(lm3533);
544 if (gpio_is_valid(lm3533->gpio_hwen)) 544 if (gpio_is_valid(lm3533->gpio_hwen))
545 gpio_free(lm3533->gpio_hwen); 545 gpio_free(lm3533->gpio_hwen);
546 } 546 }
547 547
548 static bool lm3533_readable_register(struct device *dev, unsigned int reg) 548 static bool lm3533_readable_register(struct device *dev, unsigned int reg)
549 { 549 {
550 switch (reg) { 550 switch (reg) {
551 case 0x10 ... 0x2c: 551 case 0x10 ... 0x2c:
552 case 0x30 ... 0x38: 552 case 0x30 ... 0x38:
553 case 0x40 ... 0x45: 553 case 0x40 ... 0x45:
554 case 0x50 ... 0x57: 554 case 0x50 ... 0x57:
555 case 0x60 ... 0x6e: 555 case 0x60 ... 0x6e:
556 case 0x70 ... 0x75: 556 case 0x70 ... 0x75:
557 case 0x80 ... 0x85: 557 case 0x80 ... 0x85:
558 case 0x90 ... 0x95: 558 case 0x90 ... 0x95:
559 case 0xa0 ... 0xa5: 559 case 0xa0 ... 0xa5:
560 case 0xb0 ... 0xb2: 560 case 0xb0 ... 0xb2:
561 return true; 561 return true;
562 default: 562 default:
563 return false; 563 return false;
564 } 564 }
565 } 565 }
566 566
567 static bool lm3533_volatile_register(struct device *dev, unsigned int reg) 567 static bool lm3533_volatile_register(struct device *dev, unsigned int reg)
568 { 568 {
569 switch (reg) { 569 switch (reg) {
570 case 0x34: /* zone */ 570 case 0x34: /* zone */
571 case 0x37 ... 0x38: /* adc */ 571 case 0x37 ... 0x38: /* adc */
572 case 0xb0 ... 0xb1: /* fault */ 572 case 0xb0 ... 0xb1: /* fault */
573 return true; 573 return true;
574 default: 574 default:
575 return false; 575 return false;
576 } 576 }
577 } 577 }
578 578
579 static bool lm3533_precious_register(struct device *dev, unsigned int reg) 579 static bool lm3533_precious_register(struct device *dev, unsigned int reg)
580 { 580 {
581 switch (reg) { 581 switch (reg) {
582 case 0x34: /* zone */ 582 case 0x34: /* zone */
583 return true; 583 return true;
584 default: 584 default:
585 return false; 585 return false;
586 } 586 }
587 } 587 }
588 588
589 static struct regmap_config regmap_config = { 589 static struct regmap_config regmap_config = {
590 .reg_bits = 8, 590 .reg_bits = 8,
591 .val_bits = 8, 591 .val_bits = 8,
592 .max_register = LM3533_REG_MAX, 592 .max_register = LM3533_REG_MAX,
593 .readable_reg = lm3533_readable_register, 593 .readable_reg = lm3533_readable_register,
594 .volatile_reg = lm3533_volatile_register, 594 .volatile_reg = lm3533_volatile_register,
595 .precious_reg = lm3533_precious_register, 595 .precious_reg = lm3533_precious_register,
596 }; 596 };
597 597
598 static int __devinit lm3533_i2c_probe(struct i2c_client *i2c, 598 static int __devinit lm3533_i2c_probe(struct i2c_client *i2c,
599 const struct i2c_device_id *id) 599 const struct i2c_device_id *id)
600 { 600 {
601 struct lm3533 *lm3533; 601 struct lm3533 *lm3533;
602 int ret; 602 int ret;
603 603
604 dev_dbg(&i2c->dev, "%s\n", __func__); 604 dev_dbg(&i2c->dev, "%s\n", __func__);
605 605
606 lm3533 = kzalloc(sizeof(*lm3533), GFP_KERNEL); 606 lm3533 = kzalloc(sizeof(*lm3533), GFP_KERNEL);
607 if (!lm3533) 607 if (!lm3533)
608 return -ENOMEM; 608 return -ENOMEM;
609 609
610 i2c_set_clientdata(i2c, lm3533); 610 i2c_set_clientdata(i2c, lm3533);
611 611
612 lm3533->regmap = regmap_init_i2c(i2c, &regmap_config); 612 lm3533->regmap = regmap_init_i2c(i2c, &regmap_config);
613 if (IS_ERR(lm3533->regmap)) { 613 if (IS_ERR(lm3533->regmap)) {
614 ret = PTR_ERR(lm3533->regmap); 614 ret = PTR_ERR(lm3533->regmap);
615 goto err_regmap; 615 goto err_regmap;
616 } 616 }
617 617
618 lm3533->dev = &i2c->dev; 618 lm3533->dev = &i2c->dev;
619 lm3533->irq = i2c->irq; 619 lm3533->irq = i2c->irq;
620 620
621 ret = lm3533_device_init(lm3533); 621 ret = lm3533_device_init(lm3533);
622 if (ret) 622 if (ret)
623 goto err_dev; 623 goto err_dev;
624 624
625 return 0; 625 return 0;
626 626
627 err_dev: 627 err_dev:
628 regmap_exit(lm3533->regmap); 628 regmap_exit(lm3533->regmap);
629 err_regmap: 629 err_regmap:
630 kfree(lm3533); 630 kfree(lm3533);
631 631
632 return ret; 632 return ret;
633 } 633 }
634 634
635 static int __devexit lm3533_i2c_remove(struct i2c_client *i2c) 635 static int __devexit lm3533_i2c_remove(struct i2c_client *i2c)
636 { 636 {
637 struct lm3533 *lm3533 = i2c_get_clientdata(i2c); 637 struct lm3533 *lm3533 = i2c_get_clientdata(i2c);
638 638
639 dev_dbg(&i2c->dev, "%s\n", __func__); 639 dev_dbg(&i2c->dev, "%s\n", __func__);
640 640
641 lm3533_device_exit(lm3533); 641 lm3533_device_exit(lm3533);
642 regmap_exit(lm3533->regmap); 642 regmap_exit(lm3533->regmap);
643 643
644 kfree(lm3533); 644 kfree(lm3533);
645 645
646 return 0; 646 return 0;
647 } 647 }
648 648
649 static const struct i2c_device_id lm3533_i2c_ids[] = { 649 static const struct i2c_device_id lm3533_i2c_ids[] = {
650 { "lm3533", 0 }, 650 { "lm3533", 0 },
651 { }, 651 { },
652 }; 652 };
653 MODULE_DEVICE_TABLE(i2c, lm3533_i2c_ids); 653 MODULE_DEVICE_TABLE(i2c, lm3533_i2c_ids);
654 654
655 static struct i2c_driver lm3533_i2c_driver = { 655 static struct i2c_driver lm3533_i2c_driver = {
656 .driver = { 656 .driver = {
657 .name = "lm3533", 657 .name = "lm3533",
658 .owner = THIS_MODULE, 658 .owner = THIS_MODULE,
659 }, 659 },
660 .id_table = lm3533_i2c_ids, 660 .id_table = lm3533_i2c_ids,
661 .probe = lm3533_i2c_probe, 661 .probe = lm3533_i2c_probe,
662 .remove = __devexit_p(lm3533_i2c_remove), 662 .remove = __devexit_p(lm3533_i2c_remove),
663 }; 663 };
664 664
665 static int __init lm3533_i2c_init(void) 665 static int __init lm3533_i2c_init(void)
666 { 666 {
667 return i2c_add_driver(&lm3533_i2c_driver); 667 return i2c_add_driver(&lm3533_i2c_driver);
668 } 668 }
669 subsys_initcall(lm3533_i2c_init); 669 subsys_initcall(lm3533_i2c_init);
670 670
671 static void __exit lm3533_i2c_exit(void) 671 static void __exit lm3533_i2c_exit(void)
672 { 672 {
673 i2c_del_driver(&lm3533_i2c_driver); 673 i2c_del_driver(&lm3533_i2c_driver);
674 } 674 }
675 module_exit(lm3533_i2c_exit); 675 module_exit(lm3533_i2c_exit);
676 676
677 MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>"); 677 MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
678 MODULE_DESCRIPTION("LM3533 Core"); 678 MODULE_DESCRIPTION("LM3533 Core");
679 MODULE_LICENSE("GPL"); 679 MODULE_LICENSE("GPL");
680 680