patch-2.4.0-test12 linux/arch/parisc/kernel/led.c

• Lines: 452
• Date: Wed Dec 6 11:46:39 2000
• Orig file: v2.4.0-test11/linux/arch/parisc/kernel/led.c
• Orig date: Wed Dec 31 16:00:00 1969

diff -u --recursive --new-file v2.4.0-test11/linux/arch/parisc/kernel/led.c linux/arch/parisc/kernel/led.c
@@ -0,0 +1,451 @@
+/*
+ *    Chassis LCD/LED driver for HP-PARISC workstations
+ *
+ *      (c) Copyright 2000 Red Hat Software
+ *      (c) Copyright 2000 Helge Deller <hdeller@redhat.com>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/kernel_stat.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/bitops.h>
+#include <asm/io.h>
+#include <asm/gsc.h>
+#include <asm/processor.h>
+#include <asm/hardware.h>
+#include <asm/param.h>		/* HZ */
+#include <asm/led.h>
+
+
+/* define to disable all LED functions */
+#undef  DISABLE_LEDS
+
+
+#define CPU_HVERSION ((boot_cpu_data.hversion >> 4) & 0x0FFF)
+
+
+struct lcd_block {
+	unsigned char command;	/* stores the command byte      */
+	unsigned char on;	/* value for turning LED on     */
+	unsigned char off;	/* value for turning LED off    */
+};
+
+/* Structure returned by PDC_RETURN_CHASSIS_INFO */
+struct pdc_chassis_lcd_info_ret_block {
+	unsigned long model:16;		/* DISPLAY_MODEL_XXXX (see below)  */
+	unsigned long lcd_width:16;	/* width of the LCD in chars (DISPLAY_MODEL_LCD only) */
+	char *lcd_cmd_reg_addr;		/* ptr to LCD cmd-register & data ptr for LED */
+	char *lcd_data_reg_addr;	/* ptr to LCD data-register (LCD only) */
+	unsigned int min_cmd_delay;	/* delay in uS after cmd-write (LCD only) */
+	unsigned char reset_cmd1;	/* command #1 for writing LCD string (LCD only) */
+	unsigned char reset_cmd2;	/* command #2 for writing LCD string (LCD only) */
+	unsigned char act_enable;	/* 0 = no activity (LCD only) */
+	struct lcd_block heartbeat;
+	struct lcd_block disk_io;
+	struct lcd_block lan_rcv;
+	struct lcd_block lan_tx;
+	char _pad;
+};
+
+/* values for pdc_chassis_lcd_info_ret_block.model: */
+#define DISPLAY_MODEL_LCD  0	/* KittyHawk LED or LCD */
+#define DISPLAY_MODEL_NONE 1	/* no LED or LCD */
+#define DISPLAY_MODEL_LASI 2	/* LASI style 8 bit LED */
+#define DISPLAY_MODEL_OLD_ASP 0x7F /* faked: ASP style 8 x 1 bit LED (only very old ASP versions) */
+
+
+/* LCD_CMD and LCD_DATA for KittyHawk machines */
+#ifdef __LP64__
+#define KITTYHAWK_LCD_CMD 0xfffffffff0190000L
+#else
+#define KITTYHAWK_LCD_CMD 0xf0190000
+#endif
+#define KITTYHAWK_LCD_DATA (KITTYHAWK_LCD_CMD + 1)
+
+
+/* lcd_info is pre-initialized to the values needed to program KittyHawk LCD's */
+static struct pdc_chassis_lcd_info_ret_block
+lcd_info __attribute__((aligned(8))) =
+{
+      model:DISPLAY_MODEL_LCD,
+      lcd_width:16,
+      lcd_cmd_reg_addr:(char *) KITTYHAWK_LCD_CMD,
+      lcd_data_reg_addr:(char *) KITTYHAWK_LCD_DATA,
+      min_cmd_delay:40,
+      reset_cmd1:0x80,
+      reset_cmd2:0xc0,
+};
+
+
+/* direct access to some of the lcd_info variables */
+#define LCD_CMD_REG	lcd_info.lcd_cmd_reg_addr	 
+#define LCD_DATA_REG	lcd_info.lcd_data_reg_addr	 
+#define LED_DATA_REG	lcd_info.lcd_cmd_reg_addr	/* LASI & ASP only */
+
+
+
+
+/*
+   ** 
+   ** led_ASP_driver()
+   ** 
+ */
+#define	LED_DATA	0x01	/* data to shift (0:on 1:off) */
+#define	LED_STROBE	0x02	/* strobe to clock data */
+static void led_ASP_driver(unsigned char leds)
+{
+	int i;
+
+	leds = ~leds;
+	for (i = 0; i < 8; i++) {
+		unsigned char value;
+		value = (leds & 0x80) >> 7;
+		gsc_writeb( value,		 LED_DATA_REG );
+		gsc_writeb( value | LED_STROBE,	 LED_DATA_REG );
+		leds <<= 1;
+	}
+}
+
+
+/*
+   ** 
+   ** led_LASI_driver()
+   ** 
+ */
+static void led_LASI_driver(unsigned char leds)
+{
+	leds = ~leds;
+	gsc_writeb( leds, LED_DATA_REG );
+}
+
+
+/*
+   ** 
+   ** led_LCD_driver()
+   ** 
+   ** The logic of the LCD driver is, that we write at every interrupt
+   ** only to one of LCD_CMD_REG _or_ LCD_DATA_REG - registers.
+   ** That way we don't need to let this interrupt routine busywait
+   ** the "min_cmd_delay", since idlewaiting in an interrupt-routine is
+   ** allways a BAD IDEA !
+   **
+   ** TODO: check the value of "min_cmd_delay" against the value of HZ.
+   **   
+ */
+
+static void led_LCD_driver(unsigned char leds)
+{
+	static int last_index;	/* 0:heartbeat, 1:disk, 2:lan_in, 3:lan_out */
+	static int last_was_cmd;/* 0: CMD was written last, 1: DATA was last */
+	struct lcd_block *block_ptr;
+	int value;
+	
+ 	// leds = ~leds;	/* needed ? */ 
+
+	switch (last_index) {
+	    case 0:	block_ptr = &lcd_info.heartbeat;
+			value = leds & LED_HEARTBEAT;
+			break;
+	    case 1:	block_ptr = &lcd_info.disk_io;
+			value = leds & LED_DISK_IO;
+			break;					
+	    case 2:	block_ptr = &lcd_info.lan_rcv;
+			value = leds & LED_LAN_RCV;
+			break;					
+	    case 3:	block_ptr = &lcd_info.lan_tx;
+			value = leds & LED_LAN_TX;
+			break;
+	    default:	/* should never happen: */
+			BUG();
+			return;
+	}
+
+	if (last_was_cmd) {
+	    /* write the value to the LCD data port */
+    	    gsc_writeb( value ? block_ptr->on : block_ptr->off, LCD_DATA_REG );
+	} else {
+	    /* write the command-byte to the LCD command register */
+    	    gsc_writeb( block_ptr->command, LCD_CMD_REG );
+	}    
+	
+	/* now update the vars for the next interrupt iteration */ 
+	if (++last_was_cmd == 2) {
+	    last_was_cmd = 0;
+	    if (++last_index == 4)
+		last_index = 0;
+	}
+}
+
+
+
+static char currentleds;	/* stores current value of the LEDs */
+
+static void (*led_func_ptr) (unsigned char); /* ptr to LCD/LED-specific function */
+
+/*
+   ** led_interrupt_func()
+   ** 
+   ** is called at every timer interrupt from time.c,
+   ** updates the chassis LCD/LED 
+ */
+
+#define HEARTBEAT_LEN	(HZ/16)
+
+void led_interrupt_func(void)
+{
+#ifndef DISABLE_LEDS
+	static int count;
+	static int lastleds = -1;
+	static int nr;
+
+	/* exit, if not initialized */
+	if (!led_func_ptr)
+	    return;
+	
+	/* increment the local counter */
+	if (count == (HZ-1))
+	    count = 0;
+	else
+	    count++;
+
+	/* calculate the Heartbeat */
+	if ((count % (HZ/2)) < HEARTBEAT_LEN) 
+	    currentleds |= LED_HEARTBEAT;
+	else
+	    currentleds &= ~LED_HEARTBEAT;
+
+	/* roll LEDs 0..2 */
+	if (count == 0) {
+	    if (nr++ >= 2) 
+		nr = 0;
+	    currentleds &= ~7;
+	    currentleds |= (1 << nr);
+	}
+
+	/* now update the LEDs */
+	if (currentleds != lastleds) {
+	    led_func_ptr(currentleds);
+	    lastleds = currentleds;
+	}
+#endif
+}
+
+
+/*
+   ** register_led_driver()
+   ** 
+   ** All information in lcd_info needs to be set up prior
+   ** calling this function. 
+ */
+
+static void __init register_led_driver(void)
+{
+#ifndef DISABLE_LEDS
+	switch (lcd_info.model) {
+	case DISPLAY_MODEL_LCD:
+		printk(KERN_INFO "LCD display at (%p,%p)\n",
+		  LCD_CMD_REG , LCD_DATA_REG);
+		led_func_ptr = led_LCD_driver;
+		break;
+
+	case DISPLAY_MODEL_LASI:
+		printk(KERN_INFO "LED display at %p\n",
+		       LED_DATA_REG);
+		led_func_ptr = led_LASI_driver;
+		break;
+
+	case DISPLAY_MODEL_OLD_ASP:
+		printk(KERN_INFO "LED (ASP-style) display at %p\n",
+		       LED_DATA_REG);
+		led_func_ptr = led_ASP_driver;
+		break;
+
+	default:
+		printk(KERN_ERR "%s: Wrong LCD/LED model %d !\n",
+		       __FUNCTION__, lcd_info.model);
+		return;
+	}
+#endif
+}
+
+/*
+ * XXX - could this move to lasi.c ??
+ */
+
+/*
+   ** lasi_led_init()
+   ** 
+   ** lasi_led_init() is called from lasi.c with the base hpa  
+   ** of the lasi controller chip. 
+   ** Since Mirage and Electra machines use a different LED
+   ** address register, we need to check for these machines 
+   ** explicitly.
+ */
+
+#ifdef CONFIG_GSC_LASI
+void __init lasi_led_init(unsigned long lasi_hpa)
+{
+	if (lcd_info.model != DISPLAY_MODEL_NONE ||
+	    lasi_hpa == 0)
+		return;
+
+	printk("%s: CPU_HVERSION %x\n", __FUNCTION__, CPU_HVERSION);
+
+	/* Mirage and Electra machines need special offsets */
+	switch (CPU_HVERSION) {
+	case 0x60A:		/* Mirage Jr (715/64) */
+	case 0x60B:		/* Mirage 100 */
+	case 0x60C:		/* Mirage 100+ */
+	case 0x60D:		/* Electra 100 */
+	case 0x60E:		/* Electra 120 */
+		LED_DATA_REG = (char *) (lasi_hpa - 0x00020000);
+		break;
+	default:
+		LED_DATA_REG = (char *) (lasi_hpa + 0x0000C000);
+		break;
+	}			/* switch() */
+
+	lcd_info.model = DISPLAY_MODEL_LASI;
+	register_led_driver();
+}
+#endif
+
+
+/*
+   ** asp_led_init()
+   ** 
+   ** asp_led_init() is called from asp.c with the ptr 
+   ** to the LED display.
+ */
+
+#ifdef CONFIG_GSC_LASI
+void __init asp_led_init(unsigned long led_ptr)
+{
+	if (lcd_info.model != DISPLAY_MODEL_NONE ||
+	    led_ptr == 0)
+		return;
+
+	lcd_info.model = DISPLAY_MODEL_OLD_ASP;
+	LED_DATA_REG = (char *) led_ptr;
+
+	register_led_driver();
+}
+
+#endif
+
+
+
+/*
+   ** register_led_regions()
+   ** 
+   ** Simple function, which registers the LCD/LED regions for /procfs.
+   ** At bootup - where the initialisation of the LCD/LED normally happens - 
+   ** not all internal structures of request_region() are properly set up,
+   ** so that we delay the registration until busdevice.c is executed.
+   **
+ */
+
+void __init register_led_regions(void)
+{
+	switch (lcd_info.model) {
+	case DISPLAY_MODEL_LCD:
+		request_region((unsigned long)LCD_CMD_REG,  1, "lcd_cmd");
+		request_region((unsigned long)LCD_DATA_REG, 1, "lcd_data");
+		break;
+	case DISPLAY_MODEL_LASI:
+	case DISPLAY_MODEL_OLD_ASP:
+		request_region((unsigned long)LED_DATA_REG, 1, "led_data");
+		break;
+	}
+}
+
+
+
+/*
+   ** led_init()
+   ** 
+   ** led_init() is called very early in the bootup-process from setup.c 
+   ** and asks the PDC for an usable chassis LCD or LED.
+   ** If the PDC doesn't return any info, then the LED
+   ** is detected by lasi.c or asp.c and registered with the
+   ** above functions lasi_led_init() or asp_led_init().
+   ** KittyHawk machines have often a buggy PDC, so that
+   ** we explicitly check for those machines here.
+ */
+
+int __init led_init(void)
+{
+#ifndef DISABLE_LEDS
+	long pdc_result[32];
+
+	printk("%s: CPU_HVERSION %x\n", __FUNCTION__, CPU_HVERSION);
+
+	/* Work around the buggy PDC of KittyHawk-machines */
+	switch (CPU_HVERSION) {
+	case 0x580:		/* KittyHawk DC2-100 (K100) */
+	case 0x581:		/* KittyHawk DC3-120 (K210) */
+	case 0x582:		/* KittyHawk DC3 100 (K400) */
+	case 0x583:		/* KittyHawk DC3 120 (K410) */
+	case 0x58B:		/* KittyHawk DC2 100 (K200) */
+		printk("%s: KittyHawk-Machine found !!\n", __FUNCTION__);
+		goto found;	/* use the preinitialized values of lcd_info */
+
+	default:
+		break;
+	}
+
+	/* initialize pdc_result, so we can check the return values of pdc_chassis_info() */
+	pdc_result[0] = pdc_result[1] = 0;
+
+	if (pdc_chassis_info(&pdc_result, &lcd_info, sizeof(lcd_info)) == PDC_OK) {
+		printk("%s: chassis info: model %d, ret0=%d, ret1=%d\n",
+		 __FUNCTION__, lcd_info.model, pdc_result[0], pdc_result[1]);
+
+		/* check the results. Some machines have a buggy PDC */
+		if (pdc_result[0] <= 0 || pdc_result[0] != pdc_result[1])
+			goto not_found;
+
+		switch (lcd_info.model) {
+		case DISPLAY_MODEL_LCD:	/* LCD display */
+			if (pdc_result[0] != sizeof(struct pdc_chassis_lcd_info_ret_block)
+			    && pdc_result[0] != sizeof(struct pdc_chassis_lcd_info_ret_block) - 1)
+				 goto not_found;
+			printk("%s: min_cmd_delay = %d uS\n",
+		             __FUNCTION__, lcd_info.min_cmd_delay);
+			break;
+
+		case DISPLAY_MODEL_NONE:	/* no LED or LCD available */
+			goto not_found;
+
+		case DISPLAY_MODEL_LASI:	/* Lasi style 8 bit LED display */
+			if (pdc_result[0] != 8 && pdc_result[0] != 32)
+				goto not_found;
+			break;
+
+		default:
+			printk(KERN_WARNING "Unknown LCD/LED model %d\n",
+			       lcd_info.model);
+			goto not_found;
+		}		/* switch() */
+
+found:
+		/* register the LCD/LED driver */
+		register_led_driver();
+		return 0;
+
+	}			/* if() */
+
+not_found:
+	lcd_info.model = DISPLAY_MODEL_NONE;
+	return 1;
+#endif
+}