![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eata_dma.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_dma.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /************************************************************
2: * *
3: * Linux EATA SCSI 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 ISA based EATA-DMA boards *
11: * -supports all EISA based EATA-DMA boards *
12: * -supports all PCI based EATA-DMA boards *
13: * -supports multiple HBAs with & without IRQ sharing *
14: * -supports all SCSI channels on multi channel boards *
15: * -needs identical IDs on all channels of a HBA *
16: * -can be loaded as module *
17: * -displays statistical and hardware information *
18: * in /proc/scsi/eata_dma *
19: * -provides rudimentary latency measurement *
20: * possibilities via /proc/scsi/eata_dma/<hostnum> *
21: * *
22: * (c)1993,94,95 Michael Neuffer *
23: * [email protected] *
24: * *
25: * This program is free software; you can redistribute it *
26: * and/or modify it under the terms of the GNU General *
27: * Public License as published by the Free Software *
28: * Foundation; either version 2 of the License, or *
29: * (at your option) any later version. *
30: * *
31: * This program is distributed in the hope that it will be *
32: * useful, but WITHOUT ANY WARRANTY; without even the *
33: * implied warranty of MERCHANTABILITY or FITNESS FOR A *
34: * PARTICULAR PURPOSE. See the GNU General Public License *
35: * for more details. *
36: * *
37: * You should have received a copy of the GNU General *
38: * Public License along with this kernel; if not, write to *
39: * the Free Software Foundation, Inc., 675 Mass Ave, *
40: * Cambridge, MA 02139, USA. *
41: * *
42: * I have to thank DPT for their excellent support. I took *
43: * me almost a year and a stopover at their HQ, on my first *
44: * trip to the USA, to get it, but since then they've been *
45: * very helpful and tried to give me all the infos and *
46: * support I need. *
47: * *
48: * Thanks also to Greg Hosler who did a lot of testing and *
49: * found quite a number of bugs during the development. *
50: ************************************************************
51: * last change: 95/11/29 OS: Linux 1.3.45 *
52: ************************************************************/
53:
54: /* Look in eata_dma.h for configuration and revision information */
55:
56: #include <linux/module.h>
57: #include <linux/kernel.h>
58: #include <linux/sched.h>
59: #include <linux/string.h>
60: #include <linux/ioport.h>
61: #include <linux/malloc.h>
62: #include <linux/in.h>
63: #include <linux/bios32.h>
64: #include <linux/pci.h>
65: #include <linux/proc_fs.h>
66: #include <asm/byteorder.h>
67: #include <asm/types.h>
68: #include <asm/io.h>
69: #include <asm/dma.h>
70: #include <linux/blk.h>
71: #include "scsi.h"
72: #include "sd.h"
73: #include "hosts.h"
74: #include <linux/scsicam.h>
75: #include "eata_dma.h"
76: #include "eata_dma_proc.h"
77:
78: #include <linux/stat.h>
79: #include <linux/config.h> /* for CONFIG_PCI */
80:
81: struct proc_dir_entry proc_scsi_eata_dma = {
82: PROC_SCSI_EATA, 8, "eata_dma",
83: S_IFDIR | S_IRUGO | S_IXUGO, 2
84: };
85:
86: static u32 ISAbases[] =
87: {0x1F0, 0x170, 0x330, 0x230};
88: static unchar EISAbases[] =
89: {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
90: static uint registered_HBAs = 0;
91: static struct Scsi_Host *last_HBA = NULL;
92: static struct Scsi_Host *first_HBA = NULL;
93: static unchar reg_IRQ[] =
94: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
95: static unchar reg_IRQL[] =
96: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
97: static struct eata_sp *status = 0; /* Statuspacket array */
98: static void *dma_scratch = 0;
99:
100: static struct eata_register *fake_int_base;
101: static int fake_int_result;
102: static int fake_int_happened;
103:
104: static ulong int_counter = 0;
105: static ulong queue_counter = 0;
106:
107: void eata_scsi_done (Scsi_Cmnd * scmd)
108: {
109: scmd->request.rq_status = RQ_SCSI_DONE;
110:
111: if (scmd->request.sem != NULL)
112: up(scmd->request.sem);
113:
114: return;
115: }
116:
117: void eata_fake_int_handler(s32 irq, struct pt_regs * regs)
118: {
119: fake_int_result = inb((ulong)fake_int_base + HA_RSTATUS);
120: fake_int_happened = TRUE;
121: DBG(DBG_INTR3, printk("eata_fake_int_handler called irq%d base %p"
122: " res %#x\n", irq, fake_int_base, fake_int_result));
123: return;
124: }
125:
126: #ifdef MACH
127: #include "eata_dma_proc.src"
128: #else
129: #include "eata_dma_proc.c"
130: #endif
131:
132: #ifdef MODULE
133: int eata_release(struct Scsi_Host *sh)
134: {
135: uint i;
136: if (sh->irq && reg_IRQ[sh->irq] == 1) free_irq(sh->irq);
137: else reg_IRQ[sh->irq]--;
138:
139: scsi_init_free((void *)status, 512);
140: scsi_init_free((void *)dma_scratch, 512);
141: for (i = 0; i < sh->can_queue; i++){ /* Free all SG arrays */
142: if(SD(sh)->ccb[i].sg_list != NULL)
143: scsi_init_free((void *) SD(sh)->ccb[i].sg_list,
144: sh->sg_tablesize * sizeof(struct eata_sg_list));
145: }
146:
147: if (SD(sh)->channel == 0) {
148: if (sh->dma_channel != BUSMASTER) free_dma(sh->dma_channel);
149: if (sh->io_port && sh->n_io_port)
150: release_region(sh->io_port, sh->n_io_port);
151: }
152: return(TRUE);
153: }
154: #endif
155:
156:
157: void eata_int_handler(int irq, struct pt_regs * regs)
158: {
159: uint i, result = 0;
160: uint hba_stat, scsi_stat, eata_stat;
161: Scsi_Cmnd *cmd;
162: struct eata_ccb *cp;
163: struct eata_sp *sp;
164: uint base;
165: ulong flags;
166: uint x;
167: struct Scsi_Host *sh;
168:
169: save_flags(flags);
170: cli();
171:
172: for (x = 1, sh = first_HBA; x <= registered_HBAs; x++, sh = SD(sh)->next) {
173: if (sh->irq != irq)
174: continue;
175:
176: while(inb((uint)sh->base + HA_RAUXSTAT) & HA_AIRQ) {
177:
178: int_counter++;
179:
180: sp = &SD(sh)->sp;
181: cp = sp->ccb;
182:
183: if(cp == NULL) {
184: eata_stat = inb((uint)sh->base + HA_RSTATUS);
185: printk("eata_dma: int_handler, Spurious IRQ %d "
186: "received. CCB pointer not set.\n", irq);
187: break;
188: }
189:
190: cmd = cp->cmd;
191: base = (uint) cmd->host->base;
192: hba_stat = sp->hba_stat;
193:
194: scsi_stat = (sp->scsi_stat >> 1) & 0x1f;
195:
196: if (sp->EOC == FALSE) {
197: eata_stat = inb(base + HA_RSTATUS);
198: printk("eata_dma: int_handler, board: %x cmd %lx returned "
199: "unfinished.\nEATA: %x HBA: %x SCSI: %x spadr %lx "
200: "spadrirq %lx, irq%d\n", base, (long)cp, eata_stat,
201: hba_stat, scsi_stat,(long)&status, (long)&status[irq],
202: irq);
203: DBG(DBG_DELAY, DEL2(800));
204: break;
205: }
206:
207: if (cp->status == LOCKED) {
208: cp->status = FREE;
209: eata_stat = inb(base + HA_RSTATUS);
210: printk("eata_dma: int_handler, freeing locked queueslot\n");
211: DBG(DBG_INTR && DBG_DELAY, DEL2(800));
212: break;
213: }
214:
215: eata_stat = inb(base + HA_RSTATUS);
216: DBG(DBG_INTR, printk("IRQ %d received, base %#.4x, pid %ld, "
217: "target: %x, lun: %x, ea_s: %#.2x, hba_s: "
218: "%#.2x \n", irq, base, cmd->pid, cmd->target,
219: cmd->lun, eata_stat, hba_stat));
220:
221: switch (hba_stat) {
222: case HA_NO_ERROR: /* NO Error */
223: if (scsi_stat == CONDITION_GOOD
224: && cmd->device->type == TYPE_DISK
225: && (HD(cmd)->t_state[cp->cp_channel][cp->cp_id] == RESET))
226: result = DID_BUS_BUSY << 16;
227: else if (scsi_stat == GOOD) {
228: HD(cmd)->t_state[cp->cp_channel][cp->cp_id] = OK;
229: if(HD(cmd)->do_latency == TRUE && cp->timestamp) {
230: uint time;
231: time = jiffies - cp->timestamp;
232: if((cp->rw_latency) == TRUE) { /* was WRITE */
233: if(HD(cmd)->writes_lat[cp->sizeindex][1] > time)
234: HD(cmd)->writes_lat[cp->sizeindex][1] = time;
235: if(HD(cmd)->writes_lat[cp->sizeindex][2] < time)
236: HD(cmd)->writes_lat[cp->sizeindex][2] = time;
237: HD(cmd)->writes_lat[cp->sizeindex][3] += time;
238: HD(cmd)->writes_lat[cp->sizeindex][0]++;
239: } else {
240: if(HD(cmd)->reads_lat[cp->sizeindex][1] > time)
241: HD(cmd)->reads_lat[cp->sizeindex][1] = time;
242: if(HD(cmd)->reads_lat[cp->sizeindex][2] < time)
243: HD(cmd)->reads_lat[cp->sizeindex][2] = time;
244: HD(cmd)->reads_lat[cp->sizeindex][3] += time;
245: HD(cmd)->reads_lat[cp->sizeindex][0]++;
246: }
247: }
248: }
249: else if (scsi_stat == CHECK_CONDITION
250: && cmd->device->type == TYPE_DISK
251: && (cmd->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
252: result = DID_BUS_BUSY << 16;
253: else
254: result = DID_OK << 16;
255: HD(cmd)->t_timeout[cp->cp_channel][cp->cp_id] = OK;
256: break;
257: case HA_ERR_SEL_TO: /* Selection Timeout */
258: result = DID_BAD_TARGET << 16;
259: break;
260: case HA_ERR_CMD_TO: /* Command Timeout */
261: if (HD(cmd)->t_timeout[cp->cp_channel][cp->cp_id] > 1)
262: result = DID_ERROR << 16;
263: else {
264: result = DID_TIME_OUT << 16;
265: HD(cmd)->t_timeout[cp->cp_channel][cp->cp_id]++;
266: }
267: break;
268: case HA_ERR_RESET: /* SCSI Bus Reset Received */
269: case HA_INIT_POWERUP: /* Initial Controller Power-up */
270: if (cmd->device->type != TYPE_TAPE)
271: result = DID_BUS_BUSY << 16;
272: else
273: result = DID_ERROR << 16;
274:
275: for (i = 0; i < MAXTARGET; i++)
276: HD(cmd)->t_state[cp->cp_channel][i] = RESET;
277: break;
278: case HA_UNX_BUSPHASE: /* Unexpected Bus Phase */
279: case HA_UNX_BUS_FREE: /* Unexpected Bus Free */
280: case HA_BUS_PARITY: /* Bus Parity Error */
281: case HA_SCSI_HUNG: /* SCSI Hung */
282: case HA_UNX_MSGRJCT: /* Unexpected Message Reject */
283: case HA_RESET_STUCK: /* SCSI Bus Reset Stuck */
284: case HA_RSENSE_FAIL: /* Auto Request-Sense Failed */
285: case HA_PARITY_ERR: /* Controller Ram Parity */
286: default:
287: result = DID_ERROR << 16;
288: break;
289: }
290: cmd->result = result | (scsi_stat << 1);
291:
292: #if DBG_INTR2
293: if (scsi_stat || result || hba_stat || eata_stat != 0x50
294: || cmd->scsi_done == NULL || cmd->device->id == 7)
295: printk("HBA: %d, channel %d, id: %d, lun %d, pid %ld:\n"
296: "eata_stat %#x, hba_stat %#.2x, scsi_stat %#.2x, "
297: "sense_key: %#x, result: %#.8x\n", x,
298: cmd->device->channel, cmd->device->id, cmd->device->lun,
299: cmd->pid, eata_stat, hba_stat, scsi_stat,
300: cmd->sense_buffer[2] & 0xf, cmd->result);
301: DBG(DBG_INTR&&DBG_DELAY,DEL2(800));
302: #endif
303:
304: cp->status = FREE; /* now we can release the slot */
305: cmd->scsi_done(cmd);
306: }
307: }
308: restore_flags(flags);
309:
310: return;
311: }
312:
313: inline int eata_send_command(u32 addr, u32 base, u8 command)
314: {
315: long loop = R_LIMIT;
316:
317: while (inb(base + HA_RAUXSTAT) & HA_ABUSY)
318: if (--loop == 0)
319: return(FALSE);
320:
321: /* And now the address in nice little byte chunks */
322: outb( addr & 0x000000ff, base + HA_WDMAADDR);
323: outb((addr & 0x0000ff00) >> 8, base + HA_WDMAADDR + 1);
324: outb((addr & 0x00ff0000) >> 16, base + HA_WDMAADDR + 2);
325: outb((addr & 0xff000000) >> 24, base + HA_WDMAADDR + 3);
326: outb(command, base + HA_WCOMMAND);
327: return(TRUE);
328: }
329:
330: #if 0
331: inline int eata_send_immediate(u32 addr, u32 base, u8 cmnd, u8 cmnd2, u8 id,
332: u8 lun)
333: {
334: if(addr){
335: outb( addr & 0x000000ff, base + HA_WDMAADDR);
336: outb((addr & 0x0000ff00) >> 8, base + HA_WDMAADDR + 1);
337: outb((addr & 0x00ff0000) >> 16, base + HA_WDMAADDR + 2);
338: outb((addr & 0xff000000) >> 24, base + HA_WDMAADDR + 3);
339: } else {
340: outb(id, base + HA_WSUBCODE);
341: outb(lun, base + HA_WSUBLUN);
342: }
343:
344: outb(cmnd2, base + HA_WCOMMAND2);
345: outb(cmnd, base + HA_WCOMMAND);
346: return(TRUE);
347: }
348: #endif
349:
350: int eata_queue(Scsi_Cmnd * cmd, void (* done) (Scsi_Cmnd *))
351: {
352: unsigned int i, x, y;
353: u32 flags;
354: hostdata *hd;
355: struct Scsi_Host *sh;
356: struct eata_ccb *cp;
357: struct scatterlist *sl;
358:
359: save_flags(flags);
360: cli();
361:
362: queue_counter++;
363:
364: hd = HD(cmd);
365: sh = cmd->host;
366:
367: /* check for free slot */
368: for (y = hd->last_ccb + 1, x = 0; x < sh->can_queue; x++, y++) {
369: if (y >= sh->can_queue)
370: y = 0;
371: if (hd->ccb[y].status == FREE)
372: break;
373: }
374:
375: hd->last_ccb = y;
376:
377: if (x >= sh->can_queue) {
378: uint z;
379:
380: printk(KERN_EMERG "eata_dma: run out of queue slots cmdno:%ld"
381: " intrno: %ld, can_queue: %d, x: %d, y: %d\n",
382: queue_counter, int_counter, sh->can_queue, x, y);
383: printk(KERN_EMERG "Status of queueslots:");
384: for(z = 0; z < sh->can_queue; z +=2) {
385: switch(hd->ccb[z].status) {
386: case FREE:
387: printk(KERN_EMERG "Slot %2d is FREE \t", z);
388: break;
389: case USED:
390: printk(KERN_EMERG "Slot %2d is USED \t", z);
391: break;
392: case LOCKED:
393: printk(KERN_EMERG "Slot %2d is LOCKED\t", z);
394: break;
395: default:
396: printk(KERN_EMERG "Slot %2d is UNKNOWN\t", z);
397: }
398: panic("\nSystem halted.\n");
399: }
400: }
401: cp = &hd->ccb[y];
402:
403: memset(cp, 0, sizeof(struct eata_ccb) - sizeof(struct eata_sg_list *));
404:
405: cp->status = USED; /* claim free slot */
406:
407: DBG(DBG_QUEUE, printk("eata_queue pid %ld, target: %x, lun: %x, y %d\n",
408: cmd->pid, cmd->target, cmd->lun, y));
409: DBG(DBG_QUEUE && DBG_DELAY, DEL2(250));
410:
411: if(hd->do_latency == TRUE) {
412: int x, z;
413: short *sho;
414: long *lon;
415: x = 0; /* just to keep GCC quiet */
416: if (cmd->cmnd[0] == WRITE_6 || cmd->cmnd[0] == WRITE_10 ||
417: cmd->cmnd[0] == WRITE_12 || cmd->cmnd[0] == READ_6 ||
418: cmd->cmnd[0] == READ_10 || cmd->cmnd[0] == READ_12) {
419:
420: cp->timestamp = jiffies; /* For latency measurements */
421: switch(cmd->cmnd[0]) {
422: case WRITE_6:
423: case READ_6:
424: x = cmd->cmnd[4]/2;
425: break;
426: case WRITE_10:
427: case READ_10:
428: sho = (short *) &cmd->cmnd[7];
429: x = ntohs(*sho)/2;
430: break;
431: case WRITE_12:
432: case READ_12:
433: lon = (long *) &cmd->cmnd[6];
434: x = ntohl(*lon)/2;
435: break;
436: }
437:
438: for(z = 0; (x > (1 << z)) && (z <= 11); z++)
439: /* nothing */;
440: cp->sizeindex = z;
441: if (cmd->cmnd[0] == WRITE_6 || cmd->cmnd[0] == WRITE_10 ||
442: cmd->cmnd[0] == WRITE_12){
443: cp->rw_latency = TRUE;
444: }
445: }
446: }
447: cmd->scsi_done = (void *)done;
448:
449: switch (cmd->cmnd[0]) {
450: case CHANGE_DEFINITION: case COMPARE: case COPY:
451: case COPY_VERIFY: case LOG_SELECT: case MODE_SELECT:
452: case MODE_SELECT_10: case SEND_DIAGNOSTIC: case WRITE_BUFFER:
453: case FORMAT_UNIT: case REASSIGN_BLOCKS: case RESERVE:
454: case SEARCH_EQUAL: case SEARCH_HIGH: case SEARCH_LOW:
455: case WRITE_6: case WRITE_10: case WRITE_VERIFY:
456: case UPDATE_BLOCK: case WRITE_LONG: case WRITE_SAME:
457: case SEARCH_HIGH_12: case SEARCH_EQUAL_12: case SEARCH_LOW_12:
458: case WRITE_12: case WRITE_VERIFY_12: case SET_WINDOW:
459: case MEDIUM_SCAN: case SEND_VOLUME_TAG:
460: case 0xea: /* alternate number for WRITE LONG */
461: cp->DataOut = TRUE; /* Output mode */
462: break;
463: case TEST_UNIT_READY:
464: default:
465: cp->DataIn = TRUE; /* Input mode */
466: }
467:
468: /* FIXME: This will will have to be changed once the midlevel driver
469: * allows different HBA IDs on every channel.
470: */
471: if (cmd->target == sh->this_id)
472: cp->Interpret = TRUE; /* Interpret command */
473:
474: if (cmd->use_sg) {
475: cp->scatter = TRUE; /* SG mode */
476: if (cp->sg_list == NULL) {
477: cp->sg_list = kmalloc(sh->sg_tablesize * sizeof(struct eata_sg_list),
478: GFP_ATOMIC | GFP_DMA);
479: }
480: if (cp->sg_list == NULL)
481: panic("eata_dma: Run out of DMA memory for SG lists !\n");
482: cp->cp_dataDMA = htonl(virt_to_bus(cp->sg_list));
483:
484: cp->cp_datalen = htonl(cmd->use_sg * sizeof(struct eata_sg_list));
485: sl=(struct scatterlist *)cmd->request_buffer;
486: for(i = 0; i < cmd->use_sg; i++, sl++){
487: cp->sg_list[i].data = htonl(virt_to_bus(sl->address));
488: cp->sg_list[i].len = htonl((u32) sl->length);
489: }
490: } else {
491: cp->scatter = FALSE;
492: cp->cp_datalen = htonl(cmd->request_bufflen);
493: cp->cp_dataDMA = htonl(virt_to_bus(cmd->request_buffer));
494: }
495:
496: cp->Auto_Req_Sen = TRUE;
497: cp->cp_reqDMA = htonl(virt_to_bus(cmd->sense_buffer));
498: cp->reqlen = sizeof(cmd->sense_buffer);
499:
500: cp->cp_id = cmd->target;
501: cp->cp_channel = cmd->channel;
502: cp->cp_lun = cmd->lun;
503: cp->cp_dispri = TRUE;
504: cp->cp_identify = TRUE;
505: memcpy(cp->cp_cdb, cmd->cmnd, cmd->cmd_len);
506:
507: cp->cp_statDMA = htonl(virt_to_bus(&(hd->sp)));
508:
509: cp->cp_viraddr = cp; /* This will be passed thru, so we don't need to
510: * convert it */
511: cp->cmd = cmd;
512: cmd->host_scribble = (char *)&hd->ccb[y];
513:
514: if(eata_send_command((u32) cp, (u32) sh->base, EATA_CMD_DMA_SEND_CP) == FALSE) {
515: cmd->result = DID_BUS_BUSY << 16;
516: DBG(DBG_QUEUE && DBG_ABNORM,
517: printk("eata_queue target %d, pid %ld, HBA busy, "
518: "returning DID_BUS_BUSY\n",cmd->target, cmd->pid));
519: done(cmd);
520: cp->status = FREE;
521: restore_flags(flags);
522: return(0);
523: }
524: DBG(DBG_QUEUE, printk("Queued base %#.4x pid: %ld target: %x lun: %x "
525: "slot %d irq %d\n", (s32)sh->base, cmd->pid,
526: cmd->target, cmd->lun, y, sh->irq));
527: DBG(DBG_QUEUE && DBG_DELAY, DEL2(200));
528: restore_flags(flags);
529: return(0);
530: }
531:
532:
533: int eata_abort(Scsi_Cmnd * cmd)
534: {
535: ulong loop = R_LIMIT;
536: ulong flags;
537:
538: save_flags(flags);
539: cli();
540:
541: DBG(DBG_ABNORM, printk("eata_abort called pid: %ld target: %x lun: %x"
542: " reason %x\n", cmd->pid, cmd->target, cmd->lun,
543: cmd->abort_reason));
544: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
545:
546: while (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY) {
547: if (--loop == 0) {
548: printk("eata_dma: abort, timeout error.\n");
549: restore_flags(flags);
550: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
551: return (SCSI_ABORT_ERROR);
552: }
553: }
554: if (CD(cmd)->status == RESET) {
555: restore_flags(flags);
556: printk("eata_dma: abort, command reset error.\n");
557: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
558: return (SCSI_ABORT_ERROR);
559: }
560: if (CD(cmd)->status == LOCKED) {
561: restore_flags(flags);
562: DBG(DBG_ABNORM, printk("eata_dma: abort, queue slot locked.\n"));
563: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
564: return (SCSI_ABORT_NOT_RUNNING);
565: }
566: if (CD(cmd)->status == USED) {
567: DBG(DBG_ABNORM, printk("Returning: SCSI_ABORT_BUSY\n"));
568: restore_flags(flags);
569: return (SCSI_ABORT_BUSY); /* SNOOZE */
570: }
571: if (CD(cmd)->status == FREE) {
572: DBG(DBG_ABNORM, printk("Returning: SCSI_ABORT_NOT_RUNNING\n"));
573: restore_flags(flags);
574: return (SCSI_ABORT_NOT_RUNNING);
575: }
576: restore_flags(flags);
577: panic("eata_dma: abort: invalid slot status\n");
578: }
579:
580: int eata_reset(Scsi_Cmnd * cmd)
581: {
582: ushort x, z;
583: ulong time, limit = 0;
584: ulong loop = R_LIMIT;
585: ulong flags;
586: unchar success = FALSE;
587: Scsi_Cmnd *sp;
588:
589: save_flags(flags);
590: cli();
591:
592: DBG(DBG_ABNORM, printk("eata_reset called pid:%ld target: %x lun: %x"
593: " reason %x\n", cmd->pid, cmd->target, cmd->lun,
594: cmd->abort_reason));
595:
596: if (HD(cmd)->state == RESET) {
597: printk("eata_reset: exit, already in reset.\n");
598: restore_flags(flags);
599: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
600: return (SCSI_RESET_ERROR);
601: }
602:
603: while (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
604: if (--loop == 0) {
605: printk("eata_reset: exit, timeout error.\n");
606: restore_flags(flags);
607: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
608: return (SCSI_RESET_ERROR);
609: }
610:
611: for (x = 0; x < MAXCHANNEL; x++) {
612: for (z = 0; z < MAXTARGET; z++) {
613: HD(cmd)->t_state[x][z] = RESET;
614: HD(cmd)->t_timeout[x][z] = NO_TIMEOUT;
615: }
616: }
617:
618: for (x = 0; x < cmd->host->can_queue; x++) {
619: if (HD(cmd)->ccb[x].status == FREE)
620: continue;
621:
622: if (HD(cmd)->ccb[x].status == LOCKED) {
623: HD(cmd)->ccb[x].status = FREE;
624: printk("eata_reset: locked slot %d forced free.\n", x);
625: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
626: continue;
627: }
628: sp = HD(cmd)->ccb[x].cmd;
629: HD(cmd)->ccb[x].status = RESET;
630: printk("eata_reset: slot %d in reset, pid %ld.\n", x, sp->pid);
631: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
632:
633: if (sp == NULL)
634: panic("eata_reset: slot %d, sp==NULL.\n", x);
635: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
636:
637: if (sp == cmd)
638: success = TRUE;
639: }
640:
641: /* hard reset the HBA */
642: inb((u32) (cmd->host->base) + HA_RSTATUS); /* This might cause trouble */
643: eata_send_command(0, (u32) cmd->host->base, EATA_CMD_RESET);
644:
645: DBG(DBG_ABNORM, printk("eata_reset: board reset done, enabling interrupts.\n"));
646: HD(cmd)->state = RESET;
647:
648: restore_flags(flags);
649:
650: time = jiffies;
651: while (jiffies < (time + (3 * HZ)) || limit++ < 10000000)
652: /* As time goes by... */;
653:
654: save_flags(flags);
655: cli();
656:
657: DBG(DBG_ABNORM, printk("eata_reset: interrupts disabled, loops %ld.\n",
658: limit));
659: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
660:
661: for (x = 0; x < cmd->host->can_queue; x++) {
662:
663: /* Skip slots already set free by interrupt */
664: if (HD(cmd)->ccb[x].status != RESET)
665: continue;
666:
667: sp = HD(cmd)->ccb[x].cmd;
668: sp->result = DID_RESET << 16;
669:
670: /* This mailbox is still waiting for its interrupt */
671: HD(cmd)->ccb[x].status = LOCKED;
672:
673: printk("eata_reset: slot %d locked, DID_RESET, pid %ld done.\n",
674: x, sp->pid);
675: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
676: restore_flags(flags);
677: sp->scsi_done(sp);
678: cli();
679: }
680:
681: HD(cmd)->state = FALSE;
682: restore_flags(flags);
683:
684: if (success) {
685: DBG(DBG_ABNORM, printk("eata_reset: exit, success.\n"));
686: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
687: return (SCSI_RESET_SUCCESS);
688: } else {
689: DBG(DBG_ABNORM, printk("eata_reset: exit, wakeup.\n"));
690: DBG(DBG_ABNORM && DBG_DELAY, DEL2(500));
691: return (SCSI_RESET_PUNT);
692: }
693: }
694:
695: char * get_board_data(u32 base, u32 irq, u32 id)
696: {
697: struct eata_ccb *cp;
698: struct eata_sp *sp;
699: static char *buff;
700: ulong i;
701: ulong limit = 0;
702:
703: cp = (struct eata_ccb *) scsi_init_malloc(sizeof(struct eata_ccb),
704: GFP_ATOMIC | GFP_DMA);
705: sp = (struct eata_sp *) scsi_init_malloc(sizeof(struct eata_sp),
706: GFP_ATOMIC | GFP_DMA);
707:
708: buff = dma_scratch;
709:
710: memset(cp, 0, sizeof(struct eata_ccb));
711: memset(sp, 0, sizeof(struct eata_sp));
712: memset(buff, 0, 256);
713:
714: cp->DataIn = TRUE;
715: cp->Interpret = TRUE; /* Interpret command */
716: cp->cp_dispri = TRUE;
717: cp->cp_identify = TRUE;
718:
719: cp->cp_datalen = htonl(56);
720: cp->cp_dataDMA = htonl(virt_to_bus(buff));
721: cp->cp_statDMA = htonl(virt_to_bus(sp));
722: cp->cp_viraddr = cp;
723:
724: cp->cp_id = id;
725: cp->cp_lun = 0;
726:
727: cp->cp_cdb[0] = INQUIRY;
728: cp->cp_cdb[1] = 0;
729: cp->cp_cdb[2] = 0;
730: cp->cp_cdb[3] = 0;
731: cp->cp_cdb[4] = 56;
732: cp->cp_cdb[5] = 0;
733:
734: fake_int_base = (struct eata_register *) base;
735: fake_int_result = FALSE;
736: fake_int_happened = FALSE;
737:
738: eata_send_command((u32) cp, (u32) base, EATA_CMD_DMA_SEND_CP);
739:
740: i = jiffies + (3 * HZ);
741: while (fake_int_happened == FALSE && jiffies <= i)
742: barrier();
743:
744: DBG(DBG_INTR3, printk("fake_int_result: %#x hbastat %#x scsistat %#x,"
745: " buff %p sp %p\n",
746: fake_int_result, (u32) (sp->hba_stat /*& 0x7f*/),
747: (u32) sp->scsi_stat, buff, sp));
748:
749: scsi_init_free((void *)cp, sizeof(struct eata_ccb));
750: scsi_init_free((void *)sp, sizeof(struct eata_sp));
751:
752: if ((fake_int_result & HA_SERROR) || jiffies > i){
753: /* hard reset the HBA */
754: inb((u32) (base) + HA_RSTATUS);
755: eata_send_command(0, base, EATA_CMD_RESET);
756: i = jiffies;
757: while (jiffies < (i + (3 * HZ)) && limit++ < 10000000)
758: barrier();
759: return (NULL);
760: } else
761: return (buff);
762: }
763:
764: int check_blink_state(long base)
765: {
766: ushort loops = 10;
767: u32 blinkindicator;
768: u32 state = 0x12345678;
769: u32 oldstate = 0;
770:
771: blinkindicator = htonl(0x54504442);
772: while ((loops--) && (state != oldstate)) {
773: oldstate = state;
774: state = inl((uint) base + 1);
775: }
776:
777: DBG(DBG_BLINK, printk("Did Blink check. Status: %d\n",
778: (state == oldstate) && (state == blinkindicator)));
779:
780: if ((state == oldstate) && (state == blinkindicator))
781: return(TRUE);
782: else
783: return (FALSE);
784: }
785:
786: int get_conf_PIO(u32 base, struct get_conf *buf)
787: {
788: ulong loop = R_LIMIT;
789: u16 *p;
790:
791: if(check_region(base, 9))
792: return (FALSE);
793:
794: memset(buf, 0, sizeof(struct get_conf));
795:
796: while (inb(base + HA_RSTATUS) & HA_SBUSY)
797: if (--loop == 0)
798: return (FALSE);
799:
800: DBG(DBG_PIO && DBG_PROBE,
801: printk("Issuing PIO READ CONFIG to HBA at %#x\n", base));
802: eata_send_command(0, base, EATA_CMD_PIO_READ_CONFIG);
803:
804: loop = R_LIMIT;
805: for (p = (u16 *) buf;
806: (long)p <= ((long)buf + (sizeof(struct get_conf) / 2)); p++) {
807: while (!(inb(base + HA_RSTATUS) & HA_SDRQ))
808: if (--loop == 0)
809: return (FALSE);
810:
811: loop = R_LIMIT;
812: *p = inw(base + HA_RDATA);
813: }
814:
815: if (!(inb(base + HA_RSTATUS) & HA_SERROR)) { /* Error ? */
816: if (htonl(EATA_SIGNATURE) == buf->signature) {
817: DBG(DBG_PIO&&DBG_PROBE, printk("EATA Controller found at %x "
818: "EATA Level: %x\n", (uint) base,
819: (uint) (buf->version)));
820:
821: while (inb(base + HA_RSTATUS) & HA_SDRQ)
822: inw(base + HA_RDATA);
823: return (TRUE);
824: }
825: } else {
826: DBG(DBG_PROBE, printk("eata_dma: get_conf_PIO, error during transfer "
827: "for HBA at %lx\n", (long)base));
828: }
829: return (FALSE);
830: }
831:
832: void print_config(struct get_conf *gc)
833: {
834: printk("LEN: %d ver:%d OCS:%d TAR:%d TRNXFR:%d MORES:%d DMAS:%d\n",
835: (u32) ntohl(gc->len), gc->version,
836: gc->OCS_enabled, gc->TAR_support, gc->TRNXFR, gc->MORE_support,
837: gc->DMA_support);
838: printk("DMAV:%d HAAV:%d SCSIID0:%d ID1:%d ID2:%d QUEUE:%d SG:%d SEC:%d\n",
839: gc->DMA_valid, gc->HAA_valid, gc->scsi_id[3], gc->scsi_id[2],
840: gc->scsi_id[1], ntohs(gc->queuesiz), ntohs(gc->SGsiz), gc->SECOND);
841: printk("IRQ:%d IRQT:%d DMAC:%d FORCADR:%d SG_64K:%d SG_UAE:%d MID:%d "
842: "MCH:%d MLUN:%d\n",
843: gc->IRQ, gc->IRQ_TR, (8 - gc->DMA_channel) & 7, gc->FORCADR,
844: gc->SG_64K, gc->SG_UAE, gc->MAX_ID, gc->MAX_CHAN, gc->MAX_LUN);
845: printk("RIDQ:%d PCI:%d EISA:%d\n",
846: gc->ID_qest, gc->is_PCI, gc->is_EISA);
847: DBG(DPT_DEBUG, DELAY(14));
848: }
849:
850: short register_HBA(u32 base, struct get_conf *gc, Scsi_Host_Template * tpnt,
851: u8 bustype)
852: {
853: ulong size = 0;
854: unchar dma_channel = 0;
855: char *buff = 0;
856: unchar bugs = 0;
857: struct Scsi_Host *sh;
858: hostdata *hd;
859: int x;
860:
861:
862: DBG(DBG_REGISTER, print_config(gc));
863:
864: if (gc->DMA_support == FALSE) {
865: printk("The EATA HBA at %#.4x does not support DMA.\n"
866: "Please use the EATA-PIO driver.\n", base);
867: return (FALSE);
868: }
869: if(gc->HAA_valid == FALSE || ntohl(gc->len) < 0x22)
870: gc->MAX_CHAN = 0;
871:
872: if (reg_IRQ[gc->IRQ] == FALSE) { /* Interrupt already registered ? */
873: if (!request_irq(gc->IRQ, (void *) eata_fake_int_handler, SA_INTERRUPT,
874: "eata_dma")){
875: reg_IRQ[gc->IRQ]++;
876: if (!gc->IRQ_TR)
877: reg_IRQL[gc->IRQ] = TRUE; /* IRQ is edge triggered */
878: } else {
879: printk("Couldn't allocate IRQ %d, Sorry.", gc->IRQ);
880: return (FALSE);
881: }
882: } else { /* More than one HBA on this IRQ */
883: if (reg_IRQL[gc->IRQ] == TRUE) {
884: printk("Can't support more than one HBA on this IRQ,\n"
885: " if the IRQ is edge triggered. Sorry.\n");
886: return (FALSE);
887: } else
888: reg_IRQ[gc->IRQ]++;
889: }
890:
891: /* if gc->DMA_valid it must be an ISA HBA and we have to register it */
892: dma_channel = BUSMASTER;
893: if (gc->DMA_valid) {
894: if (request_dma(dma_channel = (8 - gc->DMA_channel) & 7, "eata_dma")) {
895: printk("Unable to allocate DMA channel %d for ISA HBA at %#.4x.\n",
896: dma_channel, base);
897: reg_IRQ[gc->IRQ]--;
898: if (reg_IRQ[gc->IRQ] == 0)
899: free_irq(gc->IRQ);
900: if (gc->IRQ_TR == FALSE)
901: reg_IRQL[gc->IRQ] = FALSE;
902: return (FALSE);
903: }
904: }
905:
906: #if !(NEWSTUFF)
907: if (bustype != IS_EISA && bustype != IS_ISA)
908: #endif
909: buff = get_board_data(base, gc->IRQ, gc->scsi_id[3]);
910:
911: if (buff == NULL) {
912: #if !(NEWSTUFF)
913: if (bustype == IS_EISA || bustype == IS_ISA) {
914: bugs = bugs || BROKEN_INQUIRY;
915: } else {
916: #endif
917: if (gc->DMA_support == FALSE)
918: printk("HBA at %#.4x doesn't support DMA. Sorry\n", base);
919: else
920: printk("HBA at %#.4x does not react on INQUIRY. Sorry.\n",
921: base);
922: if (gc->DMA_valid)
923: free_dma(dma_channel);
924: reg_IRQ[gc->IRQ]--;
925: if (reg_IRQ[gc->IRQ] == 0)
926: free_irq(gc->IRQ);
927: if (gc->IRQ_TR == FALSE)
928: reg_IRQL[gc->IRQ] = FALSE;
929: return (FALSE);
930: #if !(NEWSTUFF)
931: }
932: #endif
933: }
934:
935: if (gc->DMA_support == FALSE && buff != NULL)
936: printk("HBA %.12sat %#.4x doesn't set the DMA_support flag correctly.\n",
937: &buff[16], base);
938:
939: request_region(base, 9, "eata_dma"); /* We already checked the
940: * availability, so this
941: * should not fail.
942: */
943:
944: if(ntohs(gc->queuesiz) == 0) {
945: gc->queuesiz = ntohs(64);
946: printk("Warning: Queue size has to be corrected. Assuming 64 queueslots\n"
947: " This might be a PM2012B with a defective Firmware\n");
948: }
949:
950: size = sizeof(hostdata) + ((sizeof(struct eata_ccb) + sizeof(long))
951: * ntohs(gc->queuesiz));
952:
953: DBG(DBG_REGISTER, printk("scsi_register size: %ld\n", size));
954:
955: sh = scsi_register(tpnt, size);
956:
957: if(sh == NULL) {
958: if (gc->DMA_valid)
959: free_dma(dma_channel);
960:
961: reg_IRQ[gc->IRQ]--;
962: if (reg_IRQ[gc->IRQ] == 0)
963: free_irq(gc->IRQ);
964: if (gc->IRQ_TR == FALSE)
965: reg_IRQL[gc->IRQ] = FALSE;
966: return (FALSE);
967: }
968:
969: hd = SD(sh);
970:
971: memset(hd->ccb, 0, sizeof(struct eata_ccb) * ntohs(gc->queuesiz));
972: memset(hd->reads, 0, sizeof(u32) * 26);
973:
974: hd->broken_INQUIRY = (bugs & BROKEN_INQUIRY);
975:
976: if(hd->broken_INQUIRY == TRUE) {
977: strcpy(SD(sh)->vendor, "DPT");
978: strcpy(SD(sh)->name, "??????????");
979: strcpy(SD(sh)->revision, "???.?");
980: } else {
981: strncpy(SD(sh)->vendor, &buff[8], 8);
982: SD(sh)->vendor[8] = 0;
983: strncpy(SD(sh)->name, &buff[16], 17);
984: SD(sh)->name[17] = 0;
985: SD(sh)->revision[0] = buff[32];
986: SD(sh)->revision[1] = buff[33];
987: SD(sh)->revision[2] = buff[34];
988: SD(sh)->revision[3] = '.';
989: SD(sh)->revision[4] = buff[35];
990: SD(sh)->revision[5] = 0;
991: }
992:
993: switch (ntohl(gc->len)) {
994: case 0x1c:
995: SD(sh)->EATA_revision = 'a';
996: break;
997: case 0x1e:
998: SD(sh)->EATA_revision = 'b';
999: break;
1000: case 0x22:
1001: SD(sh)->EATA_revision = 'c';
1002: break;
1003: case 0x24:
1004: SD(sh)->EATA_revision = 'z';
1005: default:
1006: SD(sh)->EATA_revision = '?';
1007: }
1008:
1009: if(ntohl(gc->len) >= 0x22) {
1010: if (gc->is_PCI == TRUE)
1011: hd->bustype = IS_PCI;
1012: else if (gc->is_EISA == TRUE)
1013: hd->bustype = IS_EISA;
1014: else
1015: hd->bustype = IS_ISA;
1016: } else if(hd->broken_INQUIRY == FALSE) {
1017: if (buff[21] == '4')
1018: hd->bustype = IS_PCI;
1019: else if (buff[21] == '2')
1020: hd->bustype = IS_EISA;
1021: else
1022: hd->bustype = IS_ISA;
1023: } else
1024: hd->bustype = bustype;
1025:
1026: if(ntohl(gc->len) >= 0x22) {
1027: sh->max_id = gc->MAX_ID + 1;
1028: sh->max_lun = gc->MAX_LUN + 1;
1029: } else {
1030: sh->max_id = 8;
1031: sh->max_lun = 8;
1032: }
1033:
1034: hd->channel = gc->MAX_CHAN;
1035: sh->max_channel = gc->MAX_CHAN;
1036: sh->unique_id = base;
1037: sh->base = (char *) base;
1038: sh->io_port = base;
1039: sh->n_io_port = 9;
1040: sh->irq = gc->IRQ;
1041: sh->dma_channel = dma_channel;
1042:
1043: /* FIXME:
1044: * SCSI midlevel code should support different HBA ids on every channel
1045: */
1046: sh->this_id = gc->scsi_id[3];
1047: sh->can_queue = ntohs(gc->queuesiz);
1048:
1049: if (gc->OCS_enabled == TRUE) {
1050: if(hd->bustype != IS_ISA)
1051: sh->cmd_per_lun = sh->can_queue/C_P_L_DIV;
1052: else
1053: sh->cmd_per_lun = 8; /* We artificially limit this to conserve
1054: * memory, which would be needed for ISA
1055: * bounce buffers */
1056: } else
1057: sh->cmd_per_lun = 1;
1058:
1059: /* FIXME:
1060: * SG should be allocated more dynamically
1061: */
1062: /*
1063: * If we are using a ISA board, we can't use extended SG,
1064: * because we would need exessive amounts of memory for
1065: * bounce buffers.
1066: */
1067: if (gc->SG_64K == TRUE && ntohs(gc->SGsiz) == 64 && hd->bustype != IS_ISA){
1068: sh->sg_tablesize = SG_SIZE_BIG;
1069: sh->use_clustering = FALSE;
1070: } else {
1071: sh->sg_tablesize = ntohs(gc->SGsiz);
1072: sh->use_clustering = TRUE;
1073: if (sh->sg_tablesize > SG_SIZE || sh->sg_tablesize == 0) {
1074: sh->sg_tablesize = SG_SIZE;
1075: if (ntohs(gc->SGsiz) == 0)
1076: printk("Warning: SG size had to be corrected.\n"
1077: "This might be a PM2012 with a defective Firmware\n");
1078: }
1079: }
1080:
1081: if (gc->SECOND)
1082: hd->primary = FALSE;
1083: else
1084: hd->primary = TRUE;
1085:
1086: sh->wish_block = FALSE;
1087:
1088: if (hd->bustype != IS_ISA) {
1089: sh->unchecked_isa_dma = FALSE;
1090: } else {
1091: sh->unchecked_isa_dma = TRUE; /* We're doing ISA DMA */
1092: }
1093:
1094: for(x = 0; x <= 11; x++){ /* Initialize min. latency */
1095: hd->writes_lat[x][1] = 0xffffffff;
1096: hd->reads_lat[x][1] = 0xffffffff;
1097: }
1098:
1099: hd->next = NULL; /* build a linked list of all HBAs */
1100: hd->prev = last_HBA;
1101: if(hd->prev != NULL)
1102: SD(hd->prev)->next = sh;
1103: last_HBA = sh;
1104: if (first_HBA == NULL)
1105: first_HBA = sh;
1106: registered_HBAs++;
1107:
1108: return (TRUE);
1109: }
1110:
1111:
1112: void find_EISA(struct get_conf *buf, Scsi_Host_Template * tpnt)
1113: {
1114: u32 base;
1115: int i;
1116:
1117: #if CHECKPAL
1118: u8 pal1, pal2, pal3;
1119: #endif
1120:
1121: for (i = 0; i < MAXEISA; i++) {
1122: if (EISAbases[i] == TRUE) { /* Still a possibility ? */
1123:
1124: base = 0x1c88 + (i * 0x1000);
1125: #if CHECKPAL
1126: pal1 = inb((u16)base - 8);
1127: pal2 = inb((u16)base - 7);
1128: pal3 = inb((u16)base - 6);
1129:
1130: if (((pal1 == DPT_ID1) && (pal2 == DPT_ID2)) ||
1131: ((pal1 == NEC_ID1) && (pal2 == NEC_ID2) && (pal3 == NEC_ID3))||
1132: ((pal1 == ATT_ID1) && (pal2 == ATT_ID2) && (pal3 == ATT_ID3))){
1133: DBG(DBG_PROBE, printk("EISA EATA id tags found: %x %x %x \n",
1134: (int)pal1, (int)pal2, (int)pal3));
1135: #endif
1136: if (get_conf_PIO(base, buf) == TRUE) {
1137: if (buf->IRQ) {
1138: DBG(DBG_EISA, printk("Registering EISA HBA\n"));
1139: register_HBA(base, buf, tpnt, IS_EISA);
1140: } else
1141: printk("eata_dma: No valid IRQ. HBA removed from list\n");
1142: } else {
1143: if (check_blink_state(base))
1144: printk("HBA is in BLINK state. Consult your HBAs "
1145: "Manual to correct this.\n");
1146: }
1147: /* Nothing found here so we take it from the list */
1148: EISAbases[i] = 0;
1149: #if CHECKPAL
1150: }
1151: #endif
1152: }
1153: }
1154: return;
1155: }
1156:
1157: void find_ISA(struct get_conf *buf, Scsi_Host_Template * tpnt)
1158: {
1159: int i;
1160:
1161: for (i = 0; i < MAXISA; i++) {
1162: if (ISAbases[i]) {
1163: if (get_conf_PIO(ISAbases[i],buf) == TRUE){
1164: DBG(DBG_ISA, printk("Registering ISA HBA\n"));
1165: register_HBA(ISAbases[i], buf, tpnt, IS_ISA);
1166: } else {
1167: if (check_blink_state(ISAbases[i]))
1168: printk("HBA is in BLINK state. Consult your HBAs "
1169: "Manual to correct this.\n");
1170: }
1171: ISAbases[i] = 0;
1172: }
1173: }
1174: return;
1175: }
1176:
1177: void find_PCI(struct get_conf *buf, Scsi_Host_Template * tpnt)
1178: {
1179:
1180: #ifndef CONFIG_PCI
1181: printk("eata_dma: kernel PCI support not enabled. Skipping scan for PCI HBAs.\n");
1182: #else
1183:
1184: u8 pci_bus, pci_device_fn;
1185: static s16 pci_index = 0; /* Device index to PCI BIOS calls */
1186: u32 base = 0;
1187: u16 com_adr;
1188: u16 rev_device;
1189: u32 error, i, x;
1190: u8 pal1, pal2, pal3;
1191:
1192: if (pcibios_present()) {
1193: for (i = 0; i <= MAXPCI; ++i, ++pci_index) {
1194: if (pcibios_find_device(PCI_VENDOR_ID_DPT, PCI_DEVICE_ID_DPT,
1195: pci_index, &pci_bus, &pci_device_fn))
1196: break;
1197: DBG(DBG_PROBE && DBG_PCI,
1198: printk("eata_dma: find_PCI, HBA at bus %d, device %d,"
1199: " function %d, index %d\n", (s32)pci_bus,
1200: (s32)((pci_device_fn & 0xf8) >> 3),
1201: (s32)(pci_device_fn & 7), pci_index));
1202:
1203: if (!(error = pcibios_read_config_word(pci_bus, pci_device_fn,
1204: PCI_CLASS_DEVICE, &rev_device))) {
1205: if (rev_device == PCI_CLASS_STORAGE_SCSI) {
1206: if (!(error = pcibios_read_config_word(pci_bus,
1207: pci_device_fn, PCI_COMMAND,
1208: (u16 *) & com_adr))) {
1209: if (!((com_adr & PCI_COMMAND_IO) &&
1210: (com_adr & PCI_COMMAND_MASTER))) {
1211: printk("eata_dma: find_PCI, HBA has IO or BUSMASTER mode disabled\n");
1212: continue;
1213: }
1214: } else
1215: printk("eata_dma: find_PCI, error %x while reading "
1216: "PCI_COMMAND\n", error);
1217: } else
1218: printk("eata_dma: find_PCI, DEVICECLASSID %x didn't match\n",
1219: rev_device);
1220: } else {
1221: printk("eata_dma: find_PCI, error %x while reading PCI_CLASS_BASE\n",
1222: error);
1223: continue;
1224: }
1225:
1226: if (!(error = pcibios_read_config_dword(pci_bus, pci_device_fn,
1227: PCI_BASE_ADDRESS_0, (int *) &base))){
1228:
1229: /* Check if the address is valid */
1230: if (base & 0x01) {
1231: base &= 0xfffffffe;
1232: /* EISA tag there ? */
1233: pal1 = inb(base);
1234: pal2 = inb(base + 1);
1235: pal3 = inb(base + 2);
1236: if (((pal1 == DPT_ID1) && (pal2 == DPT_ID2)) ||
1237: ((pal1 == NEC_ID1) && (pal2 == NEC_ID2) &&
1238: (pal3 == NEC_ID3)) ||
1239: ((pal1 == ATT_ID1) && (pal2 == ATT_ID2) &&
1240: (pal3 == ATT_ID3)))
1241: base += 0x08;
1242: else
1243: base += 0x10; /* Now, THIS is the real address */
1244:
1245: if (base != 0x1f8) {
1246: /* We didn't find it in the primary search */
1247: if (get_conf_PIO(base, buf) == TRUE) {
1248:
1249: /* OK. We made it till here, so we can go now
1250: * and register it. We only have to check and
1251: * eventually remove it from the EISA and ISA list
1252: */
1253: DBG(DBG_PCI, printk("Registering PCI HBA\n"));
1254: register_HBA(base, buf, tpnt, IS_PCI);
1255:
1256: if (base < 0x1000) {
1257: for (x = 0; x < MAXISA; ++x) {
1258: if (ISAbases[x] == base) {
1259: ISAbases[x] = 0;
1260: break;
1261: }
1262: }
1263: } else if ((base & 0x0fff) == 0x0c88)
1264: EISAbases[(base >> 12) & 0x0f] = 0;
1265: continue; /* break; */
1266: } else if (check_blink_state(base) == TRUE) {
1267: printk("eata_dma: HBA is in BLINK state.\n"
1268: "Consult your HBAs Manual to correct this.\n");
1269: }
1270: }
1271: }
1272: } else {
1273: printk("eata_dma: error %x while reading "
1274: "PCI_BASE_ADDRESS_0\n", error);
1275: }
1276: }
1277: } else {
1278: printk("eata_dma: No BIOS32 extensions present. This driver release "
1279: "still depends on it.\n"
1280: " Skipping scan for PCI HBAs. \n");
1281: }
1282: #endif /* #ifndef CONFIG_PCI */
1283: return;
1284: }
1285:
1286: int eata_detect(Scsi_Host_Template * tpnt)
1287: {
1288: struct Scsi_Host *HBA_ptr;
1289: struct get_conf gc;
1290: int i;
1291:
1292: DBG((DBG_PROBE && DBG_DELAY) || DPT_DEBUG,
1293: printk("Using lots of delays to let you read the debugging output\n"));
1294:
1295: tpnt->proc_dir = &proc_scsi_eata_dma;
1296:
1297: status = scsi_init_malloc(512, GFP_ATOMIC | GFP_DMA);
1298: dma_scratch = scsi_init_malloc(512, GFP_ATOMIC | GFP_DMA);
1299:
1300: if(status == NULL || dma_scratch == NULL) {
1301: printk("eata_dma: can't allocate enough memory to probe for hosts !\n");
1302: return(0);
1303: }
1304:
1305: find_PCI(&gc, tpnt);
1306:
1307: find_EISA(&gc, tpnt);
1308:
1309: find_ISA(&gc, tpnt);
1310:
1311: for (i = 0; i <= MAXIRQ; i++) { /* Now that we know what we have, we */
1312: if (reg_IRQ[i]){ /* exchange the interrupt handler which */
1313: free_irq(i); /* we used for probing with the real one */
1314: request_irq(i, (void *)(eata_int_handler), SA_INTERRUPT, "eata_dma");
1315: }
1316: }
1317: HBA_ptr = first_HBA;
1318:
1319: if (registered_HBAs != 0) {
1320: printk("EATA (Extended Attachment) driver version: %d.%d%s\n"
1321: "developed in co-operation with DPT\n"
1322: "(c) 1993-95 Michael Neuffer, [email protected]\n",
1323: VER_MAJOR, VER_MINOR, VER_SUB);
1324: printk("Registered HBAs:");
1325: printk("\nHBA no. Boardtype: Revis: EATA: Bus: BaseIO: IRQ: DMA: Ch: "
1326: "ID: Pr: QS: SG: CPL:\n");
1327: for (i = 1; i <= registered_HBAs; i++) {
1328: printk("scsi%-2d: %.10s v%s 2.0%c %s %#.4x %2d",
1329: HBA_ptr->host_no, SD(HBA_ptr)->name, SD(HBA_ptr)->revision,
1330: SD(HBA_ptr)->EATA_revision, (SD(HBA_ptr)->bustype == 'P')?
1331: "PCI ":(SD(HBA_ptr)->bustype == 'E')?"EISA":"ISA ",
1332: (u32) HBA_ptr->base, HBA_ptr->irq);
1333: if(HBA_ptr->dma_channel != BUSMASTER)
1334: printk(" %2x ", HBA_ptr->dma_channel);
1335: else
1336: printk(" %s", "BMST");
1337: printk(" %d %d %c %2d %2d %2d\n", SD(HBA_ptr)->channel,
1338: HBA_ptr->this_id, (SD(HBA_ptr)->primary == TRUE)?'Y':'N',
1339: HBA_ptr->can_queue, HBA_ptr->sg_tablesize, HBA_ptr->cmd_per_lun);
1340: HBA_ptr = SD(HBA_ptr)->next;
1341: }
1342: } else {
1343: scsi_init_free((void *)status, 512);
1344: }
1345:
1346: scsi_init_free((void *)dma_scratch, 512);
1347:
1348: DBG(DPT_DEBUG, DELAY(12));
1349:
1350: return(registered_HBAs);
1351: }
1352:
1353: #ifdef MODULE
1354: /* Eventually this will go into an include file, but this will be later */
1355: Scsi_Host_Template driver_template = EATA_DMA;
1356: #include "scsi_module.c"
1357: #endif
1358:
1359: /*
1360: * Overrides for Emacs so that we almost follow Linus's tabbing style.
1361: * Emacs will notice this stuff at the end of the file and automatically
1362: * adjust the settings for this buffer only. This must remain at the end
1363: * of the file.
1364: * ---------------------------------------------------------------------------
1365: * Local variables:
1366: * c-indent-level: 4
1367: * c-brace-imaginary-offset: 0
1368: * c-brace-offset: -4
1369: * c-argdecl-indent: 4
1370: * c-label-offset: -4
1371: * c-continued-statement-offset: 4
1372: * c-continued-brace-offset: 0
1373: * tab-width: 8
1374: * End:
1375: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.