blob: dbbc601948e5328e4c9a0bbfeb18ee8ac7f7fd91 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Initio A100 device driver for Linux.
3 *
4 * Copyright (c) 1994-1998 Initio Corporation
5 * Copyright (c) 2003-2004 Christoph Hellwig
6 * All rights reserved.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2, or (at your option)
11 * any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; see the file COPYING. If not, write to
20 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
26 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35/*
36 * Revision History:
37 * 07/02/98 hl - v.91n Initial drivers.
38 * 09/14/98 hl - v1.01 Support new Kernel.
39 * 09/22/98 hl - v1.01a Support reset.
40 * 09/24/98 hl - v1.01b Fixed reset.
41 * 10/05/98 hl - v1.02 split the source code and release.
42 * 12/19/98 bv - v1.02a Use spinlocks for 2.1.95 and up
43 * 01/31/99 bv - v1.02b Use mdelay instead of waitForPause
44 * 08/08/99 bv - v1.02c Use waitForPause again.
45 * 06/25/02 Doug Ledford <dledford@redhat.com> - v1.02d
46 * - Remove limit on number of controllers
47 * - Port to DMA mapping API
48 * - Clean up interrupt handler registration
49 * - Fix memory leaks
50 * - Fix allocation of scsi host structs and private data
51 * 11/18/03 Christoph Hellwig <hch@lst.de>
52 * - Port to new probing API
53 * - Fix some more leaks in init failure cases
54 * 9/28/04 Christoph Hellwig <hch@lst.de>
55 * - merge the two source files
56 * - remove internal queueing code
Alan Coxfa195af2008-10-27 15:16:36 +000057 * 14/06/07 Alan Cox <alan@lxorguk.ukuu.org.uk>
Alan Cox4023c472007-06-15 14:45:30 +010058 * - Grand cleanup and Linuxisation
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 */
60
61#include <linux/module.h>
62#include <linux/errno.h>
63#include <linux/delay.h>
64#include <linux/interrupt.h>
65#include <linux/pci.h>
66#include <linux/init.h>
67#include <linux/blkdev.h>
68#include <linux/spinlock.h>
69#include <linux/kernel.h>
70#include <linux/string.h>
71#include <linux/ioport.h>
Matthias Gehre910638a2006-03-28 01:56:48 -080072#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74#include <asm/io.h>
75#include <asm/irq.h>
76
77#include <scsi/scsi.h>
78#include <scsi/scsi_cmnd.h>
79#include <scsi/scsi_device.h>
80#include <scsi/scsi_host.h>
81
82#include "a100u2w.h"
83
84
Alan Cox4023c472007-06-15 14:45:30 +010085static struct orc_scb *__orc_alloc_scb(struct orc_host * host);
86static void inia100_scb_handler(struct orc_host *host, struct orc_scb *scb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Alan Cox4023c472007-06-15 14:45:30 +010088static struct orc_nvram nvram, *nvramp = &nvram;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Alan Cox4023c472007-06-15 14:45:30 +010090static u8 default_nvram[64] =
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
92/*----------header -------------*/
93 0x01, /* 0x00: Sub System Vendor ID 0 */
94 0x11, /* 0x01: Sub System Vendor ID 1 */
95 0x60, /* 0x02: Sub System ID 0 */
96 0x10, /* 0x03: Sub System ID 1 */
97 0x00, /* 0x04: SubClass */
98 0x01, /* 0x05: Vendor ID 0 */
99 0x11, /* 0x06: Vendor ID 1 */
100 0x60, /* 0x07: Device ID 0 */
101 0x10, /* 0x08: Device ID 1 */
102 0x00, /* 0x09: Reserved */
103 0x00, /* 0x0A: Reserved */
104 0x01, /* 0x0B: Revision of Data Structure */
105 /* -- Host Adapter Structure --- */
106 0x01, /* 0x0C: Number Of SCSI Channel */
107 0x01, /* 0x0D: BIOS Configuration 1 */
108 0x00, /* 0x0E: BIOS Configuration 2 */
109 0x00, /* 0x0F: BIOS Configuration 3 */
110 /* --- SCSI Channel 0 Configuration --- */
111 0x07, /* 0x10: H/A ID */
112 0x83, /* 0x11: Channel Configuration */
113 0x20, /* 0x12: MAX TAG per target */
114 0x0A, /* 0x13: SCSI Reset Recovering time */
115 0x00, /* 0x14: Channel Configuration4 */
116 0x00, /* 0x15: Channel Configuration5 */
117 /* SCSI Channel 0 Target Configuration */
118 /* 0x16-0x25 */
119 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
120 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
121 /* --- SCSI Channel 1 Configuration --- */
122 0x07, /* 0x26: H/A ID */
123 0x83, /* 0x27: Channel Configuration */
124 0x20, /* 0x28: MAX TAG per target */
125 0x0A, /* 0x29: SCSI Reset Recovering time */
126 0x00, /* 0x2A: Channel Configuration4 */
127 0x00, /* 0x2B: Channel Configuration5 */
128 /* SCSI Channel 1 Target Configuration */
129 /* 0x2C-0x3B */
130 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
131 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
132 0x00, /* 0x3C: Reserved */
133 0x00, /* 0x3D: Reserved */
134 0x00, /* 0x3E: Reserved */
135 0x00 /* 0x3F: Checksum */
136};
137
138
Alan Cox4023c472007-06-15 14:45:30 +0100139static u8 wait_chip_ready(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140{
141 int i;
142
143 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
Alan Cox4023c472007-06-15 14:45:30 +0100144 if (inb(host->base + ORC_HCTRL) & HOSTSTOP) /* Wait HOSTSTOP set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 return 1;
Alan Cox4023c472007-06-15 14:45:30 +0100146 mdelay(100);
147 }
148 return 0;
149}
150
151static u8 wait_firmware_ready(struct orc_host * host)
152{
153 int i;
154
155 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
156 if (inb(host->base + ORC_HSTUS) & RREADY) /* Wait READY set */
157 return 1;
158 mdelay(100); /* wait 100ms before try again */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 }
160 return 0;
161}
162
163/***************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100164static u8 wait_scsi_reset_done(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165{
166 int i;
167
168 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
Alan Cox4023c472007-06-15 14:45:30 +0100169 if (!(inb(host->base + ORC_HCTRL) & SCSIRST)) /* Wait SCSIRST done */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 return 1;
Alan Cox4023c472007-06-15 14:45:30 +0100171 mdelay(100); /* wait 100ms before try again */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 }
173 return 0;
174}
175
176/***************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100177static u8 wait_HDO_off(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 int i;
180
181 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
Alan Cox4023c472007-06-15 14:45:30 +0100182 if (!(inb(host->base + ORC_HCTRL) & HDO)) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 return 1;
Alan Cox4023c472007-06-15 14:45:30 +0100184 mdelay(100); /* wait 100ms before try again */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 }
186 return 0;
187}
188
189/***************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100190static u8 wait_hdi_set(struct orc_host * host, u8 * data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
192 int i;
193
194 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
Alan Cox4023c472007-06-15 14:45:30 +0100195 if ((*data = inb(host->base + ORC_HSTUS)) & HDI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 return 1; /* Wait HDI set */
Alan Cox4023c472007-06-15 14:45:30 +0100197 mdelay(100); /* wait 100ms before try again */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 }
199 return 0;
200}
201
202/***************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100203static unsigned short orc_read_fwrev(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
Alan Cox4023c472007-06-15 14:45:30 +0100205 u16 version;
206 u8 data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Alan Cox4023c472007-06-15 14:45:30 +0100208 outb(ORC_CMD_VERSION, host->base + ORC_HDATA);
209 outb(HDO, host->base + ORC_HCTRL);
210 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 return 0;
212
Alan Cox4023c472007-06-15 14:45:30 +0100213 if (wait_hdi_set(host, &data) == 0) /* Wait HDI set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 return 0;
Alan Cox4023c472007-06-15 14:45:30 +0100215 version = inb(host->base + ORC_HDATA);
216 outb(data, host->base + ORC_HSTUS); /* Clear HDI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Alan Cox4023c472007-06-15 14:45:30 +0100218 if (wait_hdi_set(host, &data) == 0) /* Wait HDI set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 return 0;
Alan Cox4023c472007-06-15 14:45:30 +0100220 version |= inb(host->base + ORC_HDATA) << 8;
221 outb(data, host->base + ORC_HSTUS); /* Clear HDI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Alan Cox4023c472007-06-15 14:45:30 +0100223 return version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224}
225
226/***************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100227static u8 orc_nv_write(struct orc_host * host, unsigned char address, unsigned char value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
Alan Cox4023c472007-06-15 14:45:30 +0100229 outb(ORC_CMD_SET_NVM, host->base + ORC_HDATA); /* Write command */
230 outb(HDO, host->base + ORC_HCTRL);
231 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return 0;
233
Alan Cox4023c472007-06-15 14:45:30 +0100234 outb(address, host->base + ORC_HDATA); /* Write address */
235 outb(HDO, host->base + ORC_HCTRL);
236 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 return 0;
238
Alan Cox4023c472007-06-15 14:45:30 +0100239 outb(value, host->base + ORC_HDATA); /* Write value */
240 outb(HDO, host->base + ORC_HCTRL);
241 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return 0;
243
244 return 1;
245}
246
247/***************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100248static u8 orc_nv_read(struct orc_host * host, u8 address, u8 *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
Alan Cox4023c472007-06-15 14:45:30 +0100250 unsigned char data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Alan Cox4023c472007-06-15 14:45:30 +0100252 outb(ORC_CMD_GET_NVM, host->base + ORC_HDATA); /* Write command */
253 outb(HDO, host->base + ORC_HCTRL);
254 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 return 0;
256
Alan Cox4023c472007-06-15 14:45:30 +0100257 outb(address, host->base + ORC_HDATA); /* Write address */
258 outb(HDO, host->base + ORC_HCTRL);
259 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 return 0;
261
Alan Cox4023c472007-06-15 14:45:30 +0100262 if (wait_hdi_set(host, &data) == 0) /* Wait HDI set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return 0;
Alan Cox4023c472007-06-15 14:45:30 +0100264 *ptr = inb(host->base + ORC_HDATA);
265 outb(data, host->base + ORC_HSTUS); /* Clear HDI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
267 return 1;
Alan Cox4023c472007-06-15 14:45:30 +0100268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
Alan Cox4023c472007-06-15 14:45:30 +0100271/**
272 * orc_exec_sb - Queue an SCB with the HA
273 * @host: host adapter the SCB belongs to
274 * @scb: SCB to queue for execution
275 */
276
277static void orc_exec_scb(struct orc_host * host, struct orc_scb * scb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278{
Alan Cox4023c472007-06-15 14:45:30 +0100279 scb->status = ORCSCB_POST;
280 outb(scb->scbidx, host->base + ORC_PQUEUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281}
282
283
Alan Cox4023c472007-06-15 14:45:30 +0100284/**
285 * se2_rd_all - read SCSI parameters from EEPROM
286 * @host: Host whose EEPROM is being loaded
287 *
288 * Read SCSI H/A configuration parameters from serial EEPROM
289 */
290
291static int se2_rd_all(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
293 int i;
Alan Cox4023c472007-06-15 14:45:30 +0100294 u8 *np, chksum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Alan Cox4023c472007-06-15 14:45:30 +0100296 np = (u8 *) nvramp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 for (i = 0; i < 64; i++, np++) { /* <01> */
Alan Cox4023c472007-06-15 14:45:30 +0100298 if (orc_nv_read(host, (u8) i, np) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 }
301
Alan Cox4023c472007-06-15 14:45:30 +0100302 /*------ Is ckecksum ok ? ------*/
303 np = (u8 *) nvramp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 for (i = 0; i < 63; i++)
305 chksum += *np++;
306
Alan Cox4023c472007-06-15 14:45:30 +0100307 if (nvramp->CheckSum != (u8) chksum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 return -1;
309 return 1;
310}
311
Alan Cox4023c472007-06-15 14:45:30 +0100312/**
313 * se2_update_all - update the EEPROM
314 * @host: Host whose EEPROM is being updated
315 *
316 * Update changed bytes in the EEPROM image.
317 */
318
319static void se2_update_all(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{ /* setup default pattern */
321 int i;
Alan Cox4023c472007-06-15 14:45:30 +0100322 u8 *np, *np1, chksum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
324 /* Calculate checksum first */
Alan Cox4023c472007-06-15 14:45:30 +0100325 np = (u8 *) default_nvram;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 for (i = 0; i < 63; i++)
327 chksum += *np++;
328 *np = chksum;
329
Alan Cox4023c472007-06-15 14:45:30 +0100330 np = (u8 *) default_nvram;
331 np1 = (u8 *) nvramp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 for (i = 0; i < 64; i++, np++, np1++) {
Alan Cox4023c472007-06-15 14:45:30 +0100333 if (*np != *np1)
334 orc_nv_write(host, (u8) i, *np);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
Alan Cox4023c472007-06-15 14:45:30 +0100338/**
339 * read_eeprom - load EEPROM
340 * @host: Host EEPROM to read
341 *
342 * Read the EEPROM for a given host. If it is invalid or fails
343 * the restore the defaults and use them.
344 */
345
346static void read_eeprom(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
Alan Cox4023c472007-06-15 14:45:30 +0100348 if (se2_rd_all(host) != 1) {
349 se2_update_all(host); /* setup default pattern */
350 se2_rd_all(host); /* load again */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 }
352}
353
354
Alan Cox4023c472007-06-15 14:45:30 +0100355/**
356 * orc_load_firmware - initialise firmware
357 * @host: Host to set up
358 *
359 * Load the firmware from the EEPROM into controller SRAM. This
360 * is basically a 4K block copy and then a 4K block read to check
361 * correctness. The rest is convulted by the indirect interfaces
362 * in the hardware
363 */
364
365static u8 orc_load_firmware(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
Alan Cox4023c472007-06-15 14:45:30 +0100367 u32 data32;
368 u16 bios_addr;
369 u16 i;
370 u8 *data32_ptr, data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
372
Alan Cox4023c472007-06-15 14:45:30 +0100373 /* Set up the EEPROM for access */
374
375 data = inb(host->base + ORC_GCFG);
376 outb(data | EEPRG, host->base + ORC_GCFG); /* Enable EEPROM programming */
377 outb(0x00, host->base + ORC_EBIOSADR2);
378 outw(0x0000, host->base + ORC_EBIOSADR0);
379 if (inb(host->base + ORC_EBIOSDATA) != 0x55) {
380 outb(data, host->base + ORC_GCFG); /* Disable EEPROM programming */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 return 0;
382 }
Alan Cox4023c472007-06-15 14:45:30 +0100383 outw(0x0001, host->base + ORC_EBIOSADR0);
384 if (inb(host->base + ORC_EBIOSDATA) != 0xAA) {
385 outb(data, host->base + ORC_GCFG); /* Disable EEPROM programming */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 return 0;
387 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Alan Cox4023c472007-06-15 14:45:30 +0100389 outb(PRGMRST | DOWNLOAD, host->base + ORC_RISCCTL); /* Enable SRAM programming */
390 data32_ptr = (u8 *) & data32;
Mikulas Patocka987ff952008-07-15 17:15:41 -0400391 data32 = cpu_to_le32(0); /* Initial FW address to 0 */
Alan Cox4023c472007-06-15 14:45:30 +0100392 outw(0x0010, host->base + ORC_EBIOSADR0);
393 *data32_ptr = inb(host->base + ORC_EBIOSDATA); /* Read from BIOS */
394 outw(0x0011, host->base + ORC_EBIOSADR0);
395 *(data32_ptr + 1) = inb(host->base + ORC_EBIOSDATA); /* Read from BIOS */
396 outw(0x0012, host->base + ORC_EBIOSADR0);
397 *(data32_ptr + 2) = inb(host->base + ORC_EBIOSDATA); /* Read from BIOS */
398 outw(*(data32_ptr + 2), host->base + ORC_EBIOSADR2);
Mikulas Patocka987ff952008-07-15 17:15:41 -0400399 outl(le32_to_cpu(data32), host->base + ORC_FWBASEADR); /* Write FW address */
Alan Cox4023c472007-06-15 14:45:30 +0100400
401 /* Copy the code from the BIOS to the SRAM */
402
Mikulas Patocka56d387e2008-07-15 17:16:38 -0400403 udelay(500); /* Required on Sun Ultra 5 ... 350 -> failures */
Mikulas Patocka987ff952008-07-15 17:15:41 -0400404 bios_addr = (u16) le32_to_cpu(data32); /* FW code locate at BIOS address + ? */
Alan Cox4023c472007-06-15 14:45:30 +0100405 for (i = 0, data32_ptr = (u8 *) & data32; /* Download the code */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 i < 0x1000; /* Firmware code size = 4K */
Alan Cox4023c472007-06-15 14:45:30 +0100407 i++, bios_addr++) {
408 outw(bios_addr, host->base + ORC_EBIOSADR0);
409 *data32_ptr++ = inb(host->base + ORC_EBIOSDATA); /* Read from BIOS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 if ((i % 4) == 3) {
Mikulas Patocka987ff952008-07-15 17:15:41 -0400411 outl(le32_to_cpu(data32), host->base + ORC_RISCRAM); /* Write every 4 bytes */
Alan Cox4023c472007-06-15 14:45:30 +0100412 data32_ptr = (u8 *) & data32;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 }
414 }
415
Alan Cox4023c472007-06-15 14:45:30 +0100416 /* Go back and check they match */
417
418 outb(PRGMRST | DOWNLOAD, host->base + ORC_RISCCTL); /* Reset program count 0 */
419 bios_addr -= 0x1000; /* Reset the BIOS adddress */
420 for (i = 0, data32_ptr = (u8 *) & data32; /* Check the code */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 i < 0x1000; /* Firmware code size = 4K */
Alan Cox4023c472007-06-15 14:45:30 +0100422 i++, bios_addr++) {
423 outw(bios_addr, host->base + ORC_EBIOSADR0);
424 *data32_ptr++ = inb(host->base + ORC_EBIOSDATA); /* Read from BIOS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 if ((i % 4) == 3) {
Mikulas Patocka987ff952008-07-15 17:15:41 -0400426 if (inl(host->base + ORC_RISCRAM) != le32_to_cpu(data32)) {
Alan Cox4023c472007-06-15 14:45:30 +0100427 outb(PRGMRST, host->base + ORC_RISCCTL); /* Reset program to 0 */
428 outb(data, host->base + ORC_GCFG); /*Disable EEPROM programming */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 return 0;
430 }
Alan Cox4023c472007-06-15 14:45:30 +0100431 data32_ptr = (u8 *) & data32;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 }
433 }
Alan Cox4023c472007-06-15 14:45:30 +0100434
435 /* Success */
436 outb(PRGMRST, host->base + ORC_RISCCTL); /* Reset program to 0 */
437 outb(data, host->base + ORC_GCFG); /* Disable EEPROM programming */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return 1;
439}
440
441/***************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100442static void setup_SCBs(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
Alan Cox4023c472007-06-15 14:45:30 +0100444 struct orc_scb *scb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 int i;
Alan Cox4023c472007-06-15 14:45:30 +0100446 struct orc_extended_scb *escb;
447 dma_addr_t escb_phys;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Alan Cox4023c472007-06-15 14:45:30 +0100449 /* Setup SCB base and SCB Size registers */
450 outb(ORC_MAXQUEUE, host->base + ORC_SCBSIZE); /* Total number of SCBs */
451 /* SCB base address 0 */
452 outl(host->scb_phys, host->base + ORC_SCBBASE0);
453 /* SCB base address 1 */
454 outl(host->scb_phys, host->base + ORC_SCBBASE1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 /* setup scatter list address with one buffer */
Alan Cox4023c472007-06-15 14:45:30 +0100457 scb = host->scb_virt;
458 escb = host->escb_virt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
460 for (i = 0; i < ORC_MAXQUEUE; i++) {
Alan Cox4023c472007-06-15 14:45:30 +0100461 escb_phys = (host->escb_phys + (sizeof(struct orc_extended_scb) * i));
Mikulas Patocka987ff952008-07-15 17:15:41 -0400462 scb->sg_addr = cpu_to_le32((u32) escb_phys);
463 scb->sense_addr = cpu_to_le32((u32) escb_phys);
Alan Cox4023c472007-06-15 14:45:30 +0100464 scb->escb = escb;
465 scb->scbidx = i;
466 scb++;
467 escb++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
470
Alan Cox4023c472007-06-15 14:45:30 +0100471/**
472 * init_alloc_map - initialise allocation map
473 * @host: host map to configure
474 *
475 * Initialise the allocation maps for this device. If the device
476 * is not quiescent the caller must hold the allocation lock
477 */
478
479static void init_alloc_map(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
Alan Cox4023c472007-06-15 14:45:30 +0100481 u8 i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483 for (i = 0; i < MAX_CHANNELS; i++) {
484 for (j = 0; j < 8; j++) {
Alan Cox4023c472007-06-15 14:45:30 +0100485 host->allocation_map[i][j] = 0xffffffff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
487 }
488}
489
Alan Cox4023c472007-06-15 14:45:30 +0100490/**
491 * init_orchid - initialise the host adapter
492 * @host:host adapter to initialise
493 *
Daniel Mack3ad2f3f2010-02-03 08:01:28 +0800494 * Initialise the controller and if necessary load the firmware.
Alan Cox4023c472007-06-15 14:45:30 +0100495 *
496 * Returns -1 if the initialisation fails.
497 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Alan Cox4023c472007-06-15 14:45:30 +0100499static int init_orchid(struct orc_host * host)
500{
501 u8 *ptr;
502 u16 revision;
503 u8 i;
504
505 init_alloc_map(host);
506 outb(0xFF, host->base + ORC_GIMSK); /* Disable all interrupts */
507
508 if (inb(host->base + ORC_HSTUS) & RREADY) { /* Orchid is ready */
509 revision = orc_read_fwrev(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 if (revision == 0xFFFF) {
Alan Cox4023c472007-06-15 14:45:30 +0100511 outb(DEVRST, host->base + ORC_HCTRL); /* Reset Host Adapter */
512 if (wait_chip_ready(host) == 0)
513 return -1;
514 orc_load_firmware(host); /* Download FW */
515 setup_SCBs(host); /* Setup SCB base and SCB Size registers */
516 outb(0x00, host->base + ORC_HCTRL); /* clear HOSTSTOP */
517 if (wait_firmware_ready(host) == 0)
518 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 /* Wait for firmware ready */
520 } else {
Alan Cox4023c472007-06-15 14:45:30 +0100521 setup_SCBs(host); /* Setup SCB base and SCB Size registers */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 }
523 } else { /* Orchid is not Ready */
Alan Cox4023c472007-06-15 14:45:30 +0100524 outb(DEVRST, host->base + ORC_HCTRL); /* Reset Host Adapter */
525 if (wait_chip_ready(host) == 0)
526 return -1;
527 orc_load_firmware(host); /* Download FW */
528 setup_SCBs(host); /* Setup SCB base and SCB Size registers */
529 outb(HDO, host->base + ORC_HCTRL); /* Do Hardware Reset & */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
531 /* clear HOSTSTOP */
Alan Cox4023c472007-06-15 14:45:30 +0100532 if (wait_firmware_ready(host) == 0) /* Wait for firmware ready */
533 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 }
535
Alan Cox4023c472007-06-15 14:45:30 +0100536 /* Load an EEProm copy into RAM */
537 /* Assumes single threaded at this point */
538 read_eeprom(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Alan Cox4023c472007-06-15 14:45:30 +0100540 if (nvramp->revision != 1)
541 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
Alan Cox4023c472007-06-15 14:45:30 +0100543 host->scsi_id = nvramp->scsi_id;
544 host->BIOScfg = nvramp->BIOSConfig1;
545 host->max_targets = MAX_TARGETS;
546 ptr = (u8 *) & (nvramp->Target00Config);
547 for (i = 0; i < 16; ptr++, i++) {
548 host->target_flag[i] = *ptr;
549 host->max_tags[i] = ORC_MAXTAGS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 }
Alan Cox4023c472007-06-15 14:45:30 +0100551
552 if (nvramp->SCSI0Config & NCC_BUSRESET)
553 host->flags |= HCF_SCSI_RESET;
554 outb(0xFB, host->base + ORC_GIMSK); /* enable RP FIFO interrupt */
555 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556}
557
Alan Cox4023c472007-06-15 14:45:30 +0100558/**
559 * orc_reset_scsi_bus - perform bus reset
560 * @host: host being reset
561 *
562 * Perform a full bus reset on the adapter.
563 */
564
565static int orc_reset_scsi_bus(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566{ /* I need Host Control Block Information */
Alan Cox4023c472007-06-15 14:45:30 +0100567 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Alan Cox4023c472007-06-15 14:45:30 +0100569 spin_lock_irqsave(&host->allocation_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Alan Cox4023c472007-06-15 14:45:30 +0100571 init_alloc_map(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 /* reset scsi bus */
Alan Cox4023c472007-06-15 14:45:30 +0100573 outb(SCSIRST, host->base + ORC_HCTRL);
574 /* FIXME: We can spend up to a second with the lock held and
575 interrupts off here */
576 if (wait_scsi_reset_done(host) == 0) {
577 spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 return FAILED;
579 } else {
Alan Cox4023c472007-06-15 14:45:30 +0100580 spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return SUCCESS;
582 }
583}
584
Alan Cox4023c472007-06-15 14:45:30 +0100585/**
586 * orc_device_reset - device reset handler
587 * @host: host to reset
588 * @cmd: command causing the reset
589 * @target; target device
590 *
591 * Reset registers, reset a hanging bus and kill active and disconnected
592 * commands for target w/o soft reset
593 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
Alan Cox4023c472007-06-15 14:45:30 +0100595static int orc_device_reset(struct orc_host * host, struct scsi_cmnd *cmd, unsigned int target)
596{ /* I need Host Control Block Information */
597 struct orc_scb *scb;
598 struct orc_extended_scb *escb;
599 struct orc_scb *host_scb;
600 u8 i;
601 unsigned long flags;
602
603 spin_lock_irqsave(&(host->allocation_lock), flags);
604 scb = (struct orc_scb *) NULL;
605 escb = (struct orc_extended_scb *) NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 /* setup scatter list address with one buffer */
Alan Cox4023c472007-06-15 14:45:30 +0100608 host_scb = host->scb_virt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Alan Cox4023c472007-06-15 14:45:30 +0100610 /* FIXME: is this safe if we then fail to issue the reset or race
611 a completion ? */
612 init_alloc_map(host);
613
614 /* Find the scb corresponding to the command */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 for (i = 0; i < ORC_MAXQUEUE; i++) {
Alan Cox4023c472007-06-15 14:45:30 +0100616 escb = host_scb->escb;
617 if (host_scb->status && escb->srb == cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 break;
Alan Cox4023c472007-06-15 14:45:30 +0100619 host_scb++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 }
621
622 if (i == ORC_MAXQUEUE) {
Alan Cox4023c472007-06-15 14:45:30 +0100623 printk(KERN_ERR "Unable to Reset - No SCB Found\n");
624 spin_unlock_irqrestore(&(host->allocation_lock), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 return FAILED;
626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Alan Cox4023c472007-06-15 14:45:30 +0100628 /* Allocate a new SCB for the reset command to the firmware */
629 if ((scb = __orc_alloc_scb(host)) == NULL) {
630 /* Can't happen.. */
631 spin_unlock_irqrestore(&(host->allocation_lock), flags);
632 return FAILED;
633 }
634
Nick Andrew89546de2009-01-03 18:56:38 +1100635 /* Reset device is handled by the firmware, we fill in an SCB and
Alan Cox4023c472007-06-15 14:45:30 +0100636 fire it at the controller, it does the rest */
637 scb->opcode = ORC_BUSDEVRST;
638 scb->target = target;
639 scb->hastat = 0;
640 scb->tastat = 0;
641 scb->status = 0x0;
642 scb->link = 0xFF;
643 scb->reserved0 = 0;
644 scb->reserved1 = 0;
Mikulas Patocka987ff952008-07-15 17:15:41 -0400645 scb->xferlen = cpu_to_le32(0);
646 scb->sg_len = cpu_to_le32(0);
Alan Cox4023c472007-06-15 14:45:30 +0100647
648 escb->srb = NULL;
649 escb->srb = cmd;
650 orc_exec_scb(host, scb); /* Start execute SCB */
651 spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 return SUCCESS;
653}
654
Alan Cox4023c472007-06-15 14:45:30 +0100655/**
656 * __orc_alloc_scb - allocate an SCB
657 * @host: host to allocate from
658 *
659 * Allocate an SCB and return a pointer to the SCB object. NULL
660 * is returned if no SCB is free. The caller must already hold
661 * the allocator lock at this point.
662 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Alan Cox4023c472007-06-15 14:45:30 +0100664
665static struct orc_scb *__orc_alloc_scb(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666{
Alan Cox4023c472007-06-15 14:45:30 +0100667 u8 channel;
668 unsigned long idx;
669 u8 index;
670 u8 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Alan Cox4023c472007-06-15 14:45:30 +0100672 channel = host->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 for (i = 0; i < 8; i++) {
674 for (index = 0; index < 32; index++) {
Alan Cox4023c472007-06-15 14:45:30 +0100675 if ((host->allocation_map[channel][i] >> index) & 0x01) {
676 host->allocation_map[channel][i] &= ~(1 << index);
Akinobu Mita28aef2f2008-03-17 21:32:02 +0900677 idx = index + 32 * i;
678 /*
679 * Translate the index to a structure instance
680 */
681 return host->scb_virt + idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 }
683 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
Alan Cox4023c472007-06-15 14:45:30 +0100685 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686}
687
Alan Cox4023c472007-06-15 14:45:30 +0100688/**
689 * orc_alloc_scb - allocate an SCB
690 * @host: host to allocate from
691 *
692 * Allocate an SCB and return a pointer to the SCB object. NULL
693 * is returned if no SCB is free.
694 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Alan Cox4023c472007-06-15 14:45:30 +0100696static struct orc_scb *orc_alloc_scb(struct orc_host * host)
697{
698 struct orc_scb *scb;
699 unsigned long flags;
700
701 spin_lock_irqsave(&host->allocation_lock, flags);
702 scb = __orc_alloc_scb(host);
703 spin_unlock_irqrestore(&host->allocation_lock, flags);
704 return scb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
Alan Cox4023c472007-06-15 14:45:30 +0100707/**
708 * orc_release_scb - release an SCB
709 * @host: host owning the SCB
710 * @scb: SCB that is now free
711 *
712 * Called to return a completed SCB to the allocation pool. Before
713 * calling the SCB must be out of use on both the host and the HA.
714 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Alan Cox4023c472007-06-15 14:45:30 +0100716static void orc_release_scb(struct orc_host *host, struct orc_scb *scb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717{
Alan Cox4023c472007-06-15 14:45:30 +0100718 unsigned long flags;
719 u8 index, i, channel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Alan Cox4023c472007-06-15 14:45:30 +0100721 spin_lock_irqsave(&(host->allocation_lock), flags);
722 channel = host->index; /* Channel */
723 index = scb->scbidx;
724 i = index / 32;
725 index %= 32;
726 host->allocation_map[channel][i] |= (1 << index);
727 spin_unlock_irqrestore(&(host->allocation_lock), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728}
729
Alan Cox4023c472007-06-15 14:45:30 +0100730/**
731 * orchid_abort_scb - abort a command
732 *
733 * Abort a queued command that has been passed to the firmware layer
734 * if possible. This is all handled by the firmware. We aks the firmware
735 * and it either aborts the command or fails
736 */
737
738static int orchid_abort_scb(struct orc_host * host, struct orc_scb * scb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
Alan Cox4023c472007-06-15 14:45:30 +0100740 unsigned char data, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
Alan Cox4023c472007-06-15 14:45:30 +0100742 outb(ORC_CMD_ABORT_SCB, host->base + ORC_HDATA); /* Write command */
743 outb(HDO, host->base + ORC_HCTRL);
744 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 return 0;
746
Alan Cox4023c472007-06-15 14:45:30 +0100747 outb(scb->scbidx, host->base + ORC_HDATA); /* Write address */
748 outb(HDO, host->base + ORC_HCTRL);
749 if (wait_HDO_off(host) == 0) /* Wait HDO off */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return 0;
751
Alan Cox4023c472007-06-15 14:45:30 +0100752 if (wait_hdi_set(host, &data) == 0) /* Wait HDI set */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return 0;
Alan Cox4023c472007-06-15 14:45:30 +0100754 status = inb(host->base + ORC_HDATA);
755 outb(data, host->base + ORC_HSTUS); /* Clear HDI */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Alan Cox4023c472007-06-15 14:45:30 +0100757 if (status == 1) /* 0 - Successfully */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 return 0; /* 1 - Fail */
759 return 1;
760}
761
Alan Cox4023c472007-06-15 14:45:30 +0100762static int inia100_abort_cmd(struct orc_host * host, struct scsi_cmnd *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763{
Alan Cox4023c472007-06-15 14:45:30 +0100764 struct orc_extended_scb *escb;
765 struct orc_scb *scb;
766 u8 i;
767 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Alan Cox4023c472007-06-15 14:45:30 +0100769 spin_lock_irqsave(&(host->allocation_lock), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
Alan Cox4023c472007-06-15 14:45:30 +0100771 scb = host->scb_virt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Alan Cox4023c472007-06-15 14:45:30 +0100773 /* Walk the queue until we find the SCB that belongs to the command
774 block. This isn't a performance critical path so a walk in the park
775 here does no harm */
776
777 for (i = 0; i < ORC_MAXQUEUE; i++, scb++) {
778 escb = scb->escb;
779 if (scb->status && escb->srb == cmd) {
780 if (scb->tag_msg == 0) {
781 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 } else {
Alan Cox4023c472007-06-15 14:45:30 +0100783 /* Issue an ABORT to the firmware */
784 if (orchid_abort_scb(host, scb)) {
785 escb->srb = NULL;
786 spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 return SUCCESS;
Alan Cox4023c472007-06-15 14:45:30 +0100788 } else
789 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 }
791 }
792 }
Alan Cox4023c472007-06-15 14:45:30 +0100793out:
794 spin_unlock_irqrestore(&host->allocation_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 return FAILED;
796}
797
Alan Cox4023c472007-06-15 14:45:30 +0100798/**
799 * orc_interrupt - IRQ processing
800 * @host: Host causing the interrupt
801 *
802 * This function is called from the IRQ handler and protected
803 * by the host lock. While the controller reports that there are
804 * scb's for processing we pull them off the controller, turn the
805 * index into a host address pointer to the scb and call the scb
806 * handler.
807 *
808 * Returns IRQ_HANDLED if any SCBs were processed, IRQ_NONE otherwise
809 */
810
811static irqreturn_t orc_interrupt(struct orc_host * host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
Alan Cox4023c472007-06-15 14:45:30 +0100813 u8 scb_index;
814 struct orc_scb *scb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Alan Cox4023c472007-06-15 14:45:30 +0100816 /* Check if we have an SCB queued for servicing */
817 if (inb(host->base + ORC_RQUEUECNT) == 0)
818 return IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 do {
Alan Cox4023c472007-06-15 14:45:30 +0100821 /* Get the SCB index of the SCB to service */
822 scb_index = inb(host->base + ORC_RQUEUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Alan Cox4023c472007-06-15 14:45:30 +0100824 /* Translate it back to a host pointer */
825 scb = (struct orc_scb *) ((unsigned long) host->scb_virt + (unsigned long) (sizeof(struct orc_scb) * scb_index));
826 scb->status = 0x0;
827 /* Process the SCB */
828 inia100_scb_handler(host, scb);
829 } while (inb(host->base + ORC_RQUEUECNT));
830 return IRQ_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831} /* End of I1060Interrupt() */
832
Alan Cox4023c472007-06-15 14:45:30 +0100833/**
834 * inia100_build_scb - build SCB
835 * @host: host owing the control block
836 * @scb: control block to use
837 * @cmd: Mid layer command
838 *
839 * Build a host adapter control block from the SCSI mid layer command
840 */
841
Mikulas Patocka3a628b02008-07-15 17:19:55 -0400842static int inia100_build_scb(struct orc_host * host, struct orc_scb * scb, struct scsi_cmnd * cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843{ /* Create corresponding SCB */
FUJITA Tomonori985c0a72007-05-14 20:26:37 +0900844 struct scatterlist *sg;
Alan Cox4023c472007-06-15 14:45:30 +0100845 struct orc_sgent *sgent; /* Pointer to SG list */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 int i, count_sg;
Alan Cox4023c472007-06-15 14:45:30 +0100847 struct orc_extended_scb *escb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
Alan Cox4023c472007-06-15 14:45:30 +0100849 /* Links between the escb, scb and Linux scsi midlayer cmd */
850 escb = scb->escb;
851 escb->srb = cmd;
852 sgent = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Alan Cox4023c472007-06-15 14:45:30 +0100854 /* Set up the SCB to do a SCSI command block */
855 scb->opcode = ORC_EXECSCSI;
856 scb->flags = SCF_NO_DCHK; /* Clear done bit */
857 scb->target = cmd->device->id;
858 scb->lun = cmd->device->lun;
859 scb->reserved0 = 0;
860 scb->reserved1 = 0;
Mikulas Patocka987ff952008-07-15 17:15:41 -0400861 scb->sg_len = cpu_to_le32(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Mikulas Patocka987ff952008-07-15 17:15:41 -0400863 scb->xferlen = cpu_to_le32((u32) scsi_bufflen(cmd));
Alan Cox4023c472007-06-15 14:45:30 +0100864 sgent = (struct orc_sgent *) & escb->sglist[0];
FUJITA Tomonori985c0a72007-05-14 20:26:37 +0900865
Alan Cox4023c472007-06-15 14:45:30 +0100866 count_sg = scsi_dma_map(cmd);
Mikulas Patocka3a628b02008-07-15 17:19:55 -0400867 if (count_sg < 0)
868 return count_sg;
Mikulas Patockaa5db3342008-07-15 17:18:38 -0400869 BUG_ON(count_sg > TOTAL_SG_ENTRY);
Alan Cox4023c472007-06-15 14:45:30 +0100870
871 /* Build the scatter gather lists */
FUJITA Tomonori985c0a72007-05-14 20:26:37 +0900872 if (count_sg) {
Mikulas Patocka987ff952008-07-15 17:15:41 -0400873 scb->sg_len = cpu_to_le32((u32) (count_sg * 8));
Alan Cox4023c472007-06-15 14:45:30 +0100874 scsi_for_each_sg(cmd, sg, count_sg, i) {
Mikulas Patocka987ff952008-07-15 17:15:41 -0400875 sgent->base = cpu_to_le32((u32) sg_dma_address(sg));
876 sgent->length = cpu_to_le32((u32) sg_dma_len(sg));
Alan Cox4023c472007-06-15 14:45:30 +0100877 sgent++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 }
FUJITA Tomonori985c0a72007-05-14 20:26:37 +0900879 } else {
Mikulas Patocka987ff952008-07-15 17:15:41 -0400880 scb->sg_len = cpu_to_le32(0);
881 sgent->base = cpu_to_le32(0);
882 sgent->length = cpu_to_le32(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 }
Mikulas Patocka987ff952008-07-15 17:15:41 -0400884 scb->sg_addr = (u32) scb->sense_addr; /* sense_addr is already little endian */
Alan Cox4023c472007-06-15 14:45:30 +0100885 scb->hastat = 0;
886 scb->tastat = 0;
887 scb->link = 0xFF;
888 scb->sense_len = SENSE_SIZE;
889 scb->cdb_len = cmd->cmd_len;
890 if (scb->cdb_len >= IMAX_CDB) {
891 printk("max cdb length= %x\b", cmd->cmd_len);
892 scb->cdb_len = IMAX_CDB;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 }
Alan Cox4023c472007-06-15 14:45:30 +0100894 scb->ident = cmd->device->lun | DISC_ALLOW;
895 if (cmd->device->tagged_supported) { /* Tag Support */
896 scb->tag_msg = SIMPLE_QUEUE_TAG; /* Do simple tag only */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 } else {
Alan Cox4023c472007-06-15 14:45:30 +0100898 scb->tag_msg = 0; /* No tag support */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 }
Boaz Harrosh64a87b22008-04-30 11:19:47 +0300900 memcpy(scb->cdb, cmd->cmnd, scb->cdb_len);
Mikulas Patocka3a628b02008-07-15 17:19:55 -0400901 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902}
903
Alan Cox4023c472007-06-15 14:45:30 +0100904/**
905 * inia100_queue - queue command with host
906 * @cmd: Command block
907 * @done: Completion function
908 *
909 * Called by the mid layer to queue a command. Process the command
910 * block, build the host specific scb structures and if there is room
911 * queue the command down to the controller
912 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Alan Cox4023c472007-06-15 14:45:30 +0100914static int inia100_queue(struct scsi_cmnd * cmd, void (*done) (struct scsi_cmnd *))
915{
916 struct orc_scb *scb;
917 struct orc_host *host; /* Point to Host adapter control block */
918
919 host = (struct orc_host *) cmd->device->host->hostdata;
920 cmd->scsi_done = done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 /* Get free SCSI control block */
Alan Cox4023c472007-06-15 14:45:30 +0100922 if ((scb = orc_alloc_scb(host)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 return SCSI_MLQUEUE_HOST_BUSY;
924
Mikulas Patocka3a628b02008-07-15 17:19:55 -0400925 if (inia100_build_scb(host, scb, cmd)) {
926 orc_release_scb(host, scb);
927 return SCSI_MLQUEUE_HOST_BUSY;
928 }
Alan Cox4023c472007-06-15 14:45:30 +0100929 orc_exec_scb(host, scb); /* Start execute SCB */
930 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931}
932
933/*****************************************************************************
934 Function name : inia100_abort
935 Description : Abort a queued command.
936 (commands that are on the bus can't be aborted easily)
Alan Cox4023c472007-06-15 14:45:30 +0100937 Input : host - Pointer to host adapter structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 Output : None.
939 Return : pSRB - Pointer to SCSI request block.
940*****************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100941static int inia100_abort(struct scsi_cmnd * cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942{
Alan Cox4023c472007-06-15 14:45:30 +0100943 struct orc_host *host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
Alan Cox4023c472007-06-15 14:45:30 +0100945 host = (struct orc_host *) cmd->device->host->hostdata;
946 return inia100_abort_cmd(host, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947}
948
949/*****************************************************************************
950 Function name : inia100_reset
951 Description : Reset registers, reset a hanging bus and
952 kill active and disconnected commands for target w/o soft reset
Alan Cox4023c472007-06-15 14:45:30 +0100953 Input : host - Pointer to host adapter structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 Output : None.
955 Return : pSRB - Pointer to SCSI request block.
956*****************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100957static int inia100_bus_reset(struct scsi_cmnd * cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958{ /* I need Host Control Block Information */
Alan Cox4023c472007-06-15 14:45:30 +0100959 struct orc_host *host;
960 host = (struct orc_host *) cmd->device->host->hostdata;
961 return orc_reset_scsi_bus(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962}
963
964/*****************************************************************************
965 Function name : inia100_device_reset
966 Description : Reset the device
Alan Cox4023c472007-06-15 14:45:30 +0100967 Input : host - Pointer to host adapter structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 Output : None.
969 Return : pSRB - Pointer to SCSI request block.
970*****************************************************************************/
Alan Cox4023c472007-06-15 14:45:30 +0100971static int inia100_device_reset(struct scsi_cmnd * cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972{ /* I need Host Control Block Information */
Alan Cox4023c472007-06-15 14:45:30 +0100973 struct orc_host *host;
974 host = (struct orc_host *) cmd->device->host->hostdata;
975 return orc_device_reset(host, cmd, scmd_id(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
977}
978
Alan Cox4023c472007-06-15 14:45:30 +0100979/**
980 * inia100_scb_handler - interrupt callback
981 * @host: Host causing the interrupt
982 * @scb: SCB the controller returned as needing processing
983 *
984 * Perform completion processing on a control block. Do the conversions
985 * from host to SCSI midlayer error coding, save any sense data and
986 * the complete with the midlayer and recycle the scb.
987 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
Alan Cox4023c472007-06-15 14:45:30 +0100989static void inia100_scb_handler(struct orc_host *host, struct orc_scb *scb)
990{
991 struct scsi_cmnd *cmd; /* Pointer to SCSI request block */
992 struct orc_extended_scb *escb;
993
994 escb = scb->escb;
995 if ((cmd = (struct scsi_cmnd *) escb->srb) == NULL) {
996 printk(KERN_ERR "inia100_scb_handler: SRB pointer is empty\n");
997 orc_release_scb(host, scb); /* Release SCB for current channel */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 return;
999 }
Alan Cox4023c472007-06-15 14:45:30 +01001000 escb->srb = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Alan Cox4023c472007-06-15 14:45:30 +01001002 switch (scb->hastat) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 case 0x0:
1004 case 0xa: /* Linked command complete without error and linked normally */
1005 case 0xb: /* Linked command complete without error interrupt generated */
Alan Cox4023c472007-06-15 14:45:30 +01001006 scb->hastat = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 break;
1008
1009 case 0x11: /* Selection time out-The initiator selection or target
1010 reselection was not complete within the SCSI Time out period */
Alan Cox4023c472007-06-15 14:45:30 +01001011 scb->hastat = DID_TIME_OUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 break;
1013
1014 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
1015 phase sequence was requested by the target. The host adapter
1016 will generate a SCSI Reset Condition, notifying the host with
1017 a SCRD interrupt */
Alan Cox4023c472007-06-15 14:45:30 +01001018 scb->hastat = DID_RESET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 break;
1020
1021 case 0x1a: /* SCB Aborted. 07/21/98 */
Alan Cox4023c472007-06-15 14:45:30 +01001022 scb->hastat = DID_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 break;
1024
1025 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
1026 than was allocated by the Data Length field or the sum of the
1027 Scatter / Gather Data Length fields. */
1028 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
1029 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid. */
1030
1031 default:
Alan Cox4023c472007-06-15 14:45:30 +01001032 printk(KERN_DEBUG "inia100: %x %x\n", scb->hastat, scb->tastat);
1033 scb->hastat = DID_ERROR; /* Couldn't find any better */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 break;
1035 }
1036
Alan Cox4023c472007-06-15 14:45:30 +01001037 if (scb->tastat == 2) { /* Check condition */
1038 memcpy((unsigned char *) &cmd->sense_buffer[0],
1039 (unsigned char *) &escb->sglist[0], SENSE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 }
Alan Cox4023c472007-06-15 14:45:30 +01001041 cmd->result = scb->tastat | (scb->hastat << 16);
1042 scsi_dma_unmap(cmd);
1043 cmd->scsi_done(cmd); /* Notify system DONE */
1044 orc_release_scb(host, scb); /* Release SCB for current channel */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045}
1046
Alan Cox4023c472007-06-15 14:45:30 +01001047/**
1048 * inia100_intr - interrupt handler
1049 * @irqno: Interrupt value
1050 * @devid: Host adapter
1051 *
1052 * Entry point for IRQ handling. All the real work is performed
1053 * by orc_interrupt.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 */
David Howells7d12e782006-10-05 14:55:46 +01001055static irqreturn_t inia100_intr(int irqno, void *devid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056{
Alan Cox4023c472007-06-15 14:45:30 +01001057 struct Scsi_Host *shost = (struct Scsi_Host *)devid;
1058 struct orc_host *host = (struct orc_host *)shost->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 unsigned long flags;
Alan Cox4023c472007-06-15 14:45:30 +01001060 irqreturn_t res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
Alan Cox4023c472007-06-15 14:45:30 +01001062 spin_lock_irqsave(shost->host_lock, flags);
1063 res = orc_interrupt(host);
1064 spin_unlock_irqrestore(shost->host_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Alan Cox4023c472007-06-15 14:45:30 +01001066 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067}
1068
1069static struct scsi_host_template inia100_template = {
1070 .proc_name = "inia100",
1071 .name = inia100_REVID,
1072 .queuecommand = inia100_queue,
1073 .eh_abort_handler = inia100_abort,
1074 .eh_bus_reset_handler = inia100_bus_reset,
1075 .eh_device_reset_handler = inia100_device_reset,
1076 .can_queue = 1,
1077 .this_id = 1,
1078 .sg_tablesize = SG_ALL,
1079 .cmd_per_lun = 1,
1080 .use_clustering = ENABLE_CLUSTERING,
1081};
1082
1083static int __devinit inia100_probe_one(struct pci_dev *pdev,
1084 const struct pci_device_id *id)
1085{
1086 struct Scsi_Host *shost;
Alan Cox4023c472007-06-15 14:45:30 +01001087 struct orc_host *host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 unsigned long port, bios;
1089 int error = -ENODEV;
1090 u32 sz;
Alan Cox4023c472007-06-15 14:45:30 +01001091 unsigned long biosaddr;
1092 char *bios_phys;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
1094 if (pci_enable_device(pdev))
1095 goto out;
Yang Hongyang284901a2009-04-06 19:01:15 -07001096 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 printk(KERN_WARNING "Unable to set 32bit DMA "
1098 "on inia100 adapter, ignoring.\n");
1099 goto out_disable_device;
1100 }
1101
1102 pci_set_master(pdev);
1103
1104 port = pci_resource_start(pdev, 0);
1105 if (!request_region(port, 256, "inia100")) {
1106 printk(KERN_WARNING "inia100: io port 0x%lx, is busy.\n", port);
1107 goto out_disable_device;
1108 }
1109
Robert P. J. Day4c3ee822007-02-17 19:18:52 +01001110 /* <02> read from base address + 0x50 offset to get the bios value. */
Alan Cox4023c472007-06-15 14:45:30 +01001111 bios = inw(port + 0x50);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
1113
Alan Cox4023c472007-06-15 14:45:30 +01001114 shost = scsi_host_alloc(&inia100_template, sizeof(struct orc_host));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 if (!shost)
1116 goto out_release_region;
1117
Alan Cox4023c472007-06-15 14:45:30 +01001118 host = (struct orc_host *)shost->hostdata;
1119 host->pdev = pdev;
1120 host->base = port;
1121 host->BIOScfg = bios;
1122 spin_lock_init(&host->allocation_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
1124 /* Get total memory needed for SCB */
Alan Cox4023c472007-06-15 14:45:30 +01001125 sz = ORC_MAXQUEUE * sizeof(struct orc_scb);
1126 host->scb_virt = pci_alloc_consistent(pdev, sz,
1127 &host->scb_phys);
1128 if (!host->scb_virt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 printk("inia100: SCB memory allocation error\n");
1130 goto out_host_put;
1131 }
Alan Cox4023c472007-06-15 14:45:30 +01001132 memset(host->scb_virt, 0, sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
1134 /* Get total memory needed for ESCB */
Alan Cox4023c472007-06-15 14:45:30 +01001135 sz = ORC_MAXQUEUE * sizeof(struct orc_extended_scb);
1136 host->escb_virt = pci_alloc_consistent(pdev, sz,
1137 &host->escb_phys);
1138 if (!host->escb_virt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 printk("inia100: ESCB memory allocation error\n");
1140 goto out_free_scb_array;
1141 }
Alan Cox4023c472007-06-15 14:45:30 +01001142 memset(host->escb_virt, 0, sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Alan Cox4023c472007-06-15 14:45:30 +01001144 biosaddr = host->BIOScfg;
1145 biosaddr = (biosaddr << 4);
1146 bios_phys = phys_to_virt(biosaddr);
1147 if (init_orchid(host)) { /* Initialize orchid chip */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 printk("inia100: initial orchid fail!!\n");
1149 goto out_free_escb_array;
1150 }
1151
Alan Cox4023c472007-06-15 14:45:30 +01001152 shost->io_port = host->base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 shost->n_io_port = 0xff;
1154 shost->can_queue = ORC_MAXQUEUE;
1155 shost->unique_id = shost->io_port;
Alan Cox4023c472007-06-15 14:45:30 +01001156 shost->max_id = host->max_targets;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 shost->max_lun = 16;
Alan Cox4023c472007-06-15 14:45:30 +01001158 shost->irq = pdev->irq;
1159 shost->this_id = host->scsi_id; /* Assign HCS index */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 shost->sg_tablesize = TOTAL_SG_ENTRY;
1161
1162 /* Initial orc chip */
Thomas Gleixner1d6f3592006-07-01 19:29:42 -07001163 error = request_irq(pdev->irq, inia100_intr, IRQF_SHARED,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 "inia100", shost);
1165 if (error < 0) {
1166 printk(KERN_WARNING "inia100: unable to get irq %d\n",
1167 pdev->irq);
1168 goto out_free_escb_array;
1169 }
1170
1171 pci_set_drvdata(pdev, shost);
1172
1173 error = scsi_add_host(shost, &pdev->dev);
1174 if (error)
1175 goto out_free_irq;
1176
1177 scsi_scan_host(shost);
1178 return 0;
1179
Alan Cox4023c472007-06-15 14:45:30 +01001180out_free_irq:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 free_irq(shost->irq, shost);
Alan Cox4023c472007-06-15 14:45:30 +01001182out_free_escb_array:
1183 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_extended_scb),
1184 host->escb_virt, host->escb_phys);
1185out_free_scb_array:
1186 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_scb),
1187 host->scb_virt, host->scb_phys);
1188out_host_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 scsi_host_put(shost);
Alan Cox4023c472007-06-15 14:45:30 +01001190out_release_region:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 release_region(port, 256);
Alan Cox4023c472007-06-15 14:45:30 +01001192out_disable_device:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 pci_disable_device(pdev);
Alan Cox4023c472007-06-15 14:45:30 +01001194out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 return error;
1196}
1197
1198static void __devexit inia100_remove_one(struct pci_dev *pdev)
1199{
1200 struct Scsi_Host *shost = pci_get_drvdata(pdev);
Alan Cox4023c472007-06-15 14:45:30 +01001201 struct orc_host *host = (struct orc_host *)shost->hostdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
1203 scsi_remove_host(shost);
1204
1205 free_irq(shost->irq, shost);
Alan Cox4023c472007-06-15 14:45:30 +01001206 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_extended_scb),
1207 host->escb_virt, host->escb_phys);
1208 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(struct orc_scb),
1209 host->scb_virt, host->scb_phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 release_region(shost->io_port, 256);
1211
1212 scsi_host_put(shost);
1213}
1214
1215static struct pci_device_id inia100_pci_tbl[] = {
1216 {PCI_VENDOR_ID_INIT, 0x1060, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
1217 {0,}
1218};
1219MODULE_DEVICE_TABLE(pci, inia100_pci_tbl);
1220
1221static struct pci_driver inia100_pci_driver = {
1222 .name = "inia100",
1223 .id_table = inia100_pci_tbl,
1224 .probe = inia100_probe_one,
1225 .remove = __devexit_p(inia100_remove_one),
1226};
1227
1228static int __init inia100_init(void)
1229{
Henrik Kretzschmardcbccbde2006-09-25 16:58:58 -07001230 return pci_register_driver(&inia100_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231}
1232
1233static void __exit inia100_exit(void)
1234{
1235 pci_unregister_driver(&inia100_pci_driver);
1236}
1237
1238MODULE_DESCRIPTION("Initio A100U2W SCSI driver");
1239MODULE_AUTHOR("Initio Corporation");
1240MODULE_LICENSE("Dual BSD/GPL");
1241
1242module_init(inia100_init);
1243module_exit(inia100_exit);