support for Cobalt Networks (x86 only) systems (for real this time)

drivers/cobalt/acpi.c +10 -0

+               if (addr) {
+                       /* get registers */
+                       if ((reg = get_reg(addr, addr + 1, 0x08))) {
+                               request_region(reg, 4, "SUPERIO (pm1_evt_blk)");
+                               superio_port = reg;
+                       }
+                       if ((reg = get_reg(addr, addr + 1, 0x0c)))
+                               request_region(reg, 2, "SUPERIO (pm1_cnt_blk)");
+                       if ((reg = get_reg(addr, addr + 1, 0x0e)))
+                               request_region(reg, 16, "SUPERIO (gpe_blk)");

drivers/cobalt/acpi.c +7 -0

+               /* setup an interrupt handler for an ACPI SCI */
+               err = request_irq(ACPI_IRQ, acpi_interrupt,
+                         SA_SHIRQ, ACPI_NAME, (void *)ACPI_MAGIC);
+               if (err) {
+                       EPRINTK("couldn't assign ACPI IRQ (%d)\n", ACPI_IRQ);
+                       return -1;
+               }

drivers/cobalt/Config.in +10 -0

+   comment 'Cobalt hardware options'
+
+   bool 'Front panel (LCD) support' CONFIG_COBALT_LCD
+   bool 'Software controlled LED support' CONFIG_COBALT_LED
+   bool 'Serial number support' CONFIG_COBALT_SERNUM
+   bool 'Watchdog timer support' CONFIG_COBALT_WDT
+   bool 'Thermal sensor support' CONFIG_COBALT_THERMAL
+   bool 'Fan tachometer support' CONFIG_COBALT_FANS
+   bool 'Disk drive ruler support' CONFIG_COBALT_RULER
+fi

drivers/cobalt/fans.c +10 -0

+               proc_cobalt, fan_read_proc, NULL);
+        if (!proc_cfaninfo) {
+               EPRINTK("can't create /proc/cobalt/faninfo\n");
+       }
+#endif
+
+       printk("Cobalt Networks fan tachometers v1.2\n");
+
+       return 0;
+}

drivers/cobalt/lcd.c +6 -0

+/* various file operations we support for this driver */
+static struct file_operations lcd_fops = {
+       read:   cobalt_lcd_read,
+       ioctl:  cobalt_lcd_ioctl,
+       open:   cobalt_lcd_open,
+};

drivers/cobalt/lcd.c +10 -0

+       int index;
+       int dlen = sizeof(struct lcd_display);
+
+       spin_lock(&lcd_lock);
+
+       switch (cmd) {
+       /* Turn the LCD on */
+       case LCD_On:
+               lcddev_write_inst(0x0F);
+               break;

drivers/cobalt/lcd.c +10 -0

+                }
+                display.line1[DD_R01] = '\0';
+
+                for (address = DD_R10; address <= DD_R11; address++) {
+                        lcddev_write_inst(address | LCD_Addr);
+                        display.line2[address - DD_R10] = lcddev_read_data();
+               }
+                display.line2[DD_R01] = '\0';
+
+                copy_to_user((struct lcd_display *)arg, &display, dlen);

drivers/cobalt/lcd.c +7 -0

+       case LCD_Raw_Inst:
+                copy_from_user(&display, (struct lcd_display *)arg, dlen);
+                lcddev_write_inst(display.character);
+                break;
+
+        case LCD_Raw_Data:
+                copy_from_user(&display, (struct lcd_display *)arg, dlen);

drivers/cobalt/lcd.c +10 -0

+       /* clear an led */
+       case LED_Bit_Clear:
+                copy_from_user(&display, (struct lcd_display *)arg, dlen);
+                cobalt_led_set_lazy(cobalt_led_get() & ~display.leds);
+               break;
+
+       default:
+       }
+
+       spin_unlock(&lcd_lock);

drivers/cobalt/lcd.c +10 -0

+       {
+               current->state = TASK_INTERRUPTIBLE;
+               schedule_timeout((2 * HZ));
+       }
+       atomic_dec(&lcd_waiters);
+
+       if (signal_pending(current))
+               return -ERESTARTSYS;
+
+       return buttons_now;

drivers/cobalt/led.c +10 -0

+       if (cobt_is_5k()) {
+               struct led_handler *newh;
+               unsigned long flags;
+
+               newh = kmalloc(sizeof(*newh), GFP_ATOMIC);
+               if (!newh) {
+                       EPRINTK("can't allocate memory for handler %p(%p)\n",
+                               function, data);
+                       return -1;
+               }

drivers/cobalt/net.c +10 -0

+       spin_lock_irqsave(&cobaltnet_lock, flags);
+
+       for (i = 0; i < n_netdevs; i++) {
+               unsigned long txrxstate;
+               struct net_device *dev = netdevs[i];
+               if (!dev) {
+                       continue;
+               }
+               /* check for link */
+               if (dev->link_check && dev->link_check(dev)) {

drivers/cobalt/net.c +10 -0

+       /* find a free slot */
+       for (i = 0; i < n_netdevs; i++) {
+               if (!netdevs[i]) {
+                       netdevs[i] = ndev;
+                       n_netdevs++;
+               }
+       }
+
+       spin_unlock_irqrestore(&cobaltnet_lock, flags);
+}

drivers/cobalt/acpi.c +3 -0

+		/* setup osb4 i/o regions */
+		if ((reg = get_reg(OSB4_INDEX_PORT, OSB4_DATA_PORT, 0x20)))
+			request_region(reg, 4, "OSB4 (pm1a_evt_blk)");

drivers/cobalt/i2c.c +2 -0

+static int 
+i2c_wait_for_smi(void)

drivers/cobalt/lcd.c +3 -0

+/* device structure */
+static struct miscdevice lcd_dev = {
+	COBALT_LCD_MINOR,

drivers/cobalt/lcd.c +5 -0

+	/* Get the current cursor position */
+        case LCD_Get_Cursor_Pos:
+                display.cursor_address = lcddev_read_inst();
+                display.cursor_address = display.cursor_address & 0x07F;
+                copy_to_user((struct lcd_display *)arg, &display, dlen);

(quoted diff) +2 -0

+        case LCD_Set_Cursor_Pos:
+                copy_from_user(&display, (struct lcd_display *)arg, dlen);

drivers/cobalt/lcd.c +10 -0

+/* LED daemon sits on this, we wake it up once a key is pressed */
+static ssize_t 
+cobalt_lcd_read(struct file *file, char *buf, size_t count, loff_t *ppos)
+{
+	int buttons_now;
+	static atomic_t lcd_waiters = ATOMIC_INIT(0);
+
+	if (atomic_read(&lcd_waiters) > 0)
+		return -EINVAL;
+	atomic_inc(&lcd_waiters);

drivers/cobalt/lcd.c +4 -0

+	while (((buttons_now = button_pressed()) == 0) &&
+	       !(signal_pending(current)))
+	{
+		current->state = TASK_INTERRUPTIBLE;