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