/* *    Disk Array driver for Compaq SMART2 Controllers *    Copyright 1998 Compaq Computer Corporation * *    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. * *    This program is distributed in the hope that it will be useful, *    but WITHOUT ANY WARRANTY; without even the implied warranty of *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or *    NON INFRINGEMENT.  See the GNU General Public License for more details. * *    You should have received a copy of the GNU General Public License *    along with this program; if not, write to the Free Software *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * *    Questions/Comments/Bugfixes to iss_storagedev@hp.com * *    If you want to make changes, improve or add functionality to this *    driver, you'll probably need the Compaq Array Controller Interface *    Specificiation (Document number ECG086/1198) *//* * This file contains the controller communication implementation for * Compaq SMART-1 and SMART-2 controllers.  To the best of my knowledge, * this should support: * *  PCI: *  SMART-2/P, SMART-2DH, SMART-2SL, SMART-221, SMART-3100ES, SMART-3200 *  Integerated SMART Array Controller, SMART-4200, SMART-4250ES * *  EISA: *  SMART-2/E, SMART, IAES, IDA-2, IDA *//* * Memory mapped FIFO interface (SMART 42xx cards) */static void smart4_submit_command(ctlr_info_t *h, cmdlist_t *c){        writel(c->busaddr, h->vaddr + S42XX_REQUEST_PORT_OFFSET);}/*   *  This card is the opposite of the other cards.   *   0 turns interrupts on...  *   0x08 turns them off...  */static void smart4_intr_mask(ctlr_info_t *h, unsigned long val){	if (val) 	{ /* Turn interrupts on */		writel(0, h->vaddr + S42XX_REPLY_INTR_MASK_OFFSET);	} else /* Turn them off */	{        	writel( S42XX_INTR_OFF, 			h->vaddr + S42XX_REPLY_INTR_MASK_OFFSET);	}}/* *  For older cards FIFO Full = 0.  *  On this card 0 means there is room, anything else FIFO Full.  *  */ static unsigned long smart4_fifo_full(ctlr_info_t *h){	        return (!readl(h->vaddr + S42XX_REQUEST_PORT_OFFSET));}/* This type of controller returns -1 if the fifo is empty,  *    Not 0 like the others. *    And we need to let it know we read a value out  */ static unsigned long smart4_completed(ctlr_info_t *h){	long register_value 		= readl(h->vaddr + S42XX_REPLY_PORT_OFFSET);	/* Fifo is empty */	if( register_value == 0xffffffff)		return 0; 		/* Need to let it know we got the reply */	/* We do this by writing a 0 to the port we just read from */	writel(0, h->vaddr + S42XX_REPLY_PORT_OFFSET);	return ((unsigned long) register_value); } /* *  This hardware returns interrupt pending at a different place and  *  it does not tell us if the fifo is empty, we will have check   *  that by getting a 0 back from the comamnd_completed call.  */static unsigned long smart4_intr_pending(ctlr_info_t *h){	unsigned long register_value  = 		readl(h->vaddr + S42XX_INTR_STATUS);	if( register_value &  S42XX_INTR_PENDING) 		return  FIFO_NOT_EMPTY;		return 0 ;}static struct access_method smart4_access = {	smart4_submit_command,	smart4_intr_mask,	smart4_fifo_full,	smart4_intr_pending,	smart4_completed,};/* * Memory mapped FIFO interface (PCI SMART2 and SMART 3xxx cards) */static void smart2_submit_command(ctlr_info_t *h, cmdlist_t *c){	writel(c->busaddr, h->vaddr + COMMAND_FIFO);}static void smart2_intr_mask(ctlr_info_t *h, unsigned long val){	writel(val, h->vaddr + INTR_MASK);}static unsigned long smart2_fifo_full(ctlr_info_t *h){	return readl(h->vaddr + COMMAND_FIFO);}static unsigned long smart2_completed(ctlr_info_t *h){	return readl(h->vaddr + COMMAND_COMPLETE_FIFO);}static unsigned long smart2_intr_pending(ctlr_info_t *h){	return readl(h->vaddr + INTR_PENDING);}static struct access_method smart2_access = {	smart2_submit_command,	smart2_intr_mask,	smart2_fifo_full,	smart2_intr_pending,	smart2_completed,};/* *  IO access for SMART-2/E cards */static void smart2e_submit_command(ctlr_info_t *h, cmdlist_t *c){	outl(c->busaddr, h->io_mem_addr + COMMAND_FIFO);}static void smart2e_intr_mask(ctlr_info_t *h, unsigned long val){	outl(val, h->io_mem_addr + INTR_MASK);}static unsigned long smart2e_fifo_full(ctlr_info_t *h){	return inl(h->io_mem_addr + COMMAND_FIFO);}static unsigned long smart2e_completed(ctlr_info_t *h){	return inl(h->io_mem_addr + COMMAND_COMPLETE_FIFO);}static unsigned long smart2e_intr_pending(ctlr_info_t *h){	return inl(h->io_mem_addr + INTR_PENDING);}static struct access_method smart2e_access = {	smart2e_submit_command,	smart2e_intr_mask,	smart2e_fifo_full,	smart2e_intr_pending,	smart2e_completed,};/* *  IO access for older SMART-1 type cards */#define SMART1_SYSTEM_MASK		0xC8E#define SMART1_SYSTEM_DOORBELL		0xC8F#define SMART1_LOCAL_MASK		0xC8C#define SMART1_LOCAL_DOORBELL		0xC8D#define SMART1_INTR_MASK		0xC89#define SMART1_LISTADDR			0xC90#define SMART1_LISTLEN			0xC94#define SMART1_TAG			0xC97#define SMART1_COMPLETE_ADDR		0xC98#define SMART1_LISTSTATUS		0xC9E#define CHANNEL_BUSY			0x01#define CHANNEL_CLEAR			0x02static void smart1_submit_command(ctlr_info_t *h, cmdlist_t *c){	/*	 * This __u16 is actually a bunch of control flags on SMART	 * and below.  We want them all to be zero.	 */	c->hdr.size = 0;	outb(CHANNEL_CLEAR, h->io_mem_addr + SMART1_SYSTEM_DOORBELL);	outl(c->busaddr, h->io_mem_addr + SMART1_LISTADDR);	outw(c->size, h->io_mem_addr + SMART1_LISTLEN);	outb(CHANNEL_BUSY, h->io_mem_addr + SMART1_LOCAL_DOORBELL);}static void smart1_intr_mask(ctlr_info_t *h, unsigned long val){	if (val == 1) {		outb(0xFD, h->io_mem_addr + SMART1_SYSTEM_DOORBELL);		outb(CHANNEL_BUSY, h->io_mem_addr + SMART1_LOCAL_DOORBELL);		outb(0x01, h->io_mem_addr + SMART1_INTR_MASK);		outb(0x01, h->io_mem_addr + SMART1_SYSTEM_MASK);	} else {		outb(0, h->io_mem_addr + 0xC8E);	}}static unsigned long smart1_fifo_full(ctlr_info_t *h){	unsigned char chan;	chan = inb(h->io_mem_addr + SMART1_SYSTEM_DOORBELL) & CHANNEL_CLEAR;	return chan;}static unsigned long smart1_completed(ctlr_info_t *h){	unsigned char status;	unsigned long cmd;	if (inb(h->io_mem_addr + SMART1_SYSTEM_DOORBELL) & CHANNEL_BUSY) {		outb(CHANNEL_BUSY, h->io_mem_addr + SMART1_SYSTEM_DOORBELL);		cmd = inl(h->io_mem_addr + SMART1_COMPLETE_ADDR);		status = inb(h->io_mem_addr + SMART1_LISTSTATUS);		outb(CHANNEL_CLEAR, h->io_mem_addr + SMART1_LOCAL_DOORBELL);		/*		 * this is x86 (actually compaq x86) only, so it's ok		 */		if (cmd) ((cmdlist_t*)bus_to_virt(cmd))->req.hdr.rcode = status;	} else {		cmd = 0;	}	return cmd;}static unsigned long smart1_intr_pending(ctlr_info_t *h){	unsigned char chan;	chan = inb(h->io_mem_addr + SMART1_SYSTEM_DOORBELL) & CHANNEL_BUSY;	return chan;}static struct access_method smart1_access = {	smart1_submit_command,	smart1_intr_mask,	smart1_fifo_full,	smart1_intr_pending,	smart1_completed,};