ledtrig-morse/src/ledtrig_morse.c

   1 /*
   2  *  LED Morse Trigger
   3  *
   4  *  Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
   5  *
   6  *  This file was based on: drivers/led/ledtrig-timer.c
   7  *      Copyright 2005-2006 Openedhand Ltd.
   8  *      Author: Richard Purdie <rpurdie@openedhand.com>
   9  *
  10  *  also based on the patch '[PATCH] 2.5.59 morse code panics' posted
  11  *  in the LKML by Tomas Szepe at Thu, 30 Jan 2003
  12  *      Copyright (C) 2002 Andrew Rodland <arodland@noln.com>
  13  *      Copyright (C) 2003 Tomas Szepe <szepe@pinerecords.com>
  14  *
  15  *  This program is free software; you can redistribute it and/or modify it
  16  *  under the terms of the GNU General Public License version 2 as published
  17  *  by the Free Software Foundation.
  18  *
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/kernel.h>
  23 #include <linux/init.h>
  24 #include <linux/slab.h>
  25 #include <linux/timer.h>
  26 #include <linux/sched.h>
  27 #include <linux/leds.h>
  28 #include <linux/reboot.h>
  29 #include <linux/ctype.h>
  30
  31 #define MORSE_DELAY_BASE        (HZ/2)
  32
  33 #define MORSE_STATE_BLINK_START 0
  34 #define MORSE_STATE_BLINK_STOP  1
  35
  36 #define MORSE_DIT_LEN   1
  37 #define MORSE_DAH_LEN   3
  38 #define MORSE_SPACE_LEN 7
  39
  40 struct morse_trig_data {
  41         unsigned long delay;
  42         char *msg;
  43
  44         unsigned char morse;
  45         unsigned char state;
  46         char *msgpos;
  47         struct timer_list timer;
  48 };
  49
  50 const unsigned char morsetable[] = {
  51         0122, 0, 0310, 0, 0, 0163,                              /* "#$%&' */
  52         055, 0155, 0, 0, 0163, 0141, 0152, 0051,                /* ()*+,-./ */
  53         077, 076, 074, 070, 060, 040, 041, 043, 047, 057,       /* 0-9 */
  54         0107, 0125, 0, 0061, 0, 0114, 0,                        /* :;<=>?@ */
  55         006, 021, 025, 011, 002, 024, 013, 020, 004,            /* A-I */
  56         036, 015, 022, 007, 005, 017, 026, 033, 012,            /* J-R */
  57         010, 003, 014, 030, 016, 031, 035, 023,                 /* S-Z */
  58         0, 0, 0, 0, 0154                                        /* [\]^_ */
  59 };
  60
  61 static inline unsigned char tomorse(char c) {
  62         if (c >= 'a' && c <= 'z')
  63                 c = c - 'a' + 'A';
  64         if (c >= '"' && c <= '_') {
  65                 return morsetable[c - '"'];
  66         } else
  67                 return 0;
  68 }
  69
  70 static inline unsigned long dit_len(struct morse_trig_data *morse_data)
  71 {
  72         return MORSE_DIT_LEN*morse_data->delay;
  73 }
  74
  75 static inline unsigned long dah_len(struct morse_trig_data *morse_data)
  76 {
  77         return MORSE_DAH_LEN*morse_data->delay;
  78 }
  79
  80 static inline unsigned long space_len(struct morse_trig_data *morse_data)
  81 {
  82         return MORSE_SPACE_LEN*morse_data->delay;
  83 }
  84
  85 static void morse_timer_function(unsigned long data)
  86 {
  87         struct led_classdev *led_cdev = (struct led_classdev *)data;
  88         struct morse_trig_data *morse_data = led_cdev->trigger_data;
  89         unsigned long brightness = LED_OFF;
  90         unsigned long delay = 0;
  91
  92         if (!morse_data->msg)
  93                 goto set_led;
  94
  95         switch (morse_data->state) {
  96         case MORSE_STATE_BLINK_START:
  97                 /* Starting a new blink.  We have a valid code in morse. */
  98                 delay = (morse_data->morse & 001) ? dah_len(morse_data):
  99                         dit_len(morse_data);
 100                 brightness = LED_FULL;
 101                 morse_data->state = MORSE_STATE_BLINK_STOP;
 102                 morse_data->morse >>= 1;
 103                 break;
 104         case MORSE_STATE_BLINK_STOP:
 105                 /* Coming off of a blink. */
 106                 morse_data->state = MORSE_STATE_BLINK_START;
 107
 108                 if (morse_data->morse > 1) {
 109                         /* Not done yet, just a one-dit pause. */
 110                         delay = dit_len(morse_data);
 111                         break;
 112                 }
 113
 114                 /* Get a new char, figure out how much space. */
 115                 /* First time through */
 116                 if (!morse_data->msgpos)
 117                         morse_data->msgpos = (char *)morse_data->msg;
 118
 119                 if (!*morse_data->msgpos) {
 120                         /* Repeating */
 121                         morse_data->msgpos = (char *)morse_data->msg;
 122                         delay = space_len(morse_data);
 123                 } else {
 124                         /* Inter-letter space */
 125                         delay = dah_len(morse_data);
 126                 }
 127
 128                 if (!(morse_data->morse = tomorse(*morse_data->msgpos))) {
 129                         delay = space_len(morse_data);
 130                         /* And get us back here */
 131                         morse_data->state = MORSE_STATE_BLINK_STOP;
 132                 }
 133                 morse_data->msgpos++;
 134                 break;
 135         }
 136
 137         mod_timer(&morse_data->timer, jiffies + msecs_to_jiffies(delay));
 138
 139 set_led:
 140         led_set_brightness(led_cdev, brightness);
 141 }
 142
 143 static ssize_t _morse_delay_show(struct led_classdev *led_cdev, char *buf)
 144 {
 145         struct morse_trig_data *morse_data = led_cdev->trigger_data;
 146
 147         sprintf(buf, "%lu\n", morse_data->delay);
 148
 149         return strlen(buf) + 1;
 150 }
 151
 152 static ssize_t _morse_delay_store(struct led_classdev *led_cdev,
 153                 const char *buf, size_t size)
 154 {
 155         struct morse_trig_data *morse_data = led_cdev->trigger_data;
 156         char *after;
 157         unsigned long state = simple_strtoul(buf, &after, 10);
 158         size_t count = after - buf;
 159         int ret = -EINVAL;
 160
 161         if (*after && isspace(*after))
 162                 count++;
 163
 164         if (count == size) {
 165                 morse_data->delay = state;
 166                 mod_timer(&morse_data->timer, jiffies + 1);
 167                 ret = count;
 168         }
 169
 170         return ret;
 171 }
 172
 173 static ssize_t _morse_msg_show(struct led_classdev *led_cdev, char *buf)
 174 {
 175         struct morse_trig_data *morse_data = led_cdev->trigger_data;
 176
 177         if (!morse_data->msg)
 178                 sprintf(buf, "<none>\n");
 179         else
 180                 sprintf(buf, "%s\n", morse_data->msg);
 181
 182         return strlen(buf) + 1;
 183 }
 184
 185 static ssize_t _morse_msg_store(struct led_classdev *led_cdev,
 186                 const char *buf, size_t size)
 187 {
 188         struct morse_trig_data *morse_data = led_cdev->trigger_data;
 189         char *m;
 190
 191         m = kmalloc(size, GFP_KERNEL);
 192         if (!m)
 193                 return -ENOMEM;
 194
 195         memcpy(m,buf,size);
 196         m[size]='\0';
 197
 198         if (morse_data->msg)
 199                 kfree(morse_data->msg);
 200
 201         morse_data->msg = m;
 202         morse_data->msgpos = NULL;
 203         morse_data->state = MORSE_STATE_BLINK_STOP;
 204
 205         mod_timer(&morse_data->timer, jiffies + 1);
 206
 207         return size;
 208 }
 209
 210 static ssize_t morse_delay_show(struct device *dev,
 211                 struct device_attribute *attr, char *buf)
 212 {
 213         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 214
 215         return _morse_delay_show(led_cdev, buf);
 216 }
 217
 218 static ssize_t morse_delay_store(struct device *dev,
 219                 struct device_attribute *attr, const char *buf, size_t size)
 220 {
 221         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 222
 223         return _morse_delay_store(led_cdev, buf, size);
 224 }
 225
 226 static ssize_t morse_msg_show(struct device *dev,
 227                 struct device_attribute *attr, char *buf)
 228 {
 229         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 230
 231         return _morse_msg_show(led_cdev, buf);
 232 }
 233
 234 static ssize_t morse_msg_store(struct device *dev,
 235                 struct device_attribute *attr, const char *buf, size_t size)
 236 {
 237         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 238
 239         return _morse_msg_store(led_cdev, buf, size);
 240 }
 241
 242 static DEVICE_ATTR(delay, 0644, morse_delay_show, morse_delay_store);
 243 static DEVICE_ATTR(message, 0644, morse_msg_show, morse_msg_store);
 244
 245 #define led_device_create_file(leddev, attr) \
 246         device_create_file(leddev->dev, &dev_attr_ ## attr)
 247 #define led_device_remove_file(leddev, attr) \
 248         device_remove_file(leddev->dev, &dev_attr_ ## attr)
 249
 250 static void morse_trig_activate(struct led_classdev *led_cdev)
 251 {
 252         struct morse_trig_data *morse_data;
 253         int rc;
 254
 255         morse_data = kzalloc(sizeof(*morse_data), GFP_KERNEL);
 256         if (!morse_data)
 257                 return;
 258
 259         morse_data->delay = MORSE_DELAY_BASE;
 260         init_timer(&morse_data->timer);
 261         morse_data->timer.function = morse_timer_function;
 262         morse_data->timer.data = (unsigned long)led_cdev;
 263
 264         rc = led_device_create_file(led_cdev, delay);
 265         if (rc) goto err;
 266
 267         rc = led_device_create_file(led_cdev, message);
 268         if (rc) goto err_delay;
 269
 270         led_cdev->trigger_data = morse_data;
 271
 272         return;
 273
 274 err_delay:
 275         led_device_remove_file(led_cdev, delay);
 276 err:
 277         kfree(morse_data);
 278 }
 279
 280 static void morse_trig_deactivate(struct led_classdev *led_cdev)
 281 {
 282         struct morse_trig_data *morse_data = led_cdev->trigger_data;
 283
 284         if (!morse_data)
 285                 return;
 286
 287         led_device_remove_file(led_cdev, message);
 288         led_device_remove_file(led_cdev, delay);
 289
 290         del_timer_sync(&morse_data->timer);
 291         if (morse_data->msg)
 292                 kfree(morse_data->msg);
 293
 294         kfree(morse_data);
 295 }
 296
 297 static struct led_trigger morse_led_trigger = {
 298         .name           = "morse",
 299         .activate       = morse_trig_activate,
 300         .deactivate     = morse_trig_deactivate,
 301 };
 302
 303 static int __init morse_trig_init(void)
 304 {
 305         return led_trigger_register(&morse_led_trigger);
 306 }
 307
 308 static void __exit morse_trig_exit(void)
 309 {
 310         led_trigger_unregister(&morse_led_trigger);
 311 }
 312
 313 module_init(morse_trig_init);
 314 module_exit(morse_trig_exit);
 315
 316 MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
 317 MODULE_DESCRIPTION("Morse LED trigger");
 318 MODULE_LICENSE("GPL");
 319