Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit e5971bbc1caf0ccbab3fea74fe37abb649d1c7cf

Authored by Simon Guinot
Committed by Nicolas Pitre
1 parent b51d92da4e
Exists in master and in 7 other branches imx_3.0.35_4.1.0, 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, smarc-l5.0.0_1.0.0-ga

leds: leds-ns2: fix private driver data storage 

dev_set_drvdata() can't be used to set the driver private data pointer.
This would overwrite the led classdev object previously registered by
led_classdev_register().

Note that despite this mistake, the driver work fine because led_dat and
led_dat->cdev are at the same memory address.

Signed-off-by: Simon Guinot <sguinot@lacie.com>
Signed-off-by: Nicolas Pitre <nico@fluxnic.net>

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

drivers/leds/leds-ns2.c
Diff comments   View file @ e5971bb
1 /* 1 /*
2 * leds-ns2.c - Driver for the Network Space v2 (and parents) dual-GPIO LED 2 * leds-ns2.c - Driver for the Network Space v2 (and parents) dual-GPIO LED
3 * 3 *
4 * Copyright (C) 2010 LaCie 4 * Copyright (C) 2010 LaCie
5 * 5 *
6 * Author: Simon Guinot <sguinot@lacie.com> 6 * Author: Simon Guinot <sguinot@lacie.com>
7 * 7 *
8 * Based on leds-gpio.c by Raphael Assenat <raph@8d.com> 8 * Based on leds-gpio.c by Raphael Assenat <raph@8d.com>
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify 10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by 11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or 12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. 13 * (at your option) any later version.
14 * 14 *
15 * This program is distributed in the hope that it will be useful, 15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details. 18 * GNU General Public License for more details.
19 * 19 *
20 * You should have received a copy of the GNU General Public License 20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software 21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */ 23 */
24 24
25 #include <linux/kernel.h> 25 #include <linux/kernel.h>
26 #include <linux/init.h> 26 #include <linux/init.h>
27 #include <linux/platform_device.h> 27 #include <linux/platform_device.h>
28 #include <linux/slab.h> 28 #include <linux/slab.h>
29 #include <linux/gpio.h> 29 #include <linux/gpio.h>
30 #include <linux/leds.h> 30 #include <linux/leds.h>
31 #include <mach/leds-ns2.h> 31 #include <mach/leds-ns2.h>
32 32
33 /* 33 /*
34 * The Network Space v2 dual-GPIO LED is wired to a CPLD and can blink in 34 * The Network Space v2 dual-GPIO LED is wired to a CPLD and can blink in
35 * relation with the SATA activity. This capability is exposed through the 35 * relation with the SATA activity. This capability is exposed through the
36 * "sata" sysfs attribute. 36 * "sata" sysfs attribute.
37 * 37 *
38 * The following array detail the different LED registers and the combination 38 * The following array detail the different LED registers and the combination
39 * of their possible values: 39 * of their possible values:
40 * 40 *
41 * cmd_led | slow_led | /SATA active | LED state 41 * cmd_led | slow_led | /SATA active | LED state
42 * | | | 42 * | | |
43 * 1 | 0 | x | off 43 * 1 | 0 | x | off
44 * - | 1 | x | on 44 * - | 1 | x | on
45 * 0 | 0 | 1 | on 45 * 0 | 0 | 1 | on
46 * 0 | 0 | 0 | blink (rate 300ms) 46 * 0 | 0 | 0 | blink (rate 300ms)
47 */ 47 */
48 48
49 enum ns2_led_modes { 49 enum ns2_led_modes {
50 NS_V2_LED_OFF, 50 NS_V2_LED_OFF,
51 NS_V2_LED_ON, 51 NS_V2_LED_ON,
52 NS_V2_LED_SATA, 52 NS_V2_LED_SATA,
53 }; 53 };
54 54
55 struct ns2_led_mode_value { 55 struct ns2_led_mode_value {
56 enum ns2_led_modes mode; 56 enum ns2_led_modes mode;
57 int cmd_level; 57 int cmd_level;
58 int slow_level; 58 int slow_level;
59 }; 59 };
60 60
61 static struct ns2_led_mode_value ns2_led_modval[] = { 61 static struct ns2_led_mode_value ns2_led_modval[] = {
62 { NS_V2_LED_OFF , 1, 0 }, 62 { NS_V2_LED_OFF , 1, 0 },
63 { NS_V2_LED_ON , 0, 1 }, 63 { NS_V2_LED_ON , 0, 1 },
64 { NS_V2_LED_ON , 1, 1 }, 64 { NS_V2_LED_ON , 1, 1 },
65 { NS_V2_LED_SATA, 0, 0 }, 65 { NS_V2_LED_SATA, 0, 0 },
66 }; 66 };
67 67
68 struct ns2_led_data { 68 struct ns2_led_data {
69 struct led_classdev cdev; 69 struct led_classdev cdev;
70 unsigned cmd; 70 unsigned cmd;
71 unsigned slow; 71 unsigned slow;
72 unsigned char sata; /* True when SATA mode active. */ 72 unsigned char sata; /* True when SATA mode active. */
73 rwlock_t rw_lock; /* Lock GPIOs. */ 73 rwlock_t rw_lock; /* Lock GPIOs. */
74 }; 74 };
75 75
76 static int ns2_led_get_mode(struct ns2_led_data *led_dat, 76 static int ns2_led_get_mode(struct ns2_led_data *led_dat,
77 enum ns2_led_modes *mode) 77 enum ns2_led_modes *mode)
78 { 78 {
79 int i; 79 int i;
80 int ret = -EINVAL; 80 int ret = -EINVAL;
81 int cmd_level; 81 int cmd_level;
82 int slow_level; 82 int slow_level;
83 83
84 read_lock_irq(&led_dat->rw_lock); 84 read_lock_irq(&led_dat->rw_lock);
85 85
86 cmd_level = gpio_get_value(led_dat->cmd); 86 cmd_level = gpio_get_value(led_dat->cmd);
87 slow_level = gpio_get_value(led_dat->slow); 87 slow_level = gpio_get_value(led_dat->slow);
88 88
89 for (i = 0; i < ARRAY_SIZE(ns2_led_modval); i++) { 89 for (i = 0; i < ARRAY_SIZE(ns2_led_modval); i++) {
90 if (cmd_level == ns2_led_modval[i].cmd_level && 90 if (cmd_level == ns2_led_modval[i].cmd_level &&
91 slow_level == ns2_led_modval[i].slow_level) { 91 slow_level == ns2_led_modval[i].slow_level) {
92 *mode = ns2_led_modval[i].mode; 92 *mode = ns2_led_modval[i].mode;
93 ret = 0; 93 ret = 0;
94 break; 94 break;
95 } 95 }
96 } 96 }
97 97
98 read_unlock_irq(&led_dat->rw_lock); 98 read_unlock_irq(&led_dat->rw_lock);
99 99
100 return ret; 100 return ret;
101 } 101 }
102 102
103 static void ns2_led_set_mode(struct ns2_led_data *led_dat, 103 static void ns2_led_set_mode(struct ns2_led_data *led_dat,
104 enum ns2_led_modes mode) 104 enum ns2_led_modes mode)
105 { 105 {
106 int i; 106 int i;
107 unsigned long flags; 107 unsigned long flags;
108 108
109 write_lock_irqsave(&led_dat->rw_lock, flags); 109 write_lock_irqsave(&led_dat->rw_lock, flags);
110 110
111 for (i = 0; i < ARRAY_SIZE(ns2_led_modval); i++) { 111 for (i = 0; i < ARRAY_SIZE(ns2_led_modval); i++) {
112 if (mode == ns2_led_modval[i].mode) { 112 if (mode == ns2_led_modval[i].mode) {
113 gpio_set_value(led_dat->cmd, 113 gpio_set_value(led_dat->cmd,
114 ns2_led_modval[i].cmd_level); 114 ns2_led_modval[i].cmd_level);
115 gpio_set_value(led_dat->slow, 115 gpio_set_value(led_dat->slow,
116 ns2_led_modval[i].slow_level); 116 ns2_led_modval[i].slow_level);
117 } 117 }
118 } 118 }
119 119
120 write_unlock_irqrestore(&led_dat->rw_lock, flags); 120 write_unlock_irqrestore(&led_dat->rw_lock, flags);
121 } 121 }
122 122
123 static void ns2_led_set(struct led_classdev *led_cdev, 123 static void ns2_led_set(struct led_classdev *led_cdev,
124 enum led_brightness value) 124 enum led_brightness value)
125 { 125 {
126 struct ns2_led_data *led_dat = 126 struct ns2_led_data *led_dat =
127 container_of(led_cdev, struct ns2_led_data, cdev); 127 container_of(led_cdev, struct ns2_led_data, cdev);
128 enum ns2_led_modes mode; 128 enum ns2_led_modes mode;
129 129
130 if (value == LED_OFF) 130 if (value == LED_OFF)
131 mode = NS_V2_LED_OFF; 131 mode = NS_V2_LED_OFF;
132 else if (led_dat->sata) 132 else if (led_dat->sata)
133 mode = NS_V2_LED_SATA; 133 mode = NS_V2_LED_SATA;
134 else 134 else
135 mode = NS_V2_LED_ON; 135 mode = NS_V2_LED_ON;
136 136
137 ns2_led_set_mode(led_dat, mode); 137 ns2_led_set_mode(led_dat, mode);
138 } 138 }
139 139
140 static ssize_t ns2_led_sata_store(struct device *dev, 140 static ssize_t ns2_led_sata_store(struct device *dev,
141 struct device_attribute *attr, 141 struct device_attribute *attr,
142 const char *buff, size_t count) 142 const char *buff, size_t count)
143 { 143 {
144 struct led_classdev *led_cdev = dev_get_drvdata(dev);
145 struct ns2_led_data *led_dat =
146 container_of(led_cdev, struct ns2_led_data, cdev);
144 int ret; 147 int ret;
145 unsigned long enable; 148 unsigned long enable;
146 enum ns2_led_modes mode; 149 enum ns2_led_modes mode;
147 struct ns2_led_data *led_dat = dev_get_drvdata(dev);
148 150
149 ret = strict_strtoul(buff, 10, &enable); 151 ret = strict_strtoul(buff, 10, &enable);
150 if (ret < 0) 152 if (ret < 0)
151 return ret; 153 return ret;
152 154
153 enable = !!enable; 155 enable = !!enable;
154 156
155 if (led_dat->sata == enable) 157 if (led_dat->sata == enable)
156 return count; 158 return count;
157 159
158 ret = ns2_led_get_mode(led_dat, &mode); 160 ret = ns2_led_get_mode(led_dat, &mode);
159 if (ret < 0) 161 if (ret < 0)
160 return ret; 162 return ret;
161 163
162 if (enable && mode == NS_V2_LED_ON) 164 if (enable && mode == NS_V2_LED_ON)
163 ns2_led_set_mode(led_dat, NS_V2_LED_SATA); 165 ns2_led_set_mode(led_dat, NS_V2_LED_SATA);
164 if (!enable && mode == NS_V2_LED_SATA) 166 if (!enable && mode == NS_V2_LED_SATA)
165 ns2_led_set_mode(led_dat, NS_V2_LED_ON); 167 ns2_led_set_mode(led_dat, NS_V2_LED_ON);
166 168
167 led_dat->sata = enable; 169 led_dat->sata = enable;
168 170
169 return count; 171 return count;
170 } 172 }
171 173
172 static ssize_t ns2_led_sata_show(struct device *dev, 174 static ssize_t ns2_led_sata_show(struct device *dev,
173 struct device_attribute *attr, char *buf) 175 struct device_attribute *attr, char *buf)
174 { 176 {
175 struct ns2_led_data *led_dat = dev_get_drvdata(dev); 177 struct led_classdev *led_cdev = dev_get_drvdata(dev);
178 struct ns2_led_data *led_dat =
179 container_of(led_cdev, struct ns2_led_data, cdev);
176 180
177 return sprintf(buf, "%d\n", led_dat->sata); 181 return sprintf(buf, "%d\n", led_dat->sata);
178 } 182 }
179 183
180 static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store); 184 static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store);
181 185
182 static int __devinit 186 static int __devinit
183 create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat, 187 create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
184 const struct ns2_led *template) 188 const struct ns2_led *template)
185 { 189 {
186 int ret; 190 int ret;
187 enum ns2_led_modes mode; 191 enum ns2_led_modes mode;
188 192
189 ret = gpio_request(template->cmd, template->name); 193 ret = gpio_request(template->cmd, template->name);
190 if (ret == 0) { 194 if (ret == 0) {
191 ret = gpio_direction_output(template->cmd, 195 ret = gpio_direction_output(template->cmd,
192 gpio_get_value(template->cmd)); 196 gpio_get_value(template->cmd));
193 if (ret) 197 if (ret)
194 gpio_free(template->cmd); 198 gpio_free(template->cmd);
195 } 199 }
196 if (ret) { 200 if (ret) {
197 dev_err(&pdev->dev, "%s: failed to setup command GPIO\n", 201 dev_err(&pdev->dev, "%s: failed to setup command GPIO\n",
198 template->name); 202 template->name);
199 } 203 }
200 204
201 ret = gpio_request(template->slow, template->name); 205 ret = gpio_request(template->slow, template->name);
202 if (ret == 0) { 206 if (ret == 0) {
203 ret = gpio_direction_output(template->slow, 207 ret = gpio_direction_output(template->slow,
204 gpio_get_value(template->slow)); 208 gpio_get_value(template->slow));
205 if (ret) 209 if (ret)
206 gpio_free(template->slow); 210 gpio_free(template->slow);
207 } 211 }
208 if (ret) { 212 if (ret) {
209 dev_err(&pdev->dev, "%s: failed to setup slow GPIO\n", 213 dev_err(&pdev->dev, "%s: failed to setup slow GPIO\n",
210 template->name); 214 template->name);
211 goto err_free_cmd; 215 goto err_free_cmd;
212 } 216 }
213 217
214 rwlock_init(&led_dat->rw_lock); 218 rwlock_init(&led_dat->rw_lock);
215 219
216 led_dat->cdev.name = template->name; 220 led_dat->cdev.name = template->name;
217 led_dat->cdev.default_trigger = template->default_trigger; 221 led_dat->cdev.default_trigger = template->default_trigger;
218 led_dat->cdev.blink_set = NULL; 222 led_dat->cdev.blink_set = NULL;
219 led_dat->cdev.brightness_set = ns2_led_set; 223 led_dat->cdev.brightness_set = ns2_led_set;
220 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME; 224 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
221 led_dat->cmd = template->cmd; 225 led_dat->cmd = template->cmd;
222 led_dat->slow = template->slow; 226 led_dat->slow = template->slow;
223 227
224 ret = ns2_led_get_mode(led_dat, &mode); 228 ret = ns2_led_get_mode(led_dat, &mode);
225 if (ret < 0) 229 if (ret < 0)
226 goto err_free_slow; 230 goto err_free_slow;
227 231
228 /* Set LED initial state. */ 232 /* Set LED initial state. */
229 led_dat->sata = (mode == NS_V2_LED_SATA) ? 1 : 0; 233 led_dat->sata = (mode == NS_V2_LED_SATA) ? 1 : 0;
230 led_dat->cdev.brightness = 234 led_dat->cdev.brightness =
231 (mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL; 235 (mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL;
232 236
233 ret = led_classdev_register(&pdev->dev, &led_dat->cdev); 237 ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
234 if (ret < 0) 238 if (ret < 0)
235 goto err_free_slow; 239 goto err_free_slow;
236 240
237 dev_set_drvdata(led_dat->cdev.dev, led_dat);
238 ret = device_create_file(led_dat->cdev.dev, &dev_attr_sata); 241 ret = device_create_file(led_dat->cdev.dev, &dev_attr_sata);
239 if (ret < 0) 242 if (ret < 0)
240 goto err_free_cdev; 243 goto err_free_cdev;
241 244
242 return 0; 245 return 0;
243 246
244 err_free_cdev: 247 err_free_cdev:
245 led_classdev_unregister(&led_dat->cdev); 248 led_classdev_unregister(&led_dat->cdev);
246 err_free_slow: 249 err_free_slow:
247 gpio_free(led_dat->slow); 250 gpio_free(led_dat->slow);
248 err_free_cmd: 251 err_free_cmd:
249 gpio_free(led_dat->cmd); 252 gpio_free(led_dat->cmd);
250 253
251 return ret; 254 return ret;
252 } 255 }
253 256
254 static void __devexit delete_ns2_led(struct ns2_led_data *led_dat) 257 static void __devexit delete_ns2_led(struct ns2_led_data *led_dat)
255 { 258 {
256 device_remove_file(led_dat->cdev.dev, &dev_attr_sata); 259 device_remove_file(led_dat->cdev.dev, &dev_attr_sata);
257 led_classdev_unregister(&led_dat->cdev); 260 led_classdev_unregister(&led_dat->cdev);
258 gpio_free(led_dat->cmd); 261 gpio_free(led_dat->cmd);
259 gpio_free(led_dat->slow); 262 gpio_free(led_dat->slow);
260 } 263 }
261 264
262 static int __devinit ns2_led_probe(struct platform_device *pdev) 265 static int __devinit ns2_led_probe(struct platform_device *pdev)
263 { 266 {
264 struct ns2_led_platform_data *pdata = pdev->dev.platform_data; 267 struct ns2_led_platform_data *pdata = pdev->dev.platform_data;
265 struct ns2_led_data *leds_data; 268 struct ns2_led_data *leds_data;
266 int i; 269 int i;
267 int ret; 270 int ret;
268 271
269 if (!pdata) 272 if (!pdata)
270 return -EINVAL; 273 return -EINVAL;
271 274
272 leds_data = kzalloc(sizeof(struct ns2_led_data) * 275 leds_data = kzalloc(sizeof(struct ns2_led_data) *
273 pdata->num_leds, GFP_KERNEL); 276 pdata->num_leds, GFP_KERNEL);
274 if (!leds_data) 277 if (!leds_data)
275 return -ENOMEM; 278 return -ENOMEM;
276 279
277 for (i = 0; i < pdata->num_leds; i++) { 280 for (i = 0; i < pdata->num_leds; i++) {
278 ret = create_ns2_led(pdev, &leds_data[i], &pdata->leds[i]); 281 ret = create_ns2_led(pdev, &leds_data[i], &pdata->leds[i]);
279 if (ret < 0) 282 if (ret < 0)
280 goto err; 283 goto err;
281 284
282 } 285 }
283 286
284 platform_set_drvdata(pdev, leds_data); 287 platform_set_drvdata(pdev, leds_data);
285 288
286 return 0; 289 return 0;
287 290
288 err: 291 err:
289 for (i = i - 1; i >= 0; i--) 292 for (i = i - 1; i >= 0; i--)
290 delete_ns2_led(&leds_data[i]); 293 delete_ns2_led(&leds_data[i]);
291 294
292 kfree(leds_data); 295 kfree(leds_data);
293 296
294 return ret; 297 return ret;
295 } 298 }
296 299
297 static int __devexit ns2_led_remove(struct platform_device *pdev) 300 static int __devexit ns2_led_remove(struct platform_device *pdev)
298 { 301 {
299 int i; 302 int i;
300 struct ns2_led_platform_data *pdata = pdev->dev.platform_data; 303 struct ns2_led_platform_data *pdata = pdev->dev.platform_data;
301 struct ns2_led_data *leds_data; 304 struct ns2_led_data *leds_data;
302 305
303 leds_data = platform_get_drvdata(pdev); 306 leds_data = platform_get_drvdata(pdev);
304 307
305 for (i = 0; i < pdata->num_leds; i++) 308 for (i = 0; i < pdata->num_leds; i++)
306 delete_ns2_led(&leds_data[i]); 309 delete_ns2_led(&leds_data[i]);
307 310
308 kfree(leds_data); 311 kfree(leds_data);
309 platform_set_drvdata(pdev, NULL); 312 platform_set_drvdata(pdev, NULL);
310 313
311 return 0; 314 return 0;
312 } 315 }
313 316
314 static struct platform_driver ns2_led_driver = { 317 static struct platform_driver ns2_led_driver = {
315 .probe = ns2_led_probe, 318 .probe = ns2_led_probe,
316 .remove = __devexit_p(ns2_led_remove), 319 .remove = __devexit_p(ns2_led_remove),
317 .driver = { 320 .driver = {
318 .name = "leds-ns2", 321 .name = "leds-ns2",
319 .owner = THIS_MODULE, 322 .owner = THIS_MODULE,
320 }, 323 },
321 }; 324 };
322 MODULE_ALIAS("platform:leds-ns2"); 325 MODULE_ALIAS("platform:leds-ns2");
323 326
324 static int __init ns2_led_init(void) 327 static int __init ns2_led_init(void)
325 { 328 {
326 return platform_driver_register(&ns2_led_driver); 329 return platform_driver_register(&ns2_led_driver);
327 } 330 }
328 331
329 static void __exit ns2_led_exit(void) 332 static void __exit ns2_led_exit(void)
330 { 333 {
331 platform_driver_unregister(&ns2_led_driver); 334 platform_driver_unregister(&ns2_led_driver);
332 } 335 }
333 336
334 module_init(ns2_led_init); 337 module_init(ns2_led_init);
335 module_exit(ns2_led_exit); 338 module_exit(ns2_led_exit);
336 339
337 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>"); 340 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
338 MODULE_DESCRIPTION("Network Space v2 LED driver"); 341 MODULE_DESCRIPTION("Network Space v2 LED driver");