blob: 188bc8496a264feb05758e36cd7c2e23dea37b63 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Chassis LCD/LED driver for HP-PARISC workstations
3 *
4 * (c) Copyright 2000 Red Hat Software
5 * (c) Copyright 2000 Helge Deller <hdeller@redhat.com>
Helge Deller8a1def42009-01-06 14:23:13 +01006 * (c) Copyright 2001-2009 Helge Deller <deller@gmx.de>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * (c) Copyright 2001 Randolph Chung <tausq@debian.org>
8 *
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.
13 *
14 * TODO:
15 * - speed-up calculations with inlined assembler
16 * - interface to write to second row of LCD from /proc (if technically possible)
17 *
18 * Changes:
19 * - Audit copy_from_user in led_proc_write.
20 * Daniele Bellucci <bellucda@tiscali.it>
Grant Grundler34994952005-10-21 22:46:18 -040021 * - Switch from using a tasklet to a work queue, so the led_LCD_driver
22 * can sleep.
23 * David Pye <dmp@davidmpye.dyndns.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 */
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#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>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080032#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/delay.h>
34#include <linux/netdevice.h>
35#include <linux/inetdevice.h>
36#include <linux/in.h>
37#include <linux/interrupt.h>
38#include <linux/kernel_stat.h>
39#include <linux/reboot.h>
40#include <linux/proc_fs.h>
Alexey Dobriyan217bfb52009-11-27 06:51:12 +000041#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/ctype.h>
43#include <linux/blkdev.h>
Grant Grundler34994952005-10-21 22:46:18 -040044#include <linux/workqueue.h>
Herbert Xue5ed6392005-10-03 14:35:55 -070045#include <linux/rcupdate.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <asm/io.h>
47#include <asm/processor.h>
48#include <asm/hardware.h>
49#include <asm/param.h> /* HZ */
50#include <asm/led.h>
51#include <asm/pdc.h>
52#include <asm/uaccess.h>
53
54/* The control of the LEDs and LCDs on PARISC-machines have to be done
Grant Grundler34994952005-10-21 22:46:18 -040055 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 turned off with the following variables (controlled via procfs) */
59
Helge Deller8039de12006-01-10 20:35:03 -050060static int led_type __read_mostly = -1;
Grant Grundler34994952005-10-21 22:46:18 -040061static unsigned char lastleds; /* LED state from most recent update */
Helge Deller8039de12006-01-10 20:35:03 -050062static unsigned int led_heartbeat __read_mostly = 1;
63static unsigned int led_diskio __read_mostly = 1;
64static unsigned int led_lanrxtx __read_mostly = 1;
65static char lcd_text[32] __read_mostly;
66static char lcd_text_default[32] __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Grant Grundler34994952005-10-21 22:46:18 -040068
69static struct workqueue_struct *led_wq;
David Howells6858f3b2006-12-07 15:31:38 +000070static void led_work_func(struct work_struct *);
71static DECLARE_DELAYED_WORK(led_task, led_work_func);
Grant Grundler34994952005-10-21 22:46:18 -040072
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#if 0
74#define DPRINTK(x) printk x
75#else
76#define DPRINTK(x)
77#endif
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079struct lcd_block {
80 unsigned char command; /* stores the command byte */
81 unsigned char on; /* value for turning LED on */
82 unsigned char off; /* value for turning LED off */
83};
84
85/* Structure returned by PDC_RETURN_CHASSIS_INFO */
86/* NOTE: we use unsigned long:16 two times, since the following member
87 lcd_cmd_reg_addr needs to be 64bit aligned on 64bit PA2.0-machines */
88struct pdc_chassis_lcd_info_ret_block {
89 unsigned long model:16; /* DISPLAY_MODEL_XXXX */
90 unsigned long lcd_width:16; /* width of the LCD in chars (DISPLAY_MODEL_LCD only) */
91 unsigned long lcd_cmd_reg_addr; /* ptr to LCD cmd-register & data ptr for LED */
92 unsigned long lcd_data_reg_addr; /* ptr to LCD data-register (LCD only) */
93 unsigned int min_cmd_delay; /* delay in uS after cmd-write (LCD only) */
94 unsigned char reset_cmd1; /* command #1 for writing LCD string (LCD only) */
95 unsigned char reset_cmd2; /* command #2 for writing LCD string (LCD only) */
96 unsigned char act_enable; /* 0 = no activity (LCD only) */
97 struct lcd_block heartbeat;
98 struct lcd_block disk_io;
99 struct lcd_block lan_rcv;
100 struct lcd_block lan_tx;
101 char _pad;
102};
103
104
105/* LCD_CMD and LCD_DATA for KittyHawk machines */
106#define KITTYHAWK_LCD_CMD F_EXTEND(0xf0190000UL) /* 64bit-ready */
107#define KITTYHAWK_LCD_DATA (KITTYHAWK_LCD_CMD+1)
108
109/* lcd_info is pre-initialized to the values needed to program KittyHawk LCD's
110 * HP seems to have used Sharp/Hitachi HD44780 LCDs most of the time. */
111static struct pdc_chassis_lcd_info_ret_block
Helge Deller8039de12006-01-10 20:35:03 -0500112lcd_info __attribute__((aligned(8))) __read_mostly =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
114 .model = DISPLAY_MODEL_LCD,
115 .lcd_width = 16,
116 .lcd_cmd_reg_addr = KITTYHAWK_LCD_CMD,
117 .lcd_data_reg_addr = KITTYHAWK_LCD_DATA,
118 .min_cmd_delay = 40,
119 .reset_cmd1 = 0x80,
120 .reset_cmd2 = 0xc0,
121};
122
123
124/* direct access to some of the lcd_info variables */
125#define LCD_CMD_REG lcd_info.lcd_cmd_reg_addr
126#define LCD_DATA_REG lcd_info.lcd_data_reg_addr
127#define LED_DATA_REG lcd_info.lcd_cmd_reg_addr /* LASI & ASP only */
128
Grant Grundler34994952005-10-21 22:46:18 -0400129#define LED_HASLCD 1
130#define LED_NOLCD 0
131
132/* The workqueue must be created at init-time */
133static int start_task(void)
134{
135 /* Display the default text now */
136 if (led_type == LED_HASLCD) lcd_print( lcd_text_default );
137
138 /* Create the work queue and queue the LED task */
139 led_wq = create_singlethread_workqueue("led_wq");
David Howells6858f3b2006-12-07 15:31:38 +0000140 queue_delayed_work(led_wq, &led_task, 0);
Grant Grundler34994952005-10-21 22:46:18 -0400141
142 return 0;
143}
144
145device_initcall(start_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147/* ptr to LCD/LED-specific function */
Helge Deller8039de12006-01-10 20:35:03 -0500148static void (*led_func_ptr) (unsigned char) __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150#ifdef CONFIG_PROC_FS
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000151static int led_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000153 switch ((long)m->private)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 {
155 case LED_NOLCD:
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000156 seq_printf(m, "Heartbeat: %d\n", led_heartbeat);
157 seq_printf(m, "Disk IO: %d\n", led_diskio);
158 seq_printf(m, "LAN Rx/Tx: %d\n", led_lanrxtx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 break;
160 case LED_HASLCD:
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000161 seq_printf(m, "%s\n", lcd_text);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 break;
163 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 return 0;
165 }
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000166 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000169static int led_proc_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000171 return single_open(file, led_proc_show, PDE(inode)->data);
172}
173
174
175static ssize_t led_proc_write(struct file *file, const char *buf,
176 size_t count, loff_t *pos)
177{
178 void *data = PDE(file->f_path.dentry->d_inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 char *cur, lbuf[count + 1];
180 int d;
181
182 if (!capable(CAP_SYS_ADMIN))
183 return -EACCES;
184
185 memset(lbuf, 0, count + 1);
186
187 if (copy_from_user(lbuf, buf, count))
188 return -EFAULT;
189
190 cur = lbuf;
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 switch ((long)data)
193 {
194 case LED_NOLCD:
195 d = *cur++ - '0';
196 if (d != 0 && d != 1) goto parse_error;
197 led_heartbeat = d;
198
199 if (*cur++ != ' ') goto parse_error;
200
201 d = *cur++ - '0';
202 if (d != 0 && d != 1) goto parse_error;
203 led_diskio = d;
204
205 if (*cur++ != ' ') goto parse_error;
206
207 d = *cur++ - '0';
208 if (d != 0 && d != 1) goto parse_error;
209 led_lanrxtx = d;
210
211 break;
212 case LED_HASLCD:
213 if (*cur && cur[strlen(cur)-1] == '\n')
214 cur[strlen(cur)-1] = 0;
215 if (*cur == 0)
216 cur = lcd_text_default;
217 lcd_print(cur);
218 break;
219 default:
220 return 0;
221 }
222
223 return count;
224
225parse_error:
226 if ((long)data == LED_NOLCD)
227 printk(KERN_CRIT "Parse error: expect \"n n n\" (n == 0 or 1) for heartbeat,\ndisk io and lan tx/rx indicators\n");
228 return -EINVAL;
229}
230
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000231static const struct file_operations led_proc_fops = {
232 .owner = THIS_MODULE,
233 .open = led_proc_open,
234 .read = seq_read,
235 .llseek = seq_lseek,
236 .release = single_release,
237 .write = led_proc_write,
238};
239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240static int __init led_create_procfs(void)
241{
242 struct proc_dir_entry *proc_pdc_root = NULL;
243 struct proc_dir_entry *ent;
244
245 if (led_type == -1) return -1;
246
247 proc_pdc_root = proc_mkdir("pdc", 0);
248 if (!proc_pdc_root) return -1;
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000249 ent = proc_create_data("led", S_IRUGO|S_IWUSR, proc_pdc_root,
250 &led_proc_fops, (void *)LED_NOLCD); /* LED */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (!ent) return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 if (led_type == LED_HASLCD)
254 {
Alexey Dobriyan217bfb52009-11-27 06:51:12 +0000255 ent = proc_create_data("lcd", S_IRUGO|S_IWUSR, proc_pdc_root,
256 &led_proc_fops, (void *)LED_HASLCD); /* LCD */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 if (!ent) return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 }
259
260 return 0;
261}
262#endif
263
264/*
265 **
266 ** led_ASP_driver()
267 **
268 */
269#define LED_DATA 0x01 /* data to shift (0:on 1:off) */
270#define LED_STROBE 0x02 /* strobe to clock data */
271static void led_ASP_driver(unsigned char leds)
272{
273 int i;
274
275 leds = ~leds;
276 for (i = 0; i < 8; i++) {
277 unsigned char value;
278 value = (leds & 0x80) >> 7;
279 gsc_writeb( value, LED_DATA_REG );
280 gsc_writeb( value | LED_STROBE, LED_DATA_REG );
281 leds <<= 1;
282 }
283}
284
285
286/*
287 **
288 ** led_LASI_driver()
289 **
290 */
291static void led_LASI_driver(unsigned char leds)
292{
293 leds = ~leds;
294 gsc_writeb( leds, LED_DATA_REG );
295}
296
297
298/*
299 **
300 ** led_LCD_driver()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 **
302 */
303static void led_LCD_driver(unsigned char leds)
304{
Grant Grundler34994952005-10-21 22:46:18 -0400305 static int i;
306 static unsigned char mask[4] = { LED_HEARTBEAT, LED_DISK_IO,
307 LED_LAN_RCV, LED_LAN_TX };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
Grant Grundler34994952005-10-21 22:46:18 -0400309 static struct lcd_block * blockp[4] = {
310 &lcd_info.heartbeat,
311 &lcd_info.disk_io,
312 &lcd_info.lan_rcv,
313 &lcd_info.lan_tx
314 };
315
316 /* Convert min_cmd_delay to milliseconds */
317 unsigned int msec_cmd_delay = 1 + (lcd_info.min_cmd_delay / 1000);
318
319 for (i=0; i<4; ++i)
320 {
321 if ((leds & mask[i]) != (lastleds & mask[i]))
322 {
323 gsc_writeb( blockp[i]->command, LCD_CMD_REG );
324 msleep(msec_cmd_delay);
325
326 gsc_writeb( leds & mask[i] ? blockp[i]->on :
327 blockp[i]->off, LCD_DATA_REG );
328 msleep(msec_cmd_delay);
329 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 }
331}
332
333
334/*
335 **
336 ** led_get_net_activity()
337 **
Adrian Bunk93b1fae2006-01-10 00:13:33 +0100338 ** calculate if there was TX- or RX-throughput on the network interfaces
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 ** (analog to dev_get_info() from net/core/dev.c)
340 **
341 */
342static __inline__ int led_get_net_activity(void)
343{
344#ifndef CONFIG_NET
345 return 0;
346#else
347 static unsigned long rx_total_last, tx_total_last;
348 unsigned long rx_total, tx_total;
349 struct net_device *dev;
350 int retval;
351
352 rx_total = tx_total = 0;
353
Eric Dumazet246c65a2009-11-09 18:07:28 +0000354 /* we are running as a workqueue task, so we can use an RCU lookup */
Herbert Xue5ed6392005-10-03 14:35:55 -0700355 rcu_read_lock();
Eric Dumazet246c65a2009-11-09 18:07:28 +0000356 for_each_netdev_rcu(&init_net, dev) {
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -0800357 const struct net_device_stats *stats;
Herbert Xue5ed6392005-10-03 14:35:55 -0700358 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (!in_dev || !in_dev->ifa_list)
360 continue;
Joe Perches17159b02007-12-16 20:28:24 -0800361 if (ipv4_is_loopback(in_dev->ifa_list->ifa_local))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 continue;
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -0800363 stats = dev_get_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 rx_total += stats->rx_packets;
365 tx_total += stats->tx_packets;
366 }
Herbert Xue5ed6392005-10-03 14:35:55 -0700367 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
369 retval = 0;
370
371 if (rx_total != rx_total_last) {
372 rx_total_last = rx_total;
373 retval |= LED_LAN_RCV;
374 }
375
376 if (tx_total != tx_total_last) {
377 tx_total_last = tx_total;
378 retval |= LED_LAN_TX;
379 }
380
381 return retval;
382#endif
383}
384
385
386/*
387 **
388 ** led_get_diskio_activity()
389 **
390 ** calculate if there was disk-io in the system
391 **
392 */
393static __inline__ int led_get_diskio_activity(void)
394{
395 static unsigned long last_pgpgin, last_pgpgout;
Christoph Lameterf8891e52006-06-30 01:55:45 -0700396 unsigned long events[NR_VM_EVENT_ITEMS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 int changed;
Grant Grundler34994952005-10-21 22:46:18 -0400398
Christoph Lameterf8891e52006-06-30 01:55:45 -0700399 all_vm_events(events);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 /* Just use a very simple calculation here. Do not care about overflow,
402 since we only want to know if there was activity or not. */
Christoph Lameterf8891e52006-06-30 01:55:45 -0700403 changed = (events[PGPGIN] != last_pgpgin) ||
404 (events[PGPGOUT] != last_pgpgout);
405 last_pgpgin = events[PGPGIN];
406 last_pgpgout = events[PGPGOUT];
Grant Grundler34994952005-10-21 22:46:18 -0400407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 return (changed ? LED_DISK_IO : 0);
409}
410
411
412
413/*
Grant Grundler34994952005-10-21 22:46:18 -0400414 ** led_work_func()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 **
Grant Grundler34994952005-10-21 22:46:18 -0400416 ** manages when and which chassis LCD/LED gets updated
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
418 TODO:
419 - display load average (older machines like 715/64 have 4 "free" LED's for that)
420 - optimizations
421 */
422
Grant Grundler34994952005-10-21 22:46:18 -0400423#define HEARTBEAT_LEN (HZ*10/100)
424#define HEARTBEAT_2ND_RANGE_START (HZ*28/100)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425#define HEARTBEAT_2ND_RANGE_END (HEARTBEAT_2ND_RANGE_START + HEARTBEAT_LEN)
426
Grant Grundler34994952005-10-21 22:46:18 -0400427#define LED_UPDATE_INTERVAL (1 + (HZ*19/1000))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
David Howells6858f3b2006-12-07 15:31:38 +0000429static void led_work_func (struct work_struct *unused)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
Grant Grundler34994952005-10-21 22:46:18 -0400431 static unsigned long last_jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 static unsigned long count_HZ; /* counter in range 0..HZ */
Grant Grundler34994952005-10-21 22:46:18 -0400433 unsigned char currentleds = 0; /* stores current value of the LEDs */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435 /* exit if not initialized */
436 if (!led_func_ptr)
437 return;
438
Grant Grundler34994952005-10-21 22:46:18 -0400439 /* increment the heartbeat timekeeper */
440 count_HZ += jiffies - last_jiffies;
441 last_jiffies = jiffies;
442 if (count_HZ >= HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 count_HZ = 0;
444
Grant Grundler34994952005-10-21 22:46:18 -0400445 if (likely(led_heartbeat))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 {
Grant Grundler34994952005-10-21 22:46:18 -0400447 /* flash heartbeat-LED like a real heart
448 * (2 x short then a long delay)
449 */
450 if (count_HZ < HEARTBEAT_LEN ||
451 (count_HZ >= HEARTBEAT_2ND_RANGE_START &&
452 count_HZ < HEARTBEAT_2ND_RANGE_END))
453 currentleds |= LED_HEARTBEAT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 }
455
Grant Grundler34994952005-10-21 22:46:18 -0400456 if (likely(led_lanrxtx)) currentleds |= led_get_net_activity();
457 if (likely(led_diskio)) currentleds |= led_get_diskio_activity();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Helge Deller8a1def42009-01-06 14:23:13 +0100459 /* blink LEDs if we got an Oops (HPMC) */
460 if (unlikely(oops_in_progress)) {
461 if (boot_cpu_data.cpu_type >= pcxl2) {
462 /* newer machines don't have loadavg. LEDs, so we
463 * let all LEDs blink twice per second instead */
464 currentleds = (count_HZ <= (HZ/2)) ? 0 : 0xff;
465 } else {
466 /* old machines: blink loadavg. LEDs twice per second */
467 if (count_HZ <= (HZ/2))
468 currentleds &= ~(LED4|LED5|LED6|LED7);
469 else
470 currentleds |= (LED4|LED5|LED6|LED7);
471 }
472 }
Grant Grundler34994952005-10-21 22:46:18 -0400473
474 if (currentleds != lastleds)
475 {
476 led_func_ptr(currentleds); /* Update the LCD/LEDs */
477 lastleds = currentleds;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 }
Grant Grundler34994952005-10-21 22:46:18 -0400479
480 queue_delayed_work(led_wq, &led_task, LED_UPDATE_INTERVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481}
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483/*
484 ** led_halt()
485 **
486 ** called by the reboot notifier chain at shutdown and stops all
487 ** LED/LCD activities.
488 **
489 */
490
491static int led_halt(struct notifier_block *, unsigned long, void *);
492
493static struct notifier_block led_notifier = {
494 .notifier_call = led_halt,
495};
Alan Sterne041c682006-03-27 01:16:30 -0800496static int notifier_disabled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498static int led_halt(struct notifier_block *nb, unsigned long event, void *buf)
499{
500 char *txt;
Alan Sterne041c682006-03-27 01:16:30 -0800501
502 if (notifier_disabled)
503 return NOTIFY_OK;
504
505 notifier_disabled = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 switch (event) {
507 case SYS_RESTART: txt = "SYSTEM RESTART";
508 break;
509 case SYS_HALT: txt = "SYSTEM HALT";
510 break;
511 case SYS_POWER_OFF: txt = "SYSTEM POWER OFF";
512 break;
513 default: return NOTIFY_DONE;
514 }
515
Grant Grundler34994952005-10-21 22:46:18 -0400516 /* Cancel the work item and delete the queue */
517 if (led_wq) {
Helge Deller8a1def42009-01-06 14:23:13 +0100518 cancel_delayed_work_sync(&led_task);
Grant Grundler34994952005-10-21 22:46:18 -0400519 destroy_workqueue(led_wq);
520 led_wq = NULL;
521 }
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (lcd_info.model == DISPLAY_MODEL_LCD)
524 lcd_print(txt);
525 else
526 if (led_func_ptr)
527 led_func_ptr(0xff); /* turn all LEDs ON */
528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 return NOTIFY_OK;
530}
531
532/*
533 ** register_led_driver()
534 **
535 ** registers an external LED or LCD for usage by this driver.
536 ** currently only LCD-, LASI- and ASP-style LCD/LED's are supported.
537 **
538 */
539
540int __init register_led_driver(int model, unsigned long cmd_reg, unsigned long data_reg)
541{
542 static int initialized;
543
544 if (initialized || !data_reg)
545 return 1;
546
547 lcd_info.model = model; /* store the values */
548 LCD_CMD_REG = (cmd_reg == LED_CMD_REG_NONE) ? 0 : cmd_reg;
549
550 switch (lcd_info.model) {
551 case DISPLAY_MODEL_LCD:
552 LCD_DATA_REG = data_reg;
553 printk(KERN_INFO "LCD display at %lx,%lx registered\n",
554 LCD_CMD_REG , LCD_DATA_REG);
555 led_func_ptr = led_LCD_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 led_type = LED_HASLCD;
557 break;
558
559 case DISPLAY_MODEL_LASI:
560 LED_DATA_REG = data_reg;
561 led_func_ptr = led_LASI_driver;
562 printk(KERN_INFO "LED display at %lx registered\n", LED_DATA_REG);
563 led_type = LED_NOLCD;
564 break;
565
566 case DISPLAY_MODEL_OLD_ASP:
567 LED_DATA_REG = data_reg;
568 led_func_ptr = led_ASP_driver;
569 printk(KERN_INFO "LED (ASP-style) display at %lx registered\n",
570 LED_DATA_REG);
571 led_type = LED_NOLCD;
572 break;
573
574 default:
575 printk(KERN_ERR "%s: Wrong LCD/LED model %d !\n",
Harvey Harrisona8043ec2008-05-14 16:21:56 -0700576 __func__, lcd_info.model);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 return 1;
578 }
579
580 /* mark the LCD/LED driver now as initialized and
581 * register to the reboot notifier chain */
582 initialized++;
583 register_reboot_notifier(&led_notifier);
584
Grant Grundler34994952005-10-21 22:46:18 -0400585 /* Ensure the work is queued */
586 if (led_wq) {
David Howells6858f3b2006-12-07 15:31:38 +0000587 queue_delayed_work(led_wq, &led_task, 0);
Grant Grundler34994952005-10-21 22:46:18 -0400588 }
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 return 0;
591}
592
593/*
594 ** register_led_regions()
595 **
596 ** register_led_regions() registers the LCD/LED regions for /procfs.
597 ** At bootup - where the initialisation of the LCD/LED normally happens -
598 ** not all internal structures of request_region() are properly set up,
599 ** so that we delay the led-registration until after busdevices_init()
600 ** has been executed.
601 **
602 */
603
604void __init register_led_regions(void)
605{
606 switch (lcd_info.model) {
607 case DISPLAY_MODEL_LCD:
608 request_mem_region((unsigned long)LCD_CMD_REG, 1, "lcd_cmd");
609 request_mem_region((unsigned long)LCD_DATA_REG, 1, "lcd_data");
610 break;
611 case DISPLAY_MODEL_LASI:
612 case DISPLAY_MODEL_OLD_ASP:
613 request_mem_region((unsigned long)LED_DATA_REG, 1, "led_data");
614 break;
615 }
616}
617
618
619/*
620 **
621 ** lcd_print()
622 **
623 ** Displays the given string on the LCD-Display of newer machines.
Grant Grundler34994952005-10-21 22:46:18 -0400624 ** lcd_print() disables/enables the timer-based led work queue to
625 ** avoid a race condition while writing the CMD/DATA register pair.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 **
627 */
Helge Deller6e16d942007-01-07 16:07:48 +0100628int lcd_print( const char *str )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
630 int i;
631
632 if (!led_func_ptr || lcd_info.model != DISPLAY_MODEL_LCD)
633 return 0;
634
Grant Grundler34994952005-10-21 22:46:18 -0400635 /* temporarily disable the led work task */
636 if (led_wq)
Helge Deller8a1def42009-01-06 14:23:13 +0100637 cancel_delayed_work_sync(&led_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
639 /* copy display string to buffer for procfs */
640 strlcpy(lcd_text, str, sizeof(lcd_text));
Grant Grundler34994952005-10-21 22:46:18 -0400641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 /* Set LCD Cursor to 1st character */
643 gsc_writeb(lcd_info.reset_cmd1, LCD_CMD_REG);
644 udelay(lcd_info.min_cmd_delay);
645
646 /* Print the string */
647 for (i=0; i < lcd_info.lcd_width; i++) {
648 if (str && *str)
649 gsc_writeb(*str++, LCD_DATA_REG);
650 else
651 gsc_writeb(' ', LCD_DATA_REG);
652 udelay(lcd_info.min_cmd_delay);
653 }
654
Grant Grundler34994952005-10-21 22:46:18 -0400655 /* re-queue the work */
656 if (led_wq) {
David Howells6858f3b2006-12-07 15:31:38 +0000657 queue_delayed_work(led_wq, &led_task, 0);
Grant Grundler34994952005-10-21 22:46:18 -0400658 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
660 return lcd_info.lcd_width;
661}
662
663/*
664 ** led_init()
665 **
666 ** led_init() is called very early in the bootup-process from setup.c
667 ** and asks the PDC for an usable chassis LCD or LED.
668 ** If the PDC doesn't return any info, then the LED
669 ** is detected by lasi.c or asp.c and registered with the
670 ** above functions lasi_led_init() or asp_led_init().
671 ** KittyHawk machines have often a buggy PDC, so that
672 ** we explicitly check for those machines here.
673 */
674
675int __init led_init(void)
676{
677 struct pdc_chassis_info chassis_info;
678 int ret;
679
680 snprintf(lcd_text_default, sizeof(lcd_text_default),
Serge E. Hallyn96b644b2006-10-02 02:18:13 -0700681 "Linux %s", init_utsname()->release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
683 /* Work around the buggy PDC of KittyHawk-machines */
684 switch (CPU_HVERSION) {
685 case 0x580: /* KittyHawk DC2-100 (K100) */
686 case 0x581: /* KittyHawk DC3-120 (K210) */
687 case 0x582: /* KittyHawk DC3 100 (K400) */
688 case 0x583: /* KittyHawk DC3 120 (K410) */
689 case 0x58B: /* KittyHawk DC2 100 (K200) */
690 printk(KERN_INFO "%s: KittyHawk-Machine (hversion 0x%x) found, "
691 "LED detection skipped.\n", __FILE__, CPU_HVERSION);
692 goto found; /* use the preinitialized values of lcd_info */
693 }
694
695 /* initialize the struct, so that we can check for valid return values */
696 lcd_info.model = DISPLAY_MODEL_NONE;
697 chassis_info.actcnt = chassis_info.maxcnt = 0;
698
699 ret = pdc_chassis_info(&chassis_info, &lcd_info, sizeof(lcd_info));
700 if (ret == PDC_OK) {
701 DPRINTK((KERN_INFO "%s: chassis info: model=%d (%s), "
702 "lcd_width=%d, cmd_delay=%u,\n"
703 "%s: sizecnt=%d, actcnt=%ld, maxcnt=%ld\n",
704 __FILE__, lcd_info.model,
705 (lcd_info.model==DISPLAY_MODEL_LCD) ? "LCD" :
706 (lcd_info.model==DISPLAY_MODEL_LASI) ? "LED" : "unknown",
707 lcd_info.lcd_width, lcd_info.min_cmd_delay,
708 __FILE__, sizeof(lcd_info),
709 chassis_info.actcnt, chassis_info.maxcnt));
710 DPRINTK((KERN_INFO "%s: cmd=%p, data=%p, reset1=%x, reset2=%x, act_enable=%d\n",
711 __FILE__, lcd_info.lcd_cmd_reg_addr,
712 lcd_info.lcd_data_reg_addr, lcd_info.reset_cmd1,
713 lcd_info.reset_cmd2, lcd_info.act_enable ));
714
715 /* check the results. Some machines have a buggy PDC */
716 if (chassis_info.actcnt <= 0 || chassis_info.actcnt != chassis_info.maxcnt)
717 goto not_found;
718
719 switch (lcd_info.model) {
720 case DISPLAY_MODEL_LCD: /* LCD display */
721 if (chassis_info.actcnt <
722 offsetof(struct pdc_chassis_lcd_info_ret_block, _pad)-1)
723 goto not_found;
724 if (!lcd_info.act_enable) {
725 DPRINTK((KERN_INFO "PDC prohibited usage of the LCD.\n"));
726 goto not_found;
727 }
728 break;
729
730 case DISPLAY_MODEL_NONE: /* no LED or LCD available */
731 printk(KERN_INFO "PDC reported no LCD or LED.\n");
732 goto not_found;
733
734 case DISPLAY_MODEL_LASI: /* Lasi style 8 bit LED display */
735 if (chassis_info.actcnt != 8 && chassis_info.actcnt != 32)
736 goto not_found;
737 break;
738
739 default:
740 printk(KERN_WARNING "PDC reported unknown LCD/LED model %d\n",
741 lcd_info.model);
742 goto not_found;
743 } /* switch() */
744
745found:
746 /* register the LCD/LED driver */
747 register_led_driver(lcd_info.model, LCD_CMD_REG, LCD_DATA_REG);
748 return 0;
749
750 } else { /* if() */
751 DPRINTK((KERN_INFO "pdc_chassis_info call failed with retval = %d\n", ret));
752 }
753
754not_found:
755 lcd_info.model = DISPLAY_MODEL_NONE;
756 return 1;
757}
758
Alan Sterne041c682006-03-27 01:16:30 -0800759static void __exit led_exit(void)
760{
761 unregister_reboot_notifier(&led_notifier);
762 return;
763}
764
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765#ifdef CONFIG_PROC_FS
766module_init(led_create_procfs)
767#endif