![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eata_pio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to eata_pio.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 ! root 1: /************************************************************ ! 2: * * ! 3: * Linux EATA SCSI PIO driver * ! 4: * * ! 5: * based on the CAM document CAM/89-004 rev. 2.0c, * ! 6: * DPT's driver kit, some internal documents and source, * ! 7: * and several other Linux scsi drivers and kernel docs. * ! 8: * * ! 9: * The driver currently: * ! 10: * -supports all EATA-PIO boards * ! 11: * -only supports DASD devices * ! 12: * * ! 13: * (c)1993,94,95 Michael Neuffer, Alfred Arnold * ! 14: * [email protected] * ! 15: * [email protected] * ! 16: * * ! 17: * This program is free software; you can redistribute it * ! 18: * and/or modify it under the terms of the GNU General * ! 19: * Public License as published by the Free Software * ! 20: * Foundation; either version 2 of the License, or * ! 21: * (at your option) any later version. * ! 22: * * ! 23: * This program is distributed in the hope that it will be * ! 24: * useful, but WITHOUT ANY WARRANTY; without even the * ! 25: * implied warranty of MERCHANTABILITY or FITNESS FOR A * ! 26: * PARTICULAR PURPOSE. See the GNU General Public License * ! 27: * for more details. * ! 28: * * ! 29: * You should have received a copy of the GNU General * ! 30: * Public License along with this kernel; if not, write to * ! 31: * the Free Software Foundation, Inc., 675 Mass Ave, * ! 32: * Cambridge, MA 02139, USA. * ! 33: * * ! 34: ************************************************************ ! 35: * last change: 95/08/04 OS: Linux 1.3.15 * ! 36: ************************************************************/ ! 37: ! 38: /* Look in eata_pio.h for configuration information */ ! 39: ! 40: #include <linux/module.h> ! 41: ! 42: #include <linux/kernel.h> ! 43: #include <linux/sched.h> ! 44: #include <linux/string.h> ! 45: #include <linux/ioport.h> ! 46: #include <linux/malloc.h> ! 47: #include <linux/in.h> ! 48: #include <linux/bios32.h> ! 49: #include <linux/pci.h> ! 50: #include <linux/proc_fs.h> ! 51: #include <asm/io.h> ! 52: #include "eata_pio.h" ! 53: #include "eata_dma_proc.h" ! 54: #include "scsi.h" ! 55: #include "sd.h" ! 56: ! 57: #include <linux/stat.h> ! 58: #include <linux/config.h> /* for CONFIG_PCI */ ! 59: ! 60: struct proc_dir_entry proc_scsi_eata_pio = { ! 61: PROC_SCSI_EATA_PIO, 9, "eata_pio", ! 62: S_IFDIR | S_IRUGO | S_IXUGO, 2 ! 63: }; ! 64: ! 65: static uint ISAbases[MAXISA] = ! 66: {0x1F0, 0x170, 0x330, 0x230}; ! 67: static uint ISAirqs[MAXISA] = ! 68: {14,12,15,11}; ! 69: static unchar EISAbases[] = ! 70: {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; ! 71: static uint registered_HBAs = 0; ! 72: static struct Scsi_Host *last_HBA = NULL; ! 73: static struct Scsi_Host *first_HBA = NULL; ! 74: static unchar reg_IRQ[] = ! 75: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; ! 76: static unchar reg_IRQL[] = ! 77: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; ! 78: ! 79: static ulong int_counter = 0; ! 80: static ulong queue_counter = 0; ! 81: ! 82: void hprint(const char *str) ! 83: { ! 84: char *hptr =(char *) 0x000b0000; ! 85: char *hptr2=(char *) 0x000b00a0; ! 86: char *hptr3=(char *) 0x000b0f00; ! 87: int z; ! 88: ! 89: memmove(hptr,hptr2,24*80*2); ! 90: for (z=0; z<strlen(str); z++) ! 91: hptr3[z*2]=str[z]; ! 92: for (; z<80; z++) ! 93: hptr3[z*2]=' '; ! 94: } ! 95: ! 96: #ifdef MACH ! 97: #include "eata_pio_proc.src" ! 98: #else ! 99: #include "eata_pio_proc.c" ! 100: #endif ! 101: ! 102: #ifdef MODULE ! 103: int eata_pio_release(struct Scsi_Host *sh) ! 104: { ! 105: if (sh->irq && reg_IRQ[sh->irq] == 1) free_irq(sh->irq); ! 106: else reg_IRQ[sh->irq]--; ! 107: if (SD(sh)->channel == 0) { ! 108: if (sh->io_port && sh->n_io_port) ! 109: release_region(sh->io_port, sh->n_io_port); ! 110: } ! 111: return(TRUE); ! 112: } ! 113: #endif ! 114: ! 115: void IncStat(Scsi_Pointer *SCp, uint Increment) ! 116: { ! 117: SCp->ptr+=Increment; ! 118: if ((SCp->this_residual-=Increment)==0) ! 119: { ! 120: if ((--SCp->buffers_residual)==0) SCp->Status=FALSE; ! 121: else ! 122: { ! 123: SCp->buffer++; ! 124: SCp->ptr=SCp->buffer->address; ! 125: SCp->this_residual=SCp->buffer->length; ! 126: } ! 127: } ! 128: } ! 129: ! 130: void eata_pio_int_handler(int irq, struct pt_regs * regs) ! 131: { ! 132: uint eata_stat = 0xfffff; ! 133: Scsi_Cmnd *cmd; ! 134: hostdata *hd; ! 135: struct eata_ccb *cp; ! 136: uint base; ! 137: ulong flags; ! 138: uint x,z; ! 139: struct Scsi_Host *sh; ! 140: ushort zwickel=0; ! 141: unchar stat,odd; ! 142: ! 143: save_flags(flags); ! 144: cli(); ! 145: ! 146: for (x = 1, sh = first_HBA; x <= registered_HBAs; x++, sh = SD(sh)->prev) { ! 147: if (sh->irq != irq) ! 148: continue; ! 149: if (inb((uint)sh->base + HA_RSTATUS) & HA_SBUSY) ! 150: continue; ! 151: ! 152: int_counter++; ! 153: ! 154: hd=SD(sh); ! 155: ! 156: cp = &hd->ccb[0]; ! 157: cmd = cp->cmd; ! 158: base = (uint) cmd->host->base; ! 159: ! 160: do ! 161: { ! 162: stat=inb(base+HA_RSTATUS); ! 163: if (stat&HA_SDRQ) ! 164: if (cp->DataIn) ! 165: { ! 166: z=256; odd=FALSE; ! 167: while ((cmd->SCp.Status)&&((z>0)||(odd))) ! 168: { ! 169: if (odd) ! 170: { ! 171: *(cmd->SCp.ptr)=zwickel>>8; ! 172: IncStat(&cmd->SCp,1); ! 173: odd=FALSE; ! 174: } ! 175: x=min(z,cmd->SCp.this_residual/2); ! 176: insw(base+HA_RDATA,cmd->SCp.ptr,x); ! 177: z-=x; ! 178: IncStat(&cmd->SCp,2*x); ! 179: if ((z>0)&&(cmd->SCp.this_residual==1)) ! 180: { ! 181: zwickel=inw(base+HA_RDATA); ! 182: *(cmd->SCp.ptr)=zwickel&0xff; ! 183: IncStat(&cmd->SCp,1); z--; ! 184: odd=TRUE; ! 185: } ! 186: } ! 187: while (z>0) { ! 188: zwickel=inw(base+HA_RDATA); ! 189: z--; ! 190: } ! 191: } ! 192: else /* cp->DataOut */ ! 193: { ! 194: odd=FALSE; z=256; ! 195: while ((cmd->SCp.Status)&&((z>0)||(odd))) ! 196: { ! 197: if (odd) ! 198: { ! 199: zwickel+=*(cmd->SCp.ptr)<<8; ! 200: IncStat(&cmd->SCp,1); ! 201: outw(zwickel,base+HA_RDATA); ! 202: z--; ! 203: odd=FALSE; ! 204: } ! 205: x=min(z,cmd->SCp.this_residual/2); ! 206: outsw(base+HA_RDATA,cmd->SCp.ptr,x); ! 207: z-=x; ! 208: IncStat(&cmd->SCp,2*x); ! 209: if ((z>0)&&(cmd->SCp.this_residual==1)) ! 210: { ! 211: zwickel=*(cmd->SCp.ptr); ! 212: zwickel&=0xff; ! 213: IncStat(&cmd->SCp,1); ! 214: odd=TRUE; ! 215: } ! 216: } ! 217: while (z>0||odd) { ! 218: outw(zwickel,base+HA_RDATA); ! 219: z--; ! 220: odd=FALSE; ! 221: } ! 222: } ! 223: } ! 224: while ((stat&HA_SDRQ)||((stat&HA_SMORE)&&hd->moresupport)); ! 225: ! 226: /* terminate handler if HBA goes busy again, i.e. transfers ! 227: * more data */ ! 228: ! 229: if (stat&HA_SBUSY) break; ! 230: ! 231: /* OK, this is quite stupid, but I haven't found any correct ! 232: * way to get HBA&SCSI status so far */ ! 233: ! 234: if (!(inb(base+HA_RSTATUS)&HA_SERROR)) ! 235: { ! 236: cmd->result=(DID_OK<<16); ! 237: hd->devflags|=(1<<cp->cp_id); ! 238: } ! 239: else if (hd->devflags&1<<cp->cp_id) ! 240: cmd->result=(DID_OK<<16)+0x02; ! 241: else cmd->result=(DID_NO_CONNECT<<16); ! 242: ! 243: if (cp->status == LOCKED) { ! 244: cp->status = FREE; ! 245: eata_stat = inb(base + HA_RSTATUS); ! 246: printk("eata_pio: int_handler, freeing locked queueslot\n"); ! 247: DBG(DBG_INTR&&DBG_DELAY,DEL2(800)); ! 248: restore_flags(flags); ! 249: return; ! 250: } ! 251: ! 252: #if DBG_INTR2 ! 253: if (stat != 0x50) ! 254: printk("stat: %#.2x, result: %#.8x\n", stat, cmd->result); ! 255: DBG(DBG_INTR&&DBG_DELAY,DEL2(800)); ! 256: #endif ! 257: ! 258: cp->status = FREE; /* now we can release the slot */ ! 259: ! 260: restore_flags(flags); ! 261: cmd->scsi_done(cmd); ! 262: save_flags(flags); ! 263: cli(); ! 264: } ! 265: restore_flags(flags); ! 266: ! 267: return; ! 268: } ! 269: ! 270: inline uint eata_pio_send_command(uint base, unchar command) ! 271: { ! 272: uint loop = R_LIMIT; ! 273: ! 274: while (inb(base + HA_RSTATUS) & HA_SBUSY) ! 275: if (--loop == 0) ! 276: return(TRUE); ! 277: ! 278: outb(command, base + HA_WCOMMAND); ! 279: return(FALSE); ! 280: } ! 281: ! 282: int eata_pio_queue(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) ! 283: { ! 284: uint x, y; ! 285: long flags; ! 286: uint base; ! 287: ! 288: hostdata *hd; ! 289: struct Scsi_Host *sh; ! 290: struct eata_ccb *cp; ! 291: ! 292: save_flags(flags); ! 293: cli(); ! 294: ! 295: queue_counter++; ! 296: ! 297: hd = HD(cmd); ! 298: sh = cmd->host; ! 299: base = (uint) sh->base; ! 300: ! 301: /* use only slot 0, as 2001 can handle only one cmd at a time */ ! 302: ! 303: y = x = 0; ! 304: ! 305: if (hd->ccb[y].status!=FREE) { ! 306: ! 307: DBG(DBG_QUEUE, printk("can_queue %d, x %d, y %d\n",sh->can_queue,x,y)); ! 308: #if DEBUG_EATA ! 309: panic("eata_pio: run out of queue slots cmdno:%ld intrno: %ld\n", ! 310: queue_counter, int_counter); ! 311: #else ! 312: panic("eata_pio: run out of queue slots....\n"); ! 313: #endif ! 314: } ! 315: ! 316: cp = &hd->ccb[y]; ! 317: ! 318: memset(cp, 0, sizeof(struct eata_ccb)); ! 319: memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer)); ! 320: ! 321: cp->status = USED; /* claim free slot */ ! 322: ! 323: DBG(DBG_QUEUE, printk("eata_pio_queue pid %ld, target: %x, lun: %x, y %d\n", ! 324: cmd->pid, cmd->target, cmd->lun, y)); ! 325: DBG(DBG_QUEUE && DBG_DELAY, DEL2(250)); ! 326: ! 327: cmd->scsi_done = (void *)done; ! 328: ! 329: switch (cmd->cmnd[0]) { ! 330: case CHANGE_DEFINITION: case COMPARE: case COPY: ! 331: case COPY_VERIFY: case LOG_SELECT: case MODE_SELECT: ! 332: case MODE_SELECT_10: case SEND_DIAGNOSTIC: case WRITE_BUFFER: ! 333: case FORMAT_UNIT: case REASSIGN_BLOCKS: case RESERVE: ! 334: case SEARCH_EQUAL: case SEARCH_HIGH: case SEARCH_LOW: ! 335: case WRITE_6: case WRITE_10: case WRITE_VERIFY: ! 336: case UPDATE_BLOCK: case WRITE_LONG: case WRITE_SAME: ! 337: case SEARCH_HIGH_12: case SEARCH_EQUAL_12: case SEARCH_LOW_12: ! 338: case WRITE_12: case WRITE_VERIFY_12: case SET_WINDOW: ! 339: case MEDIUM_SCAN: case SEND_VOLUME_TAG: ! 340: case 0xea: /* alternate number for WRITE LONG */ ! 341: cp->DataOut = TRUE; /* Output mode */ ! 342: break; ! 343: case TEST_UNIT_READY: ! 344: default: ! 345: cp->DataIn = TRUE; /* Input mode */ ! 346: } ! 347: ! 348: cp->Interpret = (cmd->target == hd->hostid); ! 349: cp->cp_datalen = htonl((ulong)cmd->request_bufflen); ! 350: cp->Auto_Req_Sen = FALSE; ! 351: cp->cp_reqDMA = htonl(0); ! 352: cp->reqlen = 0; ! 353: ! 354: cp->cp_id = cmd->target; ! 355: cp->cp_lun = cmd->lun; ! 356: cp->cp_dispri = FALSE; ! 357: cp->cp_identify = TRUE; ! 358: memcpy(cp->cp_cdb, cmd->cmnd, COMMAND_SIZE(*cmd->cmnd)); ! 359: ! 360: cp->cp_statDMA = htonl(0); ! 361: ! 362: cp->cp_viraddr = cp; ! 363: cp->cmd = cmd; ! 364: cmd->host_scribble = (char *)&hd->ccb[y]; ! 365: ! 366: if (cmd->use_sg == 0) ! 367: { ! 368: cmd->SCp.buffers_residual=1; ! 369: cmd->SCp.ptr = cmd->request_buffer; ! 370: cmd->SCp.this_residual = cmd->request_bufflen; ! 371: cmd->SCp.buffer = NULL; ! 372: } else { ! 373: cmd->SCp.buffer = cmd->request_buffer; ! 374: cmd->SCp.buffers_residual = cmd->use_sg; ! 375: cmd->SCp.ptr = cmd->SCp.buffer->address; ! 376: cmd->SCp.this_residual = cmd->SCp.buffer->length; ! 377: } ! 378: cmd->SCp.Status = (cmd->SCp.this_residual != 0); /* TRUE as long as bytes ! 379: * are to transfer */ ! 380: ! 381: if (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) ! 382: { ! 383: cmd->result = DID_BUS_BUSY << 16; ! 384: printk("eata_pio_queue target %d, pid %ld, HBA busy, returning " ! 385: "DID_BUS_BUSY, done.\n", cmd->target, cmd->pid); ! 386: done(cmd); ! 387: cp->status = FREE; ! 388: restore_flags(flags); ! 389: return (0); ! 390: } ! 391: while (!(inb(base + HA_RSTATUS) & HA_SDRQ)); ! 392: outsw(base + HA_RDATA, cp, hd->cplen); ! 393: outb(EATA_CMD_PIO_TRUNC, base + HA_WCOMMAND); ! 394: for (x = 0; x < hd->cppadlen; x++) outw(0, base + HA_RDATA); ! 395: ! 396: DBG(DBG_QUEUE,printk("Queued base %#.4lx pid: %ld target: %x lun: %x " ! 397: "slot %d irq %d\n", (long)sh->base, cmd->pid, ! 398: cmd->target, cmd->lun, y, sh->irq)); ! 399: DBG(DBG_QUEUE && DBG_DELAY, DEL2(200)); ! 400: ! 401: restore_flags(flags); ! 402: return (0); ! 403: } ! 404: ! 405: int eata_pio_abort(Scsi_Cmnd * cmd) ! 406: { ! 407: ulong flags; ! 408: uint loop = R_LIMIT; ! 409: ! 410: save_flags(flags); ! 411: cli(); ! 412: ! 413: DBG(DBG_ABNORM, printk("eata_pio_abort called pid: %ld target: %x lun: %x" ! 414: " reason %x\n", cmd->pid, cmd->target, cmd->lun, ! 415: cmd->abort_reason)); ! 416: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 417: ! 418: ! 419: while (inb((uint)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY) ! 420: if (--loop == 0) { ! 421: printk("eata_pio: abort, timeout error.\n"); ! 422: restore_flags(flags); ! 423: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 424: return (SCSI_ABORT_ERROR); ! 425: } ! 426: if (CD(cmd)->status == FREE) { ! 427: DBG(DBG_ABNORM, printk("Returning: SCSI_ABORT_NOT_RUNNING\n")); ! 428: restore_flags(flags); ! 429: return (SCSI_ABORT_NOT_RUNNING); ! 430: } ! 431: if (CD(cmd)->status == USED) { ! 432: DBG(DBG_ABNORM, printk("Returning: SCSI_ABORT_BUSY\n")); ! 433: restore_flags(flags); ! 434: return (SCSI_ABORT_BUSY); /* SNOOZE */ ! 435: } ! 436: if (CD(cmd)->status == RESET) { ! 437: restore_flags(flags); ! 438: printk("eata_pio: abort, command reset error.\n"); ! 439: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 440: return (SCSI_ABORT_ERROR); ! 441: } ! 442: if (CD(cmd)->status == LOCKED) { ! 443: restore_flags(flags); ! 444: DBG(DBG_ABNORM, printk("eata_pio: abort, queue slot locked.\n")); ! 445: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 446: return (SCSI_ABORT_NOT_RUNNING); ! 447: } ! 448: restore_flags(flags); ! 449: panic("eata_pio: abort: invalid slot status\n"); ! 450: } ! 451: ! 452: int eata_pio_reset(Scsi_Cmnd * cmd) ! 453: { ! 454: uint x, z, time, limit = 0; ! 455: ulong flags; ! 456: unchar success = FALSE; ! 457: Scsi_Cmnd *sp; ! 458: ! 459: save_flags(flags); ! 460: cli(); ! 461: hprint("reset"); ! 462: DBG(DBG_ABNORM, printk("eata_pio_reset called pid:%ld target: %x lun: %x " ! 463: "reason %x\n", cmd->pid, cmd->target, cmd->lun, ! 464: cmd->abort_reason)); ! 465: ! 466: if (HD(cmd)->state == RESET) { ! 467: printk("eata_pio_reset: exit, already in reset.\n"); ! 468: restore_flags(flags); ! 469: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 470: return (SCSI_RESET_ERROR); ! 471: } ! 472: ! 473: for (z = 0; z < MAXTARGET; z++) { ! 474: HD(cmd)->t_state[0][z] = RESET; ! 475: HD(cmd)->t_timeout[0][z] = NO_TIMEOUT; ! 476: } ! 477: ! 478: /* force all slots to be free */ ! 479: ! 480: for (x = 0; x < cmd->host->can_queue; x++) { ! 481: ! 482: if (HD(cmd)->ccb[x].status == FREE) ! 483: continue; ! 484: ! 485: sp = HD(cmd)->ccb[x].cmd; ! 486: HD(cmd)->ccb[x].status = RESET; ! 487: printk("eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->pid); ! 488: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 489: ! 490: if (sp == NULL) ! 491: panic("eata_pio_reset: slot %d, sp==NULL.\n", x); ! 492: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 493: } ! 494: ! 495: /* hard reset the HBA */ ! 496: outb((uint) cmd->host->base+HA_WCOMMAND, EATA_CMD_RESET); ! 497: ! 498: DBG(DBG_ABNORM, printk("eata_pio_reset: board reset done.\n")); ! 499: HD(cmd)->state = RESET; ! 500: ! 501: time = jiffies; ! 502: while (jiffies < (time + (3 * HZ)) && limit++ < 10000000); ! 503: ! 504: DBG(DBG_ABNORM, printk("eata_pio_reset: interrupts disabled, loops %d.\n", limit)); ! 505: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 506: ! 507: for (x = 0; x < cmd->host->can_queue; x++) { ! 508: ! 509: /* Skip slots already set free by interrupt */ ! 510: if (HD(cmd)->ccb[x].status != RESET) ! 511: continue; ! 512: ! 513: sp = HD(cmd)->ccb[x].cmd; ! 514: sp->result = DID_RESET << 16; ! 515: ! 516: /* This mailbox is terminated */ ! 517: printk("eata_pio_reset: resetted ccb %d.\n",x); ! 518: HD(cmd)->ccb[x].status = FREE; ! 519: ! 520: restore_flags(flags); ! 521: sp->scsi_done(sp); ! 522: cli(); ! 523: } ! 524: ! 525: HD(cmd)->state = FALSE; ! 526: restore_flags(flags); ! 527: ! 528: if (success) { /* hmmm... */ ! 529: DBG(DBG_ABNORM, printk("eata_pio_reset: exit, success.\n")); ! 530: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 531: return (SCSI_RESET_SUCCESS); ! 532: } else { ! 533: DBG(DBG_ABNORM, printk("eata_pio_reset: exit, wakeup.\n")); ! 534: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500)); ! 535: return (SCSI_RESET_PUNT); ! 536: } ! 537: } ! 538: ! 539: char * get_pio_board_data(ulong base, uint irq, uint id, ulong cplen, ushort cppadlen) ! 540: { ! 541: struct eata_ccb cp; ! 542: static char buff[256]; ! 543: int z; ! 544: ! 545: memset(&cp, 0, sizeof(struct eata_ccb)); ! 546: memset(buff, 0, sizeof(buff)); ! 547: ! 548: cp.DataIn = TRUE; ! 549: cp.Interpret = TRUE; /* Interpret command */ ! 550: ! 551: cp.cp_datalen = htonl(254); ! 552: cp.cp_dataDMA = htonl(0); ! 553: ! 554: cp.cp_id = id; ! 555: cp.cp_lun = 0; ! 556: ! 557: cp.cp_cdb[0] = INQUIRY; ! 558: cp.cp_cdb[1] = 0; ! 559: cp.cp_cdb[2] = 0; ! 560: cp.cp_cdb[3] = 0; ! 561: cp.cp_cdb[4] = 254; ! 562: cp.cp_cdb[5] = 0; ! 563: ! 564: if (eata_pio_send_command((uint) base, EATA_CMD_PIO_SEND_CP)) ! 565: return (NULL); ! 566: while (!(inb(base + HA_RSTATUS) & HA_SDRQ)); ! 567: outsw(base + HA_RDATA, &cp, cplen); ! 568: outb(EATA_CMD_PIO_TRUNC, base + HA_WCOMMAND); ! 569: for (z = 0; z < cppadlen; z++) outw(0, base + HA_RDATA); ! 570: ! 571: while (inb(base + HA_RSTATUS) & HA_SBUSY); ! 572: if (inb(base + HA_RSTATUS) & HA_SERROR) ! 573: return (NULL); ! 574: else if (!(inb(base + HA_RSTATUS) & HA_SDRQ)) ! 575: return (NULL); ! 576: else ! 577: { ! 578: insw(base+HA_RDATA, &buff, 127); ! 579: while (inb(base + HA_RSTATUS)&HA_SDRQ) inw(base + HA_RDATA); ! 580: return (buff); ! 581: } ! 582: } ! 583: ! 584: int get_pio_conf_PIO(u32 base, struct get_conf *buf) ! 585: { ! 586: ulong loop = R_LIMIT; ! 587: int z; ! 588: ushort *p; ! 589: ! 590: if(check_region(base, 9)) ! 591: return (FALSE); ! 592: ! 593: memset(buf, 0, sizeof(struct get_conf)); ! 594: ! 595: while (inb(base + HA_RSTATUS) & HA_SBUSY) ! 596: if (--loop == 0) ! 597: return (FALSE); ! 598: ! 599: DBG(DBG_PIO && DBG_PROBE, ! 600: printk("Issuing PIO READ CONFIG to HBA at %#x\n", base)); ! 601: eata_pio_send_command(base, EATA_CMD_PIO_READ_CONFIG); ! 602: ! 603: loop = R_LIMIT; ! 604: for (p = (ushort *) buf; ! 605: (long)p <= ((long)buf + (sizeof(struct get_conf) / 2)); p++) { ! 606: while (!(inb(base + HA_RSTATUS) & HA_SDRQ)) ! 607: if (--loop == 0) ! 608: return (FALSE); ! 609: ! 610: loop = R_LIMIT; ! 611: *p = inw(base + HA_RDATA); ! 612: } ! 613: if (!(inb(base + HA_RSTATUS) & HA_SERROR)) { /* Error ? */ ! 614: if (htonl(EATA_SIGNATURE) == buf->signature) { ! 615: DBG(DBG_PIO&&DBG_PROBE, printk("EATA Controller found at %#4x " ! 616: "EATA Level: %x\n", base, ! 617: (uint) (buf->version))); ! 618: ! 619: while (inb(base + HA_RSTATUS) & HA_SDRQ) ! 620: inw(base + HA_RDATA); ! 621: if(ALLOW_DMA_BOARDS == FALSE) { ! 622: for (z = 0; z < MAXISA; z++) ! 623: if (base == ISAbases[z]) { ! 624: buf->IRQ = ISAirqs[z]; ! 625: break; ! 626: } ! 627: } ! 628: return (TRUE); ! 629: } ! 630: } else { ! 631: DBG(DBG_PROBE, printk("eata_dma: get_conf_PIO, error during transfer " ! 632: "for HBA at %x\n", base)); ! 633: } ! 634: return (FALSE); ! 635: } ! 636: ! 637: void print_pio_config(struct get_conf *gc) ! 638: { ! 639: printk("Please check values: (read config data)\n"); ! 640: printk("LEN: %d ver:%d OCS:%d TAR:%d TRNXFR:%d MORES:%d\n", ! 641: (uint) ntohl(gc->len), gc->version, ! 642: gc->OCS_enabled, gc->TAR_support, gc->TRNXFR, gc->MORE_support); ! 643: printk("HAAV:%d SCSIID0:%d ID1:%d ID2:%d QUEUE:%d SG:%d SEC:%d\n", ! 644: gc->HAA_valid, gc->scsi_id[3], gc->scsi_id[2], ! 645: gc->scsi_id[1], ntohs(gc->queuesiz), ntohs(gc->SGsiz), gc->SECOND); ! 646: printk("IRQ:%d IRQT:%d FORCADR:%d MCH:%d RIDQ:%d\n", ! 647: gc->IRQ, gc->IRQ_TR, gc->FORCADR, ! 648: gc->MAX_CHAN, gc->ID_qest); ! 649: DBG(DPT_DEBUG, DELAY(14)); ! 650: } ! 651: ! 652: static uint print_selftest(uint base) ! 653: { ! 654: unchar buffer[512]; ! 655: #ifdef VERBOSE_SETUP ! 656: int z; ! 657: #endif ! 658: ! 659: printk("eata_pio: executing controller self test & setup...\n"); ! 660: while (inb(base + HA_RSTATUS) & HA_SBUSY); ! 661: outb(EATA_CMD_PIO_SETUPTEST, base + HA_WCOMMAND); ! 662: do { ! 663: while (inb(base + HA_RSTATUS) & HA_SBUSY) ! 664: /* nothing */ ; ! 665: if (inb(base + HA_RSTATUS) & HA_SDRQ) ! 666: { ! 667: insw(base + HA_RDATA, &buffer, 256); ! 668: #ifdef VERBOSE_SETUP ! 669: /* no beeps please... */ ! 670: for (z = 0; z < 511 && buffer[z]; z++) ! 671: if (buffer[z] != 7) printk("%c", buffer[z]); ! 672: #endif ! 673: } ! 674: } while (inb(base+HA_RSTATUS) & (HA_SBUSY|HA_SDRQ)); ! 675: ! 676: return (!(inb(base+HA_RSTATUS) & HA_SERROR)); ! 677: } ! 678: ! 679: int register_pio_HBA(long base, struct get_conf *gc, Scsi_Host_Template * tpnt) ! 680: { ! 681: ulong size = 0; ! 682: char *buff; ! 683: ulong cplen; ! 684: ushort cppadlen; ! 685: struct Scsi_Host *sh; ! 686: hostdata *hd; ! 687: ! 688: DBG(DBG_REGISTER, print_pio_config(gc)); ! 689: ! 690: if (gc->DMA_support == TRUE) { ! 691: printk("HBA at %#.4lx supports DMA. Please use EATA-DMA driver.\n",base); ! 692: if(ALLOW_DMA_BOARDS == FALSE) ! 693: return (FALSE); ! 694: } ! 695: ! 696: if ((buff = get_pio_board_data((uint)base, gc->IRQ, gc->scsi_id[3], ! 697: cplen =(htonl(gc->cplen )+1)/2, ! 698: cppadlen=(htons(gc->cppadlen)+1)/2)) == NULL) ! 699: { ! 700: printk("HBA at %#lx didn't react on INQUIRY. Sorry.\n", (ulong) base); ! 701: return (FALSE); ! 702: } ! 703: ! 704: if (print_selftest(base) == FALSE && ALLOW_DMA_BOARDS == FALSE) ! 705: { ! 706: printk("HBA at %#lx failed while performing self test & setup.\n", ! 707: (ulong) base); ! 708: return (FALSE); ! 709: } ! 710: ! 711: if (!reg_IRQ[gc->IRQ]) { /* Interrupt already registered ? */ ! 712: if (!request_irq(gc->IRQ, eata_pio_int_handler, SA_INTERRUPT, ! 713: "EATA-PIO")){ ! 714: reg_IRQ[gc->IRQ]++; ! 715: if (!gc->IRQ_TR) ! 716: reg_IRQL[gc->IRQ] = TRUE; /* IRQ is edge triggered */ ! 717: } else { ! 718: printk("Couldn't allocate IRQ %d, Sorry.", gc->IRQ); ! 719: return (FALSE); ! 720: } ! 721: } else { /* More than one HBA on this IRQ */ ! 722: if (reg_IRQL[gc->IRQ] == TRUE) { ! 723: printk("Can't support more than one HBA on this IRQ,\n" ! 724: " if the IRQ is edge triggered. Sorry.\n"); ! 725: return (FALSE); ! 726: } else ! 727: reg_IRQ[gc->IRQ]++; ! 728: } ! 729: ! 730: request_region(base, 8, "eata_pio"); ! 731: ! 732: size = sizeof(hostdata) + (sizeof(struct eata_ccb) * ntohs(gc->queuesiz)); ! 733: ! 734: sh = scsi_register(tpnt, size); ! 735: hd = SD(sh); ! 736: ! 737: memset(hd->ccb, 0, (sizeof(struct eata_ccb) * ntohs(gc->queuesiz))); ! 738: memset(hd->reads, 0, sizeof(ulong) * 26); ! 739: ! 740: strncpy(SD(sh)->vendor, &buff[8], 8); ! 741: SD(sh)->vendor[8] = 0; ! 742: strncpy(SD(sh)->name, &buff[16], 17); ! 743: SD(sh)->name[17] = 0; ! 744: SD(sh)->revision[0] = buff[32]; ! 745: SD(sh)->revision[1] = buff[33]; ! 746: SD(sh)->revision[2] = buff[34]; ! 747: SD(sh)->revision[3] = '.'; ! 748: SD(sh)->revision[4] = buff[35]; ! 749: SD(sh)->revision[5] = 0; ! 750: ! 751: switch (ntohl(gc->len)) { ! 752: case 0x1c: ! 753: SD(sh)->EATA_revision = 'a'; ! 754: break; ! 755: case 0x1e: ! 756: SD(sh)->EATA_revision = 'b'; ! 757: break; ! 758: case 0x22: ! 759: SD(sh)->EATA_revision = 'c'; ! 760: break; ! 761: case 0x24: ! 762: SD(sh)->EATA_revision = 'z'; ! 763: default: ! 764: SD(sh)->EATA_revision = '?'; ! 765: } ! 766: ! 767: if(ntohl(gc->len) >= 0x22) { ! 768: if (gc->is_PCI == TRUE) ! 769: hd->bustype = IS_PCI; ! 770: else if (gc->is_EISA == TRUE) ! 771: hd->bustype = IS_EISA; ! 772: else ! 773: hd->bustype = IS_ISA; ! 774: } else { ! 775: if (buff[21] == '4') ! 776: hd->bustype = IS_PCI; ! 777: else if (buff[21] == '2') ! 778: hd->bustype = IS_EISA; ! 779: else ! 780: hd->bustype = IS_ISA; ! 781: } ! 782: ! 783: SD(sh)->cplen=cplen; ! 784: SD(sh)->cppadlen=cppadlen; ! 785: SD(sh)->hostid=gc->scsi_id[3]; ! 786: SD(sh)->devflags=1<<gc->scsi_id[3]; ! 787: SD(sh)->moresupport=gc->MORE_support; ! 788: sh->unique_id = base; ! 789: sh->base = (char *) base; ! 790: sh->io_port = base; ! 791: sh->n_io_port = 8; ! 792: sh->irq = gc->IRQ; ! 793: sh->dma_channel = PIO; ! 794: sh->this_id = gc->scsi_id[3]; ! 795: sh->can_queue = 1; ! 796: sh->cmd_per_lun = 1; ! 797: sh->sg_tablesize = SG_ALL; ! 798: ! 799: hd->channel = 0; ! 800: ! 801: sh->max_id = 8; ! 802: sh->max_lun = 8; ! 803: ! 804: if (gc->SECOND) ! 805: hd->primary = FALSE; ! 806: else ! 807: hd->primary = TRUE; ! 808: ! 809: sh->unchecked_isa_dma = FALSE; /* We can only do PIO */ ! 810: ! 811: hd->next = NULL; /* build a linked list of all HBAs */ ! 812: hd->prev = last_HBA; ! 813: if(hd->prev != NULL) ! 814: SD(hd->prev)->next = sh; ! 815: last_HBA = sh; ! 816: if (first_HBA == NULL) ! 817: first_HBA = sh; ! 818: registered_HBAs++; ! 819: return (1); ! 820: } ! 821: ! 822: void find_pio_ISA(struct get_conf *buf, Scsi_Host_Template * tpnt) ! 823: { ! 824: int i; ! 825: ! 826: for (i = 0; i < MAXISA; i++) { ! 827: if (ISAbases[i]) { ! 828: if (get_pio_conf_PIO(ISAbases[i], buf) == TRUE){ ! 829: register_pio_HBA(ISAbases[i], buf, tpnt); ! 830: } ! 831: ISAbases[i] = 0; ! 832: } ! 833: } ! 834: return; ! 835: } ! 836: ! 837: void find_pio_EISA(struct get_conf *buf, Scsi_Host_Template * tpnt) ! 838: { ! 839: u32 base; ! 840: int i; ! 841: ! 842: #if CHECKPAL ! 843: u8 pal1, pal2, pal3; ! 844: #endif ! 845: ! 846: for (i = 0; i < MAXEISA; i++) { ! 847: if (EISAbases[i] == TRUE) { /* Still a possibility ? */ ! 848: ! 849: base = 0x1c88 + (i * 0x1000); ! 850: #if CHECKPAL ! 851: pal1 = inb((u16)base - 8); ! 852: pal2 = inb((u16)base - 7); ! 853: pal3 = inb((u16)base - 6); ! 854: ! 855: if (((pal1 == 0x12) && (pal2 == 0x14)) || ! 856: ((pal1 == 0x38) && (pal2 == 0xa3) && (pal3 == 0x82)) || ! 857: ((pal1 == 0x06) && (pal2 == 0x94) && (pal3 == 0x24))) { ! 858: DBG(DBG_PROBE, printk("EISA EATA id tags found: %x %x %x \n", ! 859: (int)pal1, (int)pal2, (int)pal3)); ! 860: #endif ! 861: if (get_pio_conf_PIO(base, buf) == TRUE) { ! 862: DBG(DBG_PROBE && DBG_EISA, print_pio_config(buf)); ! 863: if (buf->IRQ) { ! 864: register_pio_HBA(base, buf, tpnt); ! 865: } else ! 866: printk("eata_dma: No valid IRQ. HBA removed from list\n"); ! 867: } ! 868: /* Nothing found here so we take it from the list */ ! 869: EISAbases[i] = 0; ! 870: #if CHECKPAL ! 871: } ! 872: #endif ! 873: } ! 874: } ! 875: return; ! 876: } ! 877: ! 878: void find_pio_PCI(struct get_conf *buf, Scsi_Host_Template * tpnt) ! 879: { ! 880: ! 881: #ifndef CONFIG_PCI ! 882: printk("eata_pio: kernel PCI support not enabled. Skipping scan for PCI HBAs.\n"); ! 883: #else ! 884: ! 885: u8 pci_bus, pci_device_fn; ! 886: static s16 pci_index = 0; /* Device index to PCI BIOS calls */ ! 887: u32 base = 0; ! 888: u16 com_adr; ! 889: u16 rev_device; ! 890: u32 error, i, x; ! 891: ! 892: if (pcibios_present()) { ! 893: for (i = 0; i <= MAXPCI; ++i, ++pci_index) { ! 894: if (pcibios_find_device(PCI_VENDOR_ID_DPT, PCI_DEVICE_ID_DPT, ! 895: pci_index, &pci_bus, &pci_device_fn)) ! 896: break; ! 897: DBG(DBG_PROBE && DBG_PCI, ! 898: printk("eata_pio: HBA at bus %d, device %d," ! 899: " function %d, index %d\n", (s32)pci_bus, ! 900: (s32)((pci_device_fn & 0xf8) >> 3), ! 901: (s32)(pci_device_fn & 7), pci_index)); ! 902: ! 903: if (!(error = pcibios_read_config_word(pci_bus, pci_device_fn, ! 904: PCI_CLASS_DEVICE, &rev_device))) { ! 905: if (rev_device == PCI_CLASS_STORAGE_SCSI) { ! 906: if (!(error = pcibios_read_config_word(pci_bus, ! 907: pci_device_fn, PCI_COMMAND, ! 908: (u16 *) & com_adr))) { ! 909: if (!((com_adr & PCI_COMMAND_IO) && ! 910: (com_adr & PCI_COMMAND_MASTER))) { ! 911: printk("HBA has IO or BUSMASTER mode disabled\n"); ! 912: continue; ! 913: } ! 914: } else ! 915: printk("eata_pio: error %x while reading " ! 916: "PCI_COMMAND\n", error); ! 917: } else ! 918: printk("DEVICECLASSID %x didn't match\n", rev_device); ! 919: } else { ! 920: printk("eata_pio: error %x while reading PCI_CLASS_BASE\n", ! 921: error); ! 922: continue; ! 923: } ! 924: ! 925: if (!(error = pcibios_read_config_dword(pci_bus, pci_device_fn, ! 926: PCI_BASE_ADDRESS_0, (int *) &base))){ ! 927: ! 928: /* Check if the address is valid */ ! 929: if (base & 0x01) { ! 930: base &= 0xfffffffe; ! 931: /* EISA tag there ? */ ! 932: if ((inb(base) == 0x12) && (inb(base + 1) == 0x14)) ! 933: continue; /* Jep, it's forced, so move on */ ! 934: base += 0x10; /* Now, THIS is the real address */ ! 935: if (base != 0x1f8) { ! 936: /* We didn't find it in the primary search */ ! 937: if (get_pio_conf_PIO(base, buf) == TRUE) { ! 938: if (buf->FORCADR) /* If the address is forced */ ! 939: continue; /* we'll find it later */ ! 940: ! 941: /* OK. We made it till here, so we can go now ! 942: * and register it. We only have to check and ! 943: * eventually remove it from the EISA and ISA list ! 944: */ ! 945: ! 946: register_pio_HBA(base, buf, tpnt); ! 947: ! 948: if (base < 0x1000) { ! 949: for (x = 0; x < MAXISA; ++x) { ! 950: if (ISAbases[x] == base) { ! 951: ISAbases[x] = 0; ! 952: break; ! 953: } ! 954: } ! 955: } else if ((base & 0x0fff) == 0x0c88) { ! 956: x = (base >> 12) & 0x0f; ! 957: EISAbases[x] = 0; ! 958: } ! 959: continue; /* break; */ ! 960: } ! 961: } ! 962: } ! 963: } else ! 964: printk("eata_pio: error %x while reading " ! 965: "PCI_BASE_ADDRESS_0\n", error); ! 966: } ! 967: } else ! 968: printk("eata_pio: No BIOS32 extensions present. This driver release " ! 969: "still depends on it.\n" ! 970: " Skipping scan for PCI HBAs.\n"); ! 971: #endif /* #ifndef CONFIG_PCI */ ! 972: return; ! 973: } ! 974: ! 975: ! 976: int eata_pio_detect(Scsi_Host_Template * tpnt) ! 977: { ! 978: struct Scsi_Host *HBA_ptr; ! 979: struct get_conf gc; ! 980: int i; ! 981: ! 982: DBG((DBG_PROBE && DBG_DELAY) || DPT_DEBUG, ! 983: printk("Using lots of delays to let you read the debugging output\n")); ! 984: ! 985: tpnt->proc_dir = &proc_scsi_eata_pio; ! 986: ! 987: find_pio_PCI(&gc, tpnt); ! 988: ! 989: find_pio_EISA(&gc, tpnt); ! 990: ! 991: find_pio_ISA(&gc, tpnt); ! 992: ! 993: for (i = 0; i <= MAXIRQ; i++) ! 994: if (reg_IRQ[i]) ! 995: request_irq(i, eata_pio_int_handler, SA_INTERRUPT, "EATA-PIO"); ! 996: ! 997: HBA_ptr = first_HBA; ! 998: ! 999: if (registered_HBAs != 0) { ! 1000: printk("EATA (Extended Attachment) PIO driver version: %d.%d%s\n" ! 1001: "(c) 1993-95 Michael Neuffer, [email protected]\n" ! 1002: " Alfred Arnold, [email protected]\n" ! 1003: "This release only supports DASD devices (harddisks)\n", ! 1004: VER_MAJOR, VER_MINOR, VER_SUB); ! 1005: ! 1006: printk("Registered HBAs:\n"); ! 1007: printk("HBA no. Boardtype: Revis: EATA: Bus: BaseIO: IRQ: Ch: ID: Pr:" ! 1008: " QS: SG: CPL:\n"); ! 1009: for (i = 1; i <= registered_HBAs; i++) { ! 1010: printk("scsi%-2d: %.10s v%s 2.0%c %s %#.4x %2d %d %d %c" ! 1011: " %2d %2d %2d\n", ! 1012: HBA_ptr->host_no, SD(HBA_ptr)->name, SD(HBA_ptr)->revision, ! 1013: SD(HBA_ptr)->EATA_revision, (SD(HBA_ptr)->bustype == 'P')? ! 1014: "PCI ":(SD(HBA_ptr)->bustype == 'E')?"EISA":"ISA ", ! 1015: (uint) HBA_ptr->base, HBA_ptr->irq, SD(HBA_ptr)->channel, ! 1016: HBA_ptr->this_id, (SD(HBA_ptr)->primary == TRUE)?'Y':'N', ! 1017: HBA_ptr->can_queue, HBA_ptr->sg_tablesize, ! 1018: HBA_ptr->cmd_per_lun); ! 1019: HBA_ptr = SD(HBA_ptr)->next; ! 1020: } ! 1021: } ! 1022: DBG(DPT_DEBUG,DELAY(12)); ! 1023: ! 1024: return (registered_HBAs); ! 1025: } ! 1026: ! 1027: #ifdef MODULE ! 1028: /* Eventually this will go into an include file, but this will be later */ ! 1029: Scsi_Host_Template driver_template = EATA_PIO; ! 1030: ! 1031: #include "scsi_module.c" ! 1032: #endif ! 1033: ! 1034: /* ! 1035: * Overrides for Emacs so that we almost follow Linus's tabbing style. ! 1036: * Emacs will notice this stuff at the end of the file and automatically ! 1037: * adjust the settings for this buffer only. This must remain at the end ! 1038: * of the file. ! 1039: * --------------------------------------------------------------------------- ! 1040: * Local variables: ! 1041: * c-indent-level: 4 ! 1042: * c-brace-imaginary-offset: 0 ! 1043: * c-brace-offset: -4 ! 1044: * c-argdecl-indent: 4 ! 1045: * c-label-offset: -4 ! 1046: * c-continued-statement-offset: 4 ! 1047: * c-continued-brace-offset: 0 ! 1048: * indent-tabs-mode: nil ! 1049: * tab-width: 8 ! 1050: * End: ! 1051: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.