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); 1203