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-2004 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>
23 #include <linux/config.h>
24 #include <linux/module.h>
25 #include <linux/stddef.h> /* for offsetof() */
26 #include <linux/init.h>
27 #include <linux/types.h>
28 #include <linux/ioport.h>
29 #include <linux/utsname.h>
30 #include <linux/delay.h>
31 #include <linux/netdevice.h>
32 #include <linux/inetdevice.h>
34 #include <linux/interrupt.h>
35 #include <linux/kernel_stat.h>
36 #include <linux/reboot.h>
37 #include <linux/proc_fs.h>
38 #include <linux/ctype.h>
39 #include <linux/blkdev.h>
40 #include <linux/rcupdate.h>
42 #include <asm/processor.h>
43 #include <asm/hardware.h>
44 #include <asm/param.h> /* HZ */
47 #include <asm/uaccess.h>
49 /* The control of the LEDs and LCDs on PARISC-machines have to be done
50 completely in software. The necessary calculations are done in a tasklet
51 which is scheduled at every timer interrupt and since the calculations
52 may consume relatively much CPU-time some of the calculations can be
53 turned off with the following variables (controlled via procfs) */
55 static int led_type
= -1;
56 static int led_heartbeat
= 1;
57 static int led_diskio
= 1;
58 static int led_lanrxtx
= 1;
59 static char lcd_text
[32];
60 static char lcd_text_default
[32];
63 #define DPRINTK(x) printk x
70 unsigned char command
; /* stores the command byte */
71 unsigned char on
; /* value for turning LED on */
72 unsigned char off
; /* value for turning LED off */
75 /* Structure returned by PDC_RETURN_CHASSIS_INFO */
76 /* NOTE: we use unsigned long:16 two times, since the following member
77 lcd_cmd_reg_addr needs to be 64bit aligned on 64bit PA2.0-machines */
78 struct pdc_chassis_lcd_info_ret_block
{
79 unsigned long model
:16; /* DISPLAY_MODEL_XXXX */
80 unsigned long lcd_width
:16; /* width of the LCD in chars (DISPLAY_MODEL_LCD only) */
81 unsigned long lcd_cmd_reg_addr
; /* ptr to LCD cmd-register & data ptr for LED */
82 unsigned long lcd_data_reg_addr
; /* ptr to LCD data-register (LCD only) */
83 unsigned int min_cmd_delay
; /* delay in uS after cmd-write (LCD only) */
84 unsigned char reset_cmd1
; /* command #1 for writing LCD string (LCD only) */
85 unsigned char reset_cmd2
; /* command #2 for writing LCD string (LCD only) */
86 unsigned char act_enable
; /* 0 = no activity (LCD only) */
87 struct lcd_block heartbeat
;
88 struct lcd_block disk_io
;
89 struct lcd_block lan_rcv
;
90 struct lcd_block lan_tx
;
95 /* LCD_CMD and LCD_DATA for KittyHawk machines */
96 #define KITTYHAWK_LCD_CMD F_EXTEND(0xf0190000UL) /* 64bit-ready */
97 #define KITTYHAWK_LCD_DATA (KITTYHAWK_LCD_CMD+1)
99 /* lcd_info is pre-initialized to the values needed to program KittyHawk LCD's
100 * HP seems to have used Sharp/Hitachi HD44780 LCDs most of the time. */
101 static struct pdc_chassis_lcd_info_ret_block
102 lcd_info
__attribute__((aligned(8))) =
104 .model
= DISPLAY_MODEL_LCD
,
106 .lcd_cmd_reg_addr
= KITTYHAWK_LCD_CMD
,
107 .lcd_data_reg_addr
= KITTYHAWK_LCD_DATA
,
114 /* direct access to some of the lcd_info variables */
115 #define LCD_CMD_REG lcd_info.lcd_cmd_reg_addr
116 #define LCD_DATA_REG lcd_info.lcd_data_reg_addr
117 #define LED_DATA_REG lcd_info.lcd_cmd_reg_addr /* LASI & ASP only */
120 /* ptr to LCD/LED-specific function */
121 static void (*led_func_ptr
) (unsigned char);
125 #ifdef CONFIG_PROC_FS
126 static int led_proc_read(char *page
, char **start
, off_t off
, int count
,
127 int *eof
, void *data
)
135 out
+= sprintf(out
, "Heartbeat: %d\n", led_heartbeat
);
136 out
+= sprintf(out
, "Disk IO: %d\n", led_diskio
);
137 out
+= sprintf(out
, "LAN Rx/Tx: %d\n", led_lanrxtx
);
140 out
+= sprintf(out
, "%s\n", lcd_text
);
147 len
= out
- page
- off
;
150 if (len
<= 0) return 0;
158 static int led_proc_write(struct file
*file
, const char *buf
,
159 unsigned long count
, void *data
)
161 char *cur
, lbuf
[count
+ 1];
164 if (!capable(CAP_SYS_ADMIN
))
167 memset(lbuf
, 0, count
+ 1);
169 if (copy_from_user(lbuf
, buf
, count
))
174 /* skip initial spaces */
175 while (*cur
&& isspace(*cur
))
184 if (d
!= 0 && d
!= 1) goto parse_error
;
187 if (*cur
++ != ' ') goto parse_error
;
190 if (d
!= 0 && d
!= 1) goto parse_error
;
193 if (*cur
++ != ' ') goto parse_error
;
196 if (d
!= 0 && d
!= 1) goto parse_error
;
201 if (*cur
&& cur
[strlen(cur
)-1] == '\n')
202 cur
[strlen(cur
)-1] = 0;
204 cur
= lcd_text_default
;
214 if ((long)data
== LED_NOLCD
)
215 printk(KERN_CRIT
"Parse error: expect \"n n n\" (n == 0 or 1) for heartbeat,\ndisk io and lan tx/rx indicators\n");
219 static int __init
led_create_procfs(void)
221 struct proc_dir_entry
*proc_pdc_root
= NULL
;
222 struct proc_dir_entry
*ent
;
224 if (led_type
== -1) return -1;
226 proc_pdc_root
= proc_mkdir("pdc", 0);
227 if (!proc_pdc_root
) return -1;
228 proc_pdc_root
->owner
= THIS_MODULE
;
229 ent
= create_proc_entry("led", S_IFREG
|S_IRUGO
|S_IWUSR
, proc_pdc_root
);
232 ent
->data
= (void *)LED_NOLCD
; /* LED */
233 ent
->read_proc
= led_proc_read
;
234 ent
->write_proc
= led_proc_write
;
235 ent
->owner
= THIS_MODULE
;
237 if (led_type
== LED_HASLCD
)
239 ent
= create_proc_entry("lcd", S_IFREG
|S_IRUGO
|S_IWUSR
, proc_pdc_root
);
242 ent
->data
= (void *)LED_HASLCD
; /* LCD */
243 ent
->read_proc
= led_proc_read
;
244 ent
->write_proc
= led_proc_write
;
245 ent
->owner
= THIS_MODULE
;
257 #define LED_DATA 0x01 /* data to shift (0:on 1:off) */
258 #define LED_STROBE 0x02 /* strobe to clock data */
259 static void led_ASP_driver(unsigned char leds
)
264 for (i
= 0; i
< 8; i
++) {
266 value
= (leds
& 0x80) >> 7;
267 gsc_writeb( value
, LED_DATA_REG
);
268 gsc_writeb( value
| LED_STROBE
, LED_DATA_REG
);
279 static void led_LASI_driver(unsigned char leds
)
282 gsc_writeb( leds
, LED_DATA_REG
);
290 ** The logic of the LCD driver is, that we write at every scheduled call
291 ** only to one of LCD_CMD_REG _or_ LCD_DATA_REG - registers.
292 ** That way we don't need to let this tasklet busywait for min_cmd_delay
295 ** TODO: check the value of "min_cmd_delay" against the value of HZ.
298 static void led_LCD_driver(unsigned char leds
)
300 static int last_index
; /* 0:heartbeat, 1:disk, 2:lan_in, 3:lan_out */
301 static int last_was_cmd
;/* 0: CMD was written last, 1: DATA was last */
302 struct lcd_block
*block_ptr
;
305 switch (last_index
) {
306 case 0: block_ptr
= &lcd_info
.heartbeat
;
307 value
= leds
& LED_HEARTBEAT
;
309 case 1: block_ptr
= &lcd_info
.disk_io
;
310 value
= leds
& LED_DISK_IO
;
312 case 2: block_ptr
= &lcd_info
.lan_rcv
;
313 value
= leds
& LED_LAN_RCV
;
315 case 3: block_ptr
= &lcd_info
.lan_tx
;
316 value
= leds
& LED_LAN_TX
;
318 default: /* should never happen: */
323 /* write the value to the LCD data port */
324 gsc_writeb( value
? block_ptr
->on
: block_ptr
->off
, LCD_DATA_REG
);
326 /* write the command-byte to the LCD command register */
327 gsc_writeb( block_ptr
->command
, LCD_CMD_REG
);
330 /* now update the vars for the next interrupt iteration */
331 if (++last_was_cmd
== 2) { /* switch between cmd & data */
333 if (++last_index
== 4)
334 last_index
= 0; /* switch back to heartbeat index */
341 ** led_get_net_activity()
343 ** calculate if there was TX- or RX-troughput on the network interfaces
344 ** (analog to dev_get_info() from net/core/dev.c)
347 static __inline__
int led_get_net_activity(void)
352 static unsigned long rx_total_last
, tx_total_last
;
353 unsigned long rx_total
, tx_total
;
354 struct net_device
*dev
;
357 rx_total
= tx_total
= 0;
359 /* we are running as tasklet, so locking dev_base
360 * for reading should be OK */
361 read_lock(&dev_base_lock
);
363 for (dev
= dev_base
; dev
; dev
= dev
->next
) {
364 struct net_device_stats
*stats
;
365 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
366 if (!in_dev
|| !in_dev
->ifa_list
)
368 if (LOOPBACK(in_dev
->ifa_list
->ifa_local
))
372 stats
= dev
->get_stats(dev
);
373 rx_total
+= stats
->rx_packets
;
374 tx_total
+= stats
->tx_packets
;
377 read_unlock(&dev_base_lock
);
381 if (rx_total
!= rx_total_last
) {
382 rx_total_last
= rx_total
;
383 retval
|= LED_LAN_RCV
;
386 if (tx_total
!= tx_total_last
) {
387 tx_total_last
= tx_total
;
388 retval
|= LED_LAN_TX
;
398 ** led_get_diskio_activity()
400 ** calculate if there was disk-io in the system
403 static __inline__
int led_get_diskio_activity(void)
405 static unsigned long last_pgpgin
, last_pgpgout
;
406 struct page_state pgstat
;
409 get_full_page_state(&pgstat
); /* get no of sectors in & out */
411 /* Just use a very simple calculation here. Do not care about overflow,
412 since we only want to know if there was activity or not. */
413 changed
= (pgstat
.pgpgin
!= last_pgpgin
) || (pgstat
.pgpgout
!= last_pgpgout
);
414 last_pgpgin
= pgstat
.pgpgin
;
415 last_pgpgout
= pgstat
.pgpgout
;
417 return (changed
? LED_DISK_IO
: 0);
423 ** led_tasklet_func()
425 ** is scheduled at every timer interrupt from time.c and
426 ** updates the chassis LCD/LED
429 - display load average (older machines like 715/64 have 4 "free" LED's for that)
433 #define HEARTBEAT_LEN (HZ*6/100)
434 #define HEARTBEAT_2ND_RANGE_START (HZ*22/100)
435 #define HEARTBEAT_2ND_RANGE_END (HEARTBEAT_2ND_RANGE_START + HEARTBEAT_LEN)
437 #define NORMALIZED_COUNT(count) (count/(HZ/100))
439 static void led_tasklet_func(unsigned long unused
)
441 static unsigned char lastleds
;
442 unsigned char currentleds
; /* stores current value of the LEDs */
443 static unsigned long count
; /* static incremented value, not wrapped */
444 static unsigned long count_HZ
; /* counter in range 0..HZ */
446 /* exit if not initialized */
450 /* increment the local counters */
452 if (++count_HZ
== HZ
)
455 currentleds
= lastleds
;
459 /* flash heartbeat-LED like a real heart (2 x short then a long delay) */
460 if (count_HZ
<HEARTBEAT_LEN
||
461 (count_HZ
>=HEARTBEAT_2ND_RANGE_START
&& count_HZ
<HEARTBEAT_2ND_RANGE_END
))
462 currentleds
|= LED_HEARTBEAT
;
464 currentleds
&= ~LED_HEARTBEAT
;
467 /* look for network activity and flash LEDs respectively */
468 if (led_lanrxtx
&& ((NORMALIZED_COUNT(count
)+(8/2)) & 7) == 0)
470 currentleds
&= ~(LED_LAN_RCV
| LED_LAN_TX
);
471 currentleds
|= led_get_net_activity();
474 /* avoid to calculate diskio-stats at same irq as netio-stats */
475 if (led_diskio
&& (NORMALIZED_COUNT(count
) & 7) == 0)
477 currentleds
&= ~LED_DISK_IO
;
478 currentleds
|= led_get_diskio_activity();
481 /* blink all LEDs twice a second if we got an Oops (HPMC) */
482 if (oops_in_progress
) {
483 currentleds
= (count_HZ
<=(HZ
/2)) ? 0 : 0xff;
486 /* update the LCD/LEDs */
487 if (currentleds
!= lastleds
) {
488 led_func_ptr(currentleds
);
489 lastleds
= currentleds
;
493 /* main led tasklet struct (scheduled from time.c) */
494 DECLARE_TASKLET_DISABLED(led_tasklet
, led_tasklet_func
, 0);
500 ** called by the reboot notifier chain at shutdown and stops all
501 ** LED/LCD activities.
505 static int led_halt(struct notifier_block
*, unsigned long, void *);
507 static struct notifier_block led_notifier
= {
508 .notifier_call
= led_halt
,
511 static int led_halt(struct notifier_block
*nb
, unsigned long event
, void *buf
)
516 case SYS_RESTART
: txt
= "SYSTEM RESTART";
518 case SYS_HALT
: txt
= "SYSTEM HALT";
520 case SYS_POWER_OFF
: txt
= "SYSTEM POWER OFF";
522 default: return NOTIFY_DONE
;
525 /* completely stop the LED/LCD tasklet */
526 tasklet_disable(&led_tasklet
);
528 if (lcd_info
.model
== DISPLAY_MODEL_LCD
)
532 led_func_ptr(0xff); /* turn all LEDs ON */
534 unregister_reboot_notifier(&led_notifier
);
539 ** register_led_driver()
541 ** registers an external LED or LCD for usage by this driver.
542 ** currently only LCD-, LASI- and ASP-style LCD/LED's are supported.
546 int __init
register_led_driver(int model
, unsigned long cmd_reg
, unsigned long data_reg
)
548 static int initialized
;
550 if (initialized
|| !data_reg
)
553 lcd_info
.model
= model
; /* store the values */
554 LCD_CMD_REG
= (cmd_reg
== LED_CMD_REG_NONE
) ? 0 : cmd_reg
;
556 switch (lcd_info
.model
) {
557 case DISPLAY_MODEL_LCD
:
558 LCD_DATA_REG
= data_reg
;
559 printk(KERN_INFO
"LCD display at %lx,%lx registered\n",
560 LCD_CMD_REG
, LCD_DATA_REG
);
561 led_func_ptr
= led_LCD_driver
;
562 lcd_print( lcd_text_default
);
563 led_type
= LED_HASLCD
;
566 case DISPLAY_MODEL_LASI
:
567 LED_DATA_REG
= data_reg
;
568 led_func_ptr
= led_LASI_driver
;
569 printk(KERN_INFO
"LED display at %lx registered\n", LED_DATA_REG
);
570 led_type
= LED_NOLCD
;
573 case DISPLAY_MODEL_OLD_ASP
:
574 LED_DATA_REG
= data_reg
;
575 led_func_ptr
= led_ASP_driver
;
576 printk(KERN_INFO
"LED (ASP-style) display at %lx registered\n",
578 led_type
= LED_NOLCD
;
582 printk(KERN_ERR
"%s: Wrong LCD/LED model %d !\n",
583 __FUNCTION__
, lcd_info
.model
);
587 /* mark the LCD/LED driver now as initialized and
588 * register to the reboot notifier chain */
590 register_reboot_notifier(&led_notifier
);
592 /* start the led tasklet for the first time */
593 tasklet_enable(&led_tasklet
);
599 ** register_led_regions()
601 ** register_led_regions() registers the LCD/LED regions for /procfs.
602 ** At bootup - where the initialisation of the LCD/LED normally happens -
603 ** not all internal structures of request_region() are properly set up,
604 ** so that we delay the led-registration until after busdevices_init()
605 ** has been executed.
609 void __init
register_led_regions(void)
611 switch (lcd_info
.model
) {
612 case DISPLAY_MODEL_LCD
:
613 request_mem_region((unsigned long)LCD_CMD_REG
, 1, "lcd_cmd");
614 request_mem_region((unsigned long)LCD_DATA_REG
, 1, "lcd_data");
616 case DISPLAY_MODEL_LASI
:
617 case DISPLAY_MODEL_OLD_ASP
:
618 request_mem_region((unsigned long)LED_DATA_REG
, 1, "led_data");
628 ** Displays the given string on the LCD-Display of newer machines.
629 ** lcd_print() disables the timer-based led tasklet during its
630 ** execution and enables it afterwards again.
633 int lcd_print( char *str
)
637 if (!led_func_ptr
|| lcd_info
.model
!= DISPLAY_MODEL_LCD
)
640 /* temporarily disable the led tasklet */
641 tasklet_disable(&led_tasklet
);
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-enable the led tasklet */
660 tasklet_enable(&led_tasklet
);
662 return lcd_info
.lcd_width
;
668 ** led_init() is called very early in the bootup-process from setup.c
669 ** and asks the PDC for an usable chassis LCD or LED.
670 ** If the PDC doesn't return any info, then the LED
671 ** is detected by lasi.c or asp.c and registered with the
672 ** above functions lasi_led_init() or asp_led_init().
673 ** KittyHawk machines have often a buggy PDC, so that
674 ** we explicitly check for those machines here.
677 int __init
led_init(void)
679 struct pdc_chassis_info chassis_info
;
682 snprintf(lcd_text_default
, sizeof(lcd_text_default
),
683 "Linux %s", system_utsname
.release
);
685 /* Work around the buggy PDC of KittyHawk-machines */
686 switch (CPU_HVERSION
) {
687 case 0x580: /* KittyHawk DC2-100 (K100) */
688 case 0x581: /* KittyHawk DC3-120 (K210) */
689 case 0x582: /* KittyHawk DC3 100 (K400) */
690 case 0x583: /* KittyHawk DC3 120 (K410) */
691 case 0x58B: /* KittyHawk DC2 100 (K200) */
692 printk(KERN_INFO
"%s: KittyHawk-Machine (hversion 0x%x) found, "
693 "LED detection skipped.\n", __FILE__
, CPU_HVERSION
);
694 goto found
; /* use the preinitialized values of lcd_info */
697 /* initialize the struct, so that we can check for valid return values */
698 lcd_info
.model
= DISPLAY_MODEL_NONE
;
699 chassis_info
.actcnt
= chassis_info
.maxcnt
= 0;
701 ret
= pdc_chassis_info(&chassis_info
, &lcd_info
, sizeof(lcd_info
));
703 DPRINTK((KERN_INFO
"%s: chassis info: model=%d (%s), "
704 "lcd_width=%d, cmd_delay=%u,\n"
705 "%s: sizecnt=%d, actcnt=%ld, maxcnt=%ld\n",
706 __FILE__
, lcd_info
.model
,
707 (lcd_info
.model
==DISPLAY_MODEL_LCD
) ? "LCD" :
708 (lcd_info
.model
==DISPLAY_MODEL_LASI
) ? "LED" : "unknown",
709 lcd_info
.lcd_width
, lcd_info
.min_cmd_delay
,
710 __FILE__
, sizeof(lcd_info
),
711 chassis_info
.actcnt
, chassis_info
.maxcnt
));
712 DPRINTK((KERN_INFO
"%s: cmd=%p, data=%p, reset1=%x, reset2=%x, act_enable=%d\n",
713 __FILE__
, lcd_info
.lcd_cmd_reg_addr
,
714 lcd_info
.lcd_data_reg_addr
, lcd_info
.reset_cmd1
,
715 lcd_info
.reset_cmd2
, lcd_info
.act_enable
));
717 /* check the results. Some machines have a buggy PDC */
718 if (chassis_info
.actcnt
<= 0 || chassis_info
.actcnt
!= chassis_info
.maxcnt
)
721 switch (lcd_info
.model
) {
722 case DISPLAY_MODEL_LCD
: /* LCD display */
723 if (chassis_info
.actcnt
<
724 offsetof(struct pdc_chassis_lcd_info_ret_block
, _pad
)-1)
726 if (!lcd_info
.act_enable
) {
727 DPRINTK((KERN_INFO
"PDC prohibited usage of the LCD.\n"));
732 case DISPLAY_MODEL_NONE
: /* no LED or LCD available */
733 printk(KERN_INFO
"PDC reported no LCD or LED.\n");
736 case DISPLAY_MODEL_LASI
: /* Lasi style 8 bit LED display */
737 if (chassis_info
.actcnt
!= 8 && chassis_info
.actcnt
!= 32)
742 printk(KERN_WARNING
"PDC reported unknown LCD/LED model %d\n",
748 /* register the LCD/LED driver */
749 register_led_driver(lcd_info
.model
, LCD_CMD_REG
, LCD_DATA_REG
);
753 DPRINTK((KERN_INFO
"pdc_chassis_info call failed with retval = %d\n", ret
));
757 lcd_info
.model
= DISPLAY_MODEL_NONE
;
761 #ifdef CONFIG_PROC_FS
762 module_init(led_create_procfs
)