leds: Add driver for Sunfire UltraSPARC server LEDs.
[linux-2.6.git] / drivers / leds / leds-pca9532.c
1 /*
2  * pca9532.c - 16-bit Led dimmer
3  *
4  * Copyright (C) 2008 Riku Voipio <riku.voipio@movial.fi>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; version 2 of the License.
9  *
10  * Datasheet: http://www.nxp.com/acrobat/datasheets/PCA9532_3.pdf
11  *
12  */
13
14 #include <linux/module.h>
15 #include <linux/i2c.h>
16 #include <linux/leds.h>
17 #include <linux/input.h>
18 #include <linux/mutex.h>
19 #include <linux/leds-pca9532.h>
20
21 static const unsigned short normal_i2c[] = { /*0x60,*/ I2C_CLIENT_END};
22 I2C_CLIENT_INSMOD_1(pca9532);
23
24 #define PCA9532_REG_PSC(i) (0x2+(i)*2)
25 #define PCA9532_REG_PWM(i) (0x3+(i)*2)
26 #define PCA9532_REG_LS0  0x6
27 #define LED_REG(led) ((led>>2)+PCA9532_REG_LS0)
28 #define LED_NUM(led) (led & 0x3)
29
30 #define ldev_to_led(c)       container_of(c, struct pca9532_led, ldev)
31
32 struct pca9532_data {
33         struct i2c_client *client;
34         struct pca9532_led leds[16];
35         struct mutex update_lock;
36         struct input_dev    *idev;
37         u8 pwm[2];
38         u8 psc[2];
39 };
40
41 static int pca9532_probe(struct i2c_client *client,
42         const struct i2c_device_id *id);
43 static int pca9532_remove(struct i2c_client *client);
44
45 static const struct i2c_device_id pca9532_id[] = {
46         { "pca9532", 0 },
47         { }
48 };
49
50 MODULE_DEVICE_TABLE(i2c, pca9532_id);
51
52 static struct i2c_driver pca9532_driver = {
53         .driver = {
54                 .name   = "pca9532",
55         },
56         .probe  = pca9532_probe,
57         .remove = pca9532_remove,
58         .id_table = pca9532_id,
59 };
60
61 /* We have two pwm/blinkers, but 16 possible leds to drive. Additionaly,
62  * the clever Thecus people are using one pwm to drive the beeper. So,
63  * as a compromise we average one pwm to the values requested by all
64  * leds that are not ON/OFF.
65  * */
66 static int pca9532_setpwm(struct i2c_client *client, int pwm, int blink,
67         enum led_brightness value)
68 {
69         int a = 0, b = 0, i = 0;
70         struct pca9532_data *data = i2c_get_clientdata(client);
71         for (i = 0; i < 16; i++) {
72                 if (data->leds[i].type == PCA9532_TYPE_LED &&
73                         data->leds[i].state == PCA9532_PWM0+pwm) {
74                                 a++;
75                                 b += data->leds[i].ldev.brightness;
76                 }
77         }
78         if (a == 0) {
79                 dev_err(&client->dev,
80                 "fear of division by zero %d/%d, wanted %d\n",
81                         b, a, value);
82                 return -EINVAL;
83         }
84         b = b/a;
85         if (b > 0xFF)
86                 return -EINVAL;
87         mutex_lock(&data->update_lock);
88         data->pwm[pwm] = b;
89         i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(pwm),
90                 data->pwm[pwm]);
91         data->psc[pwm] = blink;
92         i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(pwm),
93                 data->psc[pwm]);
94         mutex_unlock(&data->update_lock);
95         return 0;
96 }
97
98 /* Set LED routing */
99 static void pca9532_setled(struct pca9532_led *led)
100 {
101         struct i2c_client *client = led->client;
102         struct pca9532_data *data = i2c_get_clientdata(client);
103         char reg;
104
105         mutex_lock(&data->update_lock);
106         reg = i2c_smbus_read_byte_data(client, LED_REG(led->id));
107         /* zero led bits */
108         reg = reg & ~(0x3<<LED_NUM(led->id)*2);
109         /* set the new value */
110         reg = reg | (led->state << LED_NUM(led->id)*2);
111         i2c_smbus_write_byte_data(client, LED_REG(led->id), reg);
112         mutex_unlock(&data->update_lock);
113 }
114
115 static void pca9532_set_brightness(struct led_classdev *led_cdev,
116         enum led_brightness value)
117 {
118         int err = 0;
119         struct pca9532_led *led = ldev_to_led(led_cdev);
120
121         if (value == LED_OFF)
122                 led->state = PCA9532_OFF;
123         else if (value == LED_FULL)
124                 led->state = PCA9532_ON;
125         else {
126                 led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */
127                 err = pca9532_setpwm(led->client, 0, 0, value);
128                 if (err)
129                         return; /* XXX: led api doesn't allow error code? */
130         }
131         pca9532_setled(led);
132 }
133
134 static int pca9532_set_blink(struct led_classdev *led_cdev,
135         unsigned long *delay_on, unsigned long *delay_off)
136 {
137         struct pca9532_led *led = ldev_to_led(led_cdev);
138         struct i2c_client *client = led->client;
139         int psc;
140
141         if (*delay_on == 0 && *delay_off == 0) {
142         /* led subsystem ask us for a blink rate */
143                 *delay_on  = 1000;
144                 *delay_off = 1000;
145         }
146         if (*delay_on != *delay_off || *delay_on > 1690 || *delay_on < 6)
147                 return -EINVAL;
148
149         /* Thecus specific: only use PSC/PWM 0 */
150         psc = (*delay_on * 152-1)/1000;
151         return pca9532_setpwm(client, 0, psc, led_cdev->brightness);
152 }
153
154 int pca9532_event(struct input_dev *dev, unsigned int type, unsigned int code,
155         int value)
156 {
157         struct pca9532_data *data = input_get_drvdata(dev);
158
159         if (type != EV_SND && (code != SND_BELL || code != SND_TONE))
160                 return -1;
161
162         /* XXX: allow different kind of beeps with psc/pwm modifications */
163         if (value > 1 && value < 32767)
164                 data->pwm[1] = 127;
165         else
166                 data->pwm[1] = 0;
167
168         dev_info(&dev->dev, "setting beep to %d \n", data->pwm[1]);
169         mutex_lock(&data->update_lock);
170         i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(1),
171                 data->pwm[1]);
172         mutex_unlock(&data->update_lock);
173
174         return 0;
175 }
176
177 static int pca9532_configure(struct i2c_client *client,
178         struct pca9532_data *data, struct pca9532_platform_data *pdata)
179 {
180         int i, err = 0;
181
182         for (i = 0; i < 2; i++) {
183                 data->pwm[i] = pdata->pwm[i];
184                 data->psc[i] = pdata->psc[i];
185                 i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(i),
186                         data->pwm[i]);
187                 i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(i),
188                         data->psc[i]);
189         }
190
191         for (i = 0; i < 16; i++) {
192                 struct pca9532_led *led = &data->leds[i];
193                 struct pca9532_led *pled = &pdata->leds[i];
194                 led->client = client;
195                 led->id = i;
196                 led->type = pled->type;
197                 switch (led->type) {
198                 case PCA9532_TYPE_NONE:
199                         break;
200                 case PCA9532_TYPE_LED:
201                         led->state = pled->state;
202                         led->name =  pled->name;
203                         led->ldev.name = led->name;
204                         led->ldev.brightness = LED_OFF;
205                         led->ldev.brightness_set = pca9532_set_brightness;
206                         led->ldev.blink_set = pca9532_set_blink;
207                         if (led_classdev_register(&client->dev,
208                                 &led->ldev) < 0)        {
209                                 dev_err(&client->dev,
210                                         "couldn't register LED %s\n",
211                                         led->name);
212                                 goto exit;
213                         }
214                         pca9532_setled(led);
215                         break;
216                 case PCA9532_TYPE_N2100_BEEP:
217                         BUG_ON(data->idev);
218                         led->state = PCA9532_PWM1;
219                         pca9532_setled(led);
220                         data->idev = input_allocate_device();
221                         if (data->idev == NULL) {
222                                 err = -ENOMEM;
223                                 goto exit;
224                         }
225                         data->idev->name = pled->name;
226                         data->idev->phys = "i2c/pca9532";
227                         data->idev->id.bustype = BUS_HOST;
228                         data->idev->id.vendor  = 0x001f;
229                         data->idev->id.product = 0x0001;
230                         data->idev->id.version = 0x0100;
231                         data->idev->evbit[0] = BIT_MASK(EV_SND);
232                         data->idev->sndbit[0] = BIT_MASK(SND_BELL) |
233                                                 BIT_MASK(SND_TONE);
234                         data->idev->event = pca9532_event;
235                         input_set_drvdata(data->idev, data);
236                         err = input_register_device(data->idev);
237                         if (err) {
238                                 input_free_device(data->idev);
239                                 data->idev = NULL;
240                                 goto exit;
241                         }
242                         break;
243                 }
244         }
245         return 0;
246
247 exit:
248         if (i > 0)
249                 for (i = i - 1; i >= 0; i--)
250                         switch (data->leds[i].type) {
251                         case PCA9532_TYPE_NONE:
252                                 break;
253                         case PCA9532_TYPE_LED:
254                                 led_classdev_unregister(&data->leds[i].ldev);
255                                 break;
256                         case PCA9532_TYPE_N2100_BEEP:
257                                 if (data->idev != NULL) {
258                                         input_unregister_device(data->idev);
259                                         input_free_device(data->idev);
260                                         data->idev = NULL;
261                                 }
262                                 break;
263                         }
264
265         return err;
266
267 }
268
269 static int pca9532_probe(struct i2c_client *client,
270         const struct i2c_device_id *id)
271 {
272         struct pca9532_data *data = i2c_get_clientdata(client);
273         struct pca9532_platform_data *pca9532_pdata = client->dev.platform_data;
274
275         if (!i2c_check_functionality(client->adapter,
276                 I2C_FUNC_SMBUS_BYTE_DATA))
277                 return -EIO;
278
279         data = kzalloc(sizeof(struct pca9532_data), GFP_KERNEL);
280         if (!data)
281                 return -ENOMEM;
282
283         dev_info(&client->dev, "setting platform data\n");
284         i2c_set_clientdata(client, data);
285         data->client = client;
286         mutex_init(&data->update_lock);
287
288         if (pca9532_pdata == NULL)
289                 return -EIO;
290
291         pca9532_configure(client, data, pca9532_pdata);
292         return 0;
293
294 }
295
296 static int pca9532_remove(struct i2c_client *client)
297 {
298         struct pca9532_data *data = i2c_get_clientdata(client);
299         int i;
300         for (i = 0; i < 16; i++)
301                 switch (data->leds[i].type) {
302                 case PCA9532_TYPE_NONE:
303                         break;
304                 case PCA9532_TYPE_LED:
305                         led_classdev_unregister(&data->leds[i].ldev);
306                         break;
307                 case PCA9532_TYPE_N2100_BEEP:
308                         if (data->idev != NULL) {
309                                 input_unregister_device(data->idev);
310                                 input_free_device(data->idev);
311                                 data->idev = NULL;
312                         }
313                         break;
314                 }
315
316         kfree(data);
317         i2c_set_clientdata(client, NULL);
318         return 0;
319 }
320
321 static int __init pca9532_init(void)
322 {
323         return i2c_add_driver(&pca9532_driver);
324 }
325
326 static void __exit pca9532_exit(void)
327 {
328         i2c_del_driver(&pca9532_driver);
329 }
330
331 MODULE_AUTHOR("Riku Voipio <riku.voipio@movial.fi>");
332 MODULE_LICENSE("GPL");
333 MODULE_DESCRIPTION("PCA 9532 LED dimmer");
334
335 module_init(pca9532_init);
336 module_exit(pca9532_exit);
337