1 /*-
2 * ----------------------------------------------------------------------------
3 * "THE BEER-WARE LICENSE" (Revision 42):
4 * <phk@FreeBSD.org> wrote this file. As long as you retain this notice you
5 * can do whatever you want with this stuff. If we meet some day, and you think
6 * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
7 * ----------------------------------------------------------------------------
8 *
9 * $FreeBSD: head/sys/dev/led/led.c 247008 2013-02-19 19:25:50Z mav $
10 */
11
12 #include <sys/param.h>
13 #include <sys/conf.h>
14 #include <sys/kernel.h>
15 #include <sys/systm.h>
16 #include <sys/limits.h>
17 #include <sys/malloc.h>
18 #include <sys/ctype.h>
19 #include <sys/sbuf.h>
20 #include <sys/queue.h>
21 #include <dev/misc/led/led.h>
22 #include <sys/uio.h>
23 #include <sys/device.h>
24 #include <sys/module.h>
25
26 struct ledsc {
27 LIST_ENTRY(ledsc) list;
28 char *name;
29 void *private;
30 int unit;
31 led_t *func;
32 struct cdev *dev;
33 struct sbuf *spec;
34 char *str;
35 char *ptr;
36 int count;
37 time_t last_second;
38 };
39
40 static struct unrhdr *led_unit;
41 static struct lock led_lock;
42 static struct lock led_lock2;
43 static LIST_HEAD(, ledsc) led_list = LIST_HEAD_INITIALIZER(led_list);
44 static struct callout led_ch;
45 static int blinkers = 0;
46
47 static MALLOC_DEFINE(M_LED, "LED", "LED driver");
48
49 static void
led_timeout(void * p)50 led_timeout(void *p)
51 {
52 struct ledsc *sc;
53
54 lockmgr(&led_lock, LK_EXCLUSIVE);
55 LIST_FOREACH(sc, &led_list, list) {
56 if (sc->ptr == NULL)
57 continue;
58 if (sc->count > 0) {
59 sc->count--;
60 continue;
61 }
62 if (*sc->ptr == '.') {
63 sc->ptr = NULL;
64 blinkers--;
65 continue;
66 } else if (*sc->ptr == 'U' || *sc->ptr == 'u') {
67 if (sc->last_second == time_second)
68 continue;
69 sc->last_second = time_second;
70 sc->func(sc->private, *sc->ptr == 'U');
71 } else if (*sc->ptr >= 'a' && *sc->ptr <= 'j') {
72 sc->func(sc->private, 0);
73 sc->count = (*sc->ptr & 0xf) - 1;
74 } else if (*sc->ptr >= 'A' && *sc->ptr <= 'J') {
75 sc->func(sc->private, 1);
76 sc->count = (*sc->ptr & 0xf) - 1;
77 }
78 sc->ptr++;
79 if (*sc->ptr == '\0')
80 sc->ptr = sc->str;
81 }
82 if (blinkers > 0)
83 callout_reset(&led_ch, hz / 10, led_timeout, p);
84 lockmgr(&led_lock, LK_RELEASE);
85 }
86
87 static int
led_state(struct ledsc * sc,struct sbuf ** sb,int state)88 led_state(struct ledsc *sc, struct sbuf **sb, int state)
89 {
90 struct sbuf *sb2 = NULL;
91
92 sb2 = sc->spec;
93 sc->spec = *sb;
94 if (*sb != NULL) {
95 sc->str = sbuf_data(*sb);
96 if (sc->ptr == NULL) {
97 blinkers++;
98 callout_reset(&led_ch, hz / 10, led_timeout, NULL);
99 }
100 sc->ptr = sc->str;
101 } else {
102 sc->str = NULL;
103 if (sc->ptr != NULL)
104 blinkers--;
105 sc->ptr = NULL;
106 sc->func(sc->private, state);
107 }
108 sc->count = 0;
109 *sb = sb2;
110 return(0);
111 }
112
113 static int
led_parse(const char * s,struct sbuf ** sb,int * state)114 led_parse(const char *s, struct sbuf **sb, int *state)
115 {
116 int i, error;
117
118 /*
119 * Handle "on" and "off" immediately so people can flash really
120 * fast from userland if they want to
121 */
122 if (*s == '0' || *s == '1') {
123 *state = *s & 1;
124 return (0);
125 }
126
127 *state = 0;
128 *sb = sbuf_new_auto();
129 if (*sb == NULL)
130 return (ENOMEM);
131 switch(s[0]) {
132 /*
133 * Flash, default is 100msec/100msec.
134 * 'f2' sets 200msec/200msec etc.
135 */
136 case 'f':
137 if (s[1] >= '1' && s[1] <= '9')
138 i = s[1] - '1';
139 else
140 i = 0;
141 sbuf_printf(*sb, "%c%c", 'A' + i, 'a' + i);
142 break;
143 /*
144 * Digits, flashes out numbers.
145 * 'd12' becomes -__________-_-______________________________
146 */
147 case 'd':
148 for(s++; *s; s++) {
149 if (!isdigit(*s))
150 continue;
151 i = *s - '0';
152 if (i == 0)
153 i = 10;
154 for (; i > 1; i--)
155 sbuf_cat(*sb, "Aa");
156 sbuf_cat(*sb, "Aj");
157 }
158 sbuf_cat(*sb, "jj");
159 break;
160 /*
161 * String, roll your own.
162 * 'a-j' gives "off" for n/10 sec.
163 * 'A-J' gives "on" for n/10 sec.
164 * no delay before repeat
165 * 'sAaAbBa' becomes _-_--__-
166 */
167 case 's':
168 for(s++; *s; s++) {
169 if ((*s >= 'a' && *s <= 'j') ||
170 (*s >= 'A' && *s <= 'J') ||
171 *s == 'U' || *s <= 'u' ||
172 *s == '.')
173 sbuf_bcat(*sb, s, 1);
174 }
175 break;
176 /*
177 * Morse.
178 * '.' becomes _-
179 * '-' becomes _---
180 * ' ' becomes __
181 * '\n' becomes ____
182 * 1sec pause between repeats
183 * '... --- ...' -> _-_-_-___---_---_---___-_-_-__________
184 */
185 case 'm':
186 for(s++; *s; s++) {
187 if (*s == '.')
188 sbuf_cat(*sb, "aA");
189 else if (*s == '-')
190 sbuf_cat(*sb, "aC");
191 else if (*s == ' ')
192 sbuf_cat(*sb, "b");
193 else if (*s == '\n')
194 sbuf_cat(*sb, "d");
195 }
196 sbuf_cat(*sb, "j");
197 break;
198 default:
199 sbuf_delete(*sb);
200 return (EINVAL);
201 }
202 error = sbuf_finish(*sb);
203 if (error != 0 || sbuf_len(*sb) == 0) {
204 *sb = NULL;
205 return (error);
206 }
207 return (0);
208 }
209
210 static int
led_open(struct dev_open_args * ap)211 led_open(struct dev_open_args *ap)
212 {
213 return (0);
214 }
215
216 static int
led_close(struct dev_close_args * ap)217 led_close(struct dev_close_args *ap)
218 {
219 return (0);
220 }
221
222 static int
led_write(struct dev_write_args * ap)223 led_write(struct dev_write_args *ap)
224 {
225 struct uio *uio = ap->a_uio;
226 cdev_t dev = ap->a_head.a_dev;
227 struct ledsc *sc;
228 char *s;
229 struct sbuf *sb = NULL;
230 int error, state = 0;
231
232 if (uio->uio_resid > 512)
233 return (EINVAL);
234 s = kmalloc(uio->uio_resid + 1, M_DEVBUF, M_WAITOK);
235 s[uio->uio_resid] = '\0';
236 error = uiomove(s, uio->uio_resid, uio);
237 if (error) {
238 kfree(s, M_DEVBUF);
239 return (error);
240 }
241 error = led_parse(s, &sb, &state);
242 kfree(s, M_DEVBUF);
243 if (error)
244 return (error);
245 lockmgr(&led_lock, LK_EXCLUSIVE);
246 sc = dev->si_drv1;
247 if (sc != NULL)
248 error = led_state(sc, &sb, state);
249 lockmgr(&led_lock, LK_RELEASE);
250 if (sb != NULL)
251 sbuf_delete(sb);
252 return (error);
253 }
254
255 int
led_set(char const * name,char const * cmd)256 led_set(char const *name, char const *cmd)
257 {
258 struct ledsc *sc;
259 struct sbuf *sb = NULL;
260 int error, state = 0;
261
262 error = led_parse(cmd, &sb, &state);
263 if (error)
264 return (error);
265 lockmgr(&led_lock, LK_EXCLUSIVE);
266 LIST_FOREACH(sc, &led_list, list) {
267 if (strcmp(sc->name, name) == 0)
268 break;
269 }
270 if (sc != NULL)
271 error = led_state(sc, &sb, state);
272 else
273 error = ENOENT;
274 lockmgr(&led_lock, LK_RELEASE);
275 if (sb != NULL)
276 sbuf_delete(sb);
277 return (0);
278 }
279
280 static struct dev_ops led_ops = {
281 { "LED", 0, D_MPSAFE },
282 .d_open = led_open,
283 .d_close = led_close,
284 .d_write = led_write,
285 };
286
287 struct cdev *
led_create(led_t * func,void * priv,char const * name)288 led_create(led_t *func, void *priv, char const *name)
289 {
290
291 return (led_create_state(func, priv, name, 0));
292 }
293 struct cdev *
led_create_state(led_t * func,void * priv,char const * name,int state)294 led_create_state(led_t *func, void *priv, char const *name, int state)
295 {
296 struct ledsc *sc;
297
298 sc = kmalloc(sizeof *sc, M_LED, M_WAITOK | M_ZERO);
299
300 lockmgr(&led_lock2, LK_EXCLUSIVE);
301 sc->name = kstrdup(name, M_LED);
302 sc->unit = alloc_unr(led_unit);
303 sc->private = priv;
304 sc->func = func;
305 sc->dev = make_dev(&led_ops, sc->unit,
306 UID_ROOT, GID_WHEEL, 0600, "led/%s", name);
307 lockmgr(&led_lock2, LK_RELEASE);
308
309 lockmgr(&led_lock, LK_EXCLUSIVE);
310 sc->dev->si_drv1 = sc;
311 LIST_INSERT_HEAD(&led_list, sc, list);
312 sc->func(sc->private, state != 0);
313 lockmgr(&led_lock, LK_RELEASE);
314
315 return (sc->dev);
316 }
317
318 void
led_destroy(struct cdev * dev)319 led_destroy(struct cdev *dev)
320 {
321 struct ledsc *sc;
322
323 lockmgr(&led_lock, LK_EXCLUSIVE);
324 sc = dev->si_drv1;
325 dev->si_drv1 = NULL;
326 if (sc->ptr != NULL)
327 blinkers--;
328 LIST_REMOVE(sc, list);
329 if (LIST_EMPTY(&led_list))
330 callout_stop(&led_ch);
331 lockmgr(&led_lock, LK_RELEASE);
332
333 lockmgr(&led_lock2, LK_EXCLUSIVE);
334 free_unr(led_unit, sc->unit);
335 destroy_dev(dev);
336 if (sc->spec != NULL)
337 sbuf_delete(sc->spec);
338 kfree(sc->name, M_LED);
339 kfree(sc, M_LED);
340 lockmgr(&led_lock2, LK_RELEASE);
341 }
342
343 static int
led_drvinit(void)344 led_drvinit(void)
345 {
346
347 led_unit = new_unrhdr(0, INT_MAX, NULL);
348 lockinit(&led_lock, "LED lock", 0, LK_CANRECURSE);
349 lockinit(&led_lock2, "LED lock2", 0, LK_CANRECURSE);
350 callout_init_mp(&led_ch);
351 return 0;
352 }
353
354 static int
led_drvexit(void)355 led_drvexit(void)
356 {
357 int error = 0;
358
359 lockmgr(&led_lock, LK_EXCLUSIVE);
360 /* A minimal sanity check, before unloading. */
361 if (!LIST_EMPTY(&led_list))
362 error = EINVAL;
363 lockmgr(&led_lock, LK_RELEASE);
364 if (error == 0) {
365 callout_cancel(&led_ch);
366 delete_unrhdr(led_unit);
367 lockuninit(&led_lock);
368 lockuninit(&led_lock2);
369 }
370 return error;
371 }
372
373 static int
led_modevent(module_t mod,int type,void * unused)374 led_modevent(module_t mod, int type, void *unused)
375 {
376 int error;
377
378 switch (type) {
379 case MOD_LOAD:
380 error = led_drvinit();
381 break;
382 case MOD_UNLOAD:
383 error = led_drvexit();
384 break;
385 default:
386 error = EINVAL;
387 break;
388 }
389 return error;
390 }
391
392 static moduledata_t led_mod = {
393 "led",
394 led_modevent,
395 0
396 };
397 DECLARE_MODULE(led, led_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE);
398 MODULE_VERSION(led, 1);
399