a100u2w.c 36 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
/*
 * Initio A100 device driver for Linux.
 *
 * Copyright (c) 1994-1998 Initio Corporation
 * Copyright (c) 2003-2004 Christoph Hellwig
 * All rights reserved.
 *
 * 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, 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.  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; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Revision History:
 * 07/02/98 hl	- v.91n Initial drivers.
 * 09/14/98 hl - v1.01 Support new Kernel.
 * 09/22/98 hl - v1.01a Support reset.
 * 09/24/98 hl - v1.01b Fixed reset.
 * 10/05/98 hl - v1.02 split the source code and release.
 * 12/19/98 bv - v1.02a Use spinlocks for 2.1.95 and up
 * 01/31/99 bv - v1.02b Use mdelay instead of waitForPause
 * 08/08/99 bv - v1.02c Use waitForPause again.
 * 06/25/02 Doug Ledford <dledford@redhat.com> - v1.02d
 *          - Remove limit on number of controllers
 *          - Port to DMA mapping API
 *          - Clean up interrupt handler registration
 *          - Fix memory leaks
 *          - Fix allocation of scsi host structs and private data
 * 11/18/03 Christoph Hellwig <hch@lst.de>
 *	    - Port to new probing API
 *	    - Fix some more leaks in init failure cases
 * 9/28/04 Christoph Hellwig <hch@lst.de>
 *	    - merge the two source files
 *	    - remove internal queueing code
57
 * 14/06/07 Alan Cox <alan@lxorguk.ukuu.org.uk>
58
 *	 - Grand cleanup and Linuxisation
Linus Torvalds's avatar
Linus Torvalds committed
59 60 61 62 63 64 65 66 67 68 69 70 71
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/spinlock.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/ioport.h>
72
#include <linux/dma-mapping.h>
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78 79 80 81 82 83 84

#include <asm/io.h>
#include <asm/irq.h>

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>

#include "a100u2w.h"


85 86
static struct orc_scb *__orc_alloc_scb(struct orc_host * host);
static void inia100_scb_handler(struct orc_host *host, struct orc_scb *scb);
Linus Torvalds's avatar
Linus Torvalds committed
87

88
static struct orc_nvram nvram, *nvramp = &nvram;
Linus Torvalds's avatar
Linus Torvalds committed
89

90
static u8 default_nvram[64] =
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
{
/*----------header -------------*/
	0x01,			/* 0x00: Sub System Vendor ID 0 */
	0x11,			/* 0x01: Sub System Vendor ID 1 */
	0x60,			/* 0x02: Sub System ID 0        */
	0x10,			/* 0x03: Sub System ID 1        */
	0x00,			/* 0x04: SubClass               */
	0x01,			/* 0x05: Vendor ID 0            */
	0x11,			/* 0x06: Vendor ID 1            */
	0x60,			/* 0x07: Device ID 0            */
	0x10,			/* 0x08: Device ID 1            */
	0x00,			/* 0x09: Reserved               */
	0x00,			/* 0x0A: Reserved               */
	0x01,			/* 0x0B: Revision of Data Structure     */
				/* -- Host Adapter Structure --- */
	0x01,			/* 0x0C: Number Of SCSI Channel */
	0x01,			/* 0x0D: BIOS Configuration 1   */
	0x00,			/* 0x0E: BIOS Configuration 2   */
	0x00,			/* 0x0F: BIOS Configuration 3   */
				/* --- SCSI Channel 0 Configuration --- */
	0x07,			/* 0x10: H/A ID                 */
	0x83,			/* 0x11: Channel Configuration  */
	0x20,			/* 0x12: MAX TAG per target     */
	0x0A,			/* 0x13: SCSI Reset Recovering time     */
	0x00,			/* 0x14: Channel Configuration4 */
	0x00,			/* 0x15: Channel Configuration5 */
				/* SCSI Channel 0 Target Configuration  */
				/* 0x16-0x25                    */
	0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
	0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
				/* --- SCSI Channel 1 Configuration --- */
	0x07,			/* 0x26: H/A ID                 */
	0x83,			/* 0x27: Channel Configuration  */
	0x20,			/* 0x28: MAX TAG per target     */
	0x0A,			/* 0x29: SCSI Reset Recovering time     */
	0x00,			/* 0x2A: Channel Configuration4 */
	0x00,			/* 0x2B: Channel Configuration5 */
				/* SCSI Channel 1 Target Configuration  */
				/* 0x2C-0x3B                    */
	0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
	0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
	0x00,			/* 0x3C: Reserved               */
	0x00,			/* 0x3D: Reserved               */
	0x00,			/* 0x3E: Reserved               */
	0x00			/* 0x3F: Checksum               */
};


