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) 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 value. */ 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, IRQF_SHARED, 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_register_driver(&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); 1204