aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/leds
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/leds')
-rw-r--r--drivers/leds/Kconfig70
-rw-r--r--drivers/leds/Makefile2
-rw-r--r--drivers/leds/led-class.c105
-rw-r--r--drivers/leds/led-triggers.c2
-rw-r--r--drivers/leds/leds-gpio.c2
-rw-r--r--drivers/leds/leds-lp5521.c837
-rw-r--r--drivers/leds/leds-lp5523.c1069
-rw-r--r--drivers/leds/leds-net5501.c2
-rw-r--r--drivers/leds/leds-ss4200.c1
-rw-r--r--drivers/leds/ledtrig-timer.c124
10 files changed, 2087 insertions, 127 deletions
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index cc2a88d5192f..6f190f4cdbc0 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -7,20 +7,20 @@ menuconfig NEW_LEDS
7 This is not related to standard keyboard LEDs which are controlled 7 This is not related to standard keyboard LEDs which are controlled
8 via the input system. 8 via the input system.
9 9
10if NEW_LEDS
11
12config LEDS_CLASS 10config LEDS_CLASS
13 tristate "LED Class Support" 11 bool "LED Class Support"
12 depends on NEW_LEDS
14 help 13 help
15 This option enables the led sysfs class in /sys/class/leds. You'll 14 This option enables the led sysfs class in /sys/class/leds. You'll
16 need this to do anything useful with LEDs. If unsure, say N. 15 need this to do anything useful with LEDs. If unsure, say N.
17 16
18if LEDS_CLASS 17if NEW_LEDS
19 18
20comment "LED drivers" 19comment "LED drivers"
21 20
22config LEDS_88PM860X 21config LEDS_88PM860X
23 tristate "LED Support for Marvell 88PM860x PMIC" 22 tristate "LED Support for Marvell 88PM860x PMIC"
23 depends on LEDS_CLASS
24 depends on MFD_88PM860X 24 depends on MFD_88PM860X
25 help 25 help
26 This option enables support for on-chip LED drivers found on Marvell 26 This option enables support for on-chip LED drivers found on Marvell
@@ -28,6 +28,7 @@ config LEDS_88PM860X
28 28
29config LEDS_ATMEL_PWM 29config LEDS_ATMEL_PWM
30 tristate "LED Support using Atmel PWM outputs" 30 tristate "LED Support using Atmel PWM outputs"
31 depends on LEDS_CLASS
31 depends on ATMEL_PWM 32 depends on ATMEL_PWM
32 help 33 help
33 This option enables support for LEDs driven using outputs 34 This option enables support for LEDs driven using outputs
@@ -35,6 +36,7 @@ config LEDS_ATMEL_PWM
35 36
36config LEDS_LOCOMO 37config LEDS_LOCOMO
37 tristate "LED Support for Locomo device" 38 tristate "LED Support for Locomo device"
39 depends on LEDS_CLASS
38 depends on SHARP_LOCOMO 40 depends on SHARP_LOCOMO
39 help 41 help
40 This option enables support for the LEDs on Sharp Locomo. 42 This option enables support for the LEDs on Sharp Locomo.
@@ -42,6 +44,7 @@ config LEDS_LOCOMO
42 44
43config LEDS_MIKROTIK_RB532 45config LEDS_MIKROTIK_RB532
44 tristate "LED Support for Mikrotik Routerboard 532" 46 tristate "LED Support for Mikrotik Routerboard 532"
47 depends on LEDS_CLASS
45 depends on MIKROTIK_RB532 48 depends on MIKROTIK_RB532
46 help 49 help
47 This option enables support for the so called "User LED" of 50 This option enables support for the so called "User LED" of
@@ -49,6 +52,7 @@ config LEDS_MIKROTIK_RB532
49 52
50config LEDS_S3C24XX 53config LEDS_S3C24XX
51 tristate "LED Support for Samsung S3C24XX GPIO LEDs" 54 tristate "LED Support for Samsung S3C24XX GPIO LEDs"
55 depends on LEDS_CLASS
52 depends on ARCH_S3C2410 56 depends on ARCH_S3C2410
53 help 57 help
54 This option enables support for LEDs connected to GPIO lines 58 This option enables support for LEDs connected to GPIO lines
@@ -56,12 +60,14 @@ config LEDS_S3C24XX
56 60
57config LEDS_AMS_DELTA 61config LEDS_AMS_DELTA
58 tristate "LED Support for the Amstrad Delta (E3)" 62 tristate "LED Support for the Amstrad Delta (E3)"
63 depends on LEDS_CLASS
59 depends on MACH_AMS_DELTA 64 depends on MACH_AMS_DELTA
60 help 65 help
61 This option enables support for the LEDs on Amstrad Delta (E3). 66 This option enables support for the LEDs on Amstrad Delta (E3).
62 67
63config LEDS_NET48XX 68config LEDS_NET48XX
64 tristate "LED Support for Soekris net48xx series Error LED" 69 tristate "LED Support for Soekris net48xx series Error LED"
70 depends on LEDS_CLASS
65 depends on SCx200_GPIO 71 depends on SCx200_GPIO
66 help 72 help
67 This option enables support for the Soekris net4801 and net4826 error 73 This option enables support for the Soekris net4801 and net4826 error
@@ -79,18 +85,21 @@ config LEDS_NET5501
79 85
80config LEDS_FSG 86config LEDS_FSG
81 tristate "LED Support for the Freecom FSG-3" 87 tristate "LED Support for the Freecom FSG-3"
88 depends on LEDS_CLASS
82 depends on MACH_FSG 89 depends on MACH_FSG
83 help 90 help
84 This option enables support for the LEDs on the Freecom FSG-3. 91 This option enables support for the LEDs on the Freecom FSG-3.
85 92
86config LEDS_WRAP 93config LEDS_WRAP
87 tristate "LED Support for the WRAP series LEDs" 94 tristate "LED Support for the WRAP series LEDs"
95 depends on LEDS_CLASS
88 depends on SCx200_GPIO 96 depends on SCx200_GPIO
89 help 97 help
90 This option enables support for the PCEngines WRAP programmable LEDs. 98 This option enables support for the PCEngines WRAP programmable LEDs.
91 99
92config LEDS_ALIX2 100config LEDS_ALIX2
93 tristate "LED Support for ALIX.2 and ALIX.3 series" 101 tristate "LED Support for ALIX.2 and ALIX.3 series"
102 depends on LEDS_CLASS
94 depends on X86 && !GPIO_CS5535 && !CS5535_GPIO 103 depends on X86 && !GPIO_CS5535 && !CS5535_GPIO
95 help 104 help
96 This option enables support for the PCEngines ALIX.2 and ALIX.3 LEDs. 105 This option enables support for the PCEngines ALIX.2 and ALIX.3 LEDs.
@@ -98,12 +107,14 @@ config LEDS_ALIX2
98 107
99config LEDS_H1940 108config LEDS_H1940
100 tristate "LED Support for iPAQ H1940 device" 109 tristate "LED Support for iPAQ H1940 device"
110 depends on LEDS_CLASS
101 depends on ARCH_H1940 111 depends on ARCH_H1940
102 help 112 help
103 This option enables support for the LEDs on the h1940. 113 This option enables support for the LEDs on the h1940.
104 114
105config LEDS_COBALT_QUBE 115config LEDS_COBALT_QUBE
106 tristate "LED Support for the Cobalt Qube series front LED" 116 tristate "LED Support for the Cobalt Qube series front LED"
117 depends on LEDS_CLASS
107 depends on MIPS_COBALT 118 depends on MIPS_COBALT
108 help 119 help
109 This option enables support for the front LED on Cobalt Qube series 120 This option enables support for the front LED on Cobalt Qube series
@@ -117,6 +128,7 @@ config LEDS_COBALT_RAQ
117 128
118config LEDS_SUNFIRE 129config LEDS_SUNFIRE
119 tristate "LED support for SunFire servers." 130 tristate "LED support for SunFire servers."
131 depends on LEDS_CLASS
120 depends on SPARC64 132 depends on SPARC64
121 select LEDS_TRIGGERS 133 select LEDS_TRIGGERS
122 help 134 help
@@ -125,6 +137,7 @@ config LEDS_SUNFIRE
125 137
126config LEDS_HP6XX 138config LEDS_HP6XX
127 tristate "LED Support for the HP Jornada 6xx" 139 tristate "LED Support for the HP Jornada 6xx"
140 depends on LEDS_CLASS
128 depends on SH_HP6XX 141 depends on SH_HP6XX
129 help 142 help
130 This option enables LED support for the handheld 143 This option enables LED support for the handheld
@@ -132,6 +145,7 @@ config LEDS_HP6XX
132 145
133config LEDS_PCA9532 146config LEDS_PCA9532
134 tristate "LED driver for PCA9532 dimmer" 147 tristate "LED driver for PCA9532 dimmer"
148 depends on LEDS_CLASS
135 depends on I2C && INPUT && EXPERIMENTAL 149 depends on I2C && INPUT && EXPERIMENTAL
136 help 150 help
137 This option enables support for NXP pca9532 151 This option enables support for NXP pca9532
@@ -140,6 +154,7 @@ config LEDS_PCA9532
140 154
141config LEDS_GPIO 155config LEDS_GPIO
142 tristate "LED Support for GPIO connected LEDs" 156 tristate "LED Support for GPIO connected LEDs"
157 depends on LEDS_CLASS
143 depends on GENERIC_GPIO 158 depends on GENERIC_GPIO
144 help 159 help
145 This option enables support for the LEDs connected to GPIO 160 This option enables support for the LEDs connected to GPIO
@@ -167,6 +182,7 @@ config LEDS_GPIO_OF
167 182
168config LEDS_LP3944 183config LEDS_LP3944
169 tristate "LED Support for N.S. LP3944 (Fun Light) I2C chip" 184 tristate "LED Support for N.S. LP3944 (Fun Light) I2C chip"
185 depends on LEDS_CLASS
170 depends on I2C 186 depends on I2C
171 help 187 help
172 This option enables support for LEDs connected to the National 188 This option enables support for LEDs connected to the National
@@ -176,8 +192,27 @@ config LEDS_LP3944
176 To compile this driver as a module, choose M here: the 192 To compile this driver as a module, choose M here: the
177 module will be called leds-lp3944. 193 module will be called leds-lp3944.
178 194
195config LEDS_LP5521
196 tristate "LED Support for N.S. LP5521 LED driver chip"
197 depends on LEDS_CLASS && I2C
198 help
199 If you say yes here you get support for the National Semiconductor
200 LP5521 LED driver. It is 3 channel chip with programmable engines.
201 Driver provides direct control via LED class and interface for
202 programming the engines.
203
204config LEDS_LP5523
205 tristate "LED Support for N.S. LP5523 LED driver chip"
206 depends on LEDS_CLASS && I2C
207 help
208 If you say yes here you get support for the National Semiconductor
209 LP5523 LED driver. It is 9 channel chip with programmable engines.
210 Driver provides direct control via LED class and interface for
211 programming the engines.
212
179config LEDS_CLEVO_MAIL 213config LEDS_CLEVO_MAIL
180 tristate "Mail LED on Clevo notebook" 214 tristate "Mail LED on Clevo notebook"
215 depends on LEDS_CLASS
181 depends on X86 && SERIO_I8042 && DMI 216 depends on X86 && SERIO_I8042 && DMI
182 help 217 help
183 This driver makes the mail LED accessible from userspace 218 This driver makes the mail LED accessible from userspace
@@ -208,6 +243,7 @@ config LEDS_CLEVO_MAIL
208 243
209config LEDS_PCA955X 244config LEDS_PCA955X
210 tristate "LED Support for PCA955x I2C chips" 245 tristate "LED Support for PCA955x I2C chips"
246 depends on LEDS_CLASS
211 depends on I2C 247 depends on I2C
212 help 248 help
213 This option enables support for LEDs connected to PCA955x 249 This option enables support for LEDs connected to PCA955x
@@ -216,6 +252,7 @@ config LEDS_PCA955X
216 252
217config LEDS_WM831X_STATUS 253config LEDS_WM831X_STATUS
218 tristate "LED support for status LEDs on WM831x PMICs" 254 tristate "LED support for status LEDs on WM831x PMICs"
255 depends on LEDS_CLASS
219 depends on MFD_WM831X 256 depends on MFD_WM831X
220 help 257 help
221 This option enables support for the status LEDs of the WM831x 258 This option enables support for the status LEDs of the WM831x
@@ -223,6 +260,7 @@ config LEDS_WM831X_STATUS
223 260
224config LEDS_WM8350 261config LEDS_WM8350
225 tristate "LED Support for WM8350 AudioPlus PMIC" 262 tristate "LED Support for WM8350 AudioPlus PMIC"
263 depends on LEDS_CLASS
226 depends on MFD_WM8350 264 depends on MFD_WM8350
227 help 265 help
228 This option enables support for LEDs driven by the Wolfson 266 This option enables support for LEDs driven by the Wolfson
@@ -230,6 +268,7 @@ config LEDS_WM8350
230 268
231config LEDS_DA903X 269config LEDS_DA903X
232 tristate "LED Support for DA9030/DA9034 PMIC" 270 tristate "LED Support for DA9030/DA9034 PMIC"
271 depends on LEDS_CLASS
233 depends on PMIC_DA903X 272 depends on PMIC_DA903X
234 help 273 help
235 This option enables support for on-chip LED drivers found 274 This option enables support for on-chip LED drivers found
@@ -237,6 +276,7 @@ config LEDS_DA903X
237 276
238config LEDS_DAC124S085 277config LEDS_DAC124S085
239 tristate "LED Support for DAC124S085 SPI DAC" 278 tristate "LED Support for DAC124S085 SPI DAC"
279 depends on LEDS_CLASS
240 depends on SPI 280 depends on SPI
241 help 281 help
242 This option enables support for DAC124S085 SPI DAC from NatSemi, 282 This option enables support for DAC124S085 SPI DAC from NatSemi,
@@ -244,18 +284,21 @@ config LEDS_DAC124S085
244 284
245config LEDS_PWM 285config LEDS_PWM
246 tristate "PWM driven LED Support" 286 tristate "PWM driven LED Support"
287 depends on LEDS_CLASS
247 depends on HAVE_PWM 288 depends on HAVE_PWM
248 help 289 help
249 This option enables support for pwm driven LEDs 290 This option enables support for pwm driven LEDs
250 291
251config LEDS_REGULATOR 292config LEDS_REGULATOR
252 tristate "REGULATOR driven LED support" 293 tristate "REGULATOR driven LED support"
294 depends on LEDS_CLASS
253 depends on REGULATOR 295 depends on REGULATOR
254 help 296 help
255 This option enables support for regulator driven LEDs. 297 This option enables support for regulator driven LEDs.
256 298
257config LEDS_BD2802 299config LEDS_BD2802
258 tristate "LED driver for BD2802 RGB LED" 300 tristate "LED driver for BD2802 RGB LED"
301 depends on LEDS_CLASS
259 depends on I2C 302 depends on I2C
260 help 303 help
261 This option enables support for BD2802GU RGB LED driver chips 304 This option enables support for BD2802GU RGB LED driver chips
@@ -263,6 +306,7 @@ config LEDS_BD2802
263 306
264config LEDS_INTEL_SS4200 307config LEDS_INTEL_SS4200
265 tristate "LED driver for Intel NAS SS4200 series" 308 tristate "LED driver for Intel NAS SS4200 series"
309 depends on LEDS_CLASS
266 depends on PCI && DMI 310 depends on PCI && DMI
267 help 311 help
268 This option enables support for the Intel SS4200 series of 312 This option enables support for the Intel SS4200 series of
@@ -272,6 +316,7 @@ config LEDS_INTEL_SS4200
272 316
273config LEDS_LT3593 317config LEDS_LT3593
274 tristate "LED driver for LT3593 controllers" 318 tristate "LED driver for LT3593 controllers"
319 depends on LEDS_CLASS
275 depends on GENERIC_GPIO 320 depends on GENERIC_GPIO
276 help 321 help
277 This option enables support for LEDs driven by a Linear Technology 322 This option enables support for LEDs driven by a Linear Technology
@@ -280,6 +325,7 @@ config LEDS_LT3593
280 325
281config LEDS_ADP5520 326config LEDS_ADP5520
282 tristate "LED Support for ADP5520/ADP5501 PMIC" 327 tristate "LED Support for ADP5520/ADP5501 PMIC"
328 depends on LEDS_CLASS
283 depends on PMIC_ADP5520 329 depends on PMIC_ADP5520
284 help 330 help
285 This option enables support for on-chip LED drivers found 331 This option enables support for on-chip LED drivers found
@@ -290,6 +336,7 @@ config LEDS_ADP5520
290 336
291config LEDS_DELL_NETBOOKS 337config LEDS_DELL_NETBOOKS
292 tristate "External LED on Dell Business Netbooks" 338 tristate "External LED on Dell Business Netbooks"
339 depends on LEDS_CLASS
293 depends on X86 && ACPI_WMI 340 depends on X86 && ACPI_WMI
294 help 341 help
295 This adds support for the Latitude 2100 and similar 342 This adds support for the Latitude 2100 and similar
@@ -297,6 +344,7 @@ config LEDS_DELL_NETBOOKS
297 344
298config LEDS_MC13783 345config LEDS_MC13783
299 tristate "LED Support for MC13783 PMIC" 346 tristate "LED Support for MC13783 PMIC"
347 depends on LEDS_CLASS
300 depends on MFD_MC13783 348 depends on MFD_MC13783
301 help 349 help
302 This option enable support for on-chip LED drivers found 350 This option enable support for on-chip LED drivers found
@@ -304,6 +352,7 @@ config LEDS_MC13783
304 352
305config LEDS_NS2 353config LEDS_NS2
306 tristate "LED support for Network Space v2 GPIO LEDs" 354 tristate "LED support for Network Space v2 GPIO LEDs"
355 depends on LEDS_CLASS
307 depends on MACH_NETSPACE_V2 || MACH_INETSPACE_V2 || MACH_NETSPACE_MAX_V2 || D2NET_V2 356 depends on MACH_NETSPACE_V2 || MACH_INETSPACE_V2 || MACH_NETSPACE_MAX_V2 || D2NET_V2
308 default y 357 default y
309 help 358 help
@@ -322,17 +371,17 @@ config LEDS_NETXBIG
322 371
323config LEDS_TRIGGERS 372config LEDS_TRIGGERS
324 bool "LED Trigger support" 373 bool "LED Trigger support"
374 depends on LEDS_CLASS
325 help 375 help
326 This option enables trigger support for the leds class. 376 This option enables trigger support for the leds class.
327 These triggers allow kernel events to drive the LEDs and can 377 These triggers allow kernel events to drive the LEDs and can
328 be configured via sysfs. If unsure, say Y. 378 be configured via sysfs. If unsure, say Y.
329 379
330if LEDS_TRIGGERS
331
332comment "LED Triggers" 380comment "LED Triggers"
333 381
334config LEDS_TRIGGER_TIMER 382config LEDS_TRIGGER_TIMER
335 tristate "LED Timer Trigger" 383 tristate "LED Timer Trigger"
384 depends on LEDS_TRIGGERS
336 help 385 help
337 This allows LEDs to be controlled by a programmable timer 386 This allows LEDs to be controlled by a programmable timer
338 via sysfs. Some LED hardware can be programmed to start 387 via sysfs. Some LED hardware can be programmed to start
@@ -344,12 +393,14 @@ config LEDS_TRIGGER_TIMER
344config LEDS_TRIGGER_IDE_DISK 393config LEDS_TRIGGER_IDE_DISK
345 bool "LED IDE Disk Trigger" 394 bool "LED IDE Disk Trigger"
346 depends on IDE_GD_ATA 395 depends on IDE_GD_ATA
396 depends on LEDS_TRIGGERS
347 help 397 help
348 This allows LEDs to be controlled by IDE disk activity. 398 This allows LEDs to be controlled by IDE disk activity.
349 If unsure, say Y. 399 If unsure, say Y.
350 400
351config LEDS_TRIGGER_HEARTBEAT 401config LEDS_TRIGGER_HEARTBEAT
352 tristate "LED Heartbeat Trigger" 402 tristate "LED Heartbeat Trigger"
403 depends on LEDS_TRIGGERS
353 help 404 help
354 This allows LEDs to be controlled by a CPU load average. 405 This allows LEDs to be controlled by a CPU load average.
355 The flash frequency is a hyperbolic function of the 1-minute 406 The flash frequency is a hyperbolic function of the 1-minute
@@ -358,6 +409,7 @@ config LEDS_TRIGGER_HEARTBEAT
358 409
359config LEDS_TRIGGER_BACKLIGHT 410config LEDS_TRIGGER_BACKLIGHT
360 tristate "LED backlight Trigger" 411 tristate "LED backlight Trigger"
412 depends on LEDS_TRIGGERS
361 help 413 help
362 This allows LEDs to be controlled as a backlight device: they 414 This allows LEDs to be controlled as a backlight device: they
363 turn off and on when the display is blanked and unblanked. 415 turn off and on when the display is blanked and unblanked.
@@ -366,6 +418,7 @@ config LEDS_TRIGGER_BACKLIGHT
366 418
367config LEDS_TRIGGER_GPIO 419config LEDS_TRIGGER_GPIO
368 tristate "LED GPIO Trigger" 420 tristate "LED GPIO Trigger"
421 depends on LEDS_TRIGGERS
369 depends on GPIOLIB 422 depends on GPIOLIB
370 help 423 help
371 This allows LEDs to be controlled by gpio events. It's good 424 This allows LEDs to be controlled by gpio events. It's good
@@ -378,6 +431,7 @@ config LEDS_TRIGGER_GPIO
378 431
379config LEDS_TRIGGER_DEFAULT_ON 432config LEDS_TRIGGER_DEFAULT_ON
380 tristate "LED Default ON Trigger" 433 tristate "LED Default ON Trigger"
434 depends on LEDS_TRIGGERS
381 help 435 help
382 This allows LEDs to be initialised in the ON state. 436 This allows LEDs to be initialised in the ON state.
383 If unsure, say Y. 437 If unsure, say Y.
@@ -385,8 +439,4 @@ config LEDS_TRIGGER_DEFAULT_ON
385comment "iptables trigger is under Netfilter config (LED target)" 439comment "iptables trigger is under Netfilter config (LED target)"
386 depends on LEDS_TRIGGERS 440 depends on LEDS_TRIGGERS
387 441
388endif # LEDS_TRIGGERS
389
390endif # LEDS_CLASS
391
392endif # NEW_LEDS 442endif # NEW_LEDS
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 9c96db40ef6d..aae6989ff6b6 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -23,6 +23,8 @@ obj-$(CONFIG_LEDS_SUNFIRE) += leds-sunfire.o
23obj-$(CONFIG_LEDS_PCA9532) += leds-pca9532.o 23obj-$(CONFIG_LEDS_PCA9532) += leds-pca9532.o
24obj-$(CONFIG_LEDS_GPIO) += leds-gpio.o 24obj-$(CONFIG_LEDS_GPIO) += leds-gpio.o
25obj-$(CONFIG_LEDS_LP3944) += leds-lp3944.o 25obj-$(CONFIG_LEDS_LP3944) += leds-lp3944.o
26obj-$(CONFIG_LEDS_LP5521) += leds-lp5521.o
27obj-$(CONFIG_LEDS_LP5523) += leds-lp5523.o
26obj-$(CONFIG_LEDS_CLEVO_MAIL) += leds-clevo-mail.o 28obj-$(CONFIG_LEDS_CLEVO_MAIL) += leds-clevo-mail.o
27obj-$(CONFIG_LEDS_HP6XX) += leds-hp6xx.o 29obj-$(CONFIG_LEDS_HP6XX) += leds-hp6xx.o
28obj-$(CONFIG_LEDS_FSG) += leds-fsg.o 30obj-$(CONFIG_LEDS_FSG) += leds-fsg.o
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index 260660076507..211e21f34bd5 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -81,6 +81,79 @@ static struct device_attribute led_class_attrs[] = {
81 __ATTR_NULL, 81 __ATTR_NULL,
82}; 82};
83 83
84static void led_timer_function(unsigned long data)
85{
86 struct led_classdev *led_cdev = (void *)data;
87 unsigned long brightness;
88 unsigned long delay;
89
90 if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
91 led_set_brightness(led_cdev, LED_OFF);
92 return;
93 }
94
95 brightness = led_get_brightness(led_cdev);
96 if (!brightness) {
97 /* Time to switch the LED on. */
98 brightness = led_cdev->blink_brightness;
99 delay = led_cdev->blink_delay_on;
100 } else {
101 /* Store the current brightness value to be able
102 * to restore it when the delay_off period is over.
103 */
104 led_cdev->blink_brightness = brightness;
105 brightness = LED_OFF;
106 delay = led_cdev->blink_delay_off;
107 }
108
109 led_set_brightness(led_cdev, brightness);
110
111 mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay));
112}
113
114static void led_stop_software_blink(struct led_classdev *led_cdev)
115{
116 /* deactivate previous settings */
117 del_timer_sync(&led_cdev->blink_timer);
118 led_cdev->blink_delay_on = 0;
119 led_cdev->blink_delay_off = 0;
120}
121
122static void led_set_software_blink(struct led_classdev *led_cdev,
123 unsigned long delay_on,
124 unsigned long delay_off)
125{
126 int current_brightness;
127
128 current_brightness = led_get_brightness(led_cdev);
129 if (current_brightness)
130 led_cdev->blink_brightness = current_brightness;
131 if (!led_cdev->blink_brightness)
132 led_cdev->blink_brightness = led_cdev->max_brightness;
133
134 if (delay_on == led_cdev->blink_delay_on &&
135 delay_off == led_cdev->blink_delay_off)
136 return;
137
138 led_stop_software_blink(led_cdev);
139
140 led_cdev->blink_delay_on = delay_on;
141 led_cdev->blink_delay_off = delay_off;
142
143 /* never on - don't blink */
144 if (!delay_on)
145 return;
146
147 /* never off - just set to brightness */
148 if (!delay_off) {
149 led_set_brightness(led_cdev, led_cdev->blink_brightness);
150 return;
151 }
152
153 mod_timer(&led_cdev->blink_timer, jiffies + 1);
154}
155
156
84/** 157/**
85 * led_classdev_suspend - suspend an led_classdev. 158 * led_classdev_suspend - suspend an led_classdev.
86 * @led_cdev: the led_classdev to suspend. 159 * @led_cdev: the led_classdev to suspend.
@@ -148,6 +221,10 @@ int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
148 221
149 led_update_brightness(led_cdev); 222 led_update_brightness(led_cdev);
150 223
224 init_timer(&led_cdev->blink_timer);
225 led_cdev->blink_timer.function = led_timer_function;
226 led_cdev->blink_timer.data = (unsigned long)led_cdev;
227
151#ifdef CONFIG_LEDS_TRIGGERS 228#ifdef CONFIG_LEDS_TRIGGERS
152 led_trigger_set_default(led_cdev); 229 led_trigger_set_default(led_cdev);
153#endif 230#endif
@@ -157,7 +234,6 @@ int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
157 234
158 return 0; 235 return 0;
159} 236}
160
161EXPORT_SYMBOL_GPL(led_classdev_register); 237EXPORT_SYMBOL_GPL(led_classdev_register);
162 238
163/** 239/**
@@ -175,6 +251,9 @@ void led_classdev_unregister(struct led_classdev *led_cdev)
175 up_write(&led_cdev->trigger_lock); 251 up_write(&led_cdev->trigger_lock);
176#endif 252#endif
177 253
254 /* Stop blinking */
255 led_brightness_set(led_cdev, LED_OFF);
256
178 device_unregister(led_cdev->dev); 257 device_unregister(led_cdev->dev);
179 258
180 down_write(&leds_list_lock); 259 down_write(&leds_list_lock);
@@ -183,6 +262,30 @@ void led_classdev_unregister(struct led_classdev *led_cdev)
183} 262}
184EXPORT_SYMBOL_GPL(led_classdev_unregister); 263EXPORT_SYMBOL_GPL(led_classdev_unregister);
185 264
265void led_blink_set(struct led_classdev *led_cdev,
266 unsigned long *delay_on,
267 unsigned long *delay_off)
268{
269 if (led_cdev->blink_set &&
270 led_cdev->blink_set(led_cdev, delay_on, delay_off))
271 return;
272
273 /* blink with 1 Hz as default if nothing specified */
274 if (!*delay_on && !*delay_off)
275 *delay_on = *delay_off = 500;
276
277 led_set_software_blink(led_cdev, *delay_on, *delay_off);
278}
279EXPORT_SYMBOL(led_blink_set);
280
281void led_brightness_set(struct led_classdev *led_cdev,
282 enum led_brightness brightness)
283{
284 led_stop_software_blink(led_cdev);
285 led_cdev->brightness_set(led_cdev, brightness);
286}
287EXPORT_SYMBOL(led_brightness_set);
288
186static int __init leds_init(void) 289static int __init leds_init(void)
187{ 290{
188 leds_class = class_create(THIS_MODULE, "leds"); 291 leds_class = class_create(THIS_MODULE, "leds");
diff --git a/drivers/leds/led-triggers.c b/drivers/leds/led-triggers.c
index f1c00db88b5e..c41eb6180c9c 100644
--- a/drivers/leds/led-triggers.c
+++ b/drivers/leds/led-triggers.c
@@ -113,7 +113,7 @@ void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger)
113 if (led_cdev->trigger->deactivate) 113 if (led_cdev->trigger->deactivate)
114 led_cdev->trigger->deactivate(led_cdev); 114 led_cdev->trigger->deactivate(led_cdev);
115 led_cdev->trigger = NULL; 115 led_cdev->trigger = NULL;
116 led_set_brightness(led_cdev, LED_OFF); 116 led_brightness_set(led_cdev, LED_OFF);
117 } 117 }
118 if (trigger) { 118 if (trigger) {
119 write_lock_irqsave(&trigger->leddev_list_lock, flags); 119 write_lock_irqsave(&trigger->leddev_list_lock, flags);
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index ea57e05d08f3..4d9fa38d9ff6 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -316,7 +316,7 @@ static struct of_platform_driver of_gpio_leds_driver = {
316 316
317static int __init gpio_led_init(void) 317static int __init gpio_led_init(void)
318{ 318{
319 int ret; 319 int ret = 0;
320 320
321#ifdef CONFIG_LEDS_GPIO_PLATFORM 321#ifdef CONFIG_LEDS_GPIO_PLATFORM
322 ret = platform_driver_register(&gpio_led_driver); 322 ret = platform_driver_register(&gpio_led_driver);
diff --git a/drivers/leds/leds-lp5521.c b/drivers/leds/leds-lp5521.c
new file mode 100644
index 000000000000..33facd0c45d1
--- /dev/null
+++ b/drivers/leds/leds-lp5521.c
@@ -0,0 +1,837 @@
1/*
2 * LP5521 LED chip driver.
3 *
4 * Copyright (C) 2010 Nokia Corporation
5 *
6 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 */
22
23#include <linux/module.h>
24#include <linux/init.h>
25#include <linux/i2c.h>
26#include <linux/mutex.h>
27#include <linux/gpio.h>
28#include <linux/interrupt.h>
29#include <linux/delay.h>
30#include <linux/ctype.h>
31#include <linux/spinlock.h>
32#include <linux/wait.h>
33#include <linux/leds.h>
34#include <linux/leds-lp5521.h>
35#include <linux/workqueue.h>
36#include <linux/slab.h>
37
38#define LP5521_PROGRAM_LENGTH 32 /* in bytes */
39
40#define LP5521_MAX_LEDS 3 /* Maximum number of LEDs */
41#define LP5521_MAX_ENGINES 3 /* Maximum number of engines */
42
43#define LP5521_ENG_MASK_BASE 0x30 /* 00110000 */
44#define LP5521_ENG_STATUS_MASK 0x07 /* 00000111 */
45
46#define LP5521_CMD_LOAD 0x15 /* 00010101 */
47#define LP5521_CMD_RUN 0x2a /* 00101010 */
48#define LP5521_CMD_DIRECT 0x3f /* 00111111 */
49#define LP5521_CMD_DISABLED 0x00 /* 00000000 */
50
51/* Registers */
52#define LP5521_REG_ENABLE 0x00
53#define LP5521_REG_OP_MODE 0x01
54#define LP5521_REG_R_PWM 0x02
55#define LP5521_REG_G_PWM 0x03
56#define LP5521_REG_B_PWM 0x04
57#define LP5521_REG_R_CURRENT 0x05
58#define LP5521_REG_G_CURRENT 0x06
59#define LP5521_REG_B_CURRENT 0x07
60#define LP5521_REG_CONFIG 0x08
61#define LP5521_REG_R_CHANNEL_PC 0x09
62#define LP5521_REG_G_CHANNEL_PC 0x0A
63#define LP5521_REG_B_CHANNEL_PC 0x0B
64#define LP5521_REG_STATUS 0x0C
65#define LP5521_REG_RESET 0x0D
66#define LP5521_REG_GPO 0x0E
67#define LP5521_REG_R_PROG_MEM 0x10
68#define LP5521_REG_G_PROG_MEM 0x30
69#define LP5521_REG_B_PROG_MEM 0x50
70
71#define LP5521_PROG_MEM_BASE LP5521_REG_R_PROG_MEM
72#define LP5521_PROG_MEM_SIZE 0x20
73
74/* Base register to set LED current */
75#define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT
76
77/* Base register to set the brightness */
78#define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM
79
80/* Bits in ENABLE register */
81#define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */
82#define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */
83#define LP5521_EXEC_RUN 0x2A
84
85/* Bits in CONFIG register */
86#define LP5521_PWM_HF 0x40 /* PWM: 0 = 256Hz, 1 = 558Hz */
87#define LP5521_PWRSAVE_EN 0x20 /* 1 = Power save mode */
88#define LP5521_CP_MODE_OFF 0 /* Charge pump (CP) off */
89#define LP5521_CP_MODE_BYPASS 8 /* CP forced to bypass mode */
90#define LP5521_CP_MODE_1X5 0x10 /* CP forced to 1.5x mode */
91#define LP5521_CP_MODE_AUTO 0x18 /* Automatic mode selection */
92#define LP5521_R_TO_BATT 4 /* R out: 0 = CP, 1 = Vbat */
93#define LP5521_CLK_SRC_EXT 0 /* Ext-clk source (CLK_32K) */
94#define LP5521_CLK_INT 1 /* Internal clock */
95#define LP5521_CLK_AUTO 2 /* Automatic clock selection */
96
97/* Status */
98#define LP5521_EXT_CLK_USED 0x08
99
100struct lp5521_engine {
101 const struct attribute_group *attributes;
102 int id;
103 u8 mode;
104 u8 prog_page;
105 u8 engine_mask;
106};
107
108struct lp5521_led {
109 int id;
110 u8 chan_nr;
111 u8 led_current;
112 u8 max_current;
113 struct led_classdev cdev;
114 struct work_struct brightness_work;
115 u8 brightness;
116};
117
118struct lp5521_chip {
119 struct lp5521_platform_data *pdata;
120 struct mutex lock; /* Serialize control */
121 struct i2c_client *client;
122 struct lp5521_engine engines[LP5521_MAX_ENGINES];
123 struct lp5521_led leds[LP5521_MAX_LEDS];
124 u8 num_channels;
125 u8 num_leds;
126};
127
128static inline struct lp5521_led *cdev_to_led(struct led_classdev *cdev)
129{
130 return container_of(cdev, struct lp5521_led, cdev);
131}
132
133static inline struct lp5521_chip *engine_to_lp5521(struct lp5521_engine *engine)
134{
135 return container_of(engine, struct lp5521_chip,
136 engines[engine->id - 1]);
137}
138
139static inline struct lp5521_chip *led_to_lp5521(struct lp5521_led *led)
140{
141 return container_of(led, struct lp5521_chip,
142 leds[led->id]);
143}
144
145static void lp5521_led_brightness_work(struct work_struct *work);
146
147static inline int lp5521_write(struct i2c_client *client, u8 reg, u8 value)
148{
149 return i2c_smbus_write_byte_data(client, reg, value);
150}
151
152static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf)
153{
154 s32 ret;
155
156 ret = i2c_smbus_read_byte_data(client, reg);
157 if (ret < 0)
158 return -EIO;
159
160 *buf = ret;
161 return 0;
162}
163
164static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode)
165{
166 struct lp5521_chip *chip = engine_to_lp5521(engine);
167 struct i2c_client *client = chip->client;
168 int ret;
169 u8 engine_state;
170
171 /* Only transition between RUN and DIRECT mode are handled here */
172 if (mode == LP5521_CMD_LOAD)
173 return 0;
174
175 if (mode == LP5521_CMD_DISABLED)
176 mode = LP5521_CMD_DIRECT;
177
178 ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state);
179
180 /* set mode only for this engine */
181 engine_state &= ~(engine->engine_mask);
182 mode &= engine->engine_mask;
183 engine_state |= mode;
184 ret |= lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
185
186 return ret;
187}
188
189static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
190{
191 struct lp5521_chip *chip = engine_to_lp5521(eng);
192 struct i2c_client *client = chip->client;
193 int ret;
194 int addr;
195 u8 mode;
196
197 /* move current engine to direct mode and remember the state */
198 ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT);
199 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
200 usleep_range(1000, 2000);
201 ret |= lp5521_read(client, LP5521_REG_OP_MODE, &mode);
202
203 /* For loading, all the engines to load mode */
204 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
205 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
206 usleep_range(1000, 2000);
207 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
208 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
209 usleep_range(1000, 2000);
210
211 addr = LP5521_PROG_MEM_BASE + eng->prog_page * LP5521_PROG_MEM_SIZE;
212 i2c_smbus_write_i2c_block_data(client,
213 addr,
214 LP5521_PROG_MEM_SIZE,
215 pattern);
216
217 ret |= lp5521_write(client, LP5521_REG_OP_MODE, mode);
218 return ret;
219}
220
221static int lp5521_set_led_current(struct lp5521_chip *chip, int led, u8 curr)
222{
223 return lp5521_write(chip->client,
224 LP5521_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr,
225 curr);
226}
227
228static void lp5521_init_engine(struct lp5521_chip *chip,
229 const struct attribute_group *attr_group)
230{
231 int i;
232 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) {
233 chip->engines[i].id = i + 1;
234 chip->engines[i].engine_mask = LP5521_ENG_MASK_BASE >> (i * 2);
235 chip->engines[i].prog_page = i;
236 chip->engines[i].attributes = &attr_group[i];
237 }
238}
239
240static int lp5521_configure(struct i2c_client *client,
241 const struct attribute_group *attr_group)
242{
243 struct lp5521_chip *chip = i2c_get_clientdata(client);
244 int ret;
245
246 lp5521_init_engine(chip, attr_group);
247
248 /* Set all PWMs to direct control mode */
249 ret = lp5521_write(client, LP5521_REG_OP_MODE, 0x3F);
250
251 /* Enable auto-powersave, set charge pump to auto, red to battery */
252 ret |= lp5521_write(client, LP5521_REG_CONFIG,
253 LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT);
254
255 /* Initialize all channels PWM to zero -> leds off */
256 ret |= lp5521_write(client, LP5521_REG_R_PWM, 0);
257 ret |= lp5521_write(client, LP5521_REG_G_PWM, 0);
258 ret |= lp5521_write(client, LP5521_REG_B_PWM, 0);
259
260 /* Set engines are set to run state when OP_MODE enables engines */
261 ret |= lp5521_write(client, LP5521_REG_ENABLE,
262 LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM |
263 LP5521_EXEC_RUN);
264 /* enable takes 500us. 1 - 2 ms leaves some margin */
265 usleep_range(1000, 2000);
266
267 return ret;
268}
269
270static int lp5521_run_selftest(struct lp5521_chip *chip, char *buf)
271{
272 int ret;
273 u8 status;
274
275 ret = lp5521_read(chip->client, LP5521_REG_STATUS, &status);
276 if (ret < 0)
277 return ret;
278
279 /* Check that ext clock is really in use if requested */
280 if (chip->pdata && chip->pdata->clock_mode == LP5521_CLOCK_EXT)
281 if ((status & LP5521_EXT_CLK_USED) == 0)
282 return -EIO;
283 return 0;
284}
285
286static void lp5521_set_brightness(struct led_classdev *cdev,
287 enum led_brightness brightness)
288{
289 struct lp5521_led *led = cdev_to_led(cdev);
290 led->brightness = (u8)brightness;
291 schedule_work(&led->brightness_work);
292}
293
294static void lp5521_led_brightness_work(struct work_struct *work)
295{
296 struct lp5521_led *led = container_of(work,
297 struct lp5521_led,
298 brightness_work);
299 struct lp5521_chip *chip = led_to_lp5521(led);
300 struct i2c_client *client = chip->client;
301
302 mutex_lock(&chip->lock);
303 lp5521_write(client, LP5521_REG_LED_PWM_BASE + led->chan_nr,
304 led->brightness);
305 mutex_unlock(&chip->lock);
306}
307
308/* Detect the chip by setting its ENABLE register and reading it back. */
309static int lp5521_detect(struct i2c_client *client)
310{
311 int ret;
312 u8 buf;
313
314 ret = lp5521_write(client, LP5521_REG_ENABLE,
315 LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM);
316 if (ret)
317 return ret;
318 /* enable takes 500us. 1 - 2 ms leaves some margin */
319 usleep_range(1000, 2000);
320 ret = lp5521_read(client, LP5521_REG_ENABLE, &buf);
321 if (ret)
322 return ret;
323 if (buf != (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM))
324 return -ENODEV;
325
326 return 0;
327}
328
329/* Set engine mode and create appropriate sysfs attributes, if required. */
330static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode)
331{
332 struct lp5521_chip *chip = engine_to_lp5521(engine);
333 struct i2c_client *client = chip->client;
334 struct device *dev = &client->dev;
335 int ret = 0;
336
337 /* if in that mode already do nothing, except for run */
338 if (mode == engine->mode && mode != LP5521_CMD_RUN)
339 return 0;
340
341 if (mode == LP5521_CMD_RUN) {
342 ret = lp5521_set_engine_mode(engine, LP5521_CMD_RUN);
343 } else if (mode == LP5521_CMD_LOAD) {
344 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
345 lp5521_set_engine_mode(engine, LP5521_CMD_LOAD);
346
347 ret = sysfs_create_group(&dev->kobj, engine->attributes);
348 if (ret)
349 return ret;
350 } else if (mode == LP5521_CMD_DISABLED) {
351 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
352 }
353
354 /* remove load attribute from sysfs if not in load mode */
355 if (engine->mode == LP5521_CMD_LOAD && mode != LP5521_CMD_LOAD)
356 sysfs_remove_group(&dev->kobj, engine->attributes);
357
358 engine->mode = mode;
359
360 return ret;
361}
362
363static int lp5521_do_store_load(struct lp5521_engine *engine,
364 const char *buf, size_t len)
365{
366 struct lp5521_chip *chip = engine_to_lp5521(engine);
367 struct i2c_client *client = chip->client;
368 int ret, nrchars, offset = 0, i = 0;
369 char c[3];
370 unsigned cmd;
371 u8 pattern[LP5521_PROGRAM_LENGTH] = {0};
372
373 while ((offset < len - 1) && (i < LP5521_PROGRAM_LENGTH)) {
374 /* separate sscanfs because length is working only for %s */
375 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
376 ret = sscanf(c, "%2x", &cmd);
377 if (ret != 1)
378 goto fail;
379 pattern[i] = (u8)cmd;
380
381 offset += nrchars;
382 i++;
383 }
384
385 /* Each instruction is 16bit long. Check that length is even */
386 if (i % 2)
387 goto fail;
388
389 mutex_lock(&chip->lock);
390 ret = lp5521_load_program(engine, pattern);
391 mutex_unlock(&chip->lock);
392
393 if (ret) {
394 dev_err(&client->dev, "failed loading pattern\n");
395 return ret;
396 }
397
398 return len;
399fail:
400 dev_err(&client->dev, "wrong pattern format\n");
401 return -EINVAL;
402}
403
404static ssize_t store_engine_load(struct device *dev,
405 struct device_attribute *attr,
406 const char *buf, size_t len, int nr)
407{
408 struct i2c_client *client = to_i2c_client(dev);
409 struct lp5521_chip *chip = i2c_get_clientdata(client);
410 return lp5521_do_store_load(&chip->engines[nr - 1], buf, len);
411}
412
413#define store_load(nr) \
414static ssize_t store_engine##nr##_load(struct device *dev, \
415 struct device_attribute *attr, \
416 const char *buf, size_t len) \
417{ \
418 return store_engine_load(dev, attr, buf, len, nr); \
419}
420store_load(1)
421store_load(2)
422store_load(3)
423
424static ssize_t show_engine_mode(struct device *dev,
425 struct device_attribute *attr,
426 char *buf, int nr)
427{
428 struct i2c_client *client = to_i2c_client(dev);
429 struct lp5521_chip *chip = i2c_get_clientdata(client);
430 switch (chip->engines[nr - 1].mode) {
431 case LP5521_CMD_RUN:
432 return sprintf(buf, "run\n");
433 case LP5521_CMD_LOAD:
434 return sprintf(buf, "load\n");
435 case LP5521_CMD_DISABLED:
436 return sprintf(buf, "disabled\n");
437 default:
438 return sprintf(buf, "disabled\n");
439 }
440}
441
442#define show_mode(nr) \
443static ssize_t show_engine##nr##_mode(struct device *dev, \
444 struct device_attribute *attr, \
445 char *buf) \
446{ \
447 return show_engine_mode(dev, attr, buf, nr); \
448}
449show_mode(1)
450show_mode(2)
451show_mode(3)
452
453static ssize_t store_engine_mode(struct device *dev,
454 struct device_attribute *attr,
455 const char *buf, size_t len, int nr)
456{
457 struct i2c_client *client = to_i2c_client(dev);
458 struct lp5521_chip *chip = i2c_get_clientdata(client);
459 struct lp5521_engine *engine = &chip->engines[nr - 1];
460 mutex_lock(&chip->lock);
461
462 if (!strncmp(buf, "run", 3))
463 lp5521_set_mode(engine, LP5521_CMD_RUN);
464 else if (!strncmp(buf, "load", 4))
465 lp5521_set_mode(engine, LP5521_CMD_LOAD);
466 else if (!strncmp(buf, "disabled", 8))
467 lp5521_set_mode(engine, LP5521_CMD_DISABLED);
468
469 mutex_unlock(&chip->lock);
470 return len;
471}
472
473#define store_mode(nr) \
474static ssize_t store_engine##nr##_mode(struct device *dev, \
475 struct device_attribute *attr, \
476 const char *buf, size_t len) \
477{ \
478 return store_engine_mode(dev, attr, buf, len, nr); \
479}
480store_mode(1)
481store_mode(2)
482store_mode(3)
483
484static ssize_t show_max_current(struct device *dev,
485 struct device_attribute *attr,
486 char *buf)
487{
488 struct led_classdev *led_cdev = dev_get_drvdata(dev);
489 struct lp5521_led *led = cdev_to_led(led_cdev);
490
491 return sprintf(buf, "%d\n", led->max_current);
492}
493
494static ssize_t show_current(struct device *dev,
495 struct device_attribute *attr,
496 char *buf)
497{
498 struct led_classdev *led_cdev = dev_get_drvdata(dev);
499 struct lp5521_led *led = cdev_to_led(led_cdev);
500
501 return sprintf(buf, "%d\n", led->led_current);
502}
503
504static ssize_t store_current(struct device *dev,
505 struct device_attribute *attr,
506 const char *buf, size_t len)
507{
508 struct led_classdev *led_cdev = dev_get_drvdata(dev);
509 struct lp5521_led *led = cdev_to_led(led_cdev);
510 struct lp5521_chip *chip = led_to_lp5521(led);
511 ssize_t ret;
512 unsigned long curr;
513
514 if (strict_strtoul(buf, 0, &curr))
515 return -EINVAL;
516
517 if (curr > led->max_current)
518 return -EINVAL;
519
520 mutex_lock(&chip->lock);
521 ret = lp5521_set_led_current(chip, led->id, curr);
522 mutex_unlock(&chip->lock);
523
524 if (ret < 0)
525 return ret;
526
527 led->led_current = (u8)curr;
528
529 return len;
530}
531
532static ssize_t lp5521_selftest(struct device *dev,
533 struct device_attribute *attr,
534 char *buf)
535{
536 struct i2c_client *client = to_i2c_client(dev);
537 struct lp5521_chip *chip = i2c_get_clientdata(client);
538 int ret;
539
540 mutex_lock(&chip->lock);
541 ret = lp5521_run_selftest(chip, buf);
542 mutex_unlock(&chip->lock);
543 return sprintf(buf, "%s\n", ret ? "FAIL" : "OK");
544}
545
546/* led class device attributes */
547static DEVICE_ATTR(led_current, S_IRUGO | S_IWUGO, show_current, store_current);
548static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL);
549
550static struct attribute *lp5521_led_attributes[] = {
551 &dev_attr_led_current.attr,
552 &dev_attr_max_current.attr,
553 NULL,
554};
555
556static struct attribute_group lp5521_led_attribute_group = {
557 .attrs = lp5521_led_attributes
558};
559
560/* device attributes */
561static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUGO,
562 show_engine1_mode, store_engine1_mode);
563static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUGO,
564 show_engine2_mode, store_engine2_mode);
565static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUGO,
566 show_engine3_mode, store_engine3_mode);
567static DEVICE_ATTR(engine1_load, S_IWUGO, NULL, store_engine1_load);
568static DEVICE_ATTR(engine2_load, S_IWUGO, NULL, store_engine2_load);
569static DEVICE_ATTR(engine3_load, S_IWUGO, NULL, store_engine3_load);
570static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL);
571
572static struct attribute *lp5521_attributes[] = {
573 &dev_attr_engine1_mode.attr,
574 &dev_attr_engine2_mode.attr,
575 &dev_attr_engine3_mode.attr,
576 &dev_attr_selftest.attr,
577 NULL
578};
579
580static struct attribute *lp5521_engine1_attributes[] = {
581 &dev_attr_engine1_load.attr,
582 NULL
583};
584
585static struct attribute *lp5521_engine2_attributes[] = {
586 &dev_attr_engine2_load.attr,
587 NULL
588};
589
590static struct attribute *lp5521_engine3_attributes[] = {
591 &dev_attr_engine3_load.attr,
592 NULL
593};
594
595static const struct attribute_group lp5521_group = {
596 .attrs = lp5521_attributes,
597};
598
599static const struct attribute_group lp5521_engine_group[] = {
600 {.attrs = lp5521_engine1_attributes },
601 {.attrs = lp5521_engine2_attributes },
602 {.attrs = lp5521_engine3_attributes },
603};
604
605static int lp5521_register_sysfs(struct i2c_client *client)
606{
607 struct device *dev = &client->dev;
608 return sysfs_create_group(&dev->kobj, &lp5521_group);
609}
610
611static void lp5521_unregister_sysfs(struct i2c_client *client)
612{
613 struct lp5521_chip *chip = i2c_get_clientdata(client);
614 struct device *dev = &client->dev;
615 int i;
616
617 sysfs_remove_group(&dev->kobj, &lp5521_group);
618
619 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) {
620 if (chip->engines[i].mode == LP5521_CMD_LOAD)
621 sysfs_remove_group(&dev->kobj,
622 chip->engines[i].attributes);
623 }
624
625 for (i = 0; i < chip->num_leds; i++)
626 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
627 &lp5521_led_attribute_group);
628}
629
630static int __init lp5521_init_led(struct lp5521_led *led,
631 struct i2c_client *client,
632 int chan, struct lp5521_platform_data *pdata)
633{
634 struct device *dev = &client->dev;
635 char name[32];
636 int res;
637
638 if (chan >= LP5521_MAX_LEDS)
639 return -EINVAL;
640
641 if (pdata->led_config[chan].led_current == 0)
642 return 0;
643
644 led->led_current = pdata->led_config[chan].led_current;
645 led->max_current = pdata->led_config[chan].max_current;
646 led->chan_nr = pdata->led_config[chan].chan_nr;
647
648 if (led->chan_nr >= LP5521_MAX_LEDS) {
649 dev_err(dev, "Use channel numbers between 0 and %d\n",
650 LP5521_MAX_LEDS - 1);
651 return -EINVAL;
652 }
653
654 snprintf(name, sizeof(name), "%s:channel%d", client->name, chan);
655 led->cdev.brightness_set = lp5521_set_brightness;
656 led->cdev.name = name;
657 res = led_classdev_register(dev, &led->cdev);
658 if (res < 0) {
659 dev_err(dev, "couldn't register led on channel %d\n", chan);
660 return res;
661 }
662
663 res = sysfs_create_group(&led->cdev.dev->kobj,
664 &lp5521_led_attribute_group);
665 if (res < 0) {
666 dev_err(dev, "couldn't register current attribute\n");
667 led_classdev_unregister(&led->cdev);
668 return res;
669 }
670 return 0;
671}
672
673static int lp5521_probe(struct i2c_client *client,
674 const struct i2c_device_id *id)
675{
676 struct lp5521_chip *chip;
677 struct lp5521_platform_data *pdata;
678 int ret, i, led;
679
680 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
681 if (!chip)
682 return -ENOMEM;
683
684 i2c_set_clientdata(client, chip);
685 chip->client = client;
686
687 pdata = client->dev.platform_data;
688
689 if (!pdata) {
690 dev_err(&client->dev, "no platform data\n");
691 ret = -EINVAL;
692 goto fail1;
693 }
694
695 mutex_init(&chip->lock);
696
697 chip->pdata = pdata;
698
699 if (pdata->setup_resources) {
700 ret = pdata->setup_resources();
701 if (ret < 0)
702 goto fail1;
703 }
704
705 if (pdata->enable) {
706 pdata->enable(0);
707 usleep_range(1000, 2000); /* Keep enable down at least 1ms */
708 pdata->enable(1);
709 usleep_range(1000, 2000); /* 500us abs min. */
710 }
711
712 lp5521_write(client, LP5521_REG_RESET, 0xff);
713 usleep_range(10000, 20000); /*
714 * Exact value is not available. 10 - 20ms
715 * appears to be enough for reset.
716 */
717 ret = lp5521_detect(client);
718
719 if (ret) {
720 dev_err(&client->dev, "Chip not found\n");
721 goto fail2;
722 }
723
724 dev_info(&client->dev, "%s programmable led chip found\n", id->name);
725
726 ret = lp5521_configure(client, lp5521_engine_group);
727 if (ret < 0) {
728 dev_err(&client->dev, "error configuring chip\n");
729 goto fail2;
730 }
731
732 /* Initialize leds */
733 chip->num_channels = pdata->num_channels;
734 chip->num_leds = 0;
735 led = 0;
736 for (i = 0; i < pdata->num_channels; i++) {
737 /* Do not initialize channels that are not connected */
738 if (pdata->led_config[i].led_current == 0)
739 continue;
740
741 ret = lp5521_init_led(&chip->leds[led], client, i, pdata);
742 if (ret) {
743 dev_err(&client->dev, "error initializing leds\n");
744 goto fail3;
745 }
746 chip->num_leds++;
747
748 chip->leds[led].id = led;
749 /* Set initial LED current */
750 lp5521_set_led_current(chip, led,
751 chip->leds[led].led_current);
752
753 INIT_WORK(&(chip->leds[led].brightness_work),
754 lp5521_led_brightness_work);
755
756 led++;
757 }
758
759 ret = lp5521_register_sysfs(client);
760 if (ret) {
761 dev_err(&client->dev, "registering sysfs failed\n");
762 goto fail3;
763 }
764 return ret;
765fail3:
766 for (i = 0; i < chip->num_leds; i++) {
767 led_classdev_unregister(&chip->leds[i].cdev);
768 cancel_work_sync(&chip->leds[i].brightness_work);
769 }
770fail2:
771 if (pdata->enable)
772 pdata->enable(0);
773 if (pdata->release_resources)
774 pdata->release_resources();
775fail1:
776 kfree(chip);
777 return ret;
778}
779
780static int lp5521_remove(struct i2c_client *client)
781{
782 struct lp5521_chip *chip = i2c_get_clientdata(client);
783 int i;
784
785 lp5521_unregister_sysfs(client);
786
787 for (i = 0; i < chip->num_leds; i++) {
788 led_classdev_unregister(&chip->leds[i].cdev);
789 cancel_work_sync(&chip->leds[i].brightness_work);
790 }
791
792 if (chip->pdata->enable)
793 chip->pdata->enable(0);
794 if (chip->pdata->release_resources)
795 chip->pdata->release_resources();
796 kfree(chip);
797 return 0;
798}
799
800static const struct i2c_device_id lp5521_id[] = {
801 { "lp5521", 0 }, /* Three channel chip */
802 { }
803};
804MODULE_DEVICE_TABLE(i2c, lp5521_id);
805
806static struct i2c_driver lp5521_driver = {
807 .driver = {
808 .name = "lp5521",
809 },
810 .probe = lp5521_probe,
811 .remove = lp5521_remove,
812 .id_table = lp5521_id,
813};
814
815static int __init lp5521_init(void)
816{
817 int ret;
818
819 ret = i2c_add_driver(&lp5521_driver);
820
821 if (ret < 0)
822 printk(KERN_ALERT "Adding lp5521 driver failed\n");
823
824 return ret;
825}
826
827static void __exit lp5521_exit(void)
828{
829 i2c_del_driver(&lp5521_driver);
830}
831
832module_init(lp5521_init);
833module_exit(lp5521_exit);
834
835MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
836MODULE_DESCRIPTION("LP5521 LED engine");
837MODULE_LICENSE("GPL v2");
diff --git a/drivers/leds/leds-lp5523.c b/drivers/leds/leds-lp5523.c
new file mode 100644
index 000000000000..0cc4ead2fd8b
--- /dev/null
+++ b/drivers/leds/leds-lp5523.c
@@ -0,0 +1,1069 @@
1/*
2 * lp5523.c - LP5523 LED Driver
3 *
4 * Copyright (C) 2010 Nokia Corporation
5 *
6 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 */
22
23#include <linux/module.h>
24#include <linux/init.h>
25#include <linux/i2c.h>
26#include <linux/mutex.h>
27#include <linux/gpio.h>
28#include <linux/interrupt.h>
29#include <linux/delay.h>
30#include <linux/ctype.h>
31#include <linux/spinlock.h>
32#include <linux/wait.h>
33#include <linux/leds.h>
34#include <linux/leds-lp5523.h>
35#include <linux/workqueue.h>
36#include <linux/slab.h>
37
38#define LP5523_REG_ENABLE 0x00
39#define LP5523_REG_OP_MODE 0x01
40#define LP5523_REG_RATIOMETRIC_MSB 0x02
41#define LP5523_REG_RATIOMETRIC_LSB 0x03
42#define LP5523_REG_ENABLE_LEDS_MSB 0x04
43#define LP5523_REG_ENABLE_LEDS_LSB 0x05
44#define LP5523_REG_LED_CNTRL_BASE 0x06
45#define LP5523_REG_LED_PWM_BASE 0x16
46#define LP5523_REG_LED_CURRENT_BASE 0x26
47#define LP5523_REG_CONFIG 0x36
48#define LP5523_REG_CHANNEL1_PC 0x37
49#define LP5523_REG_CHANNEL2_PC 0x38
50#define LP5523_REG_CHANNEL3_PC 0x39
51#define LP5523_REG_STATUS 0x3a
52#define LP5523_REG_GPO 0x3b
53#define LP5523_REG_VARIABLE 0x3c
54#define LP5523_REG_RESET 0x3d
55#define LP5523_REG_TEMP_CTRL 0x3e
56#define LP5523_REG_TEMP_READ 0x3f
57#define LP5523_REG_TEMP_WRITE 0x40
58#define LP5523_REG_LED_TEST_CTRL 0x41
59#define LP5523_REG_LED_TEST_ADC 0x42
60#define LP5523_REG_ENG1_VARIABLE 0x45
61#define LP5523_REG_ENG2_VARIABLE 0x46
62#define LP5523_REG_ENG3_VARIABLE 0x47
63#define LP5523_REG_MASTER_FADER1 0x48
64#define LP5523_REG_MASTER_FADER2 0x49
65#define LP5523_REG_MASTER_FADER3 0x4a
66#define LP5523_REG_CH1_PROG_START 0x4c
67#define LP5523_REG_CH2_PROG_START 0x4d
68#define LP5523_REG_CH3_PROG_START 0x4e
69#define LP5523_REG_PROG_PAGE_SEL 0x4f
70#define LP5523_REG_PROG_MEM 0x50
71
72#define LP5523_CMD_LOAD 0x15 /* 00010101 */
73#define LP5523_CMD_RUN 0x2a /* 00101010 */
74#define LP5523_CMD_DISABLED 0x00 /* 00000000 */
75
76#define LP5523_ENABLE 0x40
77#define LP5523_AUTO_INC 0x40
78#define LP5523_PWR_SAVE 0x20
79#define LP5523_PWM_PWR_SAVE 0x04
80#define LP5523_CP_1 0x08
81#define LP5523_CP_1_5 0x10
82#define LP5523_CP_AUTO 0x18
83#define LP5523_INT_CLK 0x01
84#define LP5523_AUTO_CLK 0x02
85#define LP5523_EN_LEDTEST 0x80
86#define LP5523_LEDTEST_DONE 0x80
87
88#define LP5523_DEFAULT_CURRENT 50 /* microAmps */
89#define LP5523_PROGRAM_LENGTH 32 /* in bytes */
90#define LP5523_PROGRAM_PAGES 6
91#define LP5523_ADC_SHORTCIRC_LIM 80
92
93#define LP5523_LEDS 9
94#define LP5523_ENGINES 3
95
96#define LP5523_ENG_MASK_BASE 0x30 /* 00110000 */
97
98#define LP5523_ENG_STATUS_MASK 0x07 /* 00000111 */
99
100#define LP5523_IRQ_FLAGS IRQF_TRIGGER_FALLING
101
102#define LP5523_EXT_CLK_USED 0x08
103
104#define LED_ACTIVE(mux, led) (!!(mux & (0x0001 << led)))
105#define SHIFT_MASK(id) (((id) - 1) * 2)
106
107struct lp5523_engine {
108 const struct attribute_group *attributes;
109 int id;
110 u8 mode;
111 u8 prog_page;
112 u8 mux_page;
113 u16 led_mux;
114 u8 engine_mask;
115};
116
117struct lp5523_led {
118 int id;
119 u8 chan_nr;
120 u8 led_current;
121 u8 max_current;
122 struct led_classdev cdev;
123 struct work_struct brightness_work;
124 u8 brightness;
125};
126
127struct lp5523_chip {
128 struct mutex lock; /* Serialize control */
129 struct i2c_client *client;
130 struct lp5523_engine engines[LP5523_ENGINES];
131 struct lp5523_led leds[LP5523_LEDS];
132 struct lp5523_platform_data *pdata;
133 u8 num_channels;
134 u8 num_leds;
135};
136
137static inline struct lp5523_led *cdev_to_led(struct led_classdev *cdev)
138{
139 return container_of(cdev, struct lp5523_led, cdev);
140}
141
142static inline struct lp5523_chip *engine_to_lp5523(struct lp5523_engine *engine)
143{
144 return container_of(engine, struct lp5523_chip,
145 engines[engine->id - 1]);
146}
147
148static inline struct lp5523_chip *led_to_lp5523(struct lp5523_led *led)
149{
150 return container_of(led, struct lp5523_chip,
151 leds[led->id]);
152}
153
154static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode);
155static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode);
156static int lp5523_load_program(struct lp5523_engine *engine, u8 *pattern);
157
158static void lp5523_led_brightness_work(struct work_struct *work);
159
160static int lp5523_write(struct i2c_client *client, u8 reg, u8 value)
161{
162 return i2c_smbus_write_byte_data(client, reg, value);
163}
164
165static int lp5523_read(struct i2c_client *client, u8 reg, u8 *buf)
166{
167 s32 ret = i2c_smbus_read_byte_data(client, reg);
168
169 if (ret < 0)
170 return -EIO;
171
172 *buf = ret;
173 return 0;
174}
175
176static int lp5523_detect(struct i2c_client *client)
177{
178 int ret;
179 u8 buf;
180
181 ret = lp5523_write(client, LP5523_REG_ENABLE, 0x40);
182 if (ret)
183 return ret;
184 ret = lp5523_read(client, LP5523_REG_ENABLE, &buf);
185 if (ret)
186 return ret;
187 if (buf == 0x40)
188 return 0;
189 else
190 return -ENODEV;
191}
192
193static int lp5523_configure(struct i2c_client *client)
194{
195 struct lp5523_chip *chip = i2c_get_clientdata(client);
196 int ret = 0;
197 u8 status;
198
199 /* one pattern per engine setting led mux start and stop addresses */
200 u8 pattern[][LP5523_PROGRAM_LENGTH] = {
201 { 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
202 { 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
203 { 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
204 };
205
206 ret |= lp5523_write(client, LP5523_REG_ENABLE, LP5523_ENABLE);
207 /* Chip startup time is 500 us, 1 - 2 ms gives some margin */
208 usleep_range(1000, 2000);
209
210 ret |= lp5523_write(client, LP5523_REG_CONFIG,
211 LP5523_AUTO_INC | LP5523_PWR_SAVE |
212 LP5523_CP_AUTO | LP5523_AUTO_CLK |
213 LP5523_PWM_PWR_SAVE);
214
215 /* turn on all leds */
216 ret |= lp5523_write(client, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
217 ret |= lp5523_write(client, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
218
219 /* hardcode 32 bytes of memory for each engine from program memory */
220 ret |= lp5523_write(client, LP5523_REG_CH1_PROG_START, 0x00);
221 ret |= lp5523_write(client, LP5523_REG_CH2_PROG_START, 0x10);
222 ret |= lp5523_write(client, LP5523_REG_CH3_PROG_START, 0x20);
223
224 /* write led mux address space for each channel */
225 ret |= lp5523_load_program(&chip->engines[0], pattern[0]);
226 ret |= lp5523_load_program(&chip->engines[1], pattern[1]);
227 ret |= lp5523_load_program(&chip->engines[2], pattern[2]);
228
229 if (ret) {
230 dev_err(&client->dev, "could not load mux programs\n");
231 return -1;
232 }
233
234 /* set all engines exec state and mode to run 00101010 */
235 ret |= lp5523_write(client, LP5523_REG_ENABLE,
236 (LP5523_CMD_RUN | LP5523_ENABLE));
237
238 ret |= lp5523_write(client, LP5523_REG_OP_MODE, LP5523_CMD_RUN);
239
240 if (ret) {
241 dev_err(&client->dev, "could not start mux programs\n");
242 return -1;
243 }
244
245 /* Let the programs run for couple of ms and check the engine status */
246 usleep_range(3000, 6000);
247 lp5523_read(client, LP5523_REG_STATUS, &status);
248 status &= LP5523_ENG_STATUS_MASK;
249
250 if (status == LP5523_ENG_STATUS_MASK) {
251 dev_dbg(&client->dev, "all engines configured\n");
252 } else {
253 dev_info(&client->dev, "status == %x\n", status);
254 dev_err(&client->dev, "cound not configure LED engine\n");
255 return -1;
256 }
257
258 dev_info(&client->dev, "disabling engines\n");
259
260 ret |= lp5523_write(client, LP5523_REG_OP_MODE, LP5523_CMD_DISABLED);
261
262 return ret;
263}
264
265static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode)
266{
267 struct lp5523_chip *chip = engine_to_lp5523(engine);
268 struct i2c_client *client = chip->client;
269 int ret;
270 u8 engine_state;
271
272 ret = lp5523_read(client, LP5523_REG_OP_MODE, &engine_state);
273 if (ret)
274 goto fail;
275
276 engine_state &= ~(engine->engine_mask);
277
278 /* set mode only for this engine */
279 mode &= engine->engine_mask;
280
281 engine_state |= mode;
282
283 ret |= lp5523_write(client, LP5523_REG_OP_MODE, engine_state);
284fail:
285 return ret;
286}
287
288static int lp5523_load_mux(struct lp5523_engine *engine, u16 mux)
289{
290 struct lp5523_chip *chip = engine_to_lp5523(engine);
291 struct i2c_client *client = chip->client;
292 int ret = 0;
293
294 ret |= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
295
296 ret |= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL, engine->mux_page);
297 ret |= lp5523_write(client, LP5523_REG_PROG_MEM,
298 (u8)(mux >> 8));
299 ret |= lp5523_write(client, LP5523_REG_PROG_MEM + 1, (u8)(mux));
300 engine->led_mux = mux;
301
302 return ret;
303}
304
305static int lp5523_load_program(struct lp5523_engine *engine, u8 *pattern)
306{
307 struct lp5523_chip *chip = engine_to_lp5523(engine);
308 struct i2c_client *client = chip->client;
309
310 int ret = 0;
311
312 ret |= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
313
314 ret |= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL,
315 engine->prog_page);
316 ret |= i2c_smbus_write_i2c_block_data(client, LP5523_REG_PROG_MEM,
317 LP5523_PROGRAM_LENGTH, pattern);
318
319 return ret;
320}
321
322static int lp5523_run_program(struct lp5523_engine *engine)
323{
324 struct lp5523_chip *chip = engine_to_lp5523(engine);
325 struct i2c_client *client = chip->client;
326 int ret;
327
328 ret = lp5523_write(client, LP5523_REG_ENABLE,
329 LP5523_CMD_RUN | LP5523_ENABLE);
330 if (ret)
331 goto fail;
332
333 ret = lp5523_set_engine_mode(engine, LP5523_CMD_RUN);
334fail:
335 return ret;
336}
337
338static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len)
339{
340 int i;
341 u16 tmp_mux = 0;
342 len = len < LP5523_LEDS ? len : LP5523_LEDS;
343 for (i = 0; i < len; i++) {
344 switch (buf[i]) {
345 case '1':
346 tmp_mux |= (1 << i);
347 break;
348 case '0':
349 break;
350 case '\n':
351 i = len;
352 break;
353 default:
354 return -1;
355 }
356 }
357 *mux = tmp_mux;
358
359 return 0;
360}
361
362static void lp5523_mux_to_array(u16 led_mux, char *array)
363{
364 int i, pos = 0;
365 for (i = 0; i < LP5523_LEDS; i++)
366 pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i));
367
368 array[pos] = '\0';
369}
370
371/*--------------------------------------------------------------*/
372/* Sysfs interface */
373/*--------------------------------------------------------------*/
374
375static ssize_t show_engine_leds(struct device *dev,
376 struct device_attribute *attr,
377 char *buf, int nr)
378{
379 struct i2c_client *client = to_i2c_client(dev);
380 struct lp5523_chip *chip = i2c_get_clientdata(client);
381 char mux[LP5523_LEDS + 1];
382
383 lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux);
384
385 return sprintf(buf, "%s\n", mux);
386}
387
388#define show_leds(nr) \
389static ssize_t show_engine##nr##_leds(struct device *dev, \
390 struct device_attribute *attr, \
391 char *buf) \
392{ \
393 return show_engine_leds(dev, attr, buf, nr); \
394}
395show_leds(1)
396show_leds(2)
397show_leds(3)
398
399static ssize_t store_engine_leds(struct device *dev,
400 struct device_attribute *attr,
401 const char *buf, size_t len, int nr)
402{
403 struct i2c_client *client = to_i2c_client(dev);
404 struct lp5523_chip *chip = i2c_get_clientdata(client);
405 u16 mux = 0;
406
407 if (lp5523_mux_parse(buf, &mux, len))
408 return -EINVAL;
409
410 if (lp5523_load_mux(&chip->engines[nr - 1], mux))
411 return -EINVAL;
412
413 return len;
414}
415
416#define store_leds(nr) \
417static ssize_t store_engine##nr##_leds(struct device *dev, \
418 struct device_attribute *attr, \
419 const char *buf, size_t len) \
420{ \
421 return store_engine_leds(dev, attr, buf, len, nr); \
422}
423store_leds(1)
424store_leds(2)
425store_leds(3)
426
427static ssize_t lp5523_selftest(struct device *dev,
428 struct device_attribute *attr,
429 char *buf)
430{
431 struct i2c_client *client = to_i2c_client(dev);
432 struct lp5523_chip *chip = i2c_get_clientdata(client);
433 int i, ret, pos = 0;
434 int led = 0;
435 u8 status, adc, vdd;
436
437 mutex_lock(&chip->lock);
438
439 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
440 if (ret < 0)
441 goto fail;
442
443 /* Check that ext clock is really in use if requested */
444 if ((chip->pdata) && (chip->pdata->clock_mode == LP5523_CLOCK_EXT))
445 if ((status & LP5523_EXT_CLK_USED) == 0)
446 goto fail;
447
448 /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
449 lp5523_write(chip->client, LP5523_REG_LED_TEST_CTRL,
450 LP5523_EN_LEDTEST | 16);
451 usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
452 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
453 if (!(status & LP5523_LEDTEST_DONE))
454 usleep_range(3000, 6000); /* Was not ready. Wait little bit */
455
456 ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &vdd);
457 vdd--; /* There may be some fluctuation in measurement */
458
459 for (i = 0; i < LP5523_LEDS; i++) {
460 /* Skip non-existing channels */
461 if (chip->pdata->led_config[i].led_current == 0)
462 continue;
463
464 /* Set default current */
465 lp5523_write(chip->client,
466 LP5523_REG_LED_CURRENT_BASE + i,
467 chip->pdata->led_config[i].led_current);
468
469 lp5523_write(chip->client, LP5523_REG_LED_PWM_BASE + i, 0xff);
470 /* let current stabilize 2 - 4ms before measurements start */
471 usleep_range(2000, 4000);
472 lp5523_write(chip->client,
473 LP5523_REG_LED_TEST_CTRL,
474 LP5523_EN_LEDTEST | i);
475 /* ADC conversion time is 2.7 ms typically */
476 usleep_range(3000, 6000);
477 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
478 if (!(status & LP5523_LEDTEST_DONE))
479 usleep_range(3000, 6000);/* Was not ready. Wait. */
480 ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &adc);
481
482 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
483 pos += sprintf(buf + pos, "LED %d FAIL\n", i);
484
485 lp5523_write(chip->client, LP5523_REG_LED_PWM_BASE + i, 0x00);
486
487 /* Restore current */
488 lp5523_write(chip->client,
489 LP5523_REG_LED_CURRENT_BASE + i,
490 chip->leds[led].led_current);
491 led++;
492 }
493 if (pos == 0)
494 pos = sprintf(buf, "OK\n");
495 goto release_lock;
496fail:
497 pos = sprintf(buf, "FAIL\n");
498
499release_lock:
500 mutex_unlock(&chip->lock);
501
502 return pos;
503}
504
505static void lp5523_set_brightness(struct led_classdev *cdev,
506 enum led_brightness brightness)
507{
508 struct lp5523_led *led = cdev_to_led(cdev);
509
510 led->brightness = (u8)brightness;
511
512 schedule_work(&led->brightness_work);
513}
514
515static void lp5523_led_brightness_work(struct work_struct *work)
516{
517 struct lp5523_led *led = container_of(work,
518 struct lp5523_led,
519 brightness_work);
520 struct lp5523_chip *chip = led_to_lp5523(led);
521 struct i2c_client *client = chip->client;
522
523 mutex_lock(&chip->lock);
524
525 lp5523_write(client, LP5523_REG_LED_PWM_BASE + led->chan_nr,
526 led->brightness);
527
528 mutex_unlock(&chip->lock);
529}
530
531static int lp5523_do_store_load(struct lp5523_engine *engine,
532 const char *buf, size_t len)
533{
534 struct lp5523_chip *chip = engine_to_lp5523(engine);
535 struct i2c_client *client = chip->client;
536 int ret, nrchars, offset = 0, i = 0;
537 char c[3];
538 unsigned cmd;
539 u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
540
541 while ((offset < len - 1) && (i < LP5523_PROGRAM_LENGTH)) {
542 /* separate sscanfs because length is working only for %s */
543 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
544 ret = sscanf(c, "%2x", &cmd);
545 if (ret != 1)
546 goto fail;
547 pattern[i] = (u8)cmd;
548
549 offset += nrchars;
550 i++;
551 }
552
553 /* Each instruction is 16bit long. Check that length is even */
554 if (i % 2)
555 goto fail;
556
557 mutex_lock(&chip->lock);
558
559 ret = lp5523_load_program(engine, pattern);
560 mutex_unlock(&chip->lock);
561
562 if (ret) {
563 dev_err(&client->dev, "failed loading pattern\n");
564 return ret;
565 }
566
567 return len;
568fail:
569 dev_err(&client->dev, "wrong pattern format\n");
570 return -EINVAL;
571}
572
573static ssize_t store_engine_load(struct device *dev,
574 struct device_attribute *attr,
575 const char *buf, size_t len, int nr)
576{
577 struct i2c_client *client = to_i2c_client(dev);
578 struct lp5523_chip *chip = i2c_get_clientdata(client);
579 return lp5523_do_store_load(&chip->engines[nr - 1], buf, len);
580}
581
582#define store_load(nr) \
583static ssize_t store_engine##nr##_load(struct device *dev, \
584 struct device_attribute *attr, \
585 const char *buf, size_t len) \
586{ \
587 return store_engine_load(dev, attr, buf, len, nr); \
588}
589store_load(1)
590store_load(2)
591store_load(3)
592
593static ssize_t show_engine_mode(struct device *dev,
594 struct device_attribute *attr,
595 char *buf, int nr)
596{
597 struct i2c_client *client = to_i2c_client(dev);
598 struct lp5523_chip *chip = i2c_get_clientdata(client);
599 switch (chip->engines[nr - 1].mode) {
600 case LP5523_CMD_RUN:
601 return sprintf(buf, "run\n");
602 case LP5523_CMD_LOAD:
603 return sprintf(buf, "load\n");
604 case LP5523_CMD_DISABLED:
605 return sprintf(buf, "disabled\n");
606 default:
607 return sprintf(buf, "disabled\n");
608 }
609}
610
611#define show_mode(nr) \
612static ssize_t show_engine##nr##_mode(struct device *dev, \
613 struct device_attribute *attr, \
614 char *buf) \
615{ \
616 return show_engine_mode(dev, attr, buf, nr); \
617}
618show_mode(1)
619show_mode(2)
620show_mode(3)
621
622static ssize_t store_engine_mode(struct device *dev,
623 struct device_attribute *attr,
624 const char *buf, size_t len, int nr)
625{
626 struct i2c_client *client = to_i2c_client(dev);
627 struct lp5523_chip *chip = i2c_get_clientdata(client);
628 struct lp5523_engine *engine = &chip->engines[nr - 1];
629 mutex_lock(&chip->lock);
630
631 if (!strncmp(buf, "run", 3))
632 lp5523_set_mode(engine, LP5523_CMD_RUN);
633 else if (!strncmp(buf, "load", 4))
634 lp5523_set_mode(engine, LP5523_CMD_LOAD);
635 else if (!strncmp(buf, "disabled", 8))
636 lp5523_set_mode(engine, LP5523_CMD_DISABLED);
637
638 mutex_unlock(&chip->lock);
639 return len;
640}
641
642#define store_mode(nr) \
643static ssize_t store_engine##nr##_mode(struct device *dev, \
644 struct device_attribute *attr, \
645 const char *buf, size_t len) \
646{ \
647 return store_engine_mode(dev, attr, buf, len, nr); \
648}
649store_mode(1)
650store_mode(2)
651store_mode(3)
652
653static ssize_t show_max_current(struct device *dev,
654 struct device_attribute *attr,
655 char *buf)
656{
657 struct led_classdev *led_cdev = dev_get_drvdata(dev);
658 struct lp5523_led *led = cdev_to_led(led_cdev);
659
660 return sprintf(buf, "%d\n", led->max_current);
661}
662
663static ssize_t show_current(struct device *dev,
664 struct device_attribute *attr,
665 char *buf)
666{
667 struct led_classdev *led_cdev = dev_get_drvdata(dev);
668 struct lp5523_led *led = cdev_to_led(led_cdev);
669
670 return sprintf(buf, "%d\n", led->led_current);
671}
672
673static ssize_t store_current(struct device *dev,
674 struct device_attribute *attr,
675 const char *buf, size_t len)
676{
677 struct led_classdev *led_cdev = dev_get_drvdata(dev);
678 struct lp5523_led *led = cdev_to_led(led_cdev);
679 struct lp5523_chip *chip = led_to_lp5523(led);
680 ssize_t ret;
681 unsigned long curr;
682
683 if (strict_strtoul(buf, 0, &curr))
684 return -EINVAL;
685
686 if (curr > led->max_current)
687 return -EINVAL;
688
689 mutex_lock(&chip->lock);
690 ret = lp5523_write(chip->client,
691 LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
692 (u8)curr);
693 mutex_unlock(&chip->lock);
694
695 if (ret < 0)
696 return ret;
697
698 led->led_current = (u8)curr;
699
700 return len;
701}
702
703/* led class device attributes */
704static DEVICE_ATTR(led_current, S_IRUGO | S_IWUGO, show_current, store_current);
705static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL);
706
707static struct attribute *lp5523_led_attributes[] = {
708 &dev_attr_led_current.attr,
709 &dev_attr_max_current.attr,
710 NULL,
711};
712
713static struct attribute_group lp5523_led_attribute_group = {
714 .attrs = lp5523_led_attributes
715};
716
717/* device attributes */
718static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUGO,
719 show_engine1_mode, store_engine1_mode);
720static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUGO,
721 show_engine2_mode, store_engine2_mode);
722static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUGO,
723 show_engine3_mode, store_engine3_mode);
724static DEVICE_ATTR(engine1_leds, S_IRUGO | S_IWUGO,
725 show_engine1_leds, store_engine1_leds);
726static DEVICE_ATTR(engine2_leds, S_IRUGO | S_IWUGO,
727 show_engine2_leds, store_engine2_leds);
728static DEVICE_ATTR(engine3_leds, S_IRUGO | S_IWUGO,
729 show_engine3_leds, store_engine3_leds);
730static DEVICE_ATTR(engine1_load, S_IWUGO, NULL, store_engine1_load);
731static DEVICE_ATTR(engine2_load, S_IWUGO, NULL, store_engine2_load);
732static DEVICE_ATTR(engine3_load, S_IWUGO, NULL, store_engine3_load);
733static DEVICE_ATTR(selftest, S_IRUGO, lp5523_selftest, NULL);
734
735static struct attribute *lp5523_attributes[] = {
736 &dev_attr_engine1_mode.attr,
737 &dev_attr_engine2_mode.attr,
738 &dev_attr_engine3_mode.attr,
739 &dev_attr_selftest.attr,
740 NULL
741};
742
743static struct attribute *lp5523_engine1_attributes[] = {
744 &dev_attr_engine1_load.attr,
745 &dev_attr_engine1_leds.attr,
746 NULL
747};
748
749static struct attribute *lp5523_engine2_attributes[] = {
750 &dev_attr_engine2_load.attr,
751 &dev_attr_engine2_leds.attr,
752 NULL
753};
754
755static struct attribute *lp5523_engine3_attributes[] = {
756 &dev_attr_engine3_load.attr,
757 &dev_attr_engine3_leds.attr,
758 NULL
759};
760
761static const struct attribute_group lp5523_group = {
762 .attrs = lp5523_attributes,
763};
764
765static const struct attribute_group lp5523_engine_group[] = {
766 {.attrs = lp5523_engine1_attributes },
767 {.attrs = lp5523_engine2_attributes },
768 {.attrs = lp5523_engine3_attributes },
769};
770
771static int lp5523_register_sysfs(struct i2c_client *client)
772{
773 struct device *dev = &client->dev;
774 int ret;
775
776 ret = sysfs_create_group(&dev->kobj, &lp5523_group);
777 if (ret < 0)
778 return ret;
779
780 return 0;
781}
782
783static void lp5523_unregister_sysfs(struct i2c_client *client)
784{
785 struct lp5523_chip *chip = i2c_get_clientdata(client);
786 struct device *dev = &client->dev;
787 int i;
788
789 sysfs_remove_group(&dev->kobj, &lp5523_group);
790
791 for (i = 0; i < ARRAY_SIZE(chip->engines); i++)
792 if (chip->engines[i].mode == LP5523_CMD_LOAD)
793 sysfs_remove_group(&dev->kobj, &lp5523_engine_group[i]);
794
795 for (i = 0; i < chip->num_leds; i++)
796 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
797 &lp5523_led_attribute_group);
798}
799
800/*--------------------------------------------------------------*/
801/* Set chip operating mode */
802/*--------------------------------------------------------------*/
803static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode)
804{
805 /* engine to chip */
806 struct lp5523_chip *chip = engine_to_lp5523(engine);
807 struct i2c_client *client = chip->client;
808 struct device *dev = &client->dev;
809 int ret = 0;
810
811 /* if in that mode already do nothing, except for run */
812 if (mode == engine->mode && mode != LP5523_CMD_RUN)
813 return 0;
814
815 if (mode == LP5523_CMD_RUN) {
816 ret = lp5523_run_program(engine);
817 } else if (mode == LP5523_CMD_LOAD) {
818 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
819 lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
820
821 ret = sysfs_create_group(&dev->kobj, engine->attributes);
822 if (ret)
823 return ret;
824 } else if (mode == LP5523_CMD_DISABLED) {
825 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
826 }
827
828 /* remove load attribute from sysfs if not in load mode */
829 if (engine->mode == LP5523_CMD_LOAD && mode != LP5523_CMD_LOAD)
830 sysfs_remove_group(&dev->kobj, engine->attributes);
831
832 engine->mode = mode;
833
834 return ret;
835}
836
837/*--------------------------------------------------------------*/
838/* Probe, Attach, Remove */
839/*--------------------------------------------------------------*/
840static int __init lp5523_init_engine(struct lp5523_engine *engine, int id)
841{
842 if (id < 1 || id > LP5523_ENGINES)
843 return -1;
844 engine->id = id;
845 engine->engine_mask = LP5523_ENG_MASK_BASE >> SHIFT_MASK(id);
846 engine->prog_page = id - 1;
847 engine->mux_page = id + 2;
848 engine->attributes = &lp5523_engine_group[id - 1];
849
850 return 0;
851}
852
853static int __init lp5523_init_led(struct lp5523_led *led, struct device *dev,
854 int chan, struct lp5523_platform_data *pdata)
855{
856 char name[32];
857 int res;
858
859 if (chan >= LP5523_LEDS)
860 return -EINVAL;
861
862 if (pdata->led_config[chan].led_current) {
863 led->led_current = pdata->led_config[chan].led_current;
864 led->max_current = pdata->led_config[chan].max_current;
865 led->chan_nr = pdata->led_config[chan].chan_nr;
866
867 if (led->chan_nr >= LP5523_LEDS) {
868 dev_err(dev, "Use channel numbers between 0 and %d\n",
869 LP5523_LEDS - 1);
870 return -EINVAL;
871 }
872
873 snprintf(name, 32, "lp5523:channel%d", chan);
874
875 led->cdev.name = name;
876 led->cdev.brightness_set = lp5523_set_brightness;
877 res = led_classdev_register(dev, &led->cdev);
878 if (res < 0) {
879 dev_err(dev, "couldn't register led on channel %d\n",
880 chan);
881 return res;
882 }
883 res = sysfs_create_group(&led->cdev.dev->kobj,
884 &lp5523_led_attribute_group);
885 if (res < 0) {
886 dev_err(dev, "couldn't register current attribute\n");
887 led_classdev_unregister(&led->cdev);
888 return res;
889 }
890 } else {
891 led->led_current = 0;
892 }
893 return 0;
894}
895
896static struct i2c_driver lp5523_driver;
897
898static int lp5523_probe(struct i2c_client *client,
899 const struct i2c_device_id *id)
900{
901 struct lp5523_chip *chip;
902 struct lp5523_platform_data *pdata;
903 int ret, i, led;
904
905 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
906 if (!chip)
907 return -ENOMEM;
908
909 i2c_set_clientdata(client, chip);
910 chip->client = client;
911
912 pdata = client->dev.platform_data;
913
914 if (!pdata) {
915 dev_err(&client->dev, "no platform data\n");
916 ret = -EINVAL;
917 goto fail1;
918 }
919
920 mutex_init(&chip->lock);
921
922 chip->pdata = pdata;
923
924 if (pdata->setup_resources) {
925 ret = pdata->setup_resources();
926 if (ret < 0)
927 goto fail1;
928 }
929
930 if (pdata->enable) {
931 pdata->enable(0);
932 usleep_range(1000, 2000); /* Keep enable down at least 1ms */
933 pdata->enable(1);
934 usleep_range(1000, 2000); /* 500us abs min. */
935 }
936
937 lp5523_write(client, LP5523_REG_RESET, 0xff);
938 usleep_range(10000, 20000); /*
939 * Exact value is not available. 10 - 20ms
940 * appears to be enough for reset.
941 */
942 ret = lp5523_detect(client);
943 if (ret)
944 goto fail2;
945
946 dev_info(&client->dev, "LP5523 Programmable led chip found\n");
947
948 /* Initialize engines */
949 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) {
950 ret = lp5523_init_engine(&chip->engines[i], i + 1);
951 if (ret) {
952 dev_err(&client->dev, "error initializing engine\n");
953 goto fail2;
954 }
955 }
956 ret = lp5523_configure(client);
957 if (ret < 0) {
958 dev_err(&client->dev, "error configuring chip\n");
959 goto fail2;
960 }
961
962 /* Initialize leds */
963 chip->num_channels = pdata->num_channels;
964 chip->num_leds = 0;
965 led = 0;
966 for (i = 0; i < pdata->num_channels; i++) {
967 /* Do not initialize channels that are not connected */
968 if (pdata->led_config[i].led_current == 0)
969 continue;
970
971 ret = lp5523_init_led(&chip->leds[led], &client->dev, i, pdata);
972 if (ret) {
973 dev_err(&client->dev, "error initializing leds\n");
974 goto fail3;
975 }
976 chip->num_leds++;
977
978 chip->leds[led].id = led;
979 /* Set LED current */
980 lp5523_write(client,
981 LP5523_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr,
982 chip->leds[led].led_current);
983
984 INIT_WORK(&(chip->leds[led].brightness_work),
985 lp5523_led_brightness_work);
986
987 led++;
988 }
989
990 ret = lp5523_register_sysfs(client);
991 if (ret) {
992 dev_err(&client->dev, "registering sysfs failed\n");
993 goto fail3;
994 }
995 return ret;
996fail3:
997 for (i = 0; i < chip->num_leds; i++) {
998 led_classdev_unregister(&chip->leds[i].cdev);
999 cancel_work_sync(&chip->leds[i].brightness_work);
1000 }
1001fail2:
1002 if (pdata->enable)
1003 pdata->enable(0);
1004 if (pdata->release_resources)
1005 pdata->release_resources();
1006fail1:
1007 kfree(chip);
1008 return ret;
1009}
1010
1011static int lp5523_remove(struct i2c_client *client)
1012{
1013 struct lp5523_chip *chip = i2c_get_clientdata(client);
1014 int i;
1015
1016 lp5523_unregister_sysfs(client);
1017
1018 for (i = 0; i < chip->num_leds; i++) {
1019 led_classdev_unregister(&chip->leds[i].cdev);
1020 cancel_work_sync(&chip->leds[i].brightness_work);
1021 }
1022
1023 if (chip->pdata->enable)
1024 chip->pdata->enable(0);
1025 if (chip->pdata->release_resources)
1026 chip->pdata->release_resources();
1027 kfree(chip);
1028 return 0;
1029}
1030
1031static const struct i2c_device_id lp5523_id[] = {
1032 { "lp5523", 0 },
1033 { }
1034};
1035
1036MODULE_DEVICE_TABLE(i2c, lp5523_id);
1037
1038static struct i2c_driver lp5523_driver = {
1039 .driver = {
1040 .name = "lp5523",
1041 },
1042 .probe = lp5523_probe,
1043 .remove = lp5523_remove,
1044 .id_table = lp5523_id,
1045};
1046
1047static int __init lp5523_init(void)
1048{
1049 int ret;
1050
1051 ret = i2c_add_driver(&lp5523_driver);
1052
1053 if (ret < 0)
1054 printk(KERN_ALERT "Adding lp5523 driver failed\n");
1055
1056 return ret;
1057}
1058
1059static void __exit lp5523_exit(void)
1060{
1061 i2c_del_driver(&lp5523_driver);
1062}
1063
1064module_init(lp5523_init);
1065module_exit(lp5523_exit);
1066
1067MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
1068MODULE_DESCRIPTION("LP5523 LED engine");
1069MODULE_LICENSE("GPL");
diff --git a/drivers/leds/leds-net5501.c b/drivers/leds/leds-net5501.c
index 3063f591f0dc..1739557a9038 100644
--- a/drivers/leds/leds-net5501.c
+++ b/drivers/leds/leds-net5501.c
@@ -92,3 +92,5 @@ unmap:
92} 92}
93 93
94arch_initcall(soekris_init); 94arch_initcall(soekris_init);
95
96MODULE_LICENSE("GPL");
diff --git a/drivers/leds/leds-ss4200.c b/drivers/leds/leds-ss4200.c
index a688293abd0b..614ebebaaa28 100644
--- a/drivers/leds/leds-ss4200.c
+++ b/drivers/leds/leds-ss4200.c
@@ -102,6 +102,7 @@ static struct dmi_system_id __initdata nas_led_whitelist[] = {
102 DMI_MATCH(DMI_PRODUCT_VERSION, "1.00.00") 102 DMI_MATCH(DMI_PRODUCT_VERSION, "1.00.00")
103 } 103 }
104 }, 104 },
105 {}
105}; 106};
106 107
107/* 108/*
diff --git a/drivers/leds/ledtrig-timer.c b/drivers/leds/ledtrig-timer.c
index 82b77bd482ff..b09bcbeade9c 100644
--- a/drivers/leds/ledtrig-timer.c
+++ b/drivers/leds/ledtrig-timer.c
@@ -12,73 +12,25 @@
12 */ 12 */
13 13
14#include <linux/module.h> 14#include <linux/module.h>
15#include <linux/jiffies.h>
16#include <linux/kernel.h> 15#include <linux/kernel.h>
17#include <linux/init.h> 16#include <linux/init.h>
18#include <linux/list.h>
19#include <linux/spinlock.h>
20#include <linux/device.h> 17#include <linux/device.h>
21#include <linux/sysdev.h>
22#include <linux/timer.h>
23#include <linux/ctype.h> 18#include <linux/ctype.h>
24#include <linux/leds.h> 19#include <linux/leds.h>
25#include <linux/slab.h>
26#include "leds.h" 20#include "leds.h"
27 21
28struct timer_trig_data {
29 int brightness_on; /* LED brightness during "on" period.
30 * (LED_OFF < brightness_on <= LED_FULL)
31 */
32 unsigned long delay_on; /* milliseconds on */
33 unsigned long delay_off; /* milliseconds off */
34 struct timer_list timer;
35};
36
37static void led_timer_function(unsigned long data)
38{
39 struct led_classdev *led_cdev = (struct led_classdev *) data;
40 struct timer_trig_data *timer_data = led_cdev->trigger_data;
41 unsigned long brightness;
42 unsigned long delay;
43
44 if (!timer_data->delay_on || !timer_data->delay_off) {
45 led_set_brightness(led_cdev, LED_OFF);
46 return;
47 }
48
49 brightness = led_get_brightness(led_cdev);
50 if (!brightness) {
51 /* Time to switch the LED on. */
52 brightness = timer_data->brightness_on;
53 delay = timer_data->delay_on;
54 } else {
55 /* Store the current brightness value to be able
56 * to restore it when the delay_off period is over.
57 */
58 timer_data->brightness_on = brightness;
59 brightness = LED_OFF;
60 delay = timer_data->delay_off;
61 }
62
63 led_set_brightness(led_cdev, brightness);
64
65 mod_timer(&timer_data->timer, jiffies + msecs_to_jiffies(delay));
66}
67
68static ssize_t led_delay_on_show(struct device *dev, 22static ssize_t led_delay_on_show(struct device *dev,
69 struct device_attribute *attr, char *buf) 23 struct device_attribute *attr, char *buf)
70{ 24{
71 struct led_classdev *led_cdev = dev_get_drvdata(dev); 25 struct led_classdev *led_cdev = dev_get_drvdata(dev);
72 struct timer_trig_data *timer_data = led_cdev->trigger_data;
73 26
74 return sprintf(buf, "%lu\n", timer_data->delay_on); 27 return sprintf(buf, "%lu\n", led_cdev->blink_delay_on);
75} 28}
76 29
77static ssize_t led_delay_on_store(struct device *dev, 30static ssize_t led_delay_on_store(struct device *dev,
78 struct device_attribute *attr, const char *buf, size_t size) 31 struct device_attribute *attr, const char *buf, size_t size)
79{ 32{
80 struct led_classdev *led_cdev = dev_get_drvdata(dev); 33 struct led_classdev *led_cdev = dev_get_drvdata(dev);
81 struct timer_trig_data *timer_data = led_cdev->trigger_data;
82 int ret = -EINVAL; 34 int ret = -EINVAL;
83 char *after; 35 char *after;
84 unsigned long state = simple_strtoul(buf, &after, 10); 36 unsigned long state = simple_strtoul(buf, &after, 10);
@@ -88,21 +40,7 @@ static ssize_t led_delay_on_store(struct device *dev,
88 count++; 40 count++;
89 41
90 if (count == size) { 42 if (count == size) {
91 if (timer_data->delay_on != state) { 43 led_blink_set(led_cdev, &state, &led_cdev->blink_delay_off);
92 /* the new value differs from the previous */
93 timer_data->delay_on = state;
94
95 /* deactivate previous settings */
96 del_timer_sync(&timer_data->timer);
97
98 /* try to activate hardware acceleration, if any */
99 if (!led_cdev->blink_set ||
100 led_cdev->blink_set(led_cdev,
101 &timer_data->delay_on, &timer_data->delay_off)) {
102 /* no hardware acceleration, blink via timer */
103 mod_timer(&timer_data->timer, jiffies + 1);
104 }
105 }
106 ret = count; 44 ret = count;
107 } 45 }
108 46
@@ -113,16 +51,14 @@ static ssize_t led_delay_off_show(struct device *dev,
113 struct device_attribute *attr, char *buf) 51 struct device_attribute *attr, char *buf)
114{ 52{
115 struct led_classdev *led_cdev = dev_get_drvdata(dev); 53 struct led_classdev *led_cdev = dev_get_drvdata(dev);
116 struct timer_trig_data *timer_data = led_cdev->trigger_data;
117 54
118 return sprintf(buf, "%lu\n", timer_data->delay_off); 55 return sprintf(buf, "%lu\n", led_cdev->blink_delay_off);
119} 56}
120 57
121static ssize_t led_delay_off_store(struct device *dev, 58static ssize_t led_delay_off_store(struct device *dev,
122 struct device_attribute *attr, const char *buf, size_t size) 59 struct device_attribute *attr, const char *buf, size_t size)
123{ 60{
124 struct led_classdev *led_cdev = dev_get_drvdata(dev); 61 struct led_classdev *led_cdev = dev_get_drvdata(dev);
125 struct timer_trig_data *timer_data = led_cdev->trigger_data;
126 int ret = -EINVAL; 62 int ret = -EINVAL;
127 char *after; 63 char *after;
128 unsigned long state = simple_strtoul(buf, &after, 10); 64 unsigned long state = simple_strtoul(buf, &after, 10);
@@ -132,21 +68,7 @@ static ssize_t led_delay_off_store(struct device *dev,
132 count++; 68 count++;
133 69
134 if (count == size) { 70 if (count == size) {
135 if (timer_data->delay_off != state) { 71 led_blink_set(led_cdev, &led_cdev->blink_delay_on, &state);
136 /* the new value differs from the previous */
137 timer_data->delay_off = state;
138
139 /* deactivate previous settings */
140 del_timer_sync(&timer_data->timer);
141
142 /* try to activate hardware acceleration, if any */
143 if (!led_cdev->blink_set ||
144 led_cdev->blink_set(led_cdev,
145 &timer_data->delay_on, &timer_data->delay_off)) {
146 /* no hardware acceleration, blink via timer */
147 mod_timer(&timer_data->timer, jiffies + 1);
148 }
149 }
150 ret = count; 72 ret = count;
151 } 73 }
152 74
@@ -158,60 +80,34 @@ static DEVICE_ATTR(delay_off, 0644, led_delay_off_show, led_delay_off_store);
158 80
159static void timer_trig_activate(struct led_classdev *led_cdev) 81static void timer_trig_activate(struct led_classdev *led_cdev)
160{ 82{
161 struct timer_trig_data *timer_data;
162 int rc; 83 int rc;
163 84
164 timer_data = kzalloc(sizeof(struct timer_trig_data), GFP_KERNEL); 85 led_cdev->trigger_data = NULL;
165 if (!timer_data)
166 return;
167
168 timer_data->brightness_on = led_get_brightness(led_cdev);
169 if (timer_data->brightness_on == LED_OFF)
170 timer_data->brightness_on = led_cdev->max_brightness;
171 led_cdev->trigger_data = timer_data;
172
173 init_timer(&timer_data->timer);
174 timer_data->timer.function = led_timer_function;
175 timer_data->timer.data = (unsigned long) led_cdev;
176 86
177 rc = device_create_file(led_cdev->dev, &dev_attr_delay_on); 87 rc = device_create_file(led_cdev->dev, &dev_attr_delay_on);
178 if (rc) 88 if (rc)
179 goto err_out; 89 return;
180 rc = device_create_file(led_cdev->dev, &dev_attr_delay_off); 90 rc = device_create_file(led_cdev->dev, &dev_attr_delay_off);
181 if (rc) 91 if (rc)
182 goto err_out_delayon; 92 goto err_out_delayon;
183 93
184 /* If there is hardware support for blinking, start one 94 led_cdev->trigger_data = (void *)1;
185 * user friendly blink rate chosen by the driver.
186 */
187 if (led_cdev->blink_set)
188 led_cdev->blink_set(led_cdev,
189 &timer_data->delay_on, &timer_data->delay_off);
190 95
191 return; 96 return;
192 97
193err_out_delayon: 98err_out_delayon:
194 device_remove_file(led_cdev->dev, &dev_attr_delay_on); 99 device_remove_file(led_cdev->dev, &dev_attr_delay_on);
195err_out:
196 led_cdev->trigger_data = NULL;
197 kfree(timer_data);
198} 100}
199 101
200static void timer_trig_deactivate(struct led_classdev *led_cdev) 102static void timer_trig_deactivate(struct led_classdev *led_cdev)
201{ 103{
202 struct timer_trig_data *timer_data = led_cdev->trigger_data; 104 if (led_cdev->trigger_data) {
203 unsigned long on = 0, off = 0;
204
205 if (timer_data) {
206 device_remove_file(led_cdev->dev, &dev_attr_delay_on); 105 device_remove_file(led_cdev->dev, &dev_attr_delay_on);
207 device_remove_file(led_cdev->dev, &dev_attr_delay_off); 106 device_remove_file(led_cdev->dev, &dev_attr_delay_off);
208 del_timer_sync(&timer_data->timer);
209 kfree(timer_data);
210 } 107 }
211 108
212 /* If there is hardware support for blinking, stop it */ 109 /* Stop blinking */
213 if (led_cdev->blink_set) 110 led_brightness_set(led_cdev, LED_OFF);
214 led_cdev->blink_set(led_cdev, &on, &off);
215} 111}
216 112
217static struct led_trigger timer_led_trigger = { 113static struct led_trigger timer_led_trigger = {
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-21 06:05:22 -0500