projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add vlynq support
[openwrt.git] / target / linux / linux-2.4 / patches / ar7 / 002-led_driver.patch
1 diff -urN linux.old/drivers/char/avalanche_led/gpio.c linux.dev/drivers/char/avalanche_led/gpio.c
2 --- linux.old/drivers/char/avalanche_led/gpio.c 1970-01-01 01:00:00.000000000 +0100
3 +++ linux.dev/drivers/char/avalanche_led/gpio.c 2005-07-12 03:13:02.696541072 +0200
4 @@ -0,0 +1,382 @@
5 +#include <linux/kernel.h>
6 +#include <asm/uaccess.h>
7 +#include <linux/spinlock.h>
8 +#include <linux/proc_fs.h>
9 +#include <linux/fs.h>
10 +#include <linux/timer.h>
11 +#include <linux/module.h>
12 +
13 +#include <asm/ar7/tnetd73xx_err.h>
14 +#include <asm/ar7/tnetd73xx_misc.h>
15 +#include <asm/ar7/ledapp.h>
16 +
17 +#define TRUE 1
18 +#define FALSE 0
19 +
20 +#if defined CONFIG_AR7WRD || defined CONFIG_AR7RD
21 +
22 +#define AR7_RESET_FILE "led_mod/ar7reset"
23 +#define AR7_VERSION_FILE "led_mod/hardware_version"
24 +#define AR7_RESET_GPIO 11
25 +#define RESET_POLL_TIME 1
26 +#define RESET_HOLD_TIME 4
27 +#define NO_OF_LEDS
28 +
29 +static struct proc_dir_entry *reset_file;
30 +static int res_state = 0;
31 +static int count;
32 +static struct timer_list *pTimer = NULL;
33 +static ssize_t proc_read_reset_fops(struct file *filp,
34 + char *buf,size_t count , loff_t *offp);
35 +
36 +static ssize_t proc_read_hwversion_fops(struct file *filp,
37 + char *buf,size_t count , loff_t *offp);
38 +
39 +struct file_operations reset_fops = {
40 + read: proc_read_reset_fops
41 + };
42 +struct file_operations hardware_version_fops = {
43 + read: proc_read_hwversion_fops
44 + };
45 +#endif
46 +
47 +static spinlock_t device_lock;
48 +led_reg_t temp[15];
49 +
50 +static void gpio_led_on( unsigned long param )
51 +{
52 + unsigned int flags;
53 +
54 + spin_lock_irqsave(&device_lock, flags);
55 +
56 + tnetd73xx_gpio_out(param,FALSE);
57 + spin_unlock_irqrestore(&device_lock, flags);
58 +}
59 +
60 +static void gpio_led_off ( unsigned long param )
61 +{
62 + unsigned int flags = 0x00;
63 +
64 + spin_lock_irqsave(&device_lock, flags);
65 +
66 + tnetd73xx_gpio_out(param,TRUE);
67 + spin_unlock_irqrestore(&device_lock, flags);
68 +}
69 +
70 +static void gpio_led_init( unsigned long param)
71 +{
72 + tnetd73xx_gpio_ctrl(param,GPIO_PIN,GPIO_OUTPUT_PIN);
73 +}
74 +
75 +static void board_gpio_reset(void)
76 +{
77 + /* Initialize the link mask */
78 + device_lock = SPIN_LOCK_UNLOCKED;
79 + return;
80 +}
81 +
82 +#if defined CONFIG_AR7WRD || defined CONFIG_AR7RD
83 +
84 +static ssize_t proc_read_hwversion_fops(struct file *filp, char *buf,
85 + size_t count, loff_t *offp)
86 +{
87 + char line[8];
88 + int len = 0;
89 + if( *offp != 0 )
90 + return 0;
91 +
92 + len = sprintf(line, "%d%d.%d%d%d%d\n", tnetd73xx_gpio_in(20),
93 + tnetd73xx_gpio_in(21), tnetd73xx_gpio_in(22),
94 + tnetd73xx_gpio_in(23), tnetd73xx_gpio_in(24),
95 + tnetd73xx_gpio_in(25));
96 +
97 + copy_to_user(buf, line, len);
98 + *offp = len;
99 + return len;
100 +}
101 +
102 +static ssize_t proc_read_reset_fops(struct file *filp,
103 + char *buf,size_t count , loff_t *offp)
104 +{
105 + char * pdata = NULL;
106 + char line[3];
107 + int len = 0;
108 + if( *offp != 0 )
109 + return 0;
110 +
111 + pdata = buf;
112 + len = sprintf(line,"%d\n", res_state );
113 +//wwzh
114 +// res_state = 0;
115 + copy_to_user(buf,line,len );
116 + *offp = len;
117 + return len;
118 +}
119 +
120 +static void reset_timer_func(unsigned long data)
121 +{
122 +//wwzh
123 +#if 0
124 + count = (tnetd73xx_gpio_in(AR7_RESET_GPIO) == 0) ? count + 1: 0;
125 + if( count >= RESET_HOLD_TIME/RESET_POLL_TIME )
126 +#endif
127 + if (tnetd73xx_gpio_in(AR7_RESET_GPIO) == 0)
128 + res_state = 1;
129 + else
130 + res_state = 0;
131 + pTimer->expires = jiffies + HZ*RESET_POLL_TIME;
132 + add_timer (pTimer);
133 + return;
134 +}
135 +
136 +static void hardware_version_init(void)
137 +{
138 + static struct proc_dir_entry *hardware_version_file;
139 + hardware_version_file = create_proc_entry(AR7_VERSION_FILE, 0777, NULL);
140 + if(hardware_version_file == NULL)
141 + return;
142 +
143 + hardware_version_file->owner = THIS_MODULE;
144 + hardware_version_file->proc_fops = &hardware_version_fops;
145 +
146 + tnetd73xx_gpio_ctrl(20,GPIO_PIN,GPIO_INPUT_PIN);
147 + tnetd73xx_gpio_ctrl(21,GPIO_PIN,GPIO_INPUT_PIN);
148 + tnetd73xx_gpio_ctrl(22,GPIO_PIN,GPIO_INPUT_PIN);
149 + tnetd73xx_gpio_ctrl(23,GPIO_PIN,GPIO_INPUT_PIN);
150 + tnetd73xx_gpio_ctrl(24,GPIO_PIN,GPIO_INPUT_PIN);
151 + tnetd73xx_gpio_ctrl(25,GPIO_PIN,GPIO_INPUT_PIN);
152 +
153 + return;
154 +}
155 +
156 +static void reset_init(void)
157 +{
158 + /* Create board reset proc file */
159 + reset_file = create_proc_entry( AR7_RESET_FILE, 0777, NULL);
160 + if( reset_file == NULL)
161 + goto reset_file;
162 + reset_file->owner = THIS_MODULE;
163 + reset_file->proc_fops = &reset_fops;
164 +
165 + /* Initialise GPIO 11 for input */
166 + tnetd73xx_gpio_ctrl(AR7_RESET_GPIO,GPIO_PIN,GPIO_INPUT_PIN);
167 +
168 + /* Create a timer which fires every seconds */
169 + pTimer = kmalloc(sizeof(struct timer_list),GFP_KERNEL);
170 + init_timer( pTimer );
171 + pTimer->function = reset_timer_func;
172 + pTimer->data = 0;
173 + /* Start the timer */
174 + reset_timer_func(0);
175 + return ;
176 +
177 + reset_file:
178 + remove_proc_entry("AR7_RESET_FILE",NULL);
179 + return;
180 +}
181 +#endif
182 +/*************wwzh****************/
183 +#if 1
184 +extern unsigned int sys_mod_state;
185 +extern unsigned int wan_mod_state;
186 +extern unsigned int wlan_mod_state;
187 +void sys_led_init(void)
188 +{
189 + tnetd73xx_gpio_ctrl(4, GPIO_PIN, GPIO_OUTPUT_PIN);
190 + tnetd73xx_gpio_ctrl(5, GPIO_PIN, GPIO_OUTPUT_PIN);
191 + tnetd73xx_gpio_ctrl(8, GPIO_PIN, GPIO_OUTPUT_PIN);
192 +
193 + tnetd73xx_gpio_out(4, FALSE);
194 + tnetd73xx_gpio_out(5, TRUE);
195 + tnetd73xx_gpio_out(8, TRUE);
196 +
197 +
198 + sys_mod_state = 2;
199 +
200 +}
201 +void wan_led_init(void)
202 +{
203 +
204 + tnetd73xx_gpio_ctrl(2, GPIO_PIN, GPIO_OUTPUT_PIN);
205 + tnetd73xx_gpio_ctrl(3, GPIO_PIN, GPIO_OUTPUT_PIN);
206 +
207 + tnetd73xx_gpio_out(2, FALSE);
208 + tnetd73xx_gpio_out(3, FALSE);
209 +
210 + wan_mod_state = 1;
211 +}
212 +//wwzh wireless
213 +#if 0
214 +void wlan_led_init(void)
215 +{
216 + //unsigned long i = 0;
217 + tnetd73xx_gpio_ctrl(12, GPIO_PIN, GPIO_OUTPUT_PIN);
218 + tnetd73xx_gpio_ctrl(13, GPIO_PIN, GPIO_OUTPUT_PIN);
219 +
220 + tnetd73xx_gpio_out(12, FALSE);
221 + tnetd73xx_gpio_out(13, TRUE);
222 + //for (i = 0; i < 0x20000000; i++);
223 + wlan_mod_state = 1;
224 +}
225 +#endif
226 +
227 +#endif
228 +/*************end ****************/
229 +
230 +void board_gpio_init(void)
231 +{
232 +
233 + board_gpio_reset();
234 +/**************wwzh*************/
235 + sys_led_init();
236 + wan_led_init();
237 +
238 + //junzhao 2004.3.15
239 + hardware_version_init();
240 +
241 + //wlan_led_init();
242 +
243 + /* Register Device MAX_LED_ID + 1 for reset to factory default */
244 + temp[0].param = 0;
245 + temp[0].init = reset_init;
246 + temp[0].onfunc = 0;
247 + temp[0].offfunc = 0;
248 + register_led_drv( MAX_LED_ID + 1 , &temp[0]);
249 +//wwzh for wireless led
250 +#if 1
251 + /* Register led 12 WiFi 6 */
252 + temp[1].param = 6;
253 + temp[1].init = gpio_led_init;
254 + temp[1].onfunc = gpio_led_on;
255 + temp[1].offfunc = gpio_led_off;
256 + register_led_drv( 12 , &temp[1]);
257 +
258 +#endif
259 +
260 +#if 0
261 +/**************end ************/
262 +#if defined(CONFIG_AR5D01)
263 + /* Register led 1 GPIO0 */
264 + temp[0].param = GPIO_0;
265 + temp[0].init = gpio_led_init;
266 + temp[0].onfunc = gpio_led_on;
267 + temp[0].offfunc = gpio_led_off;
268 + register_led_drv( 1 , &temp[0]);
269 +
270 + /* Register led 2 EINT1 */
271 + temp[1].param = EINT_1;
272 + temp[1].init = gpio_led_init;
273 + temp[1].onfunc = gpio_led_on;
274 + temp[1].offfunc = gpio_led_off;
275 + register_led_drv( 2 , &temp[1]);
276 +
277 + /* Register led 5 EINT1 */
278 + temp[2].param = GPIO_1;
279 + temp[2].init = gpio_led_init;
280 + temp[2].onfunc = gpio_led_on;
281 + temp[2].offfunc = gpio_led_off;
282 + register_led_drv( 5 , &temp[2]);
283 +#endif
284 +
285 +#if defined(CONFIG_AR5W01)
286 + /* Register led 5 GPIO_1 */
287 + temp[0].param = GPIO_1;
288 + temp[0].init = gpio_led_init;
289 + temp[0].onfunc = gpio_led_on;
290 + temp[0].offfunc = gpio_led_off;
291 + register_led_drv( 5 , &temp[0]);
292 +
293 + /* Register led 7 GPIO_0 */
294 + temp[1].param = GPIO_0;
295 + temp[1].init = gpio_led_init;
296 + temp[1].onfunc = gpio_led_on;
297 + temp[1].offfunc = gpio_led_off;
298 + register_led_drv( 7 , &temp[1]);
299 +#endif
300 +
301 +//wwzh #if defined(CONFIG_AR7RD)
302 +#if defined CONFIG_AR7WRD || defined CONFIG_AR7RD
303 + /* Register led 5 Green PPPOE GPIO 13 */
304 + temp[0].param = 13;
305 + temp[0].init = gpio_led_init;
306 + temp[0].onfunc = gpio_led_on;
307 + temp[0].offfunc = gpio_led_off;
308 + register_led_drv( 5 , &temp[0]);
309 +
310 + /* Register led 7 Green USB GPIO 12 */
311 + temp[1].param = 12;
312 + temp[1].init = gpio_led_init;
313 + temp[1].onfunc = gpio_led_on;
314 + temp[1].offfunc = gpio_led_off;
315 + register_led_drv( 7 , &temp[1]);
316 +
317 + /* Register Device MAX_LED_ID + 1 for reset to factory default */
318 + temp[2].param = 0;
319 + temp[2].init = reset_init;
320 + temp[2].onfunc = 0;
321 + temp[2].offfunc = 0;
322 + register_led_drv( MAX_LED_ID + 1 , &temp[2]);
323 +
324 + /* Register led 8 RED DSL GPIO 10 */
325 + temp[3].param = 10;
326 + temp[3].init = gpio_led_init;
327 + temp[3].onfunc = gpio_led_on;
328 + temp[3].offfunc = gpio_led_off;
329 + register_led_drv( 8 , &temp[3]);
330 +
331 + /* Register led 9 RED PPPoE down GPIO 9 */
332 + temp[4].param = 9;
333 + temp[4].init = gpio_led_init;
334 + temp[4].onfunc = gpio_led_on;
335 + temp[4].offfunc = gpio_led_off;
336 + register_led_drv( 9 , &temp[4]);
337 +
338 + /* Register led 10 DSL down GPIO 8 */
339 + temp[5].param = 8;
340 + temp[5].init = gpio_led_init;
341 + temp[5].onfunc = gpio_led_on;
342 + temp[5].offfunc = gpio_led_off;
343 + register_led_drv( 10 , &temp[5]);
344 +
345 + /* Register led 11 Power GPIO 7 */
346 + temp[6].param = 7;
347 + temp[6].init = gpio_led_init;
348 + temp[6].onfunc = gpio_led_on;
349 + temp[6].offfunc = gpio_led_off;
350 + register_led_drv( 11 , &temp[6]);
351 +
352 + /* Register led 12 WiFi 6 */
353 + temp[7].param = 6;
354 + temp[7].init = gpio_led_init;
355 + temp[7].onfunc = gpio_led_on;
356 + temp[7].offfunc = gpio_led_off;
357 + register_led_drv( 12 , &temp[7]);
358 +
359 + /* Register led 13 ELINK(AA1313) GPIO 15 */
360 + temp[8].param = 15;
361 + temp[8].init = gpio_led_init;
362 + temp[8].onfunc = gpio_led_on;
363 + temp[8].offfunc = gpio_led_off;
364 + register_led_drv( 13 , &temp[8]);
365 +
366 + /* Register led 14 EACT(Y13) GPIO 16 */
367 + temp[9].param = 16;
368 + temp[9].init = gpio_led_init;
369 + temp[9].onfunc = gpio_led_on;
370 + temp[9].offfunc = gpio_led_off;
371 + register_led_drv( 14 , &temp[9]);
372 +
373 +#endif
374 +/**************wwzh**************/
375 +#endif
376 +/**************end **************/
377 + return;
378 +}
379 +
380 +
381 +
382 +
383 +
384 +
385 +
386 +
387 diff -urN linux.old/drivers/char/avalanche_led/ledmod.c linux.dev/drivers/char/avalanche_led/ledmod.c
388 --- linux.old/drivers/char/avalanche_led/ledmod.c 1970-01-01 01:00:00.000000000 +0100
389 +++ linux.dev/drivers/char/avalanche_led/ledmod.c 2005-07-12 03:12:40.675888720 +0200
390 @@ -0,0 +1,1116 @@
391 +#include <linux/config.h>
392 +#include <linux/init.h>
393 +#include <linux/kernel.h>
394 +#include <linux/proc_fs.h>
395 +#include <asm/uaccess.h>
396 +#include <linux/fs.h>
397 +#include <linux/timer.h>
398 +#include <linux/delay.h>
399 +#include <linux/spinlock.h>
400 +#include <asm/ar7/avalanche_regs.h>
401 +#include <asm/ar7/ledapp.h>
402 +#include <linux/module.h>
403 +
404 +#define LED_ON 1
405 +#define LED_OFF 2
406 +#define LED_BLINK 3
407 +#define LED_FLASH 4
408 +
409 +#define LED_BLINK_UP 5
410 +#define LED_BLINK_DOWN 6
411 +
412 +extern void avalanche_leds_init(void);
413 +
414 +/***********wwzh**************/
415 +unsigned int sys_mod_state;
416 +unsigned int wan_mod_state;
417 +unsigned int wlan_mod_state;
418 +
419 +struct timer_list *pWanTimer = NULL;
420 +struct timer_list *pWlanTimer = NULL;
421 +/***********end **************/
422 +
423 +typedef struct state_entry{
424 + unsigned char mode;
425 + unsigned char led;
426 + void (*handler)(struct state_entry *pState);
427 + unsigned long param;
428 +}state_entry_t;
429 +
430 +typedef struct mod_entry{
431 + state_entry_t *states[MAX_STATE_ID];
432 +}mod_entry_t;
433 +
434 +static mod_entry_t *modArr[MAX_MOD_ID];
435 +static struct proc_dir_entry *led_proc_dir,*led_file;
436 +
437 +/* index of the array is the led number HARDWARE SPECIFIC*/
438 +typedef struct led_data{
439 + led_reg_t *led;
440 + int state;
441 + struct timer_list *pTimer;
442 + unsigned char timer_running;
443 + unsigned long param;
444 +}led_data_t;
445 +
446 +led_data_t led_arr[MAX_LED_ID + 1];
447 +/*!!! The last device is actually being used for ar7 reset to factory default */
448 +
449 +
450 +static spinlock_t config_lock;
451 +
452 +static void board_led_link_up( state_entry_t *pState );
453 +static void board_led_link_down( state_entry_t *pState );
454 +static void board_led_activity_on( state_entry_t *pState );
455 +static void board_led_activity_off( state_entry_t *pState );
456 +static void led_timer_func(unsigned long data);
457 +
458 +extern void board_gpio_init(void);
459 +extern void uart_led_init(void);
460 +
461 +static ssize_t proc_read_led_fops(struct file *filp,
462 + char *buf,size_t count , loff_t *offp);
463 +static ssize_t proc_write_led_fops(struct file *filp,const char *buffer,
464 + size_t count , loff_t *offp);
465 +static int config_led( unsigned long y);
466 +
467 +struct file_operations led_fops = {
468 + read: proc_read_led_fops,
469 + write: proc_write_led_fops,
470 + };
471 +
472 +static int led_atoi( char *name)
473 +{
474 + int val = 0;
475 + for(;;name++)
476 + {
477 + switch(*name)
478 + {
479 + case '0'...'9':
480 + val = val*10+(*name - '0');
481 + break;
482 + default:
483 + return val;
484 + }
485 + }
486 +}
487 +
488 +static int free_memory(void)
489 +{
490 + int i, j;
491 +
492 + for( i = 0; i < MAX_MOD_ID ; i++)
493 + {
494 + if( modArr[i] != NULL )
495 + {
496 + for( j = 0; j < MAX_STATE_ID ; j++ )
497 + {
498 + if( modArr[i]->states[j] != NULL )
499 + kfree( modArr[i]->states[j]);
500 + }
501 + kfree(modArr[i]);
502 + modArr[i] = NULL;
503 + }
504 + }
505 + return 0;
506 +}
507 +
508 +static int led_on( state_entry_t *pState )
509 +{
510 + if( led_arr[pState->led].led == NULL)
511 + return -1;
512 + led_arr[pState->led].led->onfunc( led_arr[pState->led].led->param);
513 + return 0;
514 +}
515 +
516 +static int led_off( state_entry_t *pState )
517 +{
518 + if( led_arr[pState->led].led == NULL)
519 + return -1;
520 + led_arr[pState->led].led->offfunc( led_arr[pState->led].led->param);
521 + return 0;
522 +}
523 +
524 +static void board_led_link_up( state_entry_t *pState )
525 +{
526 + led_arr[pState->led].state = LED_ON;
527 + if( led_arr[pState->led].timer_running == 0 )
528 + led_on(pState);
529 + return;
530 +}
531 +
532 +static void board_led_link_down( state_entry_t *pState )
533 +{
534 + led_arr[pState->led].state = LED_OFF;
535 + if( led_arr[pState->led].timer_running == 0 )
536 + led_off(pState);
537 + return;
538 +}
539 +
540 +static void add_led_timer(state_entry_t *pState)
541 +{
542 + led_arr[pState->led].pTimer->expires = jiffies + HZ*(pState->param)/1000;
543 + led_arr[pState->led].param = pState->param;
544 + led_arr[pState->led].pTimer->data = pState;
545 + add_timer (led_arr[pState->led].pTimer);
546 +}
547 +
548 +static void board_led_activity_on(state_entry_t *pState)
549 +{
550 + if(led_arr[pState->led].timer_running == 0)
551 + {
552 + led_on(pState);
553 + add_led_timer(pState);
554 + led_arr[pState->led].timer_running = 1;
555 + led_arr[pState->led].state = LED_BLINK_UP;
556 + }
557 + else if( led_arr[pState->led].timer_running > 0xF0)
558 + {
559 + led_arr[pState->led].state = LED_BLINK_UP;
560 + led_arr[pState->led].pTimer->expires = jiffies + HZ*(pState->param)/1000;
561 + led_arr[pState->led].param = pState->param;
562 + led_arr[pState->led].pTimer->data = pState;
563 + }
564 + return;
565 +}
566 +
567 +static void board_led_activity_off(state_entry_t *pState)
568 +{
569 + if(led_arr[pState->led].timer_running == 0)
570 + {
571 + led_off(pState);
572 + add_led_timer(pState);
573 + led_arr[pState->led].timer_running = 1;
574 + led_arr[pState->led].state = LED_BLINK_UP;
575 + }
576 + else if( led_arr[pState->led].timer_running > 0xF0)
577 + {
578 + led_arr[pState->led].state = LED_BLINK_UP;
579 + led_arr[pState->led].pTimer->expires = jiffies + HZ*(pState->param)/1000;
580 + led_arr[pState->led].param = pState->param;
581 + led_arr[pState->led].pTimer->data = pState;
582 + }
583 + return;
584 +}
585 +
586 +static void board_led_link_flash(state_entry_t *pState)
587 +{
588 + if(led_on(pState))
589 + return;
590 + if(led_arr[pState->led].timer_running == 0)
591 + add_led_timer(pState);
592 + else
593 + led_arr[pState->led].param = pState->param;
594 + led_arr[pState->led].timer_running = 0xFF;
595 + led_arr[pState->led].state = LED_FLASH;
596 + return;
597 +}
598 +
599 +static void led_timer_func(unsigned long data)
600 +{
601 + state_entry_t *pState = NULL;
602 + mod_entry_t *pMod = NULL;
603 + unsigned int flags;
604 +
605 + spin_lock_irqsave(&config_lock, flags);
606 +
607 + pState = (state_entry_t *)data;
608 +
609 + if( led_arr[pState->led].state == LED_BLINK_DOWN )
610 + {
611 + led_arr[pState->led].timer_running = 0;
612 + if( pState->mode == 2 )
613 + led_arr[pState->led].state = LED_OFF;
614 + else
615 + led_arr[pState->led].state = LED_ON;
616 + }
617 + else if( led_arr[pState->led].state == LED_BLINK_UP )
618 + {
619 + led_arr[pState->led].pTimer->expires = jiffies + HZ*(led_arr[pState->led].param)/1000;
620 + led_arr[pState->led].pTimer->data = pState;
621 + add_timer (led_arr[pState->led].pTimer);
622 + if( pState->mode == 2 )
623 + {
624 + led_off(pState);
625 + led_arr[pState->led].state = LED_BLINK_DOWN;
626 + }
627 + else
628 + {
629 + led_on(pState);
630 + led_arr[pState->led].state = LED_BLINK_DOWN;
631 + }
632 + led_arr[pState->led].timer_running = 1;
633 + }
634 + else if( led_arr[pState->led].state == LED_FLASH )
635 + {
636 + led_arr[pState->led].pTimer->expires = jiffies + HZ*(led_arr[pState->led].param)/1000;
637 + led_arr[pState->led].pTimer->data = pState;
638 + add_timer (led_arr[pState->led].pTimer);
639 +
640 + if( led_arr[pState->led].timer_running == 0xFF )
641 + {
642 + led_off(pState);
643 + led_arr[pState->led].timer_running--;
644 + }
645 + else
646 + {
647 + led_on(pState);
648 + led_arr[pState->led].timer_running++;
649 + }
650 + spin_unlock_irqrestore(&config_lock, flags);
651 + return;
652 + }
653 + else if(led_arr[pState->led].state == LED_OFF)
654 + {
655 + led_off(pState);
656 + led_arr[pState->led].timer_running = 0;
657 + }
658 + else if( led_arr[pState->led].state == LED_ON )
659 + {
660 + led_on(pState);
661 + led_arr[pState->led].timer_running = 0;
662 + }
663 + spin_unlock_irqrestore(&config_lock, flags);
664 + return;
665 +}
666 +/************wwzh*****************/
667 +#if 0
668 +/************end *****************/
669 +static ssize_t proc_read_led_fops(struct file *filp,
670 + char *buf,size_t count , loff_t *offp)
671 +{
672 + char * pdata = NULL;
673 + int i = 0, j = 0, len = 0, totallen = 0;
674 + char line[255];
675 +
676 + if( *offp != 0 )
677 + return 0;
678 +
679 + pdata = buf;
680 + len += sprintf(line,"LEDS Registered for use are:");
681 + for( i = 0; i< MAX_LED_ID; i++)
682 + if( led_arr[i].led != NULL )
683 + len += sprintf(&line[len]," %d ", i );
684 + line[len++] = '\n';
685 +
686 + copy_to_user(pdata, line,len );
687 + pdata += len;
688 + totallen += len;
689 + len = 0;
690 + len = sprintf(line,"USER MODULE INFORMATION:\n");
691 + copy_to_user(pdata, line,len );
692 + pdata += len;
693 + totallen += len;
694 + len = 0;
695 + for( i = 0; i< MAX_MOD_ID; i++)
696 + {
697 + if( modArr[i] != NULL )
698 + {
699 + len = sprintf(line," Module ID = %d \n" , i);
700 + copy_to_user(pdata, line,len );
701 + pdata += len;
702 + totallen += len;
703 + len = 0;
704 + for( j = 0; j < MAX_STATE_ID; j++)
705 + {
706 + if( modArr[i]->states[j] != NULL)
707 + {
708 + len = sprintf(line ,
709 + " State = %d , Led = %d," , j , modArr[i]->states[j]->led);
710 + copy_to_user(pdata, line,len );
711 + pdata += len;
712 + totallen += len;
713 +
714 + len = 0;
715 + switch( modArr[i]->states[j]->mode )
716 + {
717 + case 1:
718 + len = sprintf(line ," Mode = OFF\n");
719 + break;
720 + case 2:
721 + len = sprintf(line ," Mode = BLINK_ON , On Time(ms) = %d\n" ,
722 + (unsigned int)modArr[i]->states[j]->param);
723 + break;
724 + case 3:
725 + len = sprintf(line ," Mode = BLINK_OFF , Off Time(ms) = %d\n" ,
726 + (unsigned int)modArr[i]->states[j]->param);
727 + break;
728 + case 4:
729 + len = sprintf(line ," Mode = ON \n");
730 + break;
731 + case 5:
732 + len = sprintf(line ," Mode = FLASH , Time Period(ms) = %d\n" ,
733 + (unsigned int)modArr[i]->states[j]->param);
734 + break;
735 + default:
736 + break;
737 +
738 + }
739 + copy_to_user(pdata, line,len );
740 + pdata += len;
741 + totallen += len;
742 +
743 + len = 0;
744 + }
745 + }
746 + }
747 + }
748 + /* Return with configuration information for LEDs */
749 + *offp = totallen;
750 + return totallen;
751 +}
752 +static ssize_t proc_write_led_fops(struct file *filp,const char *buffer,
753 + size_t count , loff_t *offp)
754 +{
755 + char *pdata = NULL, *ptemp = NULL;
756 + char line[10],temp[10];
757 + int i = 0;
758 + int mod = 0xFFFF , state = 0xFFFF;
759 + int flag = 0;
760 +
761 + /* Check if this write is for configuring stuff */
762 + if( *(int *)(buffer) == 0xFFEEDDCC )
763 + {
764 + printk("<1>proc write:Calling Configuration\n");
765 + config_led((unsigned long)(buffer + sizeof(int)) );
766 + return count;
767 + }
768 +
769 + if( count >= 10)
770 + {
771 + printk("<1>proc write:Input too long,max length = %d\n",10);
772 + return count;
773 + }
774 + memset( temp, 0x00 , 10);
775 + memset( line, 0x00 , 10);
776 + copy_from_user(line,buffer,count);
777 + line[count] = 0x00;
778 + pdata = line;
779 + ptemp = temp;
780 + while( flag == 0)
781 + {
782 + if( i > 10 )
783 + break;
784 + if( ((*pdata) >= '0' ) && ((*pdata) <= '9') )
785 + {
786 + *ptemp = *pdata ;
787 + ptemp++;
788 + }
789 + else if( (*pdata) == ',' )
790 + {
791 + *ptemp = 0x00;
792 + flag = 1;
793 + }
794 + pdata++;
795 + i++;
796 + };
797 + if( flag == 1)
798 + mod = led_atoi( temp);
799 + else
800 + return count;
801 +
802 + ptemp = temp;
803 + *ptemp = 0x00;
804 + flag = 0;
805 + while( flag == 0)
806 + {
807 + if( i > 10 )
808 + break;
809 + if( ((*pdata) >= '0' ) && ((*pdata) <= '9') )
810 + {
811 + *ptemp = *pdata ;
812 + ptemp++;
813 + }
814 + else if( (*pdata) == 0x00 )
815 + {
816 + *ptemp = 0x00;
817 + flag = 1;
818 + }
819 + pdata++;
820 + i++;
821 + };
822 + if( flag == 1)
823 + state = led_atoi( temp);
824 + else
825 + return count;
826 + if( (mod == 0xFFFF) || (state == 0xFFFF))
827 + return count;
828 + else
829 + led_operation( mod , state );
830 + return count;
831 +}
832 +
833 +/************wwzh*******************/
834 +#else
835 +
836 +#define TRUE 1
837 +#define FALSE 0
838 +#define FLICK_TIME (HZ*100/1000)
839 +static unsigned int wan_txrx_state = 0;
840 +static unsigned int wlan_txrx_state = 0;
841 +
842 +void led_operation( int mod , int state)
843 +{
844 +
845 + unsigned int flags;
846 +
847 + spin_lock_irqsave(&config_lock, flags);
848 +
849 + if( (mod >= MAX_MOD_ID) || ( state >= MAX_STATE_ID) )
850 + {
851 + spin_unlock_irqrestore(&config_lock, flags);
852 + return;
853 + }
854 + if ( modArr[mod] == NULL )
855 + {
856 + spin_unlock_irqrestore(&config_lock, flags);
857 + return;
858 + }
859 + if( modArr[mod]->states[state] == NULL )
860 + {
861 + spin_unlock_irqrestore(&config_lock, flags);
862 + return;
863 + }
864 + /* Call the function handler */
865 + modArr[mod]->states[state]->handler(modArr[mod]->states[state]);
866 +
867 + spin_unlock_irqrestore(&config_lock, flags);
868 +}
869 +
870 +static void wan_led_func(unsigned long data)
871 +{
872 + if (wan_txrx_state == 0)
873 + {
874 + tnetd73xx_gpio_out(2, TRUE);
875 + tnetd73xx_gpio_out(3, FALSE);
876 + wan_txrx_state = 1;
877 + }
878 + else
879 + {
880 + tnetd73xx_gpio_out(2, FALSE);
881 + tnetd73xx_gpio_out(3, FALSE);
882 + wan_txrx_state = 0;
883 + }
884 + pWanTimer->expires = jiffies + FLICK_TIME;
885 + add_timer(pWanTimer);
886 +}
887 +//wwzh for wireless
888 +#if 0
889 +static void wlan_led_func(unsigned long data)
890 +{
891 + if (wlan_txrx_state == 0)
892 + {
893 + tnetd73xx_gpio_out(12, TRUE);
894 + tnetd73xx_gpio_out(13, FALSE);
895 + wlan_txrx_state = 1;
896 + }
897 + else
898 + {
899 + tnetd73xx_gpio_out(12, FALSE);
900 + tnetd73xx_gpio_out(13, FALSE);
901 + wlan_txrx_state = 0;
902 +
903 + }
904 + pWlanTimer->expires = jiffies + FLICK_TIME;
905 + add_timer(pWlanTimer);
906 +}
907 +#endif
908 +
909 +void led_active(int mod, int state)
910 +{
911 + unsigned int flags = 0;
912 +
913 +//printk("mod = %d state = %d\n", mod, state);
914 + spin_lock_irqsave(&config_lock, flags);
915 + if ((mod >= 5) || (state >= 5))
916 + {
917 + spin_unlock_irqrestore(&config_lock, flags);
918 + return;
919 + }
920 +
921 + switch (mod)
922 + {
923 + case 2: /*system led */
924 + sys_mod_state = state;
925 + switch (state)
926 + {
927 + case 1:
928 + break;
929 + case 2: /*sys led flashing green */
930 + tnetd73xx_gpio_out(4, FALSE);
931 + tnetd73xx_gpio_out(5, TRUE);
932 + tnetd73xx_gpio_out(8, TRUE);
933 + break;
934 + case 3: /*sys led solid green */
935 + tnetd73xx_gpio_out(4, TRUE);
936 + tnetd73xx_gpio_out(5, TRUE);
937 + tnetd73xx_gpio_out(8, TRUE);
938 +
939 + break;
940 + case 4: /*sys fail red */
941 + tnetd73xx_gpio_out(4, TRUE);
942 + tnetd73xx_gpio_out(5, FALSE);
943 + tnetd73xx_gpio_out(8, FALSE);
944 + break;
945 + default:
946 + break;
947 + }
948 + break;
949 + case 3: /*wan led */
950 + wan_mod_state = state;
951 + switch (state)
952 + {
953 + case 1: /*no wan interface*/
954 + if (pWanTimer)
955 + {
956 + del_timer(pWanTimer);
957 + kfree(pWanTimer);
958 + pWanTimer = NULL;
959 + }
960 + tnetd73xx_gpio_out(2, FALSE);
961 + tnetd73xx_gpio_out(3, FALSE);
962 + break;
963 + case 2: /*wan connected */
964 + if (pWanTimer)
965 + {
966 + del_timer(pWanTimer);
967 + kfree(pWanTimer);
968 + pWanTimer = NULL;
969 + }
970 + tnetd73xx_gpio_out(2, TRUE);
971 + tnetd73xx_gpio_out(3, FALSE);
972 + break;
973 + case 3: /*rx/tx activity */
974 + if (pWanTimer != NULL)
975 + break;
976 +
977 + pWanTimer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
978 + init_timer(pWanTimer);
979 +
980 + pWanTimer->function = wan_led_func;
981 + pWanTimer->data = 0;
982 + pWanTimer->expires = jiffies + FLICK_TIME;
983 + tnetd73xx_gpio_out(2, FALSE);
984 + tnetd73xx_gpio_out(3, FALSE);
985 + wan_txrx_state = 0;
986 + add_timer(pWanTimer);
987 +
988 + break;
989 + case 4: /*no ipaddress */
990 + if (pWanTimer)
991 + {
992 + del_timer(pWanTimer);
993 + kfree(pWanTimer);
994 + pWanTimer = NULL;
995 + }
996 + tnetd73xx_gpio_out(2, FALSE);
997 + tnetd73xx_gpio_out(3, TRUE);
998 + break;
999 + default:
1000 + if (pWanTimer)
1001 + {
1002 + del_timer(pWanTimer);
1003 + kfree(pWanTimer);
1004 + pWanTimer = NULL;
1005 + }
1006 + break;
1007 + }
1008 + break;
1009 + //wwzh for wireless
1010 + #if 0
1011 + case 4: /*wlan led */
1012 + wlan_mod_state = state;
1013 + switch (state)
1014 + {
1015 + case 1: /* wlan off */
1016 + if (pWlanTimer)
1017 + {
1018 + del_timer(pWlanTimer);
1019 + kfree(pWlanTimer);
1020 + pWlanTimer = NULL;
1021 + }
1022 + tnetd73xx_gpio_out(12, FALSE);
1023 + tnetd73xx_gpio_out(13, FALSE);
1024 + break;
1025 + case 2: /* wlan ready */
1026 + if (pWlanTimer)
1027 + {
1028 + del_timer(pWlanTimer);
1029 + kfree(pWlanTimer);
1030 + pWlanTimer = NULL;
1031 + }
1032 + tnetd73xx_gpio_out(12, TRUE);
1033 + tnetd73xx_gpio_out(13, FALSE);
1034 + break;
1035 + case 3: /* wlan rx/tx activity */
1036 + if (pWlanTimer != NULL)
1037 + break;
1038 +
1039 + pWlanTimer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
1040 + init_timer(pWlanTimer);
1041 +
1042 + pWlanTimer->function = wlan_led_func;
1043 + pWlanTimer->data = 0;
1044 + pWlanTimer->expires = jiffies + FLICK_TIME;
1045 + tnetd73xx_gpio_out(12, FALSE);
1046 + tnetd73xx_gpio_out(13, FALSE);
1047 + wlan_txrx_state = 0;
1048 + add_timer(pWlanTimer);
1049 +
1050 + break;
1051 + default:
1052 + if (pWlanTimer)
1053 + {
1054 + del_timer(pWlanTimer);
1055 + kfree(pWlanTimer);
1056 + pWlanTimer = NULL;
1057 + }
1058 +
1059 + break;
1060 + }
1061 + break;
1062 + #endif //for wireless
1063 + default:
1064 + break;
1065 + }
1066 + spin_unlock_irqrestore(&config_lock, flags);
1067 +}
1068 +static ssize_t proc_read_led_fops(struct file *filp,
1069 + char *buf,size_t count , loff_t *offp)
1070 +{
1071 + char *pdata = NULL;
1072 + int i = 0, j = 0, len = 0, totallen = 0;
1073 + char line[255];
1074 +
1075 + if (*offp != 0)
1076 + return 0;
1077 + pdata = buf;
1078 + len = sprintf(line, "USER MODULE INFORMATION:\n");
1079 + copy_to_user(pdata, line, len);
1080 + pdata += len;
1081 + totallen += len;
1082 + len = 0;
1083 +
1084 + //*******add Module 1 , this Module is ADSL ********/
1085 + for (i = 0; i < MAX_MOD_ID; i++)
1086 + {
1087 + if (modArr[i] != NULL)
1088 + {
1089 + len = sprintf(line, " Module ID = %d\n", i);
1090 + copy_to_user(pdata, line, len);
1091 + pdata += len;
1092 + totallen += len;
1093 + len = 0;
1094 + for(j = 0; j < MAX_STATE_ID; j++)
1095 + {
1096 + if (modArr[i]->states[j] != NULL)
1097 + {
1098 + len = sprintf(line, "State =%d, Led = %d,", j, modArr[i]->states[j]->led);
1099 + copy_to_user(pdata, line, len);
1100 + pdata += len;
1101 + totallen += len;
1102 + len = 0;
1103 + switch(modArr[i]->states[j]->mode)
1104 + {
1105 + case 1:
1106 + len = sprintf(line, "Mode = OFF\n");
1107 + break;
1108 + case 2:
1109 + len = sprintf(line, "Mode = BLINK_ON, On Time(ms) = %d\n", (unsigned int)modArr[i]->states[j]->param);
1110 + break;
1111 + case 3:
1112 + len = sprintf(line, "Mode = BLINK_OFF, Off Time(ms) = %d\n", (unsigned int)modArr[i]->states[j]->param);
1113 + break;
1114 + case 4:
1115 + len = sprintf(line, "Mode = On\n");
1116 + break;
1117 + case 5:
1118 + len = sprintf(line, "Mode = FLASH, Time Period(ms) = %d\n", (unsigned int)modArr[i]->states[j]->param);
1119 + break;
1120 + default:
1121 + break;
1122 + }
1123 + copy_to_user(pdata, line, len);
1124 + pdata += len;
1125 + totallen += len;
1126 + len = 0;
1127 + }
1128 + }
1129 + }
1130 +
1131 + }
1132 +
1133 + len = sprintf(line, "Module ID = 2(system led)\n");
1134 + copy_to_user(pdata, line, len);
1135 + pdata += len;
1136 + totallen += len;
1137 + len = 0;
1138 + switch(sys_mod_state)
1139 + {
1140 + case 1:
1141 + len = sprintf(line, "State = OFF\n");
1142 + break;
1143 + case 2:
1144 + len = sprintf(line, "State = Booting\n");
1145 + break;
1146 + case 3:
1147 + len = sprintf(line, "State = System Ready\n");
1148 + break;
1149 + case 4:
1150 + len = sprintf(line, "State = System Failure\n");
1151 + break;
1152 + default:
1153 + break;
1154 + }
1155 + copy_to_user(pdata, line, len);
1156 + pdata += len;
1157 + totallen += len;
1158 + len = 0;
1159 +
1160 + len = sprintf(line, "Module ID = 3(WAN led)\n");
1161 + copy_to_user(pdata, line, len);
1162 + pdata += len;
1163 + totallen += len;
1164 + len = 0;
1165 + switch(wan_mod_state)
1166 + {
1167 + case 1:
1168 + len = sprintf(line, "State = OFF\n");
1169 + break;
1170 + case 2:
1171 + len = sprintf(line, "State = Wan Connected\n");
1172 + break;
1173 + case 3:
1174 + len = sprintf(line, "State = Wan Tx/Rx Activity\n");
1175 + break;
1176 + case 4:
1177 + len = sprintf(line, "State = Wan Connect Failure\n");
1178 + break;
1179 + default:
1180 + break;
1181 + }
1182 + copy_to_user(pdata, line, len);
1183 + pdata += len;
1184 + totallen += len;
1185 + len = 0;
1186 +
1187 +//wwzh for wireless
1188 +#if 0
1189 + len = sprintf(line, "Module ID = 4(WLAN led)\n");
1190 + copy_to_user(pdata, line, len);
1191 + pdata += len;
1192 + totallen += len;
1193 + len = 0;
1194 + switch(wlan_mod_state)
1195 + {
1196 + case 1:
1197 + len = sprintf(line, "State = OFF\n");
1198 + break;
1199 + case 2:
1200 + len = sprintf(line, "State = wlan Ready\n");
1201 + break;
1202 + case 3:
1203 + len = sprintf(line, "State = wlan rx/tx activity\n");
1204 + break;
1205 + default:
1206 + break;
1207 + }
1208 + copy_to_user(pdata, line, len);
1209 + pdata += len;
1210 + totallen += len;
1211 + len = 0;
1212 +#endif //for wireless
1213 +
1214 + *offp = totallen;
1215 + return totallen;
1216 +}
1217 +static ssize_t proc_write_led_fops(struct file *filp,const char *buffer,
1218 + size_t count , loff_t *offp)
1219 +{
1220 + char *pdata = NULL, *ptemp = NULL;
1221 + char line[10], temp[10];
1222 + int i = 0;
1223 + int mod = 0xffff, state = 0xffff;
1224 + int flag = 0;
1225 +
1226 + /* Check if this write is for configuring ADSL */
1227 + if( *(int *)(buffer) == 0xFFEEDDCC )
1228 + {
1229 + printk("<1>proc write:Calling Configuration\n");
1230 + config_led((unsigned long)(buffer + sizeof(int)) );
1231 + return count;
1232 + }
1233 +
1234 + if (count > 10)
1235 + {
1236 + printk("<1> proc write: Input too long, max length = 10\n");
1237 + return count;
1238 + }
1239 + memset(temp, 0x00, 10);
1240 + memset(line, 0x00, 10);
1241 + copy_from_user(line, buffer, count);
1242 + line[count] = 0x00;
1243 + pdata = line;
1244 + ptemp = temp;
1245 +
1246 + while (flag == 0)
1247 + {
1248 + if (i > 10)
1249 + break;
1250 + if (((*pdata) >= '0') && ((*pdata) <= '9'))
1251 + {
1252 + *ptemp = *pdata;
1253 + ptemp++;
1254 + }
1255 + else if ((*pdata) == ',')
1256 + {
1257 + *ptemp = 0x00;
1258 + flag = 1;
1259 + }
1260 + pdata++;
1261 + i++;
1262 + }
1263 + if (flag == 1)
1264 + mod = led_atoi(temp);
1265 + else
1266 + return count;
1267 +
1268 + ptemp = temp;
1269 + *ptemp = 0x00;
1270 + flag = 0;
1271 +
1272 + while(flag == 0)
1273 + {
1274 + if (i > 10)
1275 + break;
1276 + if (((*pdata) >= '0') && ((*pdata) <= '9'))
1277 + {
1278 + *ptemp = *pdata;
1279 + ptemp++;
1280 + }
1281 + else if ((*pdata) == 0x00)
1282 + {
1283 + *ptemp = 0x00;
1284 + flag = 1;
1285 + }
1286 + pdata++;
1287 + i++;
1288 + }
1289 + if (flag == 1)
1290 + state = led_atoi(temp);
1291 + else
1292 + return count;
1293 + if ((mod == 0xFFFF) || (state == 0xFFFF))
1294 + return count;
1295 + else
1296 + {
1297 + if (mod != 4)
1298 + led_active(mod, state);
1299 + else
1300 + led_operation(mod, state);
1301 + }
1302 + return 1;
1303 +}
1304 +#endif
1305 +/************end *******************/
1306 +static int config_led(unsigned long y)
1307 +{
1308 + config_elem_t *pcfg = NULL;
1309 + char *pdata = NULL;
1310 + int i;
1311 + int length = 0 , number = 0;
1312 + unsigned int flags;
1313 +
1314 + spin_lock_irqsave(&config_lock, flags);
1315 +
1316 + /* ioctl to configure */
1317 + length = *((int*)y);
1318 + pdata = (char *)y + sizeof(int);
1319 + number = (length - sizeof(int))/sizeof(config_elem_t);
1320 + pcfg = (config_elem_t *)(pdata);
1321 +
1322 + /* Check if an earlier configuration exists IF yes free it up */
1323 + free_memory();
1324 +
1325 + for ( i = 0 ; i < number ; i++ )
1326 + {
1327 + /* If no structure has been allocated for the module do so */
1328 + if ( modArr[pcfg->name] == NULL )
1329 + {
1330 + printk("<1>module = %d\n",pcfg->name);
1331 + if( pcfg->name >= MAX_MOD_ID)
1332 + {
1333 + printk("<1>Exiting Configuration: Module ID too large %d\n",pcfg->name);
1334 + free_memory();
1335 + spin_unlock_irqrestore(&config_lock, flags);
1336 + return -1;
1337 + }
1338 + modArr[pcfg->name] = kmalloc(sizeof(mod_entry_t),GFP_KERNEL);
1339 + if(modArr[pcfg->name] == NULL)
1340 + {
1341 + printk("<1>Exiting Configuration: Error in allocating memory\n");
1342 + free_memory();
1343 + spin_unlock_irqrestore(&config_lock, flags);
1344 + return -1;
1345 + }
1346 + memset( modArr[pcfg->name], 0x00, sizeof(mod_entry_t));
1347 + }
1348 +
1349 + /* if no structure is allocated previously for this state
1350 + allocate a structure, if it's already there fill it up */
1351 + if( modArr[pcfg->name]->states[pcfg->state] == NULL)
1352 + {
1353 + printk("<1>STATE = %d\n",pcfg->state);
1354 + if( pcfg->state >= MAX_STATE_ID)
1355 + {
1356 + printk("<1>Exiting Configuration: State ID too large\n");
1357 + free_memory();
1358 + spin_unlock_irqrestore(&config_lock, flags);
1359 + return -1;
1360 + }
1361 + modArr[pcfg->name]->states[pcfg->state] =
1362 + kmalloc(sizeof(state_entry_t),GFP_KERNEL);
1363 + if( modArr[pcfg->name]->states[pcfg->state] == NULL)
1364 + {
1365 + free_memory();
1366 + spin_unlock_irqrestore(&config_lock, flags);
1367 + return -1;
1368 + }
1369 + memset( modArr[pcfg->name]->states[pcfg->state], 0x00, sizeof(state_entry_t));
1370 + }
1371 + /* Fill up the fields of the state */
1372 + if( pcfg->led >= MAX_LED_ID)
1373 + {
1374 + printk("<1>led = %d\n",pcfg->led);
1375 + free_memory();
1376 + spin_unlock_irqrestore(&config_lock, flags);
1377 + return -1;
1378 + }
1379 + modArr[pcfg->name]->states[pcfg->state]->led = pcfg->led;
1380 + modArr[pcfg->name]->states[pcfg->state]->mode = pcfg->mode;
1381 + modArr[pcfg->name]->states[pcfg->state]->param = pcfg->param;
1382 + switch(pcfg->mode)
1383 + {
1384 + case 1:
1385 + modArr[pcfg->name]->states[pcfg->state]->handler = board_led_link_down;
1386 + break;
1387 + case 2:
1388 + case 3:
1389 + case 5:
1390 + if( pcfg->mode == 2 )
1391 + modArr[pcfg->name]->states[pcfg->state]->handler = board_led_activity_on;
1392 + else if( pcfg->mode == 3)
1393 + modArr[pcfg->name]->states[pcfg->state]->handler = board_led_activity_off;
1394 + else
1395 + modArr[pcfg->name]->states[pcfg->state]->handler = board_led_link_flash;
1396 + break;
1397 + case 4:
1398 + modArr[pcfg->name]->states[pcfg->state]->handler = board_led_link_up;
1399 + break;
1400 + default:
1401 + printk("<1>Exiting Configuration: Unknown LED Mode\n");
1402 + free_memory();
1403 + spin_unlock_irqrestore(&config_lock, flags);
1404 + return -1;
1405 + }
1406 + pcfg++;
1407 + }
1408 + spin_unlock_irqrestore(&config_lock, flags);
1409 + return 0;
1410 +}
1411 +
1412 +
1413 +int __init led_init(void)
1414 +{
1415 +
1416 + /* Clear our memory */
1417 + memset(modArr,0x00,sizeof(mod_entry_t *)*MAX_MOD_ID);
1418 + memset(led_arr,0x00,sizeof(led_data_t *)*MAX_LED_ID);
1419 +
1420 + /* Create spin lock for config data structure */
1421 + config_lock=SPIN_LOCK_UNLOCKED;
1422 +
1423 + /* Create directory */
1424 + led_proc_dir = proc_mkdir("led", NULL);
1425 + if( led_proc_dir == NULL )
1426 + goto out;
1427 +
1428 + /* Create adsl file */
1429 + led_file = create_proc_entry("led", 0777, led_proc_dir);
1430 + if( led_file == NULL)
1431 + goto led_file;
1432 + led_file->owner = THIS_MODULE;
1433 + led_file->proc_fops = &led_fops;
1434 +
1435 + memset( modArr , 0x00 , sizeof(mod_entry_t *) * MAX_MOD_ID);
1436 + /* Reset the GPIO pins */
1437 + board_gpio_init();
1438 +
1439 + /* Register the UART controlled LEDS */
1440 + uart_led_init();
1441 + /* Create the usb proc file */
1442 + avalanche_leds_init();
1443 + return 0;
1444 +
1445 + led_file:
1446 + remove_proc_entry("led",led_proc_dir);
1447 + out:
1448 + return 0;
1449 +
1450 +}
1451 +
1452 +void led_exit()
1453 +{
1454 + remove_proc_entry("led", led_proc_dir);
1455 +}
1456 +
1457 +module_init(led_init);
1458 +module_exit(led_exit);
1459 +
1460 +void register_led_drv( int device , led_reg_t *pInfo)
1461 +{
1462 + unsigned int flags;
1463 + struct timer_list *pTimer = NULL;
1464 +
1465 + spin_lock_irqsave(&config_lock, flags);
1466 +
1467 + led_arr[device].led = pInfo;
1468 + if( led_arr[device].led->init != 0x00)
1469 + led_arr[device].led->init(led_arr[device].led->param);
1470 + if( led_arr[device].led->offfunc != 0x00)
1471 + led_arr[device].led->offfunc(led_arr[device].led->param);
1472 +
1473 + /* Create a timer for blinking */
1474 + pTimer = kmalloc(sizeof(struct timer_list),GFP_KERNEL);
1475 + init_timer( pTimer );
1476 + pTimer->function = led_timer_func;
1477 + pTimer->data = 0;
1478 + led_arr[device].pTimer = pTimer;
1479 + led_arr[device].timer_running = 0;
1480 +
1481 + spin_unlock_irqrestore(&config_lock, flags);
1482 +
1483 + return;
1484 +}
1485 +
1486 +void deregister_led_drv( int device)
1487 +{
1488 + unsigned int flags;
1489 +
1490 + spin_lock_irqsave(&config_lock, flags);
1491 + led_arr[device].led = NULL;
1492 +
1493 + if( led_arr[device].pTimer != NULL)
1494 + {
1495 + del_timer(led_arr[device].pTimer);
1496 + kfree(led_arr[device].pTimer);
1497 + }
1498 + spin_unlock_irqrestore(&config_lock, flags);
1499 +
1500 + return;
1501 +}
1502 +
1503 +EXPORT_SYMBOL_NOVERS(led_operation);
1504 +EXPORT_SYMBOL_NOVERS(register_led_drv);
1505 +EXPORT_SYMBOL_NOVERS(deregister_led_drv);
1506 +
1507 diff -urN linux.old/drivers/char/avalanche_led/leds.c linux.dev/drivers/char/avalanche_led/leds.c
1508 --- linux.old/drivers/char/avalanche_led/leds.c 1970-01-01 01:00:00.000000000 +0100
1509 +++ linux.dev/drivers/char/avalanche_led/leds.c 2005-07-12 03:08:48.265220512 +0200
1510 @@ -0,0 +1,133 @@
1511 +#include <linux/config.h>
1512 +#include <linux/init.h>
1513 +#include <linux/delay.h>
1514 +#include <asm/ar7/avalanche_regs.h>
1515 +#include <linux/spinlock.h>
1516 +#include <linux/timer.h>
1517 +#include <linux/sched.h>
1518 +#include <linux/module.h>
1519 +#include <linux/proc_fs.h>
1520 +#include <asm/uaccess.h>
1521 +#include <linux/fs.h>
1522 +
1523 +#include <asm/ar7/ledapp.h>
1524 +
1525 +#if defined(CONFIG_AR5D01) || defined(CONFIG_AR5W01) || defined(CONFIG_AR7)
1526 +
1527 +#define ETH_MASK 0x01
1528 +#define USB_MASK 0x02
1529 +
1530 +static struct proc_dir_entry *usb_file;
1531 +static ssize_t proc_read_usb_fops(struct file *filp,
1532 + char *buf,size_t count , loff_t *offp);
1533 +struct file_operations usb_fops = {read: proc_read_usb_fops};
1534 +
1535 +typedef struct mod_states{
1536 + int module;
1537 + int activity;
1538 + int linkup;
1539 + int idle;
1540 +}mod_states_t;
1541 +
1542 +mod_states_t state_arr[] = {
1543 + { MOD_ETH,DEF_ETH_ACTIVITY,DEF_ETH_LINK_UP,DEF_ETH_IDLE },
1544 + { MOD_USB,DEF_USB_ACTIVITY,DEF_USB_LINK_UP,DEF_USB_IDLE },
1545 + { MOD_LAN,DEF_LAN_ACTIVITY,DEF_LAN_LINK_UP,DEF_LAN_IDLE }
1546 + };
1547 +
1548 +unsigned char device_links = 0; /* Bitmask with the devices that are up */
1549 +
1550 +
1551 +void avalanche_led_activity_pulse(unsigned long device)
1552 +{
1553 + /* If device link is not up return */
1554 + if( !(device_links & (unsigned char)(1 << device)))
1555 + return;
1556 +#ifdef MULTIPLEX_LED
1557 + led_operation( state_arr[2].module, state_arr[2].activity);
1558 +#else
1559 + led_operation( state_arr[device].module, state_arr[device].activity);
1560 +#endif
1561 +}
1562 +
1563 +void avalanche_led_link_up( unsigned long device )
1564 +{
1565 +
1566 + /* If already UP ignore */
1567 + if( device_links & (unsigned char)(1 << device))
1568 + return;
1569 + /* Turn on the bit for the device */
1570 + device_links |= (unsigned char)(1 << device);
1571 +#ifdef MULTIPLEX_LED
1572 + led_operation( state_arr[2].module, state_arr[2].linkup);
1573 +#else
1574 + led_operation( state_arr[device].module, state_arr[device].linkup);
1575 +#endif
1576 +}
1577 +
1578 +void avalanche_led_link_down ( unsigned long device )
1579 +{
1580 +
1581 + /* If already DOWN ignore */
1582 + if( !(device_links & (unsigned char)(1 << device)))
1583 + return;
1584 +
1585 + /* Turn off the bit for the device */
1586 + device_links &= ~(unsigned char)(1 << device);
1587 +#ifdef MULTIPLEX_LED
1588 + /* If no links, then shut the LED off */
1589 + if(!device_links)
1590 + led_operation( state_arr[2].module, state_arr[2].idle);
1591 +#else
1592 + led_operation( state_arr[device].module, state_arr[device].idle);
1593 +#endif
1594 +}
1595 +
1596 +static ssize_t proc_read_usb_fops(struct file *filp,
1597 + char *buf,size_t count , loff_t *offp)
1598 +{
1599 + char * pdata = NULL;
1600 + char line[3];
1601 + if( *offp != 0 )
1602 + return 0;
1603 + pdata = buf;
1604 + if( device_links & USB_MASK)
1605 + sprintf(line,"%s\n","1");
1606 + else
1607 + sprintf(line,"%s\n","0");
1608 + copy_to_user(pdata,line,2);
1609 + *offp = 2;
1610 + return 2;
1611 +}
1612 +
1613 +
1614 +void avalanche_leds_init(void)
1615 +{
1616 + /* Create usb link proc file */
1617 + usb_file = create_proc_entry("avalanche/usb_link", 0444, NULL);
1618 + if( usb_file == NULL)
1619 + return;
1620 + usb_file->owner = THIS_MODULE;
1621 + usb_file->proc_fops = &usb_fops;
1622 + return;
1623 +}
1624 +
1625 +EXPORT_SYMBOL(avalanche_led_activity_pulse);
1626 +EXPORT_SYMBOL(avalanche_led_link_up);
1627 +EXPORT_SYMBOL(avalanche_led_link_down);
1628 +
1629 +#else
1630 +/* We make a dummy init routine for the platforms that do not support this led
1631 + API
1632 +*/
1633 +
1634 +void avalanche_leds_init(void)
1635 +{
1636 +}
1637 +
1638 +#endif
1639 +
1640 +
1641 +
1642 +
1643 +
1644 diff -urN linux.old/drivers/char/avalanche_led/Makefile linux.dev/drivers/char/avalanche_led/Makefile
1645 --- linux.old/drivers/char/avalanche_led/Makefile 1970-01-01 01:00:00.000000000 +0100
1646 +++ linux.dev/drivers/char/avalanche_led/Makefile 2005-07-12 03:08:48.265220512 +0200
1647 @@ -0,0 +1,23 @@
1648 +# File: drivers/char/avalanche_led/Makefile
1649 +#
1650 +# Makefile for the Linux LED device driver.
1651 +#
1652 +
1653 +
1654 +O_TARGET := avalanche_led.o
1655 +obj-m := avalanche_led.o
1656 +list-multi := avalanche_led.o
1657 +
1658 +EXTRA_CFLAGS := -I$(TOPDIR)/include/asm/ar7
1659 +
1660 +export-objs := ledmod.o leds.o
1661 +
1662 +avalanche_led-objs := ledmod.o gpio.o uartled.o leds.o
1663 +
1664 +include $(TOPDIR)/Rules.make
1665 +
1666 +avalanche_led.o: $(avalanche_led-objs)
1667 + $(LD) -r -o $@ $(avalanche_led-objs)
1668 +
1669 +clean:
1670 + rm -f core *.o *.a *.s
1671 diff -urN linux.old/drivers/char/avalanche_led/uartled.c linux.dev/drivers/char/avalanche_led/uartled.c
1672 --- linux.old/drivers/char/avalanche_led/uartled.c 1970-01-01 01:00:00.000000000 +0100
1673 +++ linux.dev/drivers/char/avalanche_led/uartled.c 2005-07-12 03:08:48.266220360 +0200
1674 @@ -0,0 +1,55 @@
1675 +#include <linux/kernel.h>
1676 +#include <asm/uaccess.h>
1677 +#include <linux/spinlock.h>
1678 +#include <asm/ar7/avalanche_regs.h>
1679 +#include <asm/ar7/ledapp.h>
1680 +
1681 +#define UART_LED_REG (*(volatile unsigned int *)(UARTA_BASE + 0x10))
1682 +
1683 +static spinlock_t device_lock;
1684 +led_reg_t temp1[2];
1685 +
1686 +static void uart_led_on(unsigned long param)
1687 +{
1688 + unsigned long flags;
1689 +
1690 + spin_lock_irqsave(&device_lock,flags);
1691 + UART_LED_REG &= 0xFFFD;
1692 + spin_unlock_irqrestore(&device_lock, flags);
1693 +}
1694 +
1695 +static void uart_led_off ( unsigned long param )
1696 +{
1697 + unsigned int flags = 0x00;
1698 + spin_lock_irqsave(&device_lock, flags);
1699 + UART_LED_REG |= 0x02;
1700 + spin_unlock_irqrestore(&device_lock, flags);
1701 +}
1702 +
1703 +void uart_led_init(void)
1704 +{
1705 +
1706 +#if defined(CONFIG_AR5D01)
1707 + /* Register led 6 UART Pin 1 */
1708 + temp1[0].param = 0;
1709 + temp1[0].init = NULL;
1710 + temp1[0].onfunc = uart_led_on;
1711 + temp1[0].offfunc = uart_led_off;
1712 + register_led_drv( 6 , &temp1[0]);
1713 +#endif
1714 +
1715 +#if defined(CONFIG_AR5W01)
1716 + /* Register led 8 UART Pin 1 */
1717 + temp1[0].param = 0;
1718 + temp1[0].init = NULL;
1719 + temp1[0].onfunc = uart_led_on;
1720 + temp1[0].offfunc = uart_led_off;
1721 + register_led_drv( 8 , &temp1[0]);
1722 +#endif
1723 +
1724 + /* Initialize the link mask */
1725 + device_lock = SPIN_LOCK_UNLOCKED;
1726 +
1727 + return;
1728 +}
1729 +
1730 diff -urN linux.old/drivers/char/Config.in linux.dev/drivers/char/Config.in
1731 --- linux.old/drivers/char/Config.in 2005-07-10 20:53:55.650624032 +0200
1732 +++ linux.dev/drivers/char/Config.in 2005-07-12 03:07:20.861507896 +0200
1733 @@ -133,6 +133,10 @@
1734 fi
1735 fi
1736 fi
1737 +if [ "$CONFIG_AR7" = "y" ]; then
1738 + bool 'Enable LED support' CONFIG_MIPS_AVALANCHE_LED
1739 +fi
1740 +
1741 if [ "$CONFIG_EXPERIMENTAL" = "y" -a "$CONFIG_ZORRO" = "y" ]; then
1742 tristate 'Commodore A2232 serial support (EXPERIMENTAL)' CONFIG_A2232
1743 fi
1744 diff -urN linux.old/drivers/char/Makefile linux.dev/drivers/char/Makefile
1745 --- linux.old/drivers/char/Makefile 2005-07-10 20:53:55.651623880 +0200
1746 +++ linux.dev/drivers/char/Makefile 2005-07-12 03:07:20.861507896 +0200
1747 @@ -190,6 +190,19 @@
1748 obj-$(CONFIG_PCI) += keyboard.o $(KEYMAP)
1749 endif
1750
1751 +#
1752 +# Texas Intruments LED driver
1753 +#
1754 +ifeq ($(CONFIG_MIPS_AVALANCHE_LED),y)
1755 +obj-$(CONFIG_MIPS_AVALANCHE_LED) += avalanche_led/avalanche_led.o
1756 +subdir-$(CONFIG_MIPS_AVALANCHE_LED) += avalanche_led
1757 +endif
1758 +
1759 +ifeq ($(CONFIG_MIPS_AVALANCHE_LED),m)
1760 +obj-$(CONFIG_MIPS_AVALANCHE_LED) += avalanche_led/avalanche_led.o
1761 +subdir-$(CONFIG_MIPS_AVALANCHE_LED) += avalanche_led
1762 +endif
1763 +
1764 obj-$(CONFIG_HIL) += hp_keyb.o
1765 obj-$(CONFIG_MAGIC_SYSRQ) += sysrq.o
1766 obj-$(CONFIG_ATARI_DSP56K) += dsp56k.o
1767 diff -urN linux.old/include/asm-mips/ar7/ledapp.h linux.dev/include/asm-mips/ar7/ledapp.h
1768 --- linux.old/include/asm-mips/ar7/ledapp.h 1970-01-01 01:00:00.000000000 +0100
1769 +++ linux.dev/include/asm-mips/ar7/ledapp.h 2005-07-12 03:08:48.266220360 +0200
1770 @@ -0,0 +1,59 @@
1771 +#ifndef __LED_APP__
1772 +#define __LED_APP__
1773 +
1774 +#define CONF_FILE "/etc/led.conf"
1775 +#define LED_PROC_FILE "/proc/led_mod/led"
1776 +
1777 +#define CONFIG_LED_MODULE
1778 +
1779 +#define MAX_MOD_ID 25
1780 +#define MAX_STATE_ID 25
1781 +#define MAX_LED_ID 25
1782 +
1783 +#define MOD_ADSL 1
1784 +#define DEF_ADSL_IDLE 1
1785 +#define DEF_ADSL_TRAINING 2
1786 +#define DEF_ADSL_SYNC 3
1787 +#define DEF_ADSL_ACTIVITY 4
1788 +
1789 +#define MOD_WAN 2
1790 +#define DEF_WAN_IDLE 1
1791 +#define DEF_WAN_NEGOTIATE 2
1792 +#define DEF_WAN_SESSION 3
1793 +
1794 +#define MOD_LAN 3
1795 +#define DEF_LAN_IDLE 1
1796 +#define DEF_LAN_LINK_UP 2
1797 +#define DEF_LAN_ACTIVITY 3
1798 +
1799 +#define MOD_WLAN 4
1800 +#define DEF_WLAN_IDLE 1
1801 +#define DEF_WLAN_LINK_UP 2
1802 +#define DEF_WLAN_ACTIVITY 3
1803 +
1804 +#define MOD_USB 5
1805 +#define DEF_USB_IDLE 1
1806 +#define DEF_USB_LINK_UP 2
1807 +#define DEF_USB_ACTIVITY 3
1808 +
1809 +#define MOD_ETH 6
1810 +#define DEF_ETH_IDLE 1
1811 +#define DEF_ETH_LINK_UP 2
1812 +#define DEF_ETH_ACTIVITY 3
1813 +
1814 +typedef struct config_elem{
1815 + unsigned char name;
1816 + unsigned char state;
1817 + unsigned char mode;
1818 + unsigned char led;
1819 + int param;
1820 +}config_elem_t;
1821 +
1822 +typedef struct led_reg{
1823 + unsigned int param;
1824 + void (*init)(unsigned long param);
1825 + void (*onfunc)(unsigned long param);
1826 + void (*offfunc)(unsigned long param);
1827 +}led_reg_t;
1828 +
1829 +#endif
Personal OpenWRT clone
This page took 0.121063 seconds and 5 git commands to generate.