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