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-2009 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/seq_file.h>
42 #include <linux/ctype.h>
43 #include <linux/blkdev.h>
44 #include <linux/workqueue.h>
45 #include <linux/rcupdate.h>
47 #include <asm/processor.h>
48 #include <asm/hardware.h>
49 #include <asm/param.h> /* HZ */
52 #include <asm/uaccess.h>
54 /* The control of the LEDs and LCDs on PARISC-machines have to be done
55 completely in software. The necessary calculations are done in a work queue
56 task which is scheduled regularly, and since the calculations may consume a
57 relatively large amount of CPU time, some of the calculations can be
58 turned off with the following variables (controlled via procfs) */
60 static int led_type __read_mostly
= -1;
61 static unsigned char lastleds
; /* LED state from most recent update */
62 static unsigned int led_heartbeat __read_mostly
= 1;
63 static unsigned int led_diskio __read_mostly
= 1;
64 static unsigned int led_lanrxtx __read_mostly
= 1;
65 static char lcd_text
[32] __read_mostly
;
66 static char lcd_text_default
[32] __read_mostly
;
69 static struct workqueue_struct
*led_wq
;
70 static void led_work_func(struct work_struct
*);
71 static DECLARE_DELAYED_WORK(led_task
, led_work_func
);
76 unsigned char command
; /* stores the command byte */
77 unsigned char on
; /* value for turning LED on */
78 unsigned char off
; /* value for turning LED off */
81 /* Structure returned by PDC_RETURN_CHASSIS_INFO */
82 /* NOTE: we use unsigned long:16 two times, since the following member
83 lcd_cmd_reg_addr needs to be 64bit aligned on 64bit PA2.0-machines */
84 struct pdc_chassis_lcd_info_ret_block
{
85 unsigned long model
:16; /* DISPLAY_MODEL_XXXX */
86 unsigned long lcd_width
:16; /* width of the LCD in chars (DISPLAY_MODEL_LCD only) */
87 unsigned long lcd_cmd_reg_addr
; /* ptr to LCD cmd-register & data ptr for LED */
88 unsigned long lcd_data_reg_addr
; /* ptr to LCD data-register (LCD only) */
89 unsigned int min_cmd_delay
; /* delay in uS after cmd-write (LCD only) */
90 unsigned char reset_cmd1
; /* command #1 for writing LCD string (LCD only) */
91 unsigned char reset_cmd2
; /* command #2 for writing LCD string (LCD only) */
92 unsigned char act_enable
; /* 0 = no activity (LCD only) */
93 struct lcd_block heartbeat
;
94 struct lcd_block disk_io
;
95 struct lcd_block lan_rcv
;
96 struct lcd_block lan_tx
;
101 /* LCD_CMD and LCD_DATA for KittyHawk machines */
102 #define KITTYHAWK_LCD_CMD F_EXTEND(0xf0190000UL) /* 64bit-ready */
103 #define KITTYHAWK_LCD_DATA (KITTYHAWK_LCD_CMD+1)
105 /* lcd_info is pre-initialized to the values needed to program KittyHawk LCD's
106 * HP seems to have used Sharp/Hitachi HD44780 LCDs most of the time. */
107 static struct pdc_chassis_lcd_info_ret_block
108 lcd_info
__attribute__((aligned(8))) __read_mostly
=
110 .model
= DISPLAY_MODEL_LCD
,
112 .lcd_cmd_reg_addr
= KITTYHAWK_LCD_CMD
,
113 .lcd_data_reg_addr
= KITTYHAWK_LCD_DATA
,
120 /* direct access to some of the lcd_info variables */
121 #define LCD_CMD_REG lcd_info.lcd_cmd_reg_addr
122 #define LCD_DATA_REG lcd_info.lcd_data_reg_addr
123 #define LED_DATA_REG lcd_info.lcd_cmd_reg_addr /* LASI & ASP only */
128 /* The workqueue must be created at init-time */
129 static int start_task(void)
131 /* Display the default text now */
132 if (led_type
== LED_HASLCD
) lcd_print( lcd_text_default
);
134 /* Create the work queue and queue the LED task */
135 led_wq
= create_singlethread_workqueue("led_wq");
136 queue_delayed_work(led_wq
, &led_task
, 0);
141 device_initcall(start_task
);
143 /* ptr to LCD/LED-specific function */
144 static void (*led_func_ptr
) (unsigned char) __read_mostly
;
146 #ifdef CONFIG_PROC_FS
147 static int led_proc_show(struct seq_file
*m
, void *v
)
149 switch ((long)m
->private)
152 seq_printf(m
, "Heartbeat: %d\n", led_heartbeat
);
153 seq_printf(m
, "Disk IO: %d\n", led_diskio
);
154 seq_printf(m
, "LAN Rx/Tx: %d\n", led_lanrxtx
);
157 seq_printf(m
, "%s\n", lcd_text
);
165 static int led_proc_open(struct inode
*inode
, struct file
*file
)
167 return single_open(file
, led_proc_show
, PDE(inode
)->data
);
171 static ssize_t
led_proc_write(struct file
*file
, const char *buf
,
172 size_t count
, loff_t
*pos
)
174 void *data
= PDE(file
->f_path
.dentry
->d_inode
)->data
;
178 if (!capable(CAP_SYS_ADMIN
))
181 if (count
>= sizeof(lbuf
))
182 count
= sizeof(lbuf
)-1;
184 if (copy_from_user(lbuf
, buf
, count
))
194 if (d
!= 0 && d
!= 1) goto parse_error
;
197 if (*cur
++ != ' ') goto parse_error
;
200 if (d
!= 0 && d
!= 1) goto parse_error
;
203 if (*cur
++ != ' ') goto parse_error
;
206 if (d
!= 0 && d
!= 1) goto parse_error
;
211 if (*cur
&& cur
[strlen(cur
)-1] == '\n')
212 cur
[strlen(cur
)-1] = 0;
214 cur
= lcd_text_default
;
224 if ((long)data
== LED_NOLCD
)
225 printk(KERN_CRIT
"Parse error: expect \"n n n\" (n == 0 or 1) for heartbeat,\ndisk io and lan tx/rx indicators\n");
229 static const struct file_operations led_proc_fops
= {
230 .owner
= THIS_MODULE
,
231 .open
= led_proc_open
,
234 .release
= single_release
,
235 .write
= led_proc_write
,
238 static int __init
led_create_procfs(void)
240 struct proc_dir_entry
*proc_pdc_root
= NULL
;
241 struct proc_dir_entry
*ent
;
243 if (led_type
== -1) return -1;
245 proc_pdc_root
= proc_mkdir("pdc", 0);
246 if (!proc_pdc_root
) return -1;
247 ent
= proc_create_data("led", S_IRUGO
|S_IWUSR
, proc_pdc_root
,
248 &led_proc_fops
, (void *)LED_NOLCD
); /* LED */
251 if (led_type
== LED_HASLCD
)
253 ent
= proc_create_data("lcd", S_IRUGO
|S_IWUSR
, proc_pdc_root
,
254 &led_proc_fops
, (void *)LED_HASLCD
); /* LCD */
267 #define LED_DATA 0x01 /* data to shift (0:on 1:off) */
268 #define LED_STROBE 0x02 /* strobe to clock data */
269 static void led_ASP_driver(unsigned char leds
)
274 for (i
= 0; i
< 8; i
++) {
276 value
= (leds
& 0x80) >> 7;
277 gsc_writeb( value
, LED_DATA_REG
);
278 gsc_writeb( value
| LED_STROBE
, LED_DATA_REG
);
289 static void led_LASI_driver(unsigned char leds
)
292 gsc_writeb( leds
, LED_DATA_REG
);
301 static void led_LCD_driver(unsigned char leds
)
304 static unsigned char mask
[4] = { LED_HEARTBEAT
, LED_DISK_IO
,
305 LED_LAN_RCV
, LED_LAN_TX
};
307 static struct lcd_block
* blockp
[4] = {
314 /* Convert min_cmd_delay to milliseconds */
315 unsigned int msec_cmd_delay
= 1 + (lcd_info
.min_cmd_delay
/ 1000);
319 if ((leds
& mask
[i
]) != (lastleds
& mask
[i
]))
321 gsc_writeb( blockp
[i
]->command
, LCD_CMD_REG
);
322 msleep(msec_cmd_delay
);
324 gsc_writeb( leds
& mask
[i
] ? blockp
[i
]->on
:
325 blockp
[i
]->off
, LCD_DATA_REG
);
326 msleep(msec_cmd_delay
);
334 ** led_get_net_activity()
336 ** calculate if there was TX- or RX-throughput on the network interfaces
337 ** (analog to dev_get_info() from net/core/dev.c)
340 static __inline__
int led_get_net_activity(void)
345 static unsigned long rx_total_last
, tx_total_last
;
346 unsigned long rx_total
, tx_total
;
347 struct net_device
*dev
;
350 rx_total
= tx_total
= 0;
352 /* we are running as a workqueue task, so we can use an RCU lookup */
354 for_each_netdev_rcu(&init_net
, dev
) {
355 const struct net_device_stats
*stats
;
356 struct rtnl_link_stats64 temp
;
357 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
358 if (!in_dev
|| !in_dev
->ifa_list
)
360 if (ipv4_is_loopback(in_dev
->ifa_list
->ifa_local
))
362 stats
= dev_get_stats(dev
, &temp
);
363 rx_total
+= stats
->rx_packets
;
364 tx_total
+= stats
->tx_packets
;
370 if (rx_total
!= rx_total_last
) {
371 rx_total_last
= rx_total
;
372 retval
|= LED_LAN_RCV
;
375 if (tx_total
!= tx_total_last
) {
376 tx_total_last
= tx_total
;
377 retval
|= LED_LAN_TX
;
387 ** led_get_diskio_activity()
389 ** calculate if there was disk-io in the system
392 static __inline__
int led_get_diskio_activity(void)
394 static unsigned long last_pgpgin
, last_pgpgout
;
395 unsigned long events
[NR_VM_EVENT_ITEMS
];
398 all_vm_events(events
);
400 /* Just use a very simple calculation here. Do not care about overflow,
401 since we only want to know if there was activity or not. */
402 changed
= (events
[PGPGIN
] != last_pgpgin
) ||
403 (events
[PGPGOUT
] != last_pgpgout
);
404 last_pgpgin
= events
[PGPGIN
];
405 last_pgpgout
= events
[PGPGOUT
];
407 return (changed
? LED_DISK_IO
: 0);
415 ** manages when and which chassis LCD/LED gets updated
418 - display load average (older machines like 715/64 have 4 "free" LED's for that)
422 #define HEARTBEAT_LEN (HZ*10/100)
423 #define HEARTBEAT_2ND_RANGE_START (HZ*28/100)
424 #define HEARTBEAT_2ND_RANGE_END (HEARTBEAT_2ND_RANGE_START + HEARTBEAT_LEN)
426 #define LED_UPDATE_INTERVAL (1 + (HZ*19/1000))
428 static void led_work_func (struct work_struct
*unused
)
430 static unsigned long last_jiffies
;
431 static unsigned long count_HZ
; /* counter in range 0..HZ */
432 unsigned char currentleds
= 0; /* stores current value of the LEDs */
434 /* exit if not initialized */
438 /* increment the heartbeat timekeeper */
439 count_HZ
+= jiffies
- last_jiffies
;
440 last_jiffies
= jiffies
;
444 if (likely(led_heartbeat
))
446 /* flash heartbeat-LED like a real heart
447 * (2 x short then a long delay)
449 if (count_HZ
< HEARTBEAT_LEN
||
450 (count_HZ
>= HEARTBEAT_2ND_RANGE_START
&&
451 count_HZ
< HEARTBEAT_2ND_RANGE_END
))
452 currentleds
|= LED_HEARTBEAT
;
455 if (likely(led_lanrxtx
)) currentleds
|= led_get_net_activity();
456 if (likely(led_diskio
)) currentleds
|= led_get_diskio_activity();
458 /* blink LEDs if we got an Oops (HPMC) */
459 if (unlikely(oops_in_progress
)) {
460 if (boot_cpu_data
.cpu_type
>= pcxl2
) {
461 /* newer machines don't have loadavg. LEDs, so we
462 * let all LEDs blink twice per second instead */
463 currentleds
= (count_HZ
<= (HZ
/2)) ? 0 : 0xff;
465 /* old machines: blink loadavg. LEDs twice per second */
466 if (count_HZ
<= (HZ
/2))
467 currentleds
&= ~(LED4
|LED5
|LED6
|LED7
);
469 currentleds
|= (LED4
|LED5
|LED6
|LED7
);
473 if (currentleds
!= lastleds
)
475 led_func_ptr(currentleds
); /* Update the LCD/LEDs */
476 lastleds
= currentleds
;
479 queue_delayed_work(led_wq
, &led_task
, LED_UPDATE_INTERVAL
);
485 ** called by the reboot notifier chain at shutdown and stops all
486 ** LED/LCD activities.
490 static int led_halt(struct notifier_block
*, unsigned long, void *);
492 static struct notifier_block led_notifier
= {
493 .notifier_call
= led_halt
,
495 static int notifier_disabled
= 0;
497 static int led_halt(struct notifier_block
*nb
, unsigned long event
, void *buf
)
501 if (notifier_disabled
)
504 notifier_disabled
= 1;
506 case SYS_RESTART
: txt
= "SYSTEM RESTART";
508 case SYS_HALT
: txt
= "SYSTEM HALT";
510 case SYS_POWER_OFF
: txt
= "SYSTEM POWER OFF";
512 default: return NOTIFY_DONE
;
515 /* Cancel the work item and delete the queue */
517 cancel_delayed_work_sync(&led_task
);
518 destroy_workqueue(led_wq
);
522 if (lcd_info
.model
== DISPLAY_MODEL_LCD
)
526 led_func_ptr(0xff); /* turn all LEDs ON */
532 ** register_led_driver()
534 ** registers an external LED or LCD for usage by this driver.
535 ** currently only LCD-, LASI- and ASP-style LCD/LED's are supported.
539 int __init
register_led_driver(int model
, unsigned long cmd_reg
, unsigned long data_reg
)
541 static int initialized
;
543 if (initialized
|| !data_reg
)
546 lcd_info
.model
= model
; /* store the values */
547 LCD_CMD_REG
= (cmd_reg
== LED_CMD_REG_NONE
) ? 0 : cmd_reg
;
549 switch (lcd_info
.model
) {
550 case DISPLAY_MODEL_LCD
:
551 LCD_DATA_REG
= data_reg
;
552 printk(KERN_INFO
"LCD display at %lx,%lx registered\n",
553 LCD_CMD_REG
, LCD_DATA_REG
);
554 led_func_ptr
= led_LCD_driver
;
555 led_type
= LED_HASLCD
;
558 case DISPLAY_MODEL_LASI
:
559 LED_DATA_REG
= data_reg
;
560 led_func_ptr
= led_LASI_driver
;
561 printk(KERN_INFO
"LED display at %lx registered\n", LED_DATA_REG
);
562 led_type
= LED_NOLCD
;
565 case DISPLAY_MODEL_OLD_ASP
:
566 LED_DATA_REG
= data_reg
;
567 led_func_ptr
= led_ASP_driver
;
568 printk(KERN_INFO
"LED (ASP-style) display at %lx registered\n",
570 led_type
= LED_NOLCD
;
574 printk(KERN_ERR
"%s: Wrong LCD/LED model %d !\n",
575 __func__
, lcd_info
.model
);
579 /* mark the LCD/LED driver now as initialized and
580 * register to the reboot notifier chain */
582 register_reboot_notifier(&led_notifier
);
584 /* Ensure the work is queued */
586 queue_delayed_work(led_wq
, &led_task
, 0);
593 ** register_led_regions()
595 ** register_led_regions() registers the LCD/LED regions for /procfs.
596 ** At bootup - where the initialisation of the LCD/LED normally happens -
597 ** not all internal structures of request_region() are properly set up,
598 ** so that we delay the led-registration until after busdevices_init()
599 ** has been executed.
603 void __init
register_led_regions(void)
605 switch (lcd_info
.model
) {
606 case DISPLAY_MODEL_LCD
:
607 request_mem_region((unsigned long)LCD_CMD_REG
, 1, "lcd_cmd");
608 request_mem_region((unsigned long)LCD_DATA_REG
, 1, "lcd_data");
610 case DISPLAY_MODEL_LASI
:
611 case DISPLAY_MODEL_OLD_ASP
:
612 request_mem_region((unsigned long)LED_DATA_REG
, 1, "led_data");
622 ** Displays the given string on the LCD-Display of newer machines.
623 ** lcd_print() disables/enables the timer-based led work queue to
624 ** avoid a race condition while writing the CMD/DATA register pair.
627 int lcd_print( const char *str
)
631 if (!led_func_ptr
|| lcd_info
.model
!= DISPLAY_MODEL_LCD
)
634 /* temporarily disable the led work task */
636 cancel_delayed_work_sync(&led_task
);
638 /* copy display string to buffer for procfs */
639 strlcpy(lcd_text
, str
, sizeof(lcd_text
));
641 /* Set LCD Cursor to 1st character */
642 gsc_writeb(lcd_info
.reset_cmd1
, LCD_CMD_REG
);
643 udelay(lcd_info
.min_cmd_delay
);
645 /* Print the string */
646 for (i
=0; i
< lcd_info
.lcd_width
; i
++) {
648 gsc_writeb(*str
++, LCD_DATA_REG
);
650 gsc_writeb(' ', LCD_DATA_REG
);
651 udelay(lcd_info
.min_cmd_delay
);
654 /* re-queue the work */
656 queue_delayed_work(led_wq
, &led_task
, 0);
659 return lcd_info
.lcd_width
;
665 ** led_init() is called very early in the bootup-process from setup.c
666 ** and asks the PDC for an usable chassis LCD or LED.
667 ** If the PDC doesn't return any info, then the LED
668 ** is detected by lasi.c or asp.c and registered with the
669 ** above functions lasi_led_init() or asp_led_init().
670 ** KittyHawk machines have often a buggy PDC, so that
671 ** we explicitly check for those machines here.
674 int __init
led_init(void)
676 struct pdc_chassis_info chassis_info
;
679 snprintf(lcd_text_default
, sizeof(lcd_text_default
),
680 "Linux %s", init_utsname()->release
);
682 switch (CPU_HVERSION
) {
683 case 0x580: /* KittyHawk DC2-100 (K100) */
684 case 0x581: /* KittyHawk DC3-120 (K210) */
685 case 0x582: /* KittyHawk DC3 100 (K400) */
686 case 0x583: /* KittyHawk DC3 120 (K410) */
687 case 0x58B: /* KittyHawk DC2 100 (K200) */
688 printk(KERN_INFO
"%s: KittyHawk-Machine (hversion 0x%x) found, "
689 "LED detection skipped.\n", __FILE__
, CPU_HVERSION
);
690 goto found
; /* use the preinitialized values of lcd_info */
693 /* initialize the struct, so that we can check for valid return values */
694 lcd_info
.model
= DISPLAY_MODEL_NONE
;
695 chassis_info
.actcnt
= chassis_info
.maxcnt
= 0;
697 ret
= pdc_chassis_info(&chassis_info
, &lcd_info
, sizeof(lcd_info
));
699 DPRINTK((KERN_INFO
"%s: chassis info: model=%d (%s), "
700 "lcd_width=%d, cmd_delay=%u,\n"
701 "%s: sizecnt=%d, actcnt=%ld, maxcnt=%ld\n",
702 __FILE__
, lcd_info
.model
,
703 (lcd_info
.model
==DISPLAY_MODEL_LCD
) ? "LCD" :
704 (lcd_info
.model
==DISPLAY_MODEL_LASI
) ? "LED" : "unknown",
705 lcd_info
.lcd_width
, lcd_info
.min_cmd_delay
,
706 __FILE__
, sizeof(lcd_info
),
707 chassis_info
.actcnt
, chassis_info
.maxcnt
));
708 DPRINTK((KERN_INFO
"%s: cmd=%p, data=%p, reset1=%x, reset2=%x, act_enable=%d\n",
709 __FILE__
, lcd_info
.lcd_cmd_reg_addr
,
710 lcd_info
.lcd_data_reg_addr
, lcd_info
.reset_cmd1
,
711 lcd_info
.reset_cmd2
, lcd_info
.act_enable
));
713 /* check the results. Some machines have a buggy PDC */
714 if (chassis_info
.actcnt
<= 0 || chassis_info
.actcnt
!= chassis_info
.maxcnt
)
717 switch (lcd_info
.model
) {
718 case DISPLAY_MODEL_LCD
: /* LCD display */
719 if (chassis_info
.actcnt
<
720 offsetof(struct pdc_chassis_lcd_info_ret_block
, _pad
)-1)
722 if (!lcd_info
.act_enable
) {
723 DPRINTK((KERN_INFO
"PDC prohibited usage of the LCD.\n"));
728 case DISPLAY_MODEL_NONE
: /* no LED or LCD available */
729 printk(KERN_INFO
"PDC reported no LCD or LED.\n");
732 case DISPLAY_MODEL_LASI
: /* Lasi style 8 bit LED display */
733 if (chassis_info
.actcnt
!= 8 && chassis_info
.actcnt
!= 32)
738 printk(KERN_WARNING
"PDC reported unknown LCD/LED model %d\n",
744 /* register the LCD/LED driver */
745 register_led_driver(lcd_info
.model
, LCD_CMD_REG
, LCD_DATA_REG
);
749 DPRINTK((KERN_INFO
"pdc_chassis_info call failed with retval = %d\n", ret
));
753 lcd_info
.model
= DISPLAY_MODEL_NONE
;
757 static void __exit
led_exit(void)
759 unregister_reboot_notifier(&led_notifier
);
763 #ifdef CONFIG_PROC_FS
764 module_init(led_create_procfs
)