?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.17.7
[linux/fpc-iii.git] / drivers / scsi / a100u2w.c
blob3dce21c7873730cf70719689576d224763ad99e4
1 /*
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 *
22 * --------------------------------------------------------------------------
23 *
24 * Redistribution and use in source and binary forms, with or without
25 * modification, are permitted provided that the following conditions
26 * are met:
27 * 1. Redistributions of source code must retain the above copyright
28 * notice, this list of conditions, and the following disclaimer,
29 * without modification, immediately at the beginning of the file.
30 * 2. Redistributions in binary form must reproduce the above copyright
31 * notice, this list of conditions and the following disclaimer in the
32 * documentation and/or other materials provided with the distribution.
33 * 3. The name of the author may not be used to endorse or promote products
34 * derived from this software without specific prior written permission.
35 *
36 * Where this Software is combined with software released under the terms of
37 * the GNU General Public License ("GPL") and the terms of the GPL would require the
38 * combined work to also be released under the terms of the GPL, the terms
39 * and conditions of this License will apply in addition to those of the
40 * GPL with the exception of any terms or conditions of this License that
41 * conflict with, or are expressly prohibited by, the GPL.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
44 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
47 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 * SUCH DAMAGE.
54 */
55
56 /*
57 * Revision History:
58 * 07/02/98 hl - v.91n Initial drivers.
59 * 09/14/98 hl - v1.01 Support new Kernel.
60 * 09/22/98 hl - v1.01a Support reset.
61 * 09/24/98 hl - v1.01b Fixed reset.
62 * 10/05/98 hl - v1.02 split the source code and release.
63 * 12/19/98 bv - v1.02a Use spinlocks for 2.1.95 and up
64 * 01/31/99 bv - v1.02b Use mdelay instead of waitForPause
65 * 08/08/99 bv - v1.02c Use waitForPause again.
66 * 06/25/02 Doug Ledford <dledford@redhat.com> - v1.02d
67 * - Remove limit on number of controllers
68 * - Port to DMA mapping API
69 * - Clean up interrupt handler registration
70 * - Fix memory leaks
71 * - Fix allocation of scsi host structs and private data
72 * 11/18/03 Christoph Hellwig <hch@lst.de>
73 * - Port to new probing API
74 * - Fix some more leaks in init failure cases
75 * 9/28/04 Christoph Hellwig <hch@lst.de>
76 * - merge the two source files
77 * - remove internal queueing code
78 */
79
80 #include <linux/module.h>
81 #include <linux/errno.h>
82 #include <linux/delay.h>
83 #include <linux/interrupt.h>
84 #include <linux/pci.h>
85 #include <linux/init.h>
86 #include <linux/blkdev.h>
87 #include <linux/spinlock.h>
88 #include <linux/kernel.h>
89 #include <linux/string.h>
90 #include <linux/ioport.h>
91 #include <linux/slab.h>
92 #include <linux/dma-mapping.h>
93
94 #include <asm/io.h>
95 #include <asm/irq.h>
96
97 #include <scsi/scsi.h>
98 #include <scsi/scsi_cmnd.h>
99 #include <scsi/scsi_device.h>
100 #include <scsi/scsi_host.h>
101
102 #include "a100u2w.h"
103
104
105 #define JIFFIES_TO_MS(t) ((t) * 1000 / HZ)
106 #define MS_TO_JIFFIES(j) ((j * HZ) / 1000)
107
108 static ORC_SCB *orc_alloc_scb(ORC_HCS * hcsp);
109 static void inia100SCBPost(BYTE * pHcb, BYTE * pScb);
110
111 static NVRAM nvram, *nvramp = &nvram;
112 static UCHAR dftNvRam[64] =
113 {
114 /*----------header -------------*/
115 0x01, /* 0x00: Sub System Vendor ID 0 */
116 0x11, /* 0x01: Sub System Vendor ID 1 */
117 0x60, /* 0x02: Sub System ID 0 */
118 0x10, /* 0x03: Sub System ID 1 */
119 0x00, /* 0x04: SubClass */
120 0x01, /* 0x05: Vendor ID 0 */
121 0x11, /* 0x06: Vendor ID 1 */
122 0x60, /* 0x07: Device ID 0 */
123 0x10, /* 0x08: Device ID 1 */
124 0x00, /* 0x09: Reserved */
125 0x00, /* 0x0A: Reserved */
126 0x01, /* 0x0B: Revision of Data Structure */
127 /* -- Host Adapter Structure --- */
128 0x01, /* 0x0C: Number Of SCSI Channel */
129 0x01, /* 0x0D: BIOS Configuration 1 */
130 0x00, /* 0x0E: BIOS Configuration 2 */
131 0x00, /* 0x0F: BIOS Configuration 3 */
132 /* --- SCSI Channel 0 Configuration --- */
133 0x07, /* 0x10: H/A ID */
134 0x83, /* 0x11: Channel Configuration */
135 0x20, /* 0x12: MAX TAG per target */
136 0x0A, /* 0x13: SCSI Reset Recovering time */
137 0x00, /* 0x14: Channel Configuration4 */
138 0x00, /* 0x15: Channel Configuration5 */
139 /* SCSI Channel 0 Target Configuration */
140 /* 0x16-0x25 */
141 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
142 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
143 /* --- SCSI Channel 1 Configuration --- */
144 0x07, /* 0x26: H/A ID */
145 0x83, /* 0x27: Channel Configuration */
146 0x20, /* 0x28: MAX TAG per target */
147 0x0A, /* 0x29: SCSI Reset Recovering time */
148 0x00, /* 0x2A: Channel Configuration4 */
149 0x00, /* 0x2B: Channel Configuration5 */
150 /* SCSI Channel 1 Target Configuration */
151 /* 0x2C-0x3B */
152 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
153 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8,
154 0x00, /* 0x3C: Reserved */
155 0x00, /* 0x3D: Reserved */
156 0x00, /* 0x3E: Reserved */
157 0x00 /* 0x3F: Checksum */
158 };
159
160
161 /***************************************************************************/
162 static void waitForPause(unsigned amount)
163 {
164 ULONG the_time = jiffies + MS_TO_JIFFIES(amount);
165 while (time_before_eq(jiffies, the_time))
166 cpu_relax();
167 }
168
169 /***************************************************************************/
170 static UCHAR waitChipReady(ORC_HCS * hcsp)
171 {
172 int i;
173
174 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
175 if (ORC_RD(hcsp->HCS_Base, ORC_HCTRL) & HOSTSTOP) /* Wait HOSTSTOP set */
176 return 1;
177 waitForPause(100); /* wait 100ms before try again */
178 }
179 return 0;
180 }
181
182 /***************************************************************************/
183 static UCHAR waitFWReady(ORC_HCS * hcsp)
184 {
185 int i;
186
187 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
188 if (ORC_RD(hcsp->HCS_Base, ORC_HSTUS) & RREADY) /* Wait READY set */
189 return 1;
190 waitForPause(100); /* wait 100ms before try again */
191 }
192 return 0;
193 }
194
195 /***************************************************************************/
196 static UCHAR waitSCSIRSTdone(ORC_HCS * hcsp)
197 {
198 int i;
199
200 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
201 if (!(ORC_RD(hcsp->HCS_Base, ORC_HCTRL) & SCSIRST)) /* Wait SCSIRST done */
202 return 1;
203 waitForPause(100); /* wait 100ms before try again */
204 }
205 return 0;
206 }
207
208 /***************************************************************************/
209 static UCHAR waitHDOoff(ORC_HCS * hcsp)
210 {
211 int i;
212
213 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
214 if (!(ORC_RD(hcsp->HCS_Base, ORC_HCTRL) & HDO)) /* Wait HDO off */
215 return 1;
216 waitForPause(100); /* wait 100ms before try again */
217 }
218 return 0;
219 }
220
221 /***************************************************************************/
222 static UCHAR waitHDIset(ORC_HCS * hcsp, UCHAR * pData)
223 {
224 int i;
225
226 for (i = 0; i < 10; i++) { /* Wait 1 second for report timeout */
227 if ((*pData = ORC_RD(hcsp->HCS_Base, ORC_HSTUS)) & HDI)
228 return 1; /* Wait HDI set */
229 waitForPause(100); /* wait 100ms before try again */
230 }
231 return 0;
232 }
233
234 /***************************************************************************/
235 static unsigned short get_FW_version(ORC_HCS * hcsp)
236 {
237 UCHAR bData;
238 union {
239 unsigned short sVersion;
240 unsigned char cVersion[2];
241 } Version;
242
243 ORC_WR(hcsp->HCS_Base + ORC_HDATA, ORC_CMD_VERSION);
244 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
245 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
246 return 0;
247
248 if (waitHDIset(hcsp, &bData) == 0) /* Wait HDI set */
249 return 0;
250 Version.cVersion[0] = ORC_RD(hcsp->HCS_Base, ORC_HDATA);
251 ORC_WR(hcsp->HCS_Base + ORC_HSTUS, bData); /* Clear HDI */
252
253 if (waitHDIset(hcsp, &bData) == 0) /* Wait HDI set */
254 return 0;
255 Version.cVersion[1] = ORC_RD(hcsp->HCS_Base, ORC_HDATA);
256 ORC_WR(hcsp->HCS_Base + ORC_HSTUS, bData); /* Clear HDI */
257
258 return (Version.sVersion);
259 }
260
261 /***************************************************************************/
262 static UCHAR set_NVRAM(ORC_HCS * hcsp, unsigned char address, unsigned char value)
263 {
264 ORC_WR(hcsp->HCS_Base + ORC_HDATA, ORC_CMD_SET_NVM); /* Write command */
265 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
266 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
267 return 0;
268
269 ORC_WR(hcsp->HCS_Base + ORC_HDATA, address); /* Write address */
270 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
271 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
272 return 0;
273
274 ORC_WR(hcsp->HCS_Base + ORC_HDATA, value); /* Write value */
275 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
276 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
277 return 0;
278
279 return 1;
280 }
281
282 /***************************************************************************/
283 static UCHAR get_NVRAM(ORC_HCS * hcsp, unsigned char address, unsigned char *pDataIn)
284 {
285 unsigned char bData;
286
287 ORC_WR(hcsp->HCS_Base + ORC_HDATA, ORC_CMD_GET_NVM); /* Write command */
288 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
289 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
290 return 0;
291
292 ORC_WR(hcsp->HCS_Base + ORC_HDATA, address); /* Write address */
293 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
294 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
295 return 0;
296
297 if (waitHDIset(hcsp, &bData) == 0) /* Wait HDI set */
298 return 0;
299 *pDataIn = ORC_RD(hcsp->HCS_Base, ORC_HDATA);
300 ORC_WR(hcsp->HCS_Base + ORC_HSTUS, bData); /* Clear HDI */
301
302 return 1;
303 }
304
305 /***************************************************************************/
306 static void orc_exec_scb(ORC_HCS * hcsp, ORC_SCB * scbp)
307 {
308 scbp->SCB_Status = ORCSCB_POST;
309 ORC_WR(hcsp->HCS_Base + ORC_PQUEUE, scbp->SCB_ScbIdx);
310 return;
311 }
312
313
314 /***********************************************************************
315 Read SCSI H/A configuration parameters from serial EEPROM
316 ************************************************************************/
317 static int se2_rd_all(ORC_HCS * hcsp)
318 {
319 int i;
320 UCHAR *np, chksum = 0;
321
322 np = (UCHAR *) nvramp;
323 for (i = 0; i < 64; i++, np++) { /* <01> */
324 if (get_NVRAM(hcsp, (unsigned char) i, np) == 0)
325 return -1;
326 // *np++ = get_NVRAM(hcsp, (unsigned char ) i);
327 }
328
329 /*------ Is ckecksum ok ? ------*/
330 np = (UCHAR *) nvramp;
331 for (i = 0; i < 63; i++)
332 chksum += *np++;
333
334 if (nvramp->CheckSum != (UCHAR) chksum)
335 return -1;
336 return 1;
337 }
338
339 /************************************************************************
340 Update SCSI H/A configuration parameters from serial EEPROM
341 *************************************************************************/
342 static void se2_update_all(ORC_HCS * hcsp)
343 { /* setup default pattern */
344 int i;
345 UCHAR *np, *np1, chksum = 0;
346
347 /* Calculate checksum first */
348 np = (UCHAR *) dftNvRam;
349 for (i = 0; i < 63; i++)
350 chksum += *np++;
351 *np = chksum;
352
353 np = (UCHAR *) dftNvRam;
354 np1 = (UCHAR *) nvramp;
355 for (i = 0; i < 64; i++, np++, np1++) {
356 if (*np != *np1) {
357 set_NVRAM(hcsp, (unsigned char) i, *np);
358 }
359 }
360 return;
361 }
362
363 /*************************************************************************
364 Function name : read_eeprom
365 **************************************************************************/
366 static void read_eeprom(ORC_HCS * hcsp)
367 {
368 if (se2_rd_all(hcsp) != 1) {
369 se2_update_all(hcsp); /* setup default pattern */
370 se2_rd_all(hcsp); /* load again */
371 }
372 }
373
374
375 /***************************************************************************/
376 static UCHAR load_FW(ORC_HCS * hcsp)
377 {
378 U32 dData;
379 USHORT wBIOSAddress;
380 USHORT i;
381 UCHAR *pData, bData;
382
383
384 bData = ORC_RD(hcsp->HCS_Base, ORC_GCFG);
385 ORC_WR(hcsp->HCS_Base + ORC_GCFG, bData | EEPRG); /* Enable EEPROM programming */
386 ORC_WR(hcsp->HCS_Base + ORC_EBIOSADR2, 0x00);
387 ORC_WRSHORT(hcsp->HCS_Base + ORC_EBIOSADR0, 0x00);
388 if (ORC_RD(hcsp->HCS_Base, ORC_EBIOSDATA) != 0x55) {
389 ORC_WR(hcsp->HCS_Base + ORC_GCFG, bData); /* Disable EEPROM programming */
390 return 0;
391 }
392 ORC_WRSHORT(hcsp->HCS_Base + ORC_EBIOSADR0, 0x01);
393 if (ORC_RD(hcsp->HCS_Base, ORC_EBIOSDATA) != 0xAA) {
394 ORC_WR(hcsp->HCS_Base + ORC_GCFG, bData); /* Disable EEPROM programming */
395 return 0;
396 }
397 ORC_WR(hcsp->HCS_Base + ORC_RISCCTL, PRGMRST | DOWNLOAD); /* Enable SRAM programming */
398 pData = (UCHAR *) & dData;
399 dData = 0; /* Initial FW address to 0 */
400 ORC_WRSHORT(hcsp->HCS_Base + ORC_EBIOSADR0, 0x10);
401 *pData = ORC_RD(hcsp->HCS_Base, ORC_EBIOSDATA); /* Read from BIOS */
402 ORC_WRSHORT(hcsp->HCS_Base + ORC_EBIOSADR0, 0x11);
403 *(pData + 1) = ORC_RD(hcsp->HCS_Base, ORC_EBIOSDATA); /* Read from BIOS */
404 ORC_WRSHORT(hcsp->HCS_Base + ORC_EBIOSADR0, 0x12);
405 *(pData + 2) = ORC_RD(hcsp->HCS_Base, ORC_EBIOSDATA); /* Read from BIOS */
406 ORC_WR(hcsp->HCS_Base + ORC_EBIOSADR2, *(pData + 2));
407 ORC_WRLONG(hcsp->HCS_Base + ORC_FWBASEADR, dData); /* Write FW address */
408
409 wBIOSAddress = (USHORT) dData; /* FW code locate at BIOS address + ? */
410 for (i = 0, pData = (UCHAR *) & dData; /* Download the code */
411 i < 0x1000; /* Firmware code size = 4K */
412 i++, wBIOSAddress++) {
413 ORC_WRSHORT(hcsp->HCS_Base + ORC_EBIOSADR0, wBIOSAddress);
414 *pData++ = ORC_RD(hcsp->HCS_Base, ORC_EBIOSDATA); /* Read from BIOS */
415 if ((i % 4) == 3) {
416 ORC_WRLONG(hcsp->HCS_Base + ORC_RISCRAM, dData); /* Write every 4 bytes */
417 pData = (UCHAR *) & dData;
418 }
419 }
420
421 ORC_WR(hcsp->HCS_Base + ORC_RISCCTL, PRGMRST | DOWNLOAD); /* Reset program count 0 */
422 wBIOSAddress -= 0x1000; /* Reset the BIOS adddress */
423 for (i = 0, pData = (UCHAR *) & dData; /* Check the code */
424 i < 0x1000; /* Firmware code size = 4K */
425 i++, wBIOSAddress++) {
426 ORC_WRSHORT(hcsp->HCS_Base + ORC_EBIOSADR0, wBIOSAddress);
427 *pData++ = ORC_RD(hcsp->HCS_Base, ORC_EBIOSDATA); /* Read from BIOS */
428 if ((i % 4) == 3) {
429 if (ORC_RDLONG(hcsp->HCS_Base, ORC_RISCRAM) != dData) {
430 ORC_WR(hcsp->HCS_Base + ORC_RISCCTL, PRGMRST); /* Reset program to 0 */
431 ORC_WR(hcsp->HCS_Base + ORC_GCFG, bData); /*Disable EEPROM programming */
432 return 0;
433 }
434 pData = (UCHAR *) & dData;
435 }
436 }
437 ORC_WR(hcsp->HCS_Base + ORC_RISCCTL, PRGMRST); /* Reset program to 0 */
438 ORC_WR(hcsp->HCS_Base + ORC_GCFG, bData); /* Disable EEPROM programming */
439 return 1;
440 }
441
442 /***************************************************************************/
443 static void setup_SCBs(ORC_HCS * hcsp)
444 {
445 ORC_SCB *pVirScb;
446 int i;
447 ESCB *pVirEscb;
448 dma_addr_t pPhysEscb;
449
450 /* Setup SCB HCS_Base and SCB Size registers */
451 ORC_WR(hcsp->HCS_Base + ORC_SCBSIZE, ORC_MAXQUEUE); /* Total number of SCBs */
452 /* SCB HCS_Base address 0 */
453 ORC_WRLONG(hcsp->HCS_Base + ORC_SCBBASE0, hcsp->HCS_physScbArray);
454 /* SCB HCS_Base address 1 */
455 ORC_WRLONG(hcsp->HCS_Base + ORC_SCBBASE1, hcsp->HCS_physScbArray);
456
457 /* setup scatter list address with one buffer */
458 pVirScb = hcsp->HCS_virScbArray;
459 pVirEscb = hcsp->HCS_virEscbArray;
460
461 for (i = 0; i < ORC_MAXQUEUE; i++) {
462 pPhysEscb = (hcsp->HCS_physEscbArray + (sizeof(ESCB) * i));
463 pVirScb->SCB_SGPAddr = (U32) pPhysEscb;
464 pVirScb->SCB_SensePAddr = (U32) pPhysEscb;
465 pVirScb->SCB_EScb = pVirEscb;
466 pVirScb->SCB_ScbIdx = i;
467 pVirScb++;
468 pVirEscb++;
469 }
470
471 return;
472 }
473
474 /***************************************************************************/
475 static void initAFlag(ORC_HCS * hcsp)
476 {
477 UCHAR i, j;
478
479 for (i = 0; i < MAX_CHANNELS; i++) {
480 for (j = 0; j < 8; j++) {
481 hcsp->BitAllocFlag[i][j] = 0xffffffff;
482 }
483 }
484 }
485
486 /***************************************************************************/
487 static int init_orchid(ORC_HCS * hcsp)
488 {
489 UBYTE *readBytep;
490 USHORT revision;
491 UCHAR i;
492
493 initAFlag(hcsp);
494 ORC_WR(hcsp->HCS_Base + ORC_GIMSK, 0xFF); /* Disable all interrupt */
495 if (ORC_RD(hcsp->HCS_Base, ORC_HSTUS) & RREADY) { /* Orchid is ready */
496 revision = get_FW_version(hcsp);
497 if (revision == 0xFFFF) {
498 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, DEVRST); /* Reset Host Adapter */
499 if (waitChipReady(hcsp) == 0)
500 return (-1);
501 load_FW(hcsp); /* Download FW */
502 setup_SCBs(hcsp); /* Setup SCB HCS_Base and SCB Size registers */
503 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, 0); /* clear HOSTSTOP */
504 if (waitFWReady(hcsp) == 0)
505 return (-1);
506 /* Wait for firmware ready */
507 } else {
508 setup_SCBs(hcsp); /* Setup SCB HCS_Base and SCB Size registers */
509 }
510 } else { /* Orchid is not Ready */
511 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, DEVRST); /* Reset Host Adapter */
512 if (waitChipReady(hcsp) == 0)
513 return (-1);
514 load_FW(hcsp); /* Download FW */
515 setup_SCBs(hcsp); /* Setup SCB HCS_Base and SCB Size registers */
516 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO); /* Do Hardware Reset & */
517
518 /* clear HOSTSTOP */
519 if (waitFWReady(hcsp) == 0) /* Wait for firmware ready */
520 return (-1);
521 }
522
523 /*------------- get serial EEProm settting -------*/
524
525 read_eeprom(hcsp);
526
527 if (nvramp->Revision != 1)
528 return (-1);
529
530 hcsp->HCS_SCSI_ID = nvramp->SCSI0Id;
531 hcsp->HCS_BIOS = nvramp->BIOSConfig1;
532 hcsp->HCS_MaxTar = MAX_TARGETS;
533 readBytep = (UCHAR *) & (nvramp->Target00Config);
534 for (i = 0; i < 16; readBytep++, i++) {
535 hcsp->TargetFlag[i] = *readBytep;
536 hcsp->MaximumTags[i] = ORC_MAXTAGS;
537 } /* for */
538
539 if (nvramp->SCSI0Config & NCC_BUSRESET) { /* Reset SCSI bus */
540 hcsp->HCS_Flags |= HCF_SCSI_RESET;
541 }
542 ORC_WR(hcsp->HCS_Base + ORC_GIMSK, 0xFB); /* enable RP FIFO interrupt */
543 return (0);
544 }
545
546 /*****************************************************************************
547 Function name : orc_reset_scsi_bus
548 Description : Reset registers, reset a hanging bus and
549 kill active and disconnected commands for target w/o soft reset
550 Input : pHCB - Pointer to host adapter structure
551 Output : None.
552 Return : pSRB - Pointer to SCSI request block.
553 *****************************************************************************/
554 static int orc_reset_scsi_bus(ORC_HCS * pHCB)
555 { /* I need Host Control Block Information */
556 ULONG flags;
557
558 spin_lock_irqsave(&(pHCB->BitAllocFlagLock), flags);
559
560 initAFlag(pHCB);
561 /* reset scsi bus */
562 ORC_WR(pHCB->HCS_Base + ORC_HCTRL, SCSIRST);
563 if (waitSCSIRSTdone(pHCB) == 0) {
564 spin_unlock_irqrestore(&(pHCB->BitAllocFlagLock), flags);
565 return FAILED;
566 } else {
567 spin_unlock_irqrestore(&(pHCB->BitAllocFlagLock), flags);
568 return SUCCESS;
569 }
570 }
571
572 /*****************************************************************************
573 Function name : orc_device_reset
574 Description : Reset registers, reset a hanging bus and
575 kill active and disconnected commands for target w/o soft reset
576 Input : pHCB - Pointer to host adapter structure
577 Output : None.
578 Return : pSRB - Pointer to SCSI request block.
579 *****************************************************************************/
580 static int orc_device_reset(ORC_HCS * pHCB, struct scsi_cmnd *SCpnt, unsigned int target)
581 { /* I need Host Control Block Information */
582 ORC_SCB *pScb;
583 ESCB *pVirEscb;
584 ORC_SCB *pVirScb;
585 UCHAR i;
586 ULONG flags;
587
588 spin_lock_irqsave(&(pHCB->BitAllocFlagLock), flags);
589 pScb = (ORC_SCB *) NULL;
590 pVirEscb = (ESCB *) NULL;
591
592 /* setup scatter list address with one buffer */
593 pVirScb = pHCB->HCS_virScbArray;
594
595 initAFlag(pHCB);
596 /* device reset */
597 for (i = 0; i < ORC_MAXQUEUE; i++) {
598 pVirEscb = pVirScb->SCB_EScb;
599 if ((pVirScb->SCB_Status) && (pVirEscb->SCB_Srb == SCpnt))
600 break;
601 pVirScb++;
602 }
603
604 if (i == ORC_MAXQUEUE) {
605 printk("Unable to Reset - No SCB Found\n");
606 spin_unlock_irqrestore(&(pHCB->BitAllocFlagLock), flags);
607 return FAILED;
608 }
609 if ((pScb = orc_alloc_scb(pHCB)) == NULL) {
610 spin_unlock_irqrestore(&(pHCB->BitAllocFlagLock), flags);
611 return FAILED;
612 }
613 pScb->SCB_Opcode = ORC_BUSDEVRST;
614 pScb->SCB_Target = target;
615 pScb->SCB_HaStat = 0;
616 pScb->SCB_TaStat = 0;
617 pScb->SCB_Status = 0x0;
618 pScb->SCB_Link = 0xFF;
619 pScb->SCB_Reserved0 = 0;
620 pScb->SCB_Reserved1 = 0;
621 pScb->SCB_XferLen = 0;
622 pScb->SCB_SGLen = 0;
623
624 pVirEscb->SCB_Srb = NULL;
625 pVirEscb->SCB_Srb = SCpnt;
626 orc_exec_scb(pHCB, pScb); /* Start execute SCB */
627 spin_unlock_irqrestore(&(pHCB->BitAllocFlagLock), flags);
628 return SUCCESS;
629 }
630
631
632 /***************************************************************************/
633 static ORC_SCB *__orc_alloc_scb(ORC_HCS * hcsp)
634 {
635 ORC_SCB *pTmpScb;
636 UCHAR Ch;
637 ULONG idx;
638 UCHAR index;
639 UCHAR i;
640
641 Ch = hcsp->HCS_Index;
642 for (i = 0; i < 8; i++) {
643 for (index = 0; index < 32; index++) {
644 if ((hcsp->BitAllocFlag[Ch][i] >> index) & 0x01) {
645 hcsp->BitAllocFlag[Ch][i] &= ~(1 << index);
646 break;
647 }
648 }
649 idx = index + 32 * i;
650 pTmpScb = (ORC_SCB *) ((ULONG) hcsp->HCS_virScbArray + (idx * sizeof(ORC_SCB)));
651 return (pTmpScb);
652 }
653 return (NULL);
654 }
655
656 static ORC_SCB *orc_alloc_scb(ORC_HCS * hcsp)
657 {
658 ORC_SCB *pTmpScb;
659 ULONG flags;
660
661 spin_lock_irqsave(&(hcsp->BitAllocFlagLock), flags);
662 pTmpScb = __orc_alloc_scb(hcsp);
663 spin_unlock_irqrestore(&(hcsp->BitAllocFlagLock), flags);
664 return (pTmpScb);
665 }
666
667
668 /***************************************************************************/
669 static void orc_release_scb(ORC_HCS * hcsp, ORC_SCB * scbp)
670 {
671 ULONG flags;
672 UCHAR Index;
673 UCHAR i;
674 UCHAR Ch;
675
676 spin_lock_irqsave(&(hcsp->BitAllocFlagLock), flags);
677 Ch = hcsp->HCS_Index;
678 Index = scbp->SCB_ScbIdx;
679 i = Index / 32;
680 Index %= 32;
681 hcsp->BitAllocFlag[Ch][i] |= (1 << Index);
682 spin_unlock_irqrestore(&(hcsp->BitAllocFlagLock), flags);
683 }
684
685 /*****************************************************************************
686 Function name : abort_SCB
687 Description : Abort a queued command.
688 (commands that are on the bus can't be aborted easily)
689 Input : pHCB - Pointer to host adapter structure
690 Output : None.
691 Return : pSRB - Pointer to SCSI request block.
692 *****************************************************************************/
693 static int abort_SCB(ORC_HCS * hcsp, ORC_SCB * pScb)
694 {
695 unsigned char bData, bStatus;
696
697 ORC_WR(hcsp->HCS_Base + ORC_HDATA, ORC_CMD_ABORT_SCB); /* Write command */
698 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
699 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
700 return 0;
701
702 ORC_WR(hcsp->HCS_Base + ORC_HDATA, pScb->SCB_ScbIdx); /* Write address */
703 ORC_WR(hcsp->HCS_Base + ORC_HCTRL, HDO);
704 if (waitHDOoff(hcsp) == 0) /* Wait HDO off */
705 return 0;
706
707 if (waitHDIset(hcsp, &bData) == 0) /* Wait HDI set */
708 return 0;
709 bStatus = ORC_RD(hcsp->HCS_Base, ORC_HDATA);
710 ORC_WR(hcsp->HCS_Base + ORC_HSTUS, bData); /* Clear HDI */
711
712 if (bStatus == 1) /* 0 - Successfully */
713 return 0; /* 1 - Fail */
714 return 1;
715 }
716
717 /*****************************************************************************
718 Function name : inia100_abort
719 Description : Abort a queued command.
720 (commands that are on the bus can't be aborted easily)
721 Input : pHCB - Pointer to host adapter structure
722 Output : None.
723 Return : pSRB - Pointer to SCSI request block.
724 *****************************************************************************/
725 static int orc_abort_srb(ORC_HCS * hcsp, struct scsi_cmnd *SCpnt)
726 {
727 ESCB *pVirEscb;
728 ORC_SCB *pVirScb;
729 UCHAR i;
730 ULONG flags;
731
732 spin_lock_irqsave(&(hcsp->BitAllocFlagLock), flags);
733
734 pVirScb = hcsp->HCS_virScbArray;
735
736 for (i = 0; i < ORC_MAXQUEUE; i++, pVirScb++) {
737 pVirEscb = pVirScb->SCB_EScb;
738 if ((pVirScb->SCB_Status) && (pVirEscb->SCB_Srb == SCpnt)) {
739 if (pVirScb->SCB_TagMsg == 0) {
740 spin_unlock_irqrestore(&(hcsp->BitAllocFlagLock), flags);
741 return FAILED;
742 } else {
743 if (abort_SCB(hcsp, pVirScb)) {
744 pVirEscb->SCB_Srb = NULL;
745 spin_unlock_irqrestore(&(hcsp->BitAllocFlagLock), flags);
746 return SUCCESS;
747 } else {
748 spin_unlock_irqrestore(&(hcsp->BitAllocFlagLock), flags);
749 return FAILED;
750 }
751 }
752 }
753 }
754 spin_unlock_irqrestore(&(hcsp->BitAllocFlagLock), flags);
755 return FAILED;
756 }
757
758 /***********************************************************************
759 Routine Description:
760 This is the interrupt service routine for the Orchid SCSI adapter.
761 It reads the interrupt register to determine if the adapter is indeed
762 the source of the interrupt and clears the interrupt at the device.
763 Arguments:
764 HwDeviceExtension - HBA miniport driver's adapter data storage
765 Return Value:
766 ***********************************************************************/
767 static void orc_interrupt(
768 ORC_HCS * hcsp
769 )
770 {
771 BYTE bScbIdx;
772 ORC_SCB *pScb;
773
774 if (ORC_RD(hcsp->HCS_Base, ORC_RQUEUECNT) == 0) {
775 return; // 0;
776
777 }
778 do {
779 bScbIdx = ORC_RD(hcsp->HCS_Base, ORC_RQUEUE);
780
781 pScb = (ORC_SCB *) ((ULONG) hcsp->HCS_virScbArray + (ULONG) (sizeof(ORC_SCB) * bScbIdx));
782 pScb->SCB_Status = 0x0;
783
784 inia100SCBPost((BYTE *) hcsp, (BYTE *) pScb);
785 } while (ORC_RD(hcsp->HCS_Base, ORC_RQUEUECNT));
786 return; //1;
787
788 } /* End of I1060Interrupt() */
789
790 /*****************************************************************************
791 Function name : inia100BuildSCB
792 Description :
793 Input : pHCB - Pointer to host adapter structure
794 Output : None.
795 Return : pSRB - Pointer to SCSI request block.
796 *****************************************************************************/
797 static void inia100BuildSCB(ORC_HCS * pHCB, ORC_SCB * pSCB, struct scsi_cmnd * SCpnt)
798 { /* Create corresponding SCB */
799 struct scatterlist *pSrbSG;
800 ORC_SG *pSG; /* Pointer to SG list */
801 int i, count_sg;
802 ESCB *pEScb;
803
804 pEScb = pSCB->SCB_EScb;
805 pEScb->SCB_Srb = SCpnt;
806 pSG = NULL;
807
808 pSCB->SCB_Opcode = ORC_EXECSCSI;
809 pSCB->SCB_Flags = SCF_NO_DCHK; /* Clear done bit */
810 pSCB->SCB_Target = SCpnt->device->id;
811 pSCB->SCB_Lun = SCpnt->device->lun;
812 pSCB->SCB_Reserved0 = 0;
813 pSCB->SCB_Reserved1 = 0;
814 pSCB->SCB_SGLen = 0;
815
816 if ((pSCB->SCB_XferLen = (U32) SCpnt->request_bufflen)) {
817 pSG = (ORC_SG *) & pEScb->ESCB_SGList[0];
818 if (SCpnt->use_sg) {
819 pSrbSG = (struct scatterlist *) SCpnt->request_buffer;
820 count_sg = pci_map_sg(pHCB->pdev, pSrbSG, SCpnt->use_sg,
821 SCpnt->sc_data_direction);
822 pSCB->SCB_SGLen = (U32) (count_sg * 8);
823 for (i = 0; i < count_sg; i++, pSG++, pSrbSG++) {
824 pSG->SG_Ptr = (U32) sg_dma_address(pSrbSG);
825 pSG->SG_Len = (U32) sg_dma_len(pSrbSG);
826 }
827 } else if (SCpnt->request_bufflen != 0) {/* Non SG */
828 pSCB->SCB_SGLen = 0x8;
829 SCpnt->SCp.dma_handle = pci_map_single(pHCB->pdev,
830 SCpnt->request_buffer,
831 SCpnt->request_bufflen,
832 SCpnt->sc_data_direction);
833 pSG->SG_Ptr = (U32) SCpnt->SCp.dma_handle;
834 pSG->SG_Len = (U32) SCpnt->request_bufflen;
835 } else {
836 pSCB->SCB_SGLen = 0;
837 pSG->SG_Ptr = 0;
838 pSG->SG_Len = 0;
839 }
840 }
841 pSCB->SCB_SGPAddr = (U32) pSCB->SCB_SensePAddr;
842 pSCB->SCB_HaStat = 0;
843 pSCB->SCB_TaStat = 0;
844 pSCB->SCB_Link = 0xFF;
845 pSCB->SCB_SenseLen = SENSE_SIZE;
846 pSCB->SCB_CDBLen = SCpnt->cmd_len;
847 if (pSCB->SCB_CDBLen >= IMAX_CDB) {
848 printk("max cdb length= %x\b", SCpnt->cmd_len);
849 pSCB->SCB_CDBLen = IMAX_CDB;
850 }
851 pSCB->SCB_Ident = SCpnt->device->lun | DISC_ALLOW;
852 if (SCpnt->device->tagged_supported) { /* Tag Support */
853 pSCB->SCB_TagMsg = SIMPLE_QUEUE_TAG; /* Do simple tag only */
854 } else {
855 pSCB->SCB_TagMsg = 0; /* No tag support */
856 }
857 memcpy(&pSCB->SCB_CDB[0], &SCpnt->cmnd, pSCB->SCB_CDBLen);
858 return;
859 }
860
861 /*****************************************************************************
862 Function name : inia100_queue
863 Description : Queue a command and setup interrupts for a free bus.
864 Input : pHCB - Pointer to host adapter structure
865 Output : None.
866 Return : pSRB - Pointer to SCSI request block.
867 *****************************************************************************/
868 static int inia100_queue(struct scsi_cmnd * SCpnt, void (*done) (struct scsi_cmnd *))
869 {
870 register ORC_SCB *pSCB;
871 ORC_HCS *pHCB; /* Point to Host adapter control block */
872
873 pHCB = (ORC_HCS *) SCpnt->device->host->hostdata;
874 SCpnt->scsi_done = done;
875 /* Get free SCSI control block */
876 if ((pSCB = orc_alloc_scb(pHCB)) == NULL)
877 return SCSI_MLQUEUE_HOST_BUSY;
878
879 inia100BuildSCB(pHCB, pSCB, SCpnt);
880 orc_exec_scb(pHCB, pSCB); /* Start execute SCB */
881
882 return (0);
883 }
884
885 /*****************************************************************************
886 Function name : inia100_abort
887 Description : Abort a queued command.
888 (commands that are on the bus can't be aborted easily)
889 Input : pHCB - Pointer to host adapter structure
890 Output : None.
891 Return : pSRB - Pointer to SCSI request block.
892 *****************************************************************************/
893 static int inia100_abort(struct scsi_cmnd * SCpnt)
894 {
895 ORC_HCS *hcsp;
896
897 hcsp = (ORC_HCS *) SCpnt->device->host->hostdata;
898 return orc_abort_srb(hcsp, SCpnt);
899 }
900
901 /*****************************************************************************
902 Function name : inia100_reset
903 Description : Reset registers, reset a hanging bus and
904 kill active and disconnected commands for target w/o soft reset
905 Input : pHCB - Pointer to host adapter structure
906 Output : None.
907 Return : pSRB - Pointer to SCSI request block.
908 *****************************************************************************/
909 static int inia100_bus_reset(struct scsi_cmnd * SCpnt)
910 { /* I need Host Control Block Information */
911 ORC_HCS *pHCB;
912 pHCB = (ORC_HCS *) SCpnt->device->host->hostdata;
913 return orc_reset_scsi_bus(pHCB);
914 }
915
916 /*****************************************************************************
917 Function name : inia100_device_reset
918 Description : Reset the device
919 Input : pHCB - Pointer to host adapter structure
920 Output : None.
921 Return : pSRB - Pointer to SCSI request block.
922 *****************************************************************************/
923 static int inia100_device_reset(struct scsi_cmnd * SCpnt)
924 { /* I need Host Control Block Information */
925 ORC_HCS *pHCB;
926 pHCB = (ORC_HCS *) SCpnt->device->host->hostdata;
927 return orc_device_reset(pHCB, SCpnt, scmd_id(SCpnt));
928
929 }
930
931 /*****************************************************************************
932 Function name : inia100SCBPost
933 Description : This is callback routine be called when orc finish one
934 SCSI command.
935 Input : pHCB - Pointer to host adapter control block.
936 pSCB - Pointer to SCSI control block.
937 Output : None.
938 Return : None.
939 *****************************************************************************/
940 static void inia100SCBPost(BYTE * pHcb, BYTE * pScb)
941 {
942 struct scsi_cmnd *pSRB; /* Pointer to SCSI request block */
943 ORC_HCS *pHCB;
944 ORC_SCB *pSCB;
945 ESCB *pEScb;
946
947 pHCB = (ORC_HCS *) pHcb;
948 pSCB = (ORC_SCB *) pScb;
949 pEScb = pSCB->SCB_EScb;
950 if ((pSRB = (struct scsi_cmnd *) pEScb->SCB_Srb) == 0) {
951 printk("inia100SCBPost: SRB pointer is empty\n");
952 orc_release_scb(pHCB, pSCB); /* Release SCB for current channel */
953 return;
954 }
955 pEScb->SCB_Srb = NULL;
956
957 switch (pSCB->SCB_HaStat) {
958 case 0x0:
959 case 0xa: /* Linked command complete without error and linked normally */
960 case 0xb: /* Linked command complete without error interrupt generated */
961 pSCB->SCB_HaStat = 0;
962 break;
963
964 case 0x11: /* Selection time out-The initiator selection or target
965 reselection was not complete within the SCSI Time out period */
966 pSCB->SCB_HaStat = DID_TIME_OUT;
967 break;
968
969 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
970 phase sequence was requested by the target. The host adapter
971 will generate a SCSI Reset Condition, notifying the host with
972 a SCRD interrupt */
973 pSCB->SCB_HaStat = DID_RESET;
974 break;
975
976 case 0x1a: /* SCB Aborted. 07/21/98 */
977 pSCB->SCB_HaStat = DID_ABORT;
978 break;
979
980 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
981 than was allocated by the Data Length field or the sum of the
982 Scatter / Gather Data Length fields. */
983 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
984 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid. */
985
986 default:
987 printk("inia100: %x %x\n", pSCB->SCB_HaStat, pSCB->SCB_TaStat);
988 pSCB->SCB_HaStat = DID_ERROR; /* Couldn't find any better */
989 break;
990 }
991
992 if (pSCB->SCB_TaStat == 2) { /* Check condition */
993 memcpy((unsigned char *) &pSRB->sense_buffer[0],
994 (unsigned char *) &pEScb->ESCB_SGList[0], SENSE_SIZE);
995 }
996 pSRB->result = pSCB->SCB_TaStat | (pSCB->SCB_HaStat << 16);
997
998 if (pSRB->use_sg) {
999 pci_unmap_sg(pHCB->pdev,
1000 (struct scatterlist *)pSRB->request_buffer,
1001 pSRB->use_sg, pSRB->sc_data_direction);
1002 } else if (pSRB->request_bufflen != 0) {
1003 pci_unmap_single(pHCB->pdev, pSRB->SCp.dma_handle,
1004 pSRB->request_bufflen,
1005 pSRB->sc_data_direction);
1006 }
1007
1008 pSRB->scsi_done(pSRB); /* Notify system DONE */
1009
1010 orc_release_scb(pHCB, pSCB); /* Release SCB for current channel */
1011 }
1012
1013 /*
1014 * Interrupt handler (main routine of the driver)
1015 */
1016 static irqreturn_t inia100_intr(int irqno, void *devid, struct pt_regs *regs)
1017 {
1018 struct Scsi_Host *host = (struct Scsi_Host *)devid;
1019 ORC_HCS *pHcb = (ORC_HCS *)host->hostdata;
1020 unsigned long flags;
1021
1022 spin_lock_irqsave(host->host_lock, flags);
1023 orc_interrupt(pHcb);
1024 spin_unlock_irqrestore(host->host_lock, flags);
1025
1026 return IRQ_HANDLED;
1027 }
1028
1029 static struct scsi_host_template inia100_template = {
1030 .proc_name = "inia100",
1031 .name = inia100_REVID,
1032 .queuecommand = inia100_queue,
1033 .eh_abort_handler = inia100_abort,
1034 .eh_bus_reset_handler = inia100_bus_reset,
1035 .eh_device_reset_handler = inia100_device_reset,
1036 .can_queue = 1,
1037 .this_id = 1,
1038 .sg_tablesize = SG_ALL,
1039 .cmd_per_lun = 1,
1040 .use_clustering = ENABLE_CLUSTERING,
1041 };
1042
1043 static int __devinit inia100_probe_one(struct pci_dev *pdev,
1044 const struct pci_device_id *id)
1045 {
1046 struct Scsi_Host *shost;
1047 ORC_HCS *pHCB;
1048 unsigned long port, bios;
1049 int error = -ENODEV;
1050 u32 sz;
1051 unsigned long dBiosAdr;
1052 char *pbBiosAdr;
1053
1054 if (pci_enable_device(pdev))
1055 goto out;
1056 if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
1057 printk(KERN_WARNING "Unable to set 32bit DMA "
1058 "on inia100 adapter, ignoring.\n");
1059 goto out_disable_device;
1060 }
1061
1062 pci_set_master(pdev);
1063
1064 port = pci_resource_start(pdev, 0);
1065 if (!request_region(port, 256, "inia100")) {
1066 printk(KERN_WARNING "inia100: io port 0x%lx, is busy.\n", port);
1067 goto out_disable_device;
1068 }
1069
1070 /* <02> read from base address + 0x50 offset to get the bios balue. */
1071 bios = ORC_RDWORD(port, 0x50);
1072
1073
1074 shost = scsi_host_alloc(&inia100_template, sizeof(ORC_HCS));
1075 if (!shost)
1076 goto out_release_region;
1077
1078 pHCB = (ORC_HCS *)shost->hostdata;
1079 pHCB->pdev = pdev;
1080 pHCB->HCS_Base = port;
1081 pHCB->HCS_BIOS = bios;
1082 spin_lock_init(&pHCB->BitAllocFlagLock);
1083
1084 /* Get total memory needed for SCB */
1085 sz = ORC_MAXQUEUE * sizeof(ORC_SCB);
1086 pHCB->HCS_virScbArray = pci_alloc_consistent(pdev, sz,
1087 &pHCB->HCS_physScbArray);
1088 if (!pHCB->HCS_virScbArray) {
1089 printk("inia100: SCB memory allocation error\n");
1090 goto out_host_put;
1091 }
1092 memset(pHCB->HCS_virScbArray, 0, sz);
1093
1094 /* Get total memory needed for ESCB */
1095 sz = ORC_MAXQUEUE * sizeof(ESCB);
1096 pHCB->HCS_virEscbArray = pci_alloc_consistent(pdev, sz,
1097 &pHCB->HCS_physEscbArray);
1098 if (!pHCB->HCS_virEscbArray) {
1099 printk("inia100: ESCB memory allocation error\n");
1100 goto out_free_scb_array;
1101 }
1102 memset(pHCB->HCS_virEscbArray, 0, sz);
1103
1104 dBiosAdr = pHCB->HCS_BIOS;
1105 dBiosAdr = (dBiosAdr << 4);
1106 pbBiosAdr = phys_to_virt(dBiosAdr);
1107 if (init_orchid(pHCB)) { /* Initialize orchid chip */
1108 printk("inia100: initial orchid fail!!\n");
1109 goto out_free_escb_array;
1110 }
1111
1112 shost->io_port = pHCB->HCS_Base;
1113 shost->n_io_port = 0xff;
1114 shost->can_queue = ORC_MAXQUEUE;
1115 shost->unique_id = shost->io_port;
1116 shost->max_id = pHCB->HCS_MaxTar;
1117 shost->max_lun = 16;
1118 shost->irq = pHCB->HCS_Intr = pdev->irq;
1119 shost->this_id = pHCB->HCS_SCSI_ID; /* Assign HCS index */
1120 shost->sg_tablesize = TOTAL_SG_ENTRY;
1121
1122 /* Initial orc chip */
1123 error = request_irq(pdev->irq, inia100_intr, SA_SHIRQ,
1124 "inia100", shost);
1125 if (error < 0) {
1126 printk(KERN_WARNING "inia100: unable to get irq %d\n",
1127 pdev->irq);
1128 goto out_free_escb_array;
1129 }
1130
1131 pci_set_drvdata(pdev, shost);
1132
1133 error = scsi_add_host(shost, &pdev->dev);
1134 if (error)
1135 goto out_free_irq;
1136
1137 scsi_scan_host(shost);
1138 return 0;
1139
1140 out_free_irq:
1141 free_irq(shost->irq, shost);
1142 out_free_escb_array:
1143 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(ESCB),
1144 pHCB->HCS_virEscbArray, pHCB->HCS_physEscbArray);
1145 out_free_scb_array:
1146 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(ORC_SCB),
1147 pHCB->HCS_virScbArray, pHCB->HCS_physScbArray);
1148 out_host_put:
1149 scsi_host_put(shost);
1150 out_release_region:
1151 release_region(port, 256);
1152 out_disable_device:
1153 pci_disable_device(pdev);
1154 out:
1155 return error;
1156 }
1157
1158 static void __devexit inia100_remove_one(struct pci_dev *pdev)
1159 {
1160 struct Scsi_Host *shost = pci_get_drvdata(pdev);
1161 ORC_HCS *pHCB = (ORC_HCS *)shost->hostdata;
1162
1163 scsi_remove_host(shost);
1164
1165 free_irq(shost->irq, shost);
1166 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(ESCB),
1167 pHCB->HCS_virEscbArray, pHCB->HCS_physEscbArray);
1168 pci_free_consistent(pdev, ORC_MAXQUEUE * sizeof(ORC_SCB),
1169 pHCB->HCS_virScbArray, pHCB->HCS_physScbArray);
1170 release_region(shost->io_port, 256);
1171
1172 scsi_host_put(shost);
1173 }
1174
1175 static struct pci_device_id inia100_pci_tbl[] = {
1176 {PCI_VENDOR_ID_INIT, 0x1060, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
1177 {0,}
1178 };
1179 MODULE_DEVICE_TABLE(pci, inia100_pci_tbl);
1180
1181 static struct pci_driver inia100_pci_driver = {
1182 .name = "inia100",
1183 .id_table = inia100_pci_tbl,
1184 .probe = inia100_probe_one,
1185 .remove = __devexit_p(inia100_remove_one),
1186 };
1187
1188 static int __init inia100_init(void)
1189 {
1190 return pci_module_init(&inia100_pci_driver);
1191 }
1192
1193 static void __exit inia100_exit(void)
1194 {
1195 pci_unregister_driver(&inia100_pci_driver);
1196 }
1197
1198 MODULE_DESCRIPTION("Initio A100U2W SCSI driver");
1199 MODULE_AUTHOR("Initio Corporation");
1200 MODULE_LICENSE("Dual BSD/GPL");
1201
1202 module_init(inia100_init);
1203 module_exit(inia100_exit);
Linux with added FPC-III support