2 * Chassis LCD/LED driver for HP-PARISC workstations
4 * (c) Copyright 2000 Red Hat Software
5 * (c) Copyright 2000 Helge Deller <hdeller@redhat.com>
6 * (c) Copyright 2001-2005 Helge Deller <deller@gmx.de>
7 * (c) Copyright 2001 Randolph Chung <tausq@debian.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
15 * - speed-up calculations with inlined assembler
16 * - interface to write to second row of LCD from /proc (if technically possible)
19 * - Audit copy_from_user in led_proc_write.
20 * Daniele Bellucci <bellucda@tiscali.it>
21 * - Switch from using a tasklet to a work queue, so the led_LCD_driver
23 * David Pye <dmp@davidmpye.dyndns.org>
26 #include <linux/module.h>
27 #include <linux/stddef.h> /* for offsetof() */
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/ioport.h>
31 #include <linux/utsname.h>
32 #include <linux/capability.h>
33 #include <linux/delay.h>
34 #include <linux/netdevice.h>
35 #include <linux/inetdevice.h>
37 #include <linux/interrupt.h>
38 #include <linux/kernel_stat.h>
39 #include <linux/reboot.h>
40 #include <linux/proc_fs.h>
41 #include <linux/ctype.h>
42 #include <linux/blkdev.h>
43 #include <linux/workqueue.h>
44 #include <linux/rcupdate.h>
46 #include <asm/processor.h>
47 #include <asm/hardware.h>
48 #include <asm/param.h> /* HZ */
51 #include <asm/uaccess.h>
53 /* The control of the LEDs and LCDs on PARISC-machines have to be done
54 completely in software. The necessary calculations are done in a work queue
55 task which is scheduled regularly, and since the calculations may consume a
56 relatively large amount of CPU time, some of the calculations can be
57 turned off with the following variables (controlled via procfs) */
59 static int led_type __read_mostly
= -1;
60 static unsigned char lastleds
; /* LED state from most recent update */
61 static unsigned int led_heartbeat __read_mostly
= 1;
62 static unsigned int led_diskio __read_mostly
= 1;
63 static unsigned int led_lanrxtx __read_mostly
= 1;
64 static char lcd_text
[32] __read_mostly
;
65 static char lcd_text_default
[32] __read_mostly
;
68 static struct workqueue_struct
*led_wq
;
69 static void led_work_func(struct work_struct
*);
70 static DECLARE_DELAYED_WORK(led_task
, led_work_func
);
73 #define DPRINTK(x) printk x
79 unsigned char command
; /* stores the command byte */
80 unsigned char on
; /* value for turning LED on */
81 unsigned char off
; /* value for turning LED off */
84 /* Structure returned by PDC_RETURN_CHASSIS_INFO */
85 /* NOTE: we use unsigned long:16 two times, since the following member
86 lcd_cmd_reg_addr needs to be 64bit aligned on 64bit PA2.0-machines */
87 struct pdc_chassis_lcd_info_ret_block
{
88 unsigned long model
:16; /* DISPLAY_MODEL_XXXX */
89 unsigned long lcd_width
:16; /* width of the LCD in chars (DISPLAY_MODEL_LCD only) */
90 unsigned long lcd_cmd_reg_addr
; /* ptr to LCD cmd-register & data ptr for LED */
91 unsigned long lcd_data_reg_addr
; /* ptr to LCD data-register (LCD only) */
92 unsigned int min_cmd_delay
; /* delay in uS after cmd-write (LCD only) */
93 unsigned char reset_cmd1
; /* command #1 for writing LCD string (LCD only) */
94 unsigned char reset_cmd2
; /* command #2 for writing LCD string (LCD only) */
95 unsigned char act_enable
; /* 0 = no activity (LCD only) */
96 struct lcd_block heartbeat
;
97 struct lcd_block disk_io
;
98 struct lcd_block lan_rcv
;
99 struct lcd_block lan_tx
;
104 /* LCD_CMD and LCD_DATA for KittyHawk machines */
105 #define KITTYHAWK_LCD_CMD F_EXTEND(0xf0190000UL) /* 64bit-ready */
106 #define KITTYHAWK_LCD_DATA (KITTYHAWK_LCD_CMD+1)
108 /* lcd_info is pre-initialized to the values needed to program KittyHawk LCD's
109 * HP seems to have used Sharp/Hitachi HD44780 LCDs most of the time. */
110 static struct pdc_chassis_lcd_info_ret_block
111 lcd_info
__attribute__((aligned(8))) __read_mostly
=
113 .model
= DISPLAY_MODEL_LCD
,
115 .lcd_cmd_reg_addr
= KITTYHAWK_LCD_CMD
,
116 .lcd_data_reg_addr
= KITTYHAWK_LCD_DATA
,
123 /* direct access to some of the lcd_info variables */
124 #define LCD_CMD_REG lcd_info.lcd_cmd_reg_addr
125 #define LCD_DATA_REG lcd_info.lcd_data_reg_addr
126 #define LED_DATA_REG lcd_info.lcd_cmd_reg_addr /* LASI & ASP only */
131 /* The workqueue must be created at init-time */
132 static int start_task(void)
134 /* Display the default text now */
135 if (led_type
== LED_HASLCD
) lcd_print( lcd_text_default
);
137 /* Create the work queue and queue the LED task */
138 led_wq
= create_singlethread_workqueue("led_wq");
139 queue_delayed_work(led_wq
, &led_task
, 0);
144 device_initcall(start_task
);
146 /* ptr to LCD/LED-specific function */
147 static void (*led_func_ptr
) (unsigned char) __read_mostly
;
149 #ifdef CONFIG_PROC_FS
150 static int led_proc_read(char *page
, char **start
, off_t off
, int count
,
151 int *eof
, void *data
)
159 out
+= sprintf(out
, "Heartbeat: %d\n", led_heartbeat
);
160 out
+= sprintf(out
, "Disk IO: %d\n", led_diskio
);
161 out
+= sprintf(out
, "LAN Rx/Tx: %d\n", led_lanrxtx
);
164 out
+= sprintf(out
, "%s\n", lcd_text
);
171 len
= out
- page
- off
;
174 if (len
<= 0) return 0;
182 static int led_proc_write(struct file
*file
, const char *buf
,
183 unsigned long count
, void *data
)
185 char *cur
, lbuf
[count
+ 1];
188 if (!capable(CAP_SYS_ADMIN
))
191 memset(lbuf
, 0, count
+ 1);
193 if (copy_from_user(lbuf
, buf
, count
))
198 /* skip initial spaces */
199 while (*cur
&& isspace(*cur
))
208 if (d
!= 0 && d
!= 1) goto parse_error
;
211 if (*cur
++ != ' ') goto parse_error
;
214 if (d
!= 0 && d
!= 1) goto parse_error
;
217 if (*cur
++ != ' ') goto parse_error
;
220 if (d
!= 0 && d
!= 1) goto parse_error
;
225 if (*cur
&& cur
[strlen(cur
)-1] == '\n')
226 cur
[strlen(cur
)-1] = 0;
228 cur
= lcd_text_default
;
238 if ((long)data
== LED_NOLCD
)
239 printk(KERN_CRIT
"Parse error: expect \"n n n\" (n == 0 or 1) for heartbeat,\ndisk io and lan tx/rx indicators\n");
243 static int __init
led_create_procfs(void)
245 struct proc_dir_entry
*proc_pdc_root
= NULL
;
246 struct proc_dir_entry
*ent
;
248 if (led_type
== -1) return -1;
250 proc_pdc_root
= proc_mkdir("pdc", 0);
251 if (!proc_pdc_root
) return -1;
252 proc_pdc_root
->owner
= THIS_MODULE
;
253 ent
= create_proc_entry("led", S_IFREG
|S_IRUGO
|S_IWUSR
, proc_pdc_root
);
255 ent
->data
= (void *)LED_NOLCD
; /* LED */
256 ent
->read_proc
= led_proc_read
;
257 ent
->write_proc
= led_proc_write
;
258 ent
->owner
= THIS_MODULE
;
260 if (led_type
== LED_HASLCD
)
262 ent
= create_proc_entry("lcd", S_IFREG
|S_IRUGO
|S_IWUSR
, proc_pdc_root
);
264 ent
->data
= (void *)LED_HASLCD
; /* LCD */
265 ent
->read_proc
= led_proc_read
;
266 ent
->write_proc
= led_proc_write
;
267 ent
->owner
= THIS_MODULE
;
279 #define LED_DATA 0x01 /* data to shift (0:on 1:off) */
280 #define LED_STROBE 0x02 /* strobe to clock data */
281 static void led_ASP_driver(unsigned char leds
)
286 for (i
= 0; i
< 8; i
++) {
288 value
= (leds
& 0x80) >> 7;
289 gsc_writeb( value
, LED_DATA_REG
);
290 gsc_writeb( value
| LED_STROBE
, LED_DATA_REG
);
301 static void led_LASI_driver(unsigned char leds
)
304 gsc_writeb( leds
, LED_DATA_REG
);
313 static void led_LCD_driver(unsigned char leds
)
316 static unsigned char mask
[4] = { LED_HEARTBEAT
, LED_DISK_IO
,
317 LED_LAN_RCV
, LED_LAN_TX
};
319 static struct lcd_block
* blockp
[4] = {
326 /* Convert min_cmd_delay to milliseconds */
327 unsigned int msec_cmd_delay
= 1 + (lcd_info
.min_cmd_delay
/ 1000);
331 if ((leds
& mask
[i
]) != (lastleds
& mask
[i
]))
333 gsc_writeb( blockp
[i
]->command
, LCD_CMD_REG
);
334 msleep(msec_cmd_delay
);
336 gsc_writeb( leds
& mask
[i
] ? blockp
[i
]->on
:
337 blockp
[i
]->off
, LCD_DATA_REG
);
338 msleep(msec_cmd_delay
);
346 ** led_get_net_activity()
348 ** calculate if there was TX- or RX-throughput on the network interfaces
349 ** (analog to dev_get_info() from net/core/dev.c)
352 static __inline__
int led_get_net_activity(void)
357 static unsigned long rx_total_last
, tx_total_last
;
358 unsigned long rx_total
, tx_total
;
359 struct net_device
*dev
;
362 rx_total
= tx_total
= 0;
364 /* we are running as a workqueue task, so locking dev_base
365 * for reading should be OK */
366 read_lock(&dev_base_lock
);
368 for (dev
= dev_base
; dev
; dev
= dev
->next
) {
369 struct net_device_stats
*stats
;
370 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
371 if (!in_dev
|| !in_dev
->ifa_list
)
373 if (LOOPBACK(in_dev
->ifa_list
->ifa_local
))
377 stats
= dev
->get_stats(dev
);
378 rx_total
+= stats
->rx_packets
;
379 tx_total
+= stats
->tx_packets
;
382 read_unlock(&dev_base_lock
);
386 if (rx_total
!= rx_total_last
) {
387 rx_total_last
= rx_total
;
388 retval
|= LED_LAN_RCV
;
391 if (tx_total
!= tx_total_last
) {
392 tx_total_last
= tx_total
;
393 retval
|= LED_LAN_TX
;
403 ** led_get_diskio_activity()
405 ** calculate if there was disk-io in the system
408 static __inline__
int led_get_diskio_activity(void)
410 static unsigned long last_pgpgin
, last_pgpgout
;
411 unsigned long events
[NR_VM_EVENT_ITEMS
];
414 all_vm_events(events
);
416 /* Just use a very simple calculation here. Do not care about overflow,
417 since we only want to know if there was activity or not. */
418 changed
= (events
[PGPGIN
] != last_pgpgin
) ||
419 (events
[PGPGOUT
] != last_pgpgout
);
420 last_pgpgin
= events
[PGPGIN
];
421 last_pgpgout
= events
[PGPGOUT
];
423 return (changed
? LED_DISK_IO
: 0);
431 ** manages when and which chassis LCD/LED gets updated
434 - display load average (older machines like 715/64 have 4 "free" LED's for that)
438 #define HEARTBEAT_LEN (HZ*10/100)
439 #define HEARTBEAT_2ND_RANGE_START (HZ*28/100)
440 #define HEARTBEAT_2ND_RANGE_END (HEARTBEAT_2ND_RANGE_START + HEARTBEAT_LEN)
442 #define LED_UPDATE_INTERVAL (1 + (HZ*19/1000))
444 static void led_work_func (struct work_struct
*unused
)
446 static unsigned long last_jiffies
;
447 static unsigned long count_HZ
; /* counter in range 0..HZ */
448 unsigned char currentleds
= 0; /* stores current value of the LEDs */
450 /* exit if not initialized */
454 /* increment the heartbeat timekeeper */
455 count_HZ
+= jiffies
- last_jiffies
;
456 last_jiffies
= jiffies
;
460 if (likely(led_heartbeat
))
462 /* flash heartbeat-LED like a real heart
463 * (2 x short then a long delay)
465 if (count_HZ
< HEARTBEAT_LEN
||
466 (count_HZ
>= HEARTBEAT_2ND_RANGE_START
&&
467 count_HZ
< HEARTBEAT_2ND_RANGE_END
))
468 currentleds
|= LED_HEARTBEAT
;
471 if (likely(led_lanrxtx
)) currentleds
|= led_get_net_activity();
472 if (likely(led_diskio
)) currentleds
|= led_get_diskio_activity();
474 /* blink all LEDs twice a second if we got an Oops (HPMC) */
475 if (unlikely(oops_in_progress
))
476 currentleds
= (count_HZ
<=(HZ
/2)) ? 0 : 0xff;
478 if (currentleds
!= lastleds
)
480 led_func_ptr(currentleds
); /* Update the LCD/LEDs */
481 lastleds
= currentleds
;
484 queue_delayed_work(led_wq
, &led_task
, LED_UPDATE_INTERVAL
);
490 ** called by the reboot notifier chain at shutdown and stops all
491 ** LED/LCD activities.
495 static int led_halt(struct notifier_block
*, unsigned long, void *);
497 static struct notifier_block led_notifier
= {
498 .notifier_call
= led_halt
,
500 static int notifier_disabled
= 0;
502 static int led_halt(struct notifier_block
*nb
, unsigned long event
, void *buf
)
506 if (notifier_disabled
)
509 notifier_disabled
= 1;
511 case SYS_RESTART
: txt
= "SYSTEM RESTART";
513 case SYS_HALT
: txt
= "SYSTEM HALT";
515 case SYS_POWER_OFF
: txt
= "SYSTEM POWER OFF";
517 default: return NOTIFY_DONE
;
520 /* Cancel the work item and delete the queue */
522 cancel_rearming_delayed_workqueue(led_wq
, &led_task
);
523 destroy_workqueue(led_wq
);
527 if (lcd_info
.model
== DISPLAY_MODEL_LCD
)
531 led_func_ptr(0xff); /* turn all LEDs ON */
537 ** register_led_driver()
539 ** registers an external LED or LCD for usage by this driver.
540 ** currently only LCD-, LASI- and ASP-style LCD/LED's are supported.
544 int __init
register_led_driver(int model
, unsigned long cmd_reg
, unsigned long data_reg
)
546 static int initialized
;
548 if (initialized
|| !data_reg
)
551 lcd_info
.model
= model
; /* store the values */
552 LCD_CMD_REG
= (cmd_reg
== LED_CMD_REG_NONE
) ? 0 : cmd_reg
;
554 switch (lcd_info
.model
) {
555 case DISPLAY_MODEL_LCD
:
556 LCD_DATA_REG
= data_reg
;
557 printk(KERN_INFO
"LCD display at %lx,%lx registered\n",
558 LCD_CMD_REG
, LCD_DATA_REG
);
559 led_func_ptr
= led_LCD_driver
;
560 led_type
= LED_HASLCD
;
563 case DISPLAY_MODEL_LASI
:
564 LED_DATA_REG
= data_reg
;
565 led_func_ptr
= led_LASI_driver
;
566 printk(KERN_INFO
"LED display at %lx registered\n", LED_DATA_REG
);
567 led_type
= LED_NOLCD
;
570 case DISPLAY_MODEL_OLD_ASP
:
571 LED_DATA_REG
= data_reg
;
572 led_func_ptr
= led_ASP_driver
;
573 printk(KERN_INFO
"LED (ASP-style) display at %lx registered\n",
575 led_type
= LED_NOLCD
;
579 printk(KERN_ERR
"%s: Wrong LCD/LED model %d !\n",
580 __FUNCTION__
, lcd_info
.model
);
584 /* mark the LCD/LED driver now as initialized and
585 * register to the reboot notifier chain */
587 register_reboot_notifier(&led_notifier
);
589 /* Ensure the work is queued */
591 queue_delayed_work(led_wq
, &led_task
, 0);
598 ** register_led_regions()
600 ** register_led_regions() registers the LCD/LED regions for /procfs.
601 ** At bootup - where the initialisation of the LCD/LED normally happens -
602 ** not all internal structures of request_region() are properly set up,
603 ** so that we delay the led-registration until after busdevices_init()
604 ** has been executed.
608 void __init
register_led_regions(void)
610 switch (lcd_info
.model
) {
611 case DISPLAY_MODEL_LCD
:
612 request_mem_region((unsigned long)LCD_CMD_REG
, 1, "lcd_cmd");
613 request_mem_region((unsigned long)LCD_DATA_REG
, 1, "lcd_data");
615 case DISPLAY_MODEL_LASI
:
616 case DISPLAY_MODEL_OLD_ASP
:
617 request_mem_region((unsigned long)LED_DATA_REG
, 1, "led_data");
627 ** Displays the given string on the LCD-Display of newer machines.
628 ** lcd_print() disables/enables the timer-based led work queue to
629 ** avoid a race condition while writing the CMD/DATA register pair.
632 int lcd_print( const char *str
)
636 if (!led_func_ptr
|| lcd_info
.model
!= DISPLAY_MODEL_LCD
)
639 /* temporarily disable the led work task */
641 cancel_rearming_delayed_workqueue(led_wq
, &led_task
);
643 /* copy display string to buffer for procfs */
644 strlcpy(lcd_text
, str
, sizeof(lcd_text
));
646 /* Set LCD Cursor to 1st character */
647 gsc_writeb(lcd_info
.reset_cmd1
, LCD_CMD_REG
);
648 udelay(lcd_info
.min_cmd_delay
);
650 /* Print the string */
651 for (i
=0; i
< lcd_info
.lcd_width
; i
++) {
653 gsc_writeb(*str
++, LCD_DATA_REG
);
655 gsc_writeb(' ', LCD_DATA_REG
);
656 udelay(lcd_info
.min_cmd_delay
);
659 /* re-queue the work */
661 queue_delayed_work(led_wq
, &led_task
, 0);
664 return lcd_info
.lcd_width
;
670 ** led_init() is called very early in the bootup-process from setup.c
671 ** and asks the PDC for an usable chassis LCD or LED.
672 ** If the PDC doesn't return any info, then the LED
673 ** is detected by lasi.c or asp.c and registered with the
674 ** above functions lasi_led_init() or asp_led_init().
675 ** KittyHawk machines have often a buggy PDC, so that
676 ** we explicitly check for those machines here.
679 int __init
led_init(void)
681 struct pdc_chassis_info chassis_info
;
684 snprintf(lcd_text_default
, sizeof(lcd_text_default
),
685 "Linux %s", init_utsname()->release
);
687 /* Work around the buggy PDC of KittyHawk-machines */
688 switch (CPU_HVERSION
) {
689 case 0x580: /* KittyHawk DC2-100 (K100) */
690 case 0x581: /* KittyHawk DC3-120 (K210) */
691 case 0x582: /* KittyHawk DC3 100 (K400) */
692 case 0x583: /* KittyHawk DC3 120 (K410) */
693 case 0x58B: /* KittyHawk DC2 100 (K200) */
694 printk(KERN_INFO
"%s: KittyHawk-Machine (hversion 0x%x) found, "
695 "LED detection skipped.\n", __FILE__
, CPU_HVERSION
);
696 goto found
; /* use the preinitialized values of lcd_info */
699 /* initialize the struct, so that we can check for valid return values */
700 lcd_info
.model
= DISPLAY_MODEL_NONE
;
701 chassis_info
.actcnt
= chassis_info
.maxcnt
= 0;
703 ret
= pdc_chassis_info(&chassis_info
, &lcd_info
, sizeof(lcd_info
));
705 DPRINTK((KERN_INFO
"%s: chassis info: model=%d (%s), "
706 "lcd_width=%d, cmd_delay=%u,\n"
707 "%s: sizecnt=%d, actcnt=%ld, maxcnt=%ld\n",
708 __FILE__
, lcd_info
.model
,
709 (lcd_info
.model
==DISPLAY_MODEL_LCD
) ? "LCD" :
710 (lcd_info
.model
==DISPLAY_MODEL_LASI
) ? "LED" : "unknown",
711 lcd_info
.lcd_width
, lcd_info
.min_cmd_delay
,
712 __FILE__
, sizeof(lcd_info
),
713 chassis_info
.actcnt
, chassis_info
.maxcnt
));
714 DPRINTK((KERN_INFO
"%s: cmd=%p, data=%p, reset1=%x, reset2=%x, act_enable=%d\n",
715 __FILE__
, lcd_info
.lcd_cmd_reg_addr
,
716 lcd_info
.lcd_data_reg_addr
, lcd_info
.reset_cmd1
,
717 lcd_info
.reset_cmd2
, lcd_info
.act_enable
));
719 /* check the results. Some machines have a buggy PDC */
720 if (chassis_info
.actcnt
<= 0 || chassis_info
.actcnt
!= chassis_info
.maxcnt
)
723 switch (lcd_info
.model
) {
724 case DISPLAY_MODEL_LCD
: /* LCD display */
725 if (chassis_info
.actcnt
<
726 offsetof(struct pdc_chassis_lcd_info_ret_block
, _pad
)-1)
728 if (!lcd_info
.act_enable
) {
729 DPRINTK((KERN_INFO
"PDC prohibited usage of the LCD.\n"));
734 case DISPLAY_MODEL_NONE
: /* no LED or LCD available */
735 printk(KERN_INFO
"PDC reported no LCD or LED.\n");
738 case DISPLAY_MODEL_LASI
: /* Lasi style 8 bit LED display */
739 if (chassis_info
.actcnt
!= 8 && chassis_info
.actcnt
!= 32)
744 printk(KERN_WARNING
"PDC reported unknown LCD/LED model %d\n",
750 /* register the LCD/LED driver */
751 register_led_driver(lcd_info
.model
, LCD_CMD_REG
, LCD_DATA_REG
);
755 DPRINTK((KERN_INFO
"pdc_chassis_info call failed with retval = %d\n", ret
));
759 lcd_info
.model
= DISPLAY_MODEL_NONE
;
763 static void __exit
led_exit(void)
765 unregister_reboot_notifier(&led_notifier
);
769 #ifdef CONFIG_PROC_FS
770 module_init(led_create_procfs
)