139
static u8 wait_chip_ready(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143
{
	int i;

	for (i = 0; i < 10; i++) {	/* Wait 1 second for report timeout     */
144
		if (inb(host->base + ORC_HCTRL) & HOSTSTOP)	/* Wait HOSTSTOP set */
Linus Torvalds's avatar
Linus Torvalds committed
145
			return 1;
146
		mdelay(100);
Linus Torvalds's avatar
Linus Torvalds committed
147 148 149 150
	}
	return 0;
}

151
static u8 wait_firmware_ready(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
152 153 154 155
{
	int i;

	for (i = 0; i < 10; i++) {	/* Wait 1 second for report timeout     */
156
		if (inb(host->base + ORC_HSTUS) & RREADY)		/* Wait READY set */
Linus Torvalds's avatar
Linus Torvalds committed
157
			return 1;
158
		mdelay(100);	/* wait 100ms before try again  */
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163
	}
	return 0;
}

/***************************************************************************/
164
static u8 wait_scsi_reset_done(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168
{
	int i;

	for (i = 0; i < 10; i++) {	/* Wait 1 second for report timeout     */
169
		if (!(inb(host->base + ORC_HCTRL) & SCSIRST))	/* Wait SCSIRST done */
Linus Torvalds's avatar
Linus Torvalds committed
170
			return 1;
171
		mdelay(100);	/* wait 100ms before try again  */
Linus Torvalds's avatar
Linus Torvalds committed
172 173 174 175 176
	}
	return 0;
}

/***************************************************************************/
177
static u8 wait_HDO_off(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180 181
{
	int i;

	for (i = 0; i < 10; i++) {	/* Wait 1 second for report timeout     */
182
		if (!(inb(host->base + ORC_HCTRL) & HDO))		/* Wait HDO off */
Linus Torvalds's avatar
Linus Torvalds committed
183
			return 1;
184
		mdelay(100);	/* wait 100ms before try again  */
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188 189
	}
	return 0;
}

/***************************************************************************/
190
static u8 wait_hdi_set(struct orc_host * host, u8 * data)
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194
{
	int i;

	for (i = 0; i < 10; i++) {	/* Wait 1 second for report timeout     */
195
		if ((*data = inb(host->base + ORC_HSTUS)) & HDI)
Linus Torvalds's avatar
Linus Torvalds committed
196
			return 1;	/* Wait HDI set */
197
		mdelay(100);	/* wait 100ms before try again  */
Linus Torvalds's avatar
Linus Torvalds committed
198 199 200 201 202
	}
	return 0;
}

/***************************************************************************/
203
static unsigned short orc_read_fwrev(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
204
{
205 206 207 208 209 210
	u16 version;
	u8 data;

	outb(ORC_CMD_VERSION, host->base + ORC_HDATA);
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
211 212
		return 0;

213
	if (wait_hdi_set(host, &data) == 0)	/* Wait HDI set   */
Linus Torvalds's avatar
Linus Torvalds committed
214
		return 0;
215 216
	version = inb(host->base + ORC_HDATA);
	outb(data, host->base + ORC_HSTUS);	/* Clear HDI            */
Linus Torvalds's avatar
Linus Torvalds committed
217

218
	if (wait_hdi_set(host, &data) == 0)	/* Wait HDI set   */
Linus Torvalds's avatar
Linus Torvalds committed
219
		return 0;
220 221
	version |= inb(host->base + ORC_HDATA) << 8;
	outb(data, host->base + ORC_HSTUS);	/* Clear HDI            */
Linus Torvalds's avatar
Linus Torvalds committed
222

223
	return version;
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226
}

/***************************************************************************/
227
static u8 orc_nv_write(struct orc_host * host, unsigned char address, unsigned char value)
Linus Torvalds's avatar
Linus Torvalds committed
228
{
229 230 231
	outb(ORC_CMD_SET_NVM, host->base + ORC_HDATA);	/* Write command */
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
232 233
		return 0;

234 235 236
	outb(address, host->base + ORC_HDATA);	/* Write address */
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
237 238
		return 0;

239 240 241
	outb(value, host->base + ORC_HDATA);	/* Write value  */
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
242 243 244 245 246 247
		return 0;

	return 1;
}

/***************************************************************************/
248
static u8 orc_nv_read(struct orc_host * host, u8 address, u8 *ptr)
Linus Torvalds's avatar
Linus Torvalds committed
249
{
250
	unsigned char data;
Linus Torvalds's avatar
Linus Torvalds committed
251

252 253 254
	outb(ORC_CMD_GET_NVM, host->base + ORC_HDATA);	/* Write command */
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
255 256
		return 0;

257 258 259
	outb(address, host->base + ORC_HDATA);	/* Write address */
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
260 261
		return 0;

262
	if (wait_hdi_set(host, &data) == 0)	/* Wait HDI set   */
Linus Torvalds's avatar
Linus Torvalds committed
263
		return 0;
264 265
	*ptr = inb(host->base + ORC_HDATA);
	outb(data, host->base + ORC_HSTUS);	/* Clear HDI    */
Linus Torvalds's avatar
Linus Torvalds committed
266 267

	return 1;
268

Linus Torvalds's avatar
Linus Torvalds committed
269 270
}

271 272 273 274 275 276 277
/**
 *	orc_exec_sb		-	Queue an SCB with the HA
 *	@host: host adapter the SCB belongs to
 *	@scb: SCB to queue for execution
 */

static void orc_exec_scb(struct orc_host * host, struct orc_scb * scb)
Linus Torvalds's avatar
Linus Torvalds committed
278
{
279 280
	scb->status = ORCSCB_POST;
	outb(scb->scbidx, host->base + ORC_PQUEUE);
Linus Torvalds's avatar
Linus Torvalds committed
281 282 283
}


284 285 286 287 288 289 290 291
/**
 *	se2_rd_all	-	read SCSI parameters from EEPROM
 *	@host: Host whose EEPROM is being loaded
 *
 *	Read SCSI H/A configuration parameters from serial EEPROM
 */

static int se2_rd_all(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
292 293
{
	int i;
294
	u8 *np, chksum = 0;
Linus Torvalds's avatar
Linus Torvalds committed
295

296
	np = (u8 *) nvramp;
Linus Torvalds's avatar
Linus Torvalds committed
297
	for (i = 0; i < 64; i++, np++) {	/* <01> */
298
		if (orc_nv_read(host, (u8) i, np) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
299 300 301
			return -1;
	}

302 303
	/*------ Is ckecksum ok ? ------*/
	np = (u8 *) nvramp;
Linus Torvalds's avatar
Linus Torvalds committed
304 305 306
	for (i = 0; i < 63; i++)
		chksum += *np++;

307
	if (nvramp->CheckSum != (u8) chksum)
Linus Torvalds's avatar
Linus Torvalds committed
308 309 310 311
		return -1;
	return 1;
}

312 313 314 315 316 317 318 319
/**
 *	se2_update_all		-	update the EEPROM
 *	@host: Host whose EEPROM is being updated
 *
 *	Update changed bytes in the EEPROM image.
 */

static void se2_update_all(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
320 321
{				/* setup default pattern  */
	int i;
322
	u8 *np, *np1, chksum = 0;
Linus Torvalds's avatar
Linus Torvalds committed
323 324

	/* Calculate checksum first   */
325
	np = (u8 *) default_nvram;
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328 329
	for (i = 0; i < 63; i++)
		chksum += *np++;
	*np = chksum;

330 331
	np = (u8 *) default_nvram;
	np1 = (u8 *) nvramp;
Linus Torvalds's avatar
Linus Torvalds committed
332
	for (i = 0; i < 64; i++, np++, np1++) {
333 334
		if (*np != *np1)
			orc_nv_write(host, (u8) i, *np);
Linus Torvalds's avatar
Linus Torvalds committed
335 336 337
	}
}

338 339 340 341 342 343 344 345 346
/**
 *	read_eeprom		-	load EEPROM
 *	@host: Host EEPROM to read
 *
 *	Read the EEPROM for a given host. If it is invalid or fails
 *	the restore the defaults and use them.
 */

static void read_eeprom(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
347
{
348 349 350
	if (se2_rd_all(host) != 1) {
		se2_update_all(host);	/* setup default pattern        */
		se2_rd_all(host);	/* load again                   */
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354
	}
}


355 356 357 358 359 360 361 362 363 364 365
/**
 *	orc_load_firmware	-	initialise firmware
 *	@host: Host to set up
 *
 *	Load the firmware from the EEPROM into controller SRAM. This
 *	is basically a 4K block copy and then a 4K block read to check
 *	correctness. The rest is convulted by the indirect interfaces
 *	in the hardware
 */

static u8 orc_load_firmware(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
366
{
367 368 369 370 371 372 373 374 375 376 377 378 379 380
	u32 data32;
	u16 bios_addr;
	u16 i;
	u8 *data32_ptr, data;


	/* Set up the EEPROM for access */

	data = inb(host->base + ORC_GCFG);
	outb(data | EEPRG, host->base + ORC_GCFG);	/* Enable EEPROM programming */
	outb(0x00, host->base + ORC_EBIOSADR2);
	outw(0x0000, host->base + ORC_EBIOSADR0);
	if (inb(host->base + ORC_EBIOSDATA) != 0x55) {
		outb(data, host->base + ORC_GCFG);	/* Disable EEPROM programming */
Linus Torvalds's avatar
Linus Torvalds committed
381 382
		return 0;
	}
383 384 385
	outw(0x0001, host->base + ORC_EBIOSADR0);
	if (inb(host->base + ORC_EBIOSDATA) != 0xAA) {
		outb(data, host->base + ORC_GCFG);	/* Disable EEPROM programming */
Linus Torvalds's avatar
Linus Torvalds committed
386 387
		return 0;
	}
388 389 390

	outb(PRGMRST | DOWNLOAD, host->base + ORC_RISCCTL);	/* Enable SRAM programming */
	data32_ptr = (u8 *) & data32;
391
	data32 = cpu_to_le32(0);		/* Initial FW address to 0 */
392 393 394 395 396 397 398
	outw(0x0010, host->base + ORC_EBIOSADR0);
	*data32_ptr = inb(host->base + ORC_EBIOSDATA);		/* Read from BIOS */
	outw(0x0011, host->base + ORC_EBIOSADR0);
	*(data32_ptr + 1) = inb(host->base + ORC_EBIOSDATA);	/* Read from BIOS */
	outw(0x0012, host->base + ORC_EBIOSADR0);
	*(data32_ptr + 2) = inb(host->base + ORC_EBIOSDATA);	/* Read from BIOS */
	outw(*(data32_ptr + 2), host->base + ORC_EBIOSADR2);
399
	outl(le32_to_cpu(data32), host->base + ORC_FWBASEADR);		/* Write FW address */
400 401 402

	/* Copy the code from the BIOS to the SRAM */

403
	udelay(500);	/* Required on Sun Ultra 5 ... 350 -> failures */
404
	bios_addr = (u16) le32_to_cpu(data32);	/* FW code locate at BIOS address + ? */
405
	for (i = 0, data32_ptr = (u8 *) & data32;	/* Download the code    */
Linus Torvalds's avatar
Linus Torvalds committed
406
	     i < 0x1000;	/* Firmware code size = 4K      */
407 408 409
	     i++, bios_addr++) {
		outw(bios_addr, host->base + ORC_EBIOSADR0);
		*data32_ptr++ = inb(host->base + ORC_EBIOSDATA);	/* Read from BIOS */
Linus Torvalds's avatar
Linus Torvalds committed
410
		if ((i % 4) == 3) {
411
			outl(le32_to_cpu(data32), host->base + ORC_RISCRAM);	/* Write every 4 bytes */
412
			data32_ptr = (u8 *) & data32;
Linus Torvalds's avatar
Linus Torvalds committed
413 414 415
		}
	}

416 417 418
	/* Go back and check they match */

	outb(PRGMRST | DOWNLOAD, host->base + ORC_RISCCTL);	/* Reset program count 0 */
419
	bios_addr -= 0x1000;	/* Reset the BIOS address */
420
	for (i = 0, data32_ptr = (u8 *) & data32;	/* Check the code       */
Linus Torvalds's avatar
Linus Torvalds committed
421
	     i < 0x1000;	/* Firmware code size = 4K      */
422 423 424
	     i++, bios_addr++) {
		outw(bios_addr, host->base + ORC_EBIOSADR0);
		*data32_ptr++ = inb(host->base + ORC_EBIOSDATA);	/* Read from BIOS */
Linus Torvalds's avatar
Linus Torvalds committed
425
		if ((i % 4) == 3) {
426
			if (inl(host->base + ORC_RISCRAM) != le32_to_cpu(data32)) {
427 428
				outb(PRGMRST, host->base + ORC_RISCCTL);	/* Reset program to 0 */
				outb(data, host->base + ORC_GCFG);	/*Disable EEPROM programming */
Linus Torvalds's avatar
Linus Torvalds committed
429 430
				return 0;
			}
431
			data32_ptr = (u8 *) & data32;
Linus Torvalds's avatar
Linus Torvalds committed
432 433
		}
	}
434 435 436 437

	/* Success */
	outb(PRGMRST, host->base + ORC_RISCCTL);	/* Reset program to 0   */
	outb(data, host->base + ORC_GCFG);	/* Disable EEPROM programming */
Linus Torvalds's avatar
Linus Torvalds committed
438 439 440 441
	return 1;
}

/***************************************************************************/
442
static void setup_SCBs(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
443
{
444
	struct orc_scb *scb;
Linus Torvalds's avatar
Linus Torvalds committed
445
	int i;
446 447
	struct orc_extended_scb *escb;
	dma_addr_t escb_phys;
Linus Torvalds's avatar
Linus Torvalds committed
448

449 450 451 452 453 454
	/* Setup SCB base and SCB Size registers */
	outb(ORC_MAXQUEUE, host->base + ORC_SCBSIZE);	/* Total number of SCBs */
	/* SCB base address 0      */
	outl(host->scb_phys, host->base + ORC_SCBBASE0);
	/* SCB base address 1      */
	outl(host->scb_phys, host->base + ORC_SCBBASE1);
Linus Torvalds's avatar
Linus Torvalds committed
455 456

	/* setup scatter list address with one buffer */
457 458
	scb = host->scb_virt;
	escb = host->escb_virt;
Linus Torvalds's avatar
Linus Torvalds committed
459 460

	for (i = 0; i < ORC_MAXQUEUE; i++) {
461
		escb_phys = (host->escb_phys + (sizeof(struct orc_extended_scb) * i));
462 463
		scb->sg_addr = cpu_to_le32((u32) escb_phys);
		scb->sense_addr = cpu_to_le32((u32) escb_phys);
464 465 466 467
		scb->escb = escb;
		scb->scbidx = i;
		scb++;
		escb++;
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470
	}
}

471 472 473 474 475 476 477 478 479
/**
 *	init_alloc_map		-	initialise allocation map
 *	@host: host map to configure
 *
 *	Initialise the allocation maps for this device. If the device
 *	is not quiescent the caller must hold the allocation lock
 */

static void init_alloc_map(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
480
{
481
	u8 i, j;
Linus Torvalds's avatar
Linus Torvalds committed
482 483 484

	for (i = 0; i < MAX_CHANNELS; i++) {
		for (j = 0; j < 8; j++) {
485
			host->allocation_map[i][j] = 0xffffffff;
Linus Torvalds's avatar
Linus Torvalds committed
486 487 488 489
		}
	}
}

490 491 492 493
/**
 *	init_orchid		-	initialise the host adapter
 *	@host:host adapter to initialise
 *
494
 *	Initialise the controller and if necessary load the firmware.
495 496 497 498 499
 *
 *	Returns -1 if the initialisation fails.
 */

static int init_orchid(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
500
{
501 502 503 504 505 506 507 508 509
	u8 *ptr;
	u16 revision;
	u8 i;

	init_alloc_map(host);
	outb(0xFF, host->base + ORC_GIMSK);	/* Disable all interrupts */

	if (inb(host->base + ORC_HSTUS) & RREADY) {	/* Orchid is ready */
		revision = orc_read_fwrev(host);
Linus Torvalds's avatar
Linus Torvalds committed
510
		if (revision == 0xFFFF) {
511 512 513 514 515 516 517 518
			outb(DEVRST, host->base + ORC_HCTRL);	/* Reset Host Adapter   */
			if (wait_chip_ready(host) == 0)
				return -1;
			orc_load_firmware(host);	/* Download FW                  */
			setup_SCBs(host);	/* Setup SCB base and SCB Size registers */
			outb(0x00, host->base + ORC_HCTRL);	/* clear HOSTSTOP       */
			if (wait_firmware_ready(host) == 0)
				return -1;
Linus Torvalds's avatar
Linus Torvalds committed
519 520
			/* Wait for firmware ready     */
		} else {
521
			setup_SCBs(host);	/* Setup SCB base and SCB Size registers */
Linus Torvalds's avatar
Linus Torvalds committed
522 523
		}
	} else {		/* Orchid is not Ready          */
524 525 526 527 528 529
		outb(DEVRST, host->base + ORC_HCTRL);	/* Reset Host Adapter   */
		if (wait_chip_ready(host) == 0)
			return -1;
		orc_load_firmware(host);	/* Download FW                  */
		setup_SCBs(host);	/* Setup SCB base and SCB Size registers */
		outb(HDO, host->base + ORC_HCTRL);	/* Do Hardware Reset &  */
Linus Torvalds's avatar
Linus Torvalds committed
530 531

		/*     clear HOSTSTOP  */
532 533
		if (wait_firmware_ready(host) == 0)		/* Wait for firmware ready      */
			return -1;
Linus Torvalds's avatar
Linus Torvalds committed
534 535
	}

536 537 538
	/* Load an EEProm copy into RAM */
	/* Assumes single threaded at this point */
	read_eeprom(host);
Linus Torvalds's avatar
Linus Torvalds committed
539

540 541
	if (nvramp->revision != 1)
		return -1;
Linus Torvalds's avatar
Linus Torvalds committed
542

543 544 545 546 547 548 549
	host->scsi_id = nvramp->scsi_id;
	host->BIOScfg = nvramp->BIOSConfig1;
	host->max_targets = MAX_TARGETS;
	ptr = (u8 *) & (nvramp->Target00Config);
	for (i = 0; i < 16; ptr++, i++) {
		host->target_flag[i] = *ptr;
		host->max_tags[i] = ORC_MAXTAGS;
Linus Torvalds's avatar
Linus Torvalds committed
550
	}
551 552 553 554 555

	if (nvramp->SCSI0Config & NCC_BUSRESET)
		host->flags |= HCF_SCSI_RESET;
	outb(0xFB, host->base + ORC_GIMSK);	/* enable RP FIFO interrupt     */
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
556 557
}

558 559 560 561 562 563 564 565
/**
 *	orc_reset_scsi_bus		-	perform bus reset
 *	@host: host being reset
 *
 *	Perform a full bus reset on the adapter.
 */

static int orc_reset_scsi_bus(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
566
{				/* I need Host Control Block Information */
567
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
568

569
	spin_lock_irqsave(&host->allocation_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
570

571
	init_alloc_map(host);
Linus Torvalds's avatar
Linus Torvalds committed
572
	/* reset scsi bus */
573 574 575 576 577
	outb(SCSIRST, host->base + ORC_HCTRL);
	/* FIXME: We can spend up to a second with the lock held and
	   interrupts off here */
	if (wait_scsi_reset_done(host) == 0) {
		spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
578 579
		return FAILED;
	} else {
580
		spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
581 582 583 584
		return SUCCESS;
	}
}

585 586 587 588 589 590 591 592 593 594 595
/**
 *	orc_device_reset	-	device reset handler
 *	@host: host to reset
 *	@cmd: command causing the reset
 *	@target; target device
 *
 *	Reset registers, reset a hanging bus and kill active and disconnected
 *	commands for target w/o soft reset
 */

static int orc_device_reset(struct orc_host * host, struct scsi_cmnd *cmd, unsigned int target)
Linus Torvalds's avatar
Linus Torvalds committed
596
{				/* I need Host Control Block Information */
597 598 599 600 601
	struct orc_scb *scb;
	struct orc_extended_scb *escb;
	struct orc_scb *host_scb;
	u8 i;
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
602

603 604 605
	spin_lock_irqsave(&(host->allocation_lock), flags);
	scb = (struct orc_scb *) NULL;
	escb = (struct orc_extended_scb *) NULL;
Linus Torvalds's avatar
Linus Torvalds committed
606 607

	/* setup scatter list address with one buffer */
608
	host_scb = host->scb_virt;
Linus Torvalds's avatar
Linus Torvalds committed
609

610 611 612 613 614
	/* FIXME: is this safe if we then fail to issue the reset or race
	   a completion ? */
	init_alloc_map(host);

	/* Find the scb corresponding to the command */
Linus Torvalds's avatar
Linus Torvalds committed
615
	for (i = 0; i < ORC_MAXQUEUE; i++) {
616 617
		escb = host_scb->escb;
		if (host_scb->status && escb->srb == cmd)
Linus Torvalds's avatar
Linus Torvalds committed
618
			break;
619
		host_scb++;
Linus Torvalds's avatar
Linus Torvalds committed
620 621 622
	}

	if (i == ORC_MAXQUEUE) {
623 624
		printk(KERN_ERR "Unable to Reset - No SCB Found\n");
		spin_unlock_irqrestore(&(host->allocation_lock), flags);
Linus Torvalds's avatar
Linus Torvalds committed
625 626
		return FAILED;
	}
627 628 629 630 631

	/* Allocate a new SCB for the reset command to the firmware */
	if ((scb = __orc_alloc_scb(host)) == NULL) {
		/* Can't happen.. */
		spin_unlock_irqrestore(&(host->allocation_lock), flags);
Linus Torvalds's avatar
Linus Torvalds committed
632 633
		return FAILED;
	}
634

635
	/* Reset device is handled by the firmware, we fill in an SCB and
636 637 638 639 640 641 642 643 644
	   fire it at the controller, it does the rest */
	scb->opcode = ORC_BUSDEVRST;
	scb->target = target;
	scb->hastat = 0;
	scb->tastat = 0;
	scb->status = 0x0;
	scb->link = 0xFF;
	scb->reserved0 = 0;
	scb->reserved1 = 0;
645 646
	scb->xferlen = cpu_to_le32(0);
	scb->sg_len = cpu_to_le32(0);
647 648 649 650 651

	escb->srb = NULL;
	escb->srb = cmd;
	orc_exec_scb(host, scb);	/* Start execute SCB            */
	spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
652 653 654
	return SUCCESS;
}

655 656 657 658 659 660 661 662
/**
 *	__orc_alloc_scb		-		allocate an SCB
 *	@host: host to allocate from
 *
 *	Allocate an SCB and return a pointer to the SCB object. NULL
 *	is returned if no SCB is free. The caller must already hold
 *	the allocator lock at this point.
 */
Linus Torvalds's avatar
Linus Torvalds committed
663

664 665

static struct orc_scb *__orc_alloc_scb(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
666
{
667 668 669 670
	u8 channel;
	unsigned long idx;
	u8 index;
	u8 i;
Linus Torvalds's avatar
Linus Torvalds committed
671

672
	channel = host->index;
Linus Torvalds's avatar
Linus Torvalds committed
673 674
	for (i = 0; i < 8; i++) {
		for (index = 0; index < 32; index++) {
675 676
			if ((host->allocation_map[channel][i] >> index) & 0x01) {
				host->allocation_map[channel][i] &= ~(1 << index);
677 678 679 680 681
				idx = index + 32 * i;
				/*
				 * Translate the index to a structure instance
				 */
				return host->scb_virt + idx;
Linus Torvalds's avatar
Linus Torvalds committed
682 683 684
			}
		}
	}
685
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
686 687
}

688 689 690 691 692 693 694 695 696
/**
 *	orc_alloc_scb		-		allocate an SCB
 *	@host: host to allocate from
 *
 *	Allocate an SCB and return a pointer to the SCB object. NULL
 *	is returned if no SCB is free.
 */

static struct orc_scb *orc_alloc_scb(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
697
{
698 699
	struct orc_scb *scb;
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
700

701 702 703 704
	spin_lock_irqsave(&host->allocation_lock, flags);
	scb = __orc_alloc_scb(host);
	spin_unlock_irqrestore(&host->allocation_lock, flags);
	return scb;
Linus Torvalds's avatar
Linus Torvalds committed
705 706
}

707 708 709 710 711 712 713 714
/**
 *	orc_release_scb			-	release an SCB
 *	@host: host owning the SCB
 *	@scb: SCB that is now free
 *
 *	Called to return a completed SCB to the allocation pool. Before
 *	calling the SCB must be out of use on both the host and the HA.
 */
Linus Torvalds's avatar
Linus Torvalds committed
715

716
static void orc_release_scb(struct orc_host *host, struct orc_scb *scb)
Linus Torvalds's avatar
Linus Torvalds committed
717
{
718 719 720 721 722 723 724 725 726 727
	unsigned long flags;
	u8 index, i, channel;

	spin_lock_irqsave(&(host->allocation_lock), flags);
	channel = host->index;	/* Channel */
	index = scb->scbidx;
	i = index / 32;
	index %= 32;
	host->allocation_map[channel][i] |= (1 << index);
	spin_unlock_irqrestore(&(host->allocation_lock), flags);
Linus Torvalds's avatar
Linus Torvalds committed
728 729
}

730 731 732 733 734 735 736 737 738
/**
 *	orchid_abort_scb	-	abort a command
 *
 *	Abort a queued command that has been passed to the firmware layer
 *	if possible. This is all handled by the firmware. We aks the firmware
 *	and it either aborts the command or fails
 */

static int orchid_abort_scb(struct orc_host * host, struct orc_scb * scb)
Linus Torvalds's avatar
Linus Torvalds committed
739
{
740
	unsigned char data, status;
Linus Torvalds's avatar
Linus Torvalds committed
741

742 743 744
	outb(ORC_CMD_ABORT_SCB, host->base + ORC_HDATA);	/* Write command */
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
745 746
		return 0;

747 748 749
	outb(scb->scbidx, host->base + ORC_HDATA);	/* Write address */
	outb(HDO, host->base + ORC_HCTRL);
	if (wait_HDO_off(host) == 0)	/* Wait HDO off   */
Linus Torvalds's avatar
Linus Torvalds committed
750 751
		return 0;

752
	if (wait_hdi_set(host, &data) == 0)	/* Wait HDI set   */
Linus Torvalds's avatar
Linus Torvalds committed
753
		return 0;
754 755
	status = inb(host->base + ORC_HDATA);
	outb(data, host->base + ORC_HSTUS);	/* Clear HDI    */
Linus Torvalds's avatar
Linus Torvalds committed
756

757
	if (status == 1)	/* 0 - Successfully               */
Linus Torvalds's avatar
Linus Torvalds committed
758 759 760 761
		return 0;	/* 1 - Fail                     */
	return 1;
}

762
static int inia100_abort_cmd(struct orc_host * host, struct scsi_cmnd *cmd)
Linus Torvalds's avatar
Linus Torvalds committed
763
{
764 765 766 767 768 769
	struct orc_extended_scb *escb;
	struct orc_scb *scb;
	u8 i;
	unsigned long flags;

	spin_lock_irqsave(&(host->allocation_lock), flags);
Linus Torvalds's avatar
Linus Torvalds committed
770

771
	scb = host->scb_virt;
Linus Torvalds's avatar
Linus Torvalds committed
772

773 774 775
	/* Walk the queue until we find the SCB that belongs to the command
	   block. This isn't a performance critical path so a walk in the park
	   here does no harm */
Linus Torvalds's avatar
Linus Torvalds committed
776

777 778 779 780 781
	for (i = 0; i < ORC_MAXQUEUE; i++, scb++) {
		escb = scb->escb;
		if (scb->status && escb->srb == cmd) {
			if (scb->tag_msg == 0) {
				goto out;
Linus Torvalds's avatar
Linus Torvalds committed
782
			} else {
783 784 785 786
				/* Issue an ABORT to the firmware */
				if (orchid_abort_scb(host, scb)) {
					escb->srb = NULL;
					spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
787
					return SUCCESS;
788 789
				} else
					goto out;
Linus Torvalds's avatar
Linus Torvalds committed
790 791 792
			}
		}
	}
793 794
out:
	spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
795 796 797
	return FAILED;
}

798 799 800 801 802 803 804 805 806 807 808 809 810 811
/**
 *	orc_interrupt		-	IRQ processing
 *	@host: Host causing the interrupt
 *
 *	This function is called from the IRQ handler and protected
 *	by the host lock. While the controller reports that there are
 *	scb's for processing we pull them off the controller, turn the
 *	index into a host address pointer to the scb and call the scb
 *	handler.
 *
 *	Returns IRQ_HANDLED if any SCBs were processed, IRQ_NONE otherwise
 */

static irqreturn_t orc_interrupt(struct orc_host * host)
Linus Torvalds's avatar
Linus Torvalds committed
812
{
813 814
	u8 scb_index;
	struct orc_scb *scb;
Linus Torvalds's avatar
Linus Torvalds committed
815

816 817 818
	/* Check if we have an SCB queued for servicing */
	if (inb(host->base + ORC_RQUEUECNT) == 0)
		return IRQ_NONE;
Linus Torvalds's avatar
Linus Torvalds committed
819 820

	do {
821 822 823 824 825 826 827 828 829 830
		/* Get the SCB index of the SCB to service */
		scb_index = inb(host->base + ORC_RQUEUE);

		/* Translate it back to a host pointer */
		scb = (struct orc_scb *) ((unsigned long) host->scb_virt + (unsigned long) (sizeof(struct orc_scb) * scb_index));
		scb->status = 0x0;
		/* Process the SCB */
		inia100_scb_handler(host, scb);
	} while (inb(host->base + ORC_RQUEUECNT));
	return IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
831 832
}				/* End of I1060Interrupt() */

833 834 835 836 837 838 839 840 841
/**
 *	inia100_build_scb	-	build SCB
 *	@host: host owing the control block
 *	@scb: control block to use
 *	@cmd: Mid layer command
 *
 *	Build a host adapter control block from the SCSI mid layer command
 */

842
static int inia100_build_scb(struct orc_host * host, struct orc_scb * scb, struct scsi_cmnd * cmd)
Linus Torvalds's avatar
Linus Torvalds committed
843
{				/* Create corresponding SCB     */
844
	struct scatterlist *sg;
845
	struct orc_sgent *sgent;		/* Pointer to SG list           */
Linus Torvalds's avatar
Linus Torvalds committed
846
	int i, count_sg;
847 848 849 850 851 852 853 854 855 856 857 858 859 860
	struct orc_extended_scb *escb;

	/* Links between the escb, scb and Linux scsi midlayer cmd */
	escb = scb->escb;
	escb->srb = cmd;
	sgent = NULL;

	/* Set up the SCB to do a SCSI command block */
	scb->opcode = ORC_EXECSCSI;
	scb->flags = SCF_NO_DCHK;	/* Clear done bit               */
	scb->target = cmd->device->id;
	scb->lun = cmd->device->lun;
	scb->reserved0 = 0;
	scb->reserved1 = 0;
861
	scb->sg_len = cpu_to_le32(0);
862

863
	scb->xferlen = cpu_to_le32((u32) scsi_bufflen(cmd));
864 865 866
	sgent = (struct orc_sgent *) & escb->sglist[0];

	count_sg = scsi_dma_map(cmd);
867 868
	if (count_sg < 0)
		return count_sg;
869
	BUG_ON(count_sg > TOTAL_SG_ENTRY);
870 871

	/* Build the scatter gather lists */
872
	if (count_sg) {
873
		scb->sg_len = cpu_to_le32((u32) (count_sg * 8));
874
		scsi_for_each_sg(cmd, sg, count_sg, i) {
875 876
			sgent->base = cpu_to_le32((u32) sg_dma_address(sg));
			sgent->length = cpu_to_le32((u32) sg_dma_len(sg));
877
			sgent++;
Linus Torvalds's avatar
Linus Torvalds committed
878
		}
879
	} else {
880 881 882
		scb->sg_len = cpu_to_le32(0);
		sgent->base = cpu_to_le32(0);
		sgent->length = cpu_to_le32(0);
Linus Torvalds's avatar
Linus Torvalds committed
883
	}
884
	scb->sg_addr = (u32) scb->sense_addr;	/* sense_addr is already little endian */
885 886 887 888 889 890
	scb->hastat = 0;
	scb->tastat = 0;
	scb->link = 0xFF;
	scb->sense_len = SENSE_SIZE;
	scb->cdb_len = cmd->cmd_len;
	if (scb->cdb_len >= IMAX_CDB) {
891
		printk("max cdb length= %x\n", cmd->cmd_len);
892
		scb->cdb_len = IMAX_CDB;
Linus Torvalds's avatar
Linus Torvalds committed
893
	}
Hannes Reinecke's avatar
Hannes Reinecke committed
894
	scb->ident = (u8)(cmd->device->lun & 0xff) | DISC_ALLOW;
895 896
	if (cmd->device->tagged_supported) {	/* Tag Support                  */
		scb->tag_msg = SIMPLE_QUEUE_TAG;	/* Do simple tag only   */
Linus Torvalds's avatar
Linus Torvalds committed
897
	} else {
898
		scb->tag_msg = 0;	/* No tag support               */
Linus Torvalds's avatar
Linus Torvalds committed
899
	}
900
	memcpy(scb->cdb, cmd->cmnd, scb->cdb_len);
901
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
902 903
}

904 905 906 907 908 909 910 911 912 913
/**
 *	inia100_queue		-	queue command with host
 *	@cmd: Command block
 *	@done: Completion function
 *
 *	Called by the mid layer to queue a command. Process the command
 *	block, build the host specific scb structures and if there is room
 *	queue the command down to the controller
 */

Jeff Garzik's avatar
Jeff Garzik committed
914
static int inia100_queue_lck(struct scsi_cmnd * cmd, void (*done) (struct scsi_cmnd *))
Linus Torvalds's avatar
Linus Torvalds committed
915
{
916 917
	struct orc_scb *scb;
	struct orc_host *host;		/* Point to Host adapter control block */
Linus Torvalds's avatar
Linus Torvalds committed
918

919 920
	host = (struct orc_host *) cmd->device->host->hostdata;
	cmd->scsi_done = done;
Linus Torvalds's avatar
Linus Torvalds committed
921
	/* Get free SCSI control block  */
922
	if ((scb = orc_alloc_scb(host)) == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
923 924
		return SCSI_MLQUEUE_HOST_BUSY;

925 926 927 928
	if (inia100_build_scb(host, scb, cmd)) {
		orc_release_scb(host, scb);
		return SCSI_MLQUEUE_HOST_BUSY;
	}
929 930
	orc_exec_scb(host, scb);	/* Start execute SCB            */
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
931 932
}

Jeff Garzik's avatar
Jeff Garzik committed
933 934
static DEF_SCSI_QCMD(inia100_queue)

Linus Torvalds's avatar
Linus Torvalds committed
935 936 937 938
/*****************************************************************************
 Function name  : inia100_abort
 Description    : Abort a queued command.
	                 (commands that are on the bus can't be aborted easily)
939
 Input          : host  -       Pointer to host adapter structure
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942
 Output         : None.
 Return         : pSRB  -       Pointer to SCSI request block.
*****************************************************************************/
943
static int inia100_abort(struct scsi_cmnd * cmd)
Linus Torvalds's avatar
Linus Torvalds committed
944
{
945
	struct orc_host *host;
Linus Torvalds's avatar
Linus Torvalds committed
946

947 948
	host = (struct orc_host *) cmd->device->host->hostdata;
	return inia100_abort_cmd(host, cmd);
Linus Torvalds's avatar
Linus Torvalds committed
949 950 951 952 953 954
}

/*****************************************************************************
 Function name  : inia100_reset
 Description    : Reset registers, reset a hanging bus and
                  kill active and disconnected commands for target w/o soft reset
955
 Input          : host  -       Pointer to host adapter structure
Linus Torvalds's avatar
Linus Torvalds committed
956 957 958
 Output         : None.
 Return         : pSRB  -       Pointer to SCSI request block.
*****************************************************************************/
959
static int inia100_bus_reset(struct scsi_cmnd * cmd)
Linus Torvalds's avatar
Linus Torvalds committed
960
{				/* I need Host Control Block Information */
961 962 963
	struct orc_host *host;
	host = (struct orc_host *) cmd->device->host->hostdata;
	return orc_reset_scsi_bus(host);
Linus Torvalds's avatar
Linus Torvalds committed
964 965 966 967 968
}

/*****************************************************************************
 Function name  : inia100_device_reset
 Description    : Reset the device
969
 Input          : host  -       Pointer to host adapter structure
Linus Torvalds's avatar
Linus Torvalds committed
970 971 972
 Output         : None.
 Return         : pSRB  -       Pointer to SCSI request block.
*****************************************************************************/
973
static int inia100_device_reset(struct scsi_cmnd * cmd)
Linus Torvalds's avatar
Linus Torvalds committed
974
{				/* I need Host Control Block Information */
975 976 977
	struct orc_host *host;
	host = (struct orc_host *) cmd->device->host->hostdata;
	return orc_device_reset(host, cmd, scmd_id(cmd));
Linus Torvalds's avatar
Linus Torvalds committed
978 979 980

}

981 982 983 984 985 986 987 988 989 990 991
/**
 *	inia100_scb_handler	-	interrupt callback
 *	@host: Host causing the interrupt
 *	@scb: SCB the controller returned as needing processing
 *
 *	Perform completion processing on a control block. Do the conversions
 *	from host to SCSI midlayer error coding, save any sense data and
 *	the complete with the midlayer and recycle the scb.
 */

static void inia100_scb_handler(struct orc_host *host, struct orc_scb *scb)
Linus Torvalds's avatar
Linus Torvalds committed
992
{
993 994 995 996 997 998 999
	struct scsi_cmnd *cmd;	/* Pointer to SCSI request block */
	struct orc_extended_scb *escb;

	escb = scb->escb;
	if ((cmd = (struct scsi_cmnd *) escb->srb) == NULL) {
		printk(KERN_ERR "inia100_scb_handler: SRB pointer is empty\n");
		orc_release_scb(host, scb);	/* Release SCB for current channel */
Linus Torvalds's avatar
Linus Torvalds committed
1000 1001
		return;
	}
1002
	escb->srb = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1003

1004
	switch (scb->hastat) {
Linus Torvalds's avatar
Linus Torvalds committed
1005 1006 1007
	case 0x0:
	case 0xa:		/* Linked command complete without error and linked normally */
	case 0xb:		/* Linked command complete without error interrupt generated */
1008
		scb->hastat = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1009 1010 1011 1012
		break;

	case 0x11:		/* Selection time out-The initiator selection or target
				   reselection was not complete within the SCSI Time out period */
1013
		scb->hastat = DID_TIME_OUT;
Linus Torvalds's avatar
Linus Torvalds committed
1014 1015 1016 1017 1018 1019
		break;

	case 0x14:		/* Target bus phase sequence failure-An invalid bus phase or bus
				   phase sequence was requested by the target. The host adapter
				   will generate a SCSI Reset Condition, notifying the host with
				   a SCRD interrupt */
1020
		scb->hastat = DID_RESET;
Linus Torvalds's avatar
Linus Torvalds committed
1021 1022 1023
		break;

	case 0x1a:		/* SCB Aborted. 07/21/98 */
1024
		scb->hastat = DID_ABORT;
Linus Torvalds's avatar
Linus Torvalds committed
1025 1026 1027 1028 1029 1030 1031 1032 1033
		break;

	case 0x12:		/* Data overrun/underrun-The target attempted to transfer more data
				   than was allocated by the Data Length field or the sum of the
				   Scatter / Gather Data Length fields. */
	case 0x13:		/* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
	case 0x16:		/* Invalid CCB Operation Code-The first byte of the CCB was invalid. */

	default:
1034 1035
		printk(KERN_DEBUG "inia100: %x %x\n", scb->hastat, scb->tastat);
		scb->hastat = DID_ERROR;	/* Couldn't find any better */
Linus Torvalds's avatar
Linus Torvalds committed
1036 1037 1038
		break;
	}

1039 1040 1041
	if (scb->tastat == 2) {	/* Check condition              */
		memcpy((unsigned char *) &cmd->sense_buffer[0],
		   (unsigned char *) &escb->sglist[0], SENSE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
1042
	}
1043 1044 1045 1046
	cmd->result = scb->tastat | (scb->hastat << 16);
	scsi_dma_unmap(cmd);
	cmd->scsi_done(cmd);	/* Notify system DONE           */
	orc_release_scb(host, scb);	/* Release SCB for current channel */
Linus Torvalds's avatar
Linus Torvalds committed
1047 1048
}

1049 1050 1051 1052 1053 1054 1055
/**
 *	inia100_intr		-	interrupt handler
 *	@irqno: Interrupt value
 *	@devid: Host adapter
 *
 *	Entry point for IRQ handling. All the real work is performed
 *	by orc_interrupt.
Linus Torvalds's avatar
Linus Torvalds committed
1056
 */
1057
static irqreturn_t inia100_intr(int irqno, void *devid)
Linus Torvalds's avatar
Linus Torvalds committed
1058
{
1059 1060
	struct Scsi_Host *shost = (struct Scsi_Host *)devid;
	struct orc_host *host = (struct orc_host *)shost->hostdata;
Linus Torvalds's avatar
Linus Torvalds committed
1061
	unsigned long flags;
1062
	irqreturn_t res;
Linus Torvalds's avatar
Linus Torvalds committed
1063

1064 1065 1066
	spin_lock_irqsave(shost->host_lock, flags);
	res = orc_interrupt(host);
	spin_unlock_irqrestore(shost->host_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1067

1068
	return res;
Linus Torvalds's avatar
Linus Torvalds committed
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
}

static struct scsi_host_template inia100_template = {
	.proc_name		= "inia100",
	.name			= inia100_REVID,
	.queuecommand		= inia100_queue,
	.eh_abort_handler	= inia100_abort,
	.eh_bus_reset_handler	= inia100_bus_reset,
	.eh_device_reset_handler = inia100_device_reset,
	.can_queue		= 1,
	.this_id		= 1,
	.sg_tablesize		= SG_ALL,
	.use_clustering		= ENABLE_CLUSTERING,
};

1084 1085
static int inia100_probe_one(struct pci_dev *pdev,
			     const struct pci_device_id *id)
Linus Torvalds's avatar
Linus Torvalds committed
1086 1087
{
	struct Scsi_Host *shost;
1088
	struct orc_host *host;
Linus Torvalds's avatar
Linus Torvalds committed
1089 1090 1091
	unsigned long port, bios;
	int error = -ENODEV;
	u32 sz;
1092 1093
	unsigned long biosaddr;
	char *bios_phys;
Linus Torvalds's avatar
Linus Torvalds committed
1094 1095 1096

	if (pci_enable_device(pdev))
		goto out;
1097
	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
Linus Torvalds's avatar
Linus Torvalds committed
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
		printk(KERN_WARNING "Unable to set 32bit DMA "
				    "on inia100 adapter, ignoring.\n");
		goto out_disable_device;
	}

	pci_set_master(pdev);

	port = pci_resource_start(pdev, 0);
	if (!request_region(port, 256, "inia100")) {
		printk(KERN_WARNING "inia100: io port 0x%lx, is busy.\n", port);
		goto out_disable_device;
	}

1111
	/* <02> read from base address + 0x50 offset to get the bios value. */
1112
	bios = inw(port + 0x50);
Linus Torvalds's avatar
Linus Torvalds committed
1113 1114


1115
	shost = scsi_host_alloc(&inia100_template, sizeof(struct orc_host));
Linus Torvalds's avatar
Linus Torvalds committed
1116 1117 1118
	if (!shost)
		goto out_release_region;

1119 1120 1121 1122 1123
	host = (struct orc_host *)shost->hostdata;
	host->pdev = pdev;
	host->base = port;
	host->BIOScfg = bios;
	spin_lock_init(&host->allocation_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1124 1125

	/* Get total memory needed for SCB */
1126
	sz = ORC_MAXQUEUE * sizeof(struct orc_scb);
Joe Perches's avatar
Joe Perches committed
1127
	host->scb_virt = pci_zalloc_consistent(pdev, sz, &host->scb_phys);
1128
	if (!host->scb_virt) {
Linus Torvalds's avatar
Linus Torvalds committed
1129 1130 1131 1132 1133
		printk("inia100: SCB memory allocation error\n");
		goto out_host_put;
	}

	/* Get total memory needed for ESCB */
1134
	sz = ORC_MAXQUEUE * sizeof(struct orc_extended_scb);
Joe Perches's avatar
Joe Perches committed
1135
	host->escb_virt = pci_zalloc_consistent(pdev, sz, &host->escb_phys);
1136
	if (!host->escb_virt) {
Linus Torvalds's avatar
Linus Torvalds committed
1137 1138 1139 1140
		printk("inia100: ESCB memory allocation error\n");
		goto out_free_scb_array;
	}

1141 1142 1143 1144
	biosaddr = host->BIOScfg;
	biosaddr = (biosaddr << 4);
	bios_phys = phys_to_virt(biosaddr);
	if (init_orchid(host)) {	/* Initialize orchid chip */
Linus Torvalds's avatar
Linus Torvalds committed
1145 1146 1147 1148
		printk("inia100: initial orchid fail!!\n");
		goto out_free_escb_array;
	}

1149
	shost->io_port = host->base;
Linus Torvalds's avatar
Linus Torvalds committed
1150 1151 1152
	shost->n_io_port = 0xff;
	shost->can_queue = ORC_MAXQUEUE;
	shost->unique_id = shost->io_port;
1153
	shost->max_id = host->max_targets;
Linus Torvalds's avatar
Linus Torvalds committed
1154
	shost->max_lun = 16;
1155 1156
	shost->irq = pdev->irq;
	shost->this_id = host->scsi_id;	/* Assign HCS index */
Linus Torvalds's avatar
Linus Torvalds committed
1157