![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to seagate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / kernel / blk_drv / scsi|
Return to seagate.c CVS log | Up to [Early Linux] / linux / kernel / blk_drv / scsi |
1.1 root 1: /*
2: * seagate.c Copyright (C) 1992 Drew Eckhardt
3: * low level scsi driver for ST01/ST02 by
4: * Drew Eckhardt
5: *
6: * <[email protected]>
7: */
8:
9: #include <linux/config.h>
10:
11: #ifdef CONFIG_SCSI_SEAGATE
12: #include <linux/sched.h>
13:
14: #include "seagate.h"
15: #include "scsi.h"
16: #include "hosts.h"
17:
18: static int incommand; /*
19: set if arbitration has finished and we are
20: in some command phase.
21: */
22:
23: static void *base_address = NULL; /*
24: Where the card ROM starts,
25: used to calculate memory mapped
26: register location.
27: */
28: static volatile int abort_confirm = 0;
29:
30: volatile void *st0x_cr_sr; /*
31: control register write,
32: status register read.
33: 256 bytes in length.
34:
35: Read is status of SCSI BUS,
36: as per STAT masks.
37:
38: */
39:
40:
41: static volatile void *st0x_dr; /*
42: data register, read write
43: 256 bytes in length.
44: */
45:
46:
47: static volatile int st0x_aborted=0; /*
48: set when we are aborted, ie by a time out, etc.
49: */
50:
51: /*
52: In theory, we have a nice auto
53: detect routine - but this
54: overides it.
55: */
56:
57:
58: #define retcode(result) (((result) << 16) | (message << 8) | status)
59: #define STATUS (*(unsigned char *) st0x_cr_sr)
60: #define CONTROL STATUS
61: #define DATA (*(unsigned char *) st0x_dr)
62:
63: #ifndef OVERRIDE
64: static const char * seagate_bases[] = {(char *) 0xc8000, (char *) 0xca000, (char *) 0xcc000, (char *) 0xce000, (char *) 0xce000,
65: (char *) 0xdc000, (char *) 0xde000};
66: typedef struct
67: {
68: char *signature ;
69: unsigned offset;
70: unsigned length;
71: } Signature;
72:
73: static const Signature signatures[] = {
74: {"SCSI BIOS 2.00 (C) Copyright 1987 Seagate", 15, 40},
75: {"SEAGATE SCSI BIOS ",16, 17},
76: {"SEAGATE SCSI BIOS ",17, 17}};
77: /*
78: Note that the last signature handles BIOS revisions 3.0.0 and
79: 3.2 - the real ID's are
80:
81: SEAGATE SCSI BIOS REVISION 3.0.0
82: SEAGATE SCSI BIOS REVISION 3.2
83:
84: */
85:
86: #define NUM_SIGNATURES (sizeof(signatures) / sizeof(Signature))
87: #endif
88:
89: int seagate_st0x_detect (int hostnum)
90: {
91: #ifndef OVERRIDE
92: int i,j;
93: #endif
94:
95: /*
96: First, we try for the manual override.
97: */
98: #ifdef DEBUG
99: printk("Autodetecting seagate ST0x\n");
100: #endif
101:
102: base_address = NULL;
103: #ifdef OVERRIDE
104: base_address = (void *) OVERRIDE;
105: #ifdef DEBUG
106: printk("Base address overridden to %x\n", base_address);
107: #endif
108: #else
109: /*
110: To detect this card, we simply look for the SEAGATE SCSI
111: from the BIOS version notice in all the possible locations
112: of the ROM's.
113: */
114:
115: for (i = 0; i < (sizeof (seagate_bases) / sizeof (char * )); ++i)
116: for (j = 0; !base_address && j < NUM_SIGNATURES; ++j)
117: if (!memcmp ((void *) (seagate_bases[i] +
118: signatures[j].offset), (void *) signatures[j].signature,
119: signatures[j].length))
120: base_address = (void *) seagate_bases[i];
121: #endif
122:
123: if (base_address)
124: {
125: st0x_cr_sr =(void *) (((unsigned char *) base_address) + 0x1a00);
126: st0x_dr = (void *) (((unsigned char *) base_address )+ 0x1c00);
127: #ifdef DEBUG
128: printk("ST0x detected. Base address = %x, cr = %x, dr = %x\n", base_address, st0x_cr_sr, st0x_dr);
129: #endif
130: return -1;
131: }
132: else
133: {
134: #ifdef DEBUG
135: printk("ST0x not detected.\n");
136: #endif
137: return 0;
138: }
139: }
140:
141:
142:
143: char *seagate_st0x_info(void)
144: {
145: static char buffer[] = "Seagate ST-0X SCSI driver by Drew Eckhardt \n"
146: "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/seagate.c,v 1.1 1992/04/24 18:01:50 root Exp root $\n";
147: return buffer;
148: }
149:
150:
151:
152: int seagate_st0x_command(unsigned char target, const void *cmnd,
153: void *buff, int bufflen)
154: {
155: int len;
156: unsigned char *data;
157:
158: int clock; /*
159: We use clock for timeouts, etc. This replaces the
160: seagate_st0x_timeout that we had been using.
161: */
162: #if (DEBUG & PHASE_SELECTION)
163: int temp;
164: #endif
165:
166: #if (DEBUG & PHASE_EXIT)
167: void *retaddr, *realretaddr;
168: #endif
169:
170: #if ((DEBUG & PHASE_ETC) || (DEBUG & PRINT_COMMAND) || (DEBUG & PHASE_EXIT))
171: int i;
172: #endif
173:
174: #if (DEBUG & PHASE_ETC)
175: int phase=0, newphase;
176: #endif
177:
178: int done = 0;
179: unsigned char status = 0;
180: unsigned char message = 0;
181: register unsigned char status_read;
182:
183: #if (DEBUG & PHASE_EXIT)
184: __asm__("
185: movl 4(%%ebp), %%eax
186: ":"=a" (realretaddr):);
187: printk("return address = %08x\n", realretaddr);
188: #endif
189:
190:
191: len=bufflen;
192: data=(unsigned char *) buff;
193:
194: incommand = 0;
195: st0x_aborted = 0;
196:
197: #if (DEBUG & PRINT_COMMAND)
198: printk ("seagate_st0x_command, target = %d, command = ", target);
199: for (i = 0; i < COMMAND_SIZE(((unsigned char *)cmnd)[0]); ++i)
200: printk("%02x ", ((unsigned char *) cmnd)[i]);
201: printk("\n");
202: #endif
203:
204: if (target > 6)
205: return DID_BAD_TARGET;
206:
207:
208: #if (DEBUG & PHASE_BUS_FREE)
209: printk ("SCSI PHASE = BUS FREE \n");
210: #endif
211:
212: /*
213:
214: BUS FREE PHASE
215:
216: On entry, we make sure that the BUS is in a BUS FREE
217: phase, by insuring that both BSY and SEL are low for
218: at least one bus settle delay. The standard requires a
219: minimum of 400 ns, which is 16 clock cycles on a
220: 386-40 .
221:
222: This doesn't give us much time - so we'll do two several
223: reads to be sure be sure.
224: */
225:
226: clock = jiffies + ST0X_BUS_FREE_DELAY;
227:
228: while (((STATUS | STATUS | STATUS) &
229: (STAT_BSY | STAT_SEL)) &&
230: (!st0x_aborted) && (jiffies < clock));
231:
232: if (jiffies > clock)
233: return retcode(DID_BUS_BUSY);
234: else if (st0x_aborted)
235: return retcode(st0x_aborted);
236:
237: /*
238: Bus free has been detected, within BUS settle. I used to support an arbitration
239: phase - however, on the seagate, this degraded performance by a factor > 10 - so
240: it is no more.
241: */
242:
243: /*
244: SELECTION PHASE
245:
246: Now, we select the disk, giving it the SCSI ID at data
247: and a command of PARITY if necessary, plus driver enable,
248: plus raise select signal.
249: */
250:
251: #if (DEBUG & PHASE_SELECTION)
252: printk("SCSI PHASE = SELECTION\n");
253: #endif
254:
255: clock = jiffies + ST0X_SELECTION_DELAY;
256: DATA = (unsigned char) (1 << target);
257:
258: CONTROL = BASE_CMD | CMD_DRVR_ENABLE | CMD_SEL;
259:
260: /*
261: When the SCSI device decides that we're gawking at it, it will respond by asserting BUSY on the bus.
262: */
263: while (!((status_read = STATUS) & STAT_BSY) && (jiffies < clock) && !st0x_aborted)
264:
265: #if (DEBUG & PHASE_SELECTION)
266: {
267: temp = clock - jiffies;
268:
269: if (!(jiffies % 5))
270: printk("seagate_st0x_timeout : %d \r",temp);
271:
272: }
273: printk("Done. \n\r");
274: printk("Status = %02x, seagate_st0x_timeout = %d, aborted = %02x \n", status_read, temp,
275: st0x_aborted);
276: #else
277: ;
278: #endif
279:
280:
281: if ((jiffies > clock) || (!st0x_aborted & !(status_read & STAT_BSY)))
282: {
283: #if (DEBUG & PHASE_SELECT)
284: printk ("NO CONNECT with target %d, status = %x \n", target, STATUS);
285: #endif
286: return retcode(DID_NO_CONNECT);
287: }
288:
289: /*
290: If we have been aborted, and we have a command in progress, IE the target still has
291: BSY asserted, then we will reset the bus, and notify the midlevel driver to
292: expect sense.
293: */
294:
295: if (st0x_aborted)
296: {
297: CONTROL = BASE_CMD;
298: if (STATUS & STAT_BSY)
299: {
300: seagate_st0x_reset();
301: return retcode(DID_RESET);
302: }
303:
304: return retcode(st0x_aborted);
305: }
306:
307: /*
308: COMMAND PHASE
309: The device has responded with a BSY, so we may now enter
310: the information transfer phase, where we will send / recieve
311: data and command as directed by the target.
312:
313:
314: The nasty looking read / write inline assembler loops we use for
315: DATAIN and DATAOUT phases are approximately 4-5 times as fast as
316: the 'C' versions - since we're moving 1024 bytes of data, this
317: really adds up.
318: */
319:
320: #if (DEBUG & PHASE_ETC)
321: printk("PHASE = information transfer\n");
322: #endif
323:
324: incommand = 1;
325:
326: /*
327: Enable command
328: */
329:
330: CONTROL = BASE_CMD | CMD_DRVR_ENABLE;
331:
332: /*
333: Now, we poll the device for status information,
334: and handle any requests it makes. Note that since we are unsure of
335: how much data will be flowing across the system, etc and cannot
336: make reasonable timeouts, that we will instead have the midlevel
337: driver handle any timeouts that occur in this phase.
338: */
339:
340: while (((status_read = STATUS) & STAT_BSY) && !st0x_aborted && !done)
341: {
342: #ifdef PARITY
343: if (status_read & STAT_PARITY)
344: {
345: done = 1;
346: st0x_aborted = DID_PARITY;
347: }
348: #endif
349:
350: if (status_read & STAT_REQ)
351: {
352: #if (DEBUG & PHASE_ETC)
353: if ((newphase = (status_read & REQ_MASK)) != phase)
354: {
355: phase = newphase;
356: switch (phase)
357: {
358: case REQ_DATAOUT : printk("SCSI PHASE = DATA OUT\n"); break;
359: case REQ_DATAIN : printk("SCSI PHASE = DATA IN\n"); break;
360: case REQ_CMDOUT : printk("SCSI PHASE = COMMAND OUT\n"); break;
361: case REQ_STATIN : printk("SCSI PHASE = STATUS IN\n"); break;
362: case REQ_MSGOUT : printk("SCSI PHASE = MESSAGE OUT\n"); break;
363: case REQ_MSGIN : printk("SCSI PHASE = MESSAGE IN\n"); break;
364: default : printk("UNKNOWN PHASE"); st0x_aborted = 1; done = 1;
365: }
366: }
367: #endif
368:
369: switch (status_read & REQ_MASK)
370: {
371: case REQ_DATAOUT :
372:
373: /*
374: We loop as long as we are in a data out phase, there is data to send, and BSY is still
375: active
376: */
377: __asm__ ("
378:
379: /*
380: Local variables :
381: len = ecx
382: data = esi
383: st0x_cr_sr = ebx
384: st0x_dr = edi
385:
386: Test for any data here at all.
387: */
388: movl %0, %%esi /* local value of data */
389: movl %1, %%ecx /* local value of len */
390: orl %%ecx, %%ecx
391: jz 2f
392:
393: cld
394:
395: movl _st0x_cr_sr, %%ebx
396: movl _st0x_dr, %%edi
397:
398: 1: movb (%%ebx), %%al
399: /*
400: Test for BSY
401: */
402:
403: test $1, %%al
404: jz 2f
405:
406: /*
407: Test for data out phase - STATUS & REQ_MASK should be REQ_DATAOUT, which is 0.
408: */
409: test $0xe, %%al
410: jnz 2f
411: /*
412: Test for REQ
413: */
414: test $0x10, %%al
415: jz 1b
416: lodsb
417: movb %%al, (%%edi)
418: loop 1b
419:
420: 2:
421: movl %%esi, %2
422: movl %%ecx, %3
423: ":
424: /* output */
425: "=r" (data), "=r" (len) :
426: /* input */
427: "0" (data), "1" (len) :
428: /* clobbered */
429: "ebx", "ecx", "edi", "esi");
430:
431: break;
432:
433: case REQ_DATAIN :
434: /*
435: We loop as long as we are in a data out phase, there is room to read, and BSY is still
436: active
437: */
438:
439: __asm__ ("
440: /*
441: Local variables :
442: ecx = len
443: edi = data
444: esi = st0x_cr_sr
445: ebx = st0x_dr
446:
447: Test for room to read
448: */
449:
450: movl %0, %%edi /* data */
451: movl %1, %%ecx /* len */
452: orl %%ecx, %%ecx
453: jz 2f
454:
455: cld
456: movl _st0x_cr_sr, %%esi
457: movl _st0x_dr, %%ebx
458:
459: 1: movb (%%esi), %%al
460: /*
461: Test for BSY
462: */
463:
464: test $1, %%al
465: jz 2f
466:
467: /*
468: Test for data in phase - STATUS & REQ_MASK should be REQ_DATAIN, = STAT_IO, which is 4.
469: */
470: movb $0xe, %%ah
471: andb %%al, %%ah
472: cmpb $0x04, %%ah
473: jne 2f
474:
475: /*
476: Test for REQ
477: */
478: test $0x10, %%al
479: jz 1b
480:
481: movb (%%ebx), %%al
482: stosb
483: loop 1b
484:
485: 2: movl %%edi, %2 /* data */
486: movl %%ecx, %3 /* len */
487: ":
488: /* output */
489: "=r" (data), "=r" (len) :
490: /* input */
491: "0" (data), "1" (len) :
492: /* clobbered */
493: "ebx", "ecx", "edi", "esi");
494: break;
495:
496: case REQ_CMDOUT :
497: while (((status_read = STATUS) & STAT_BSY) && ((status_read & REQ_MASK) ==
498: REQ_CMDOUT))
499: DATA = *(unsigned char *) cmnd ++;
500: break;
501:
502: case REQ_STATIN :
503: status = DATA;
504: break;
505:
506: case REQ_MSGOUT :
507: DATA = MESSAGE_REJECT;
508: break;
509:
510: case REQ_MSGIN :
511: if ((message = DATA) == COMMAND_COMPLETE)
512: done=1;
513:
514: break;
515:
516: default : printk("UNKNOWN PHASE"); st0x_aborted = DID_ERROR;
517: }
518: }
519:
520: }
521:
522: #if (DEBUG & (PHASE_DATAIN | PHASE_DATAOUT | PHASE_EXIT))
523: printk("Transfered %d bytes, allowed %d additional bytes\n", (bufflen - len), len);
524: #endif
525:
526: #if (DEBUG & PHASE_EXIT)
527: printk("Buffer : \n");
528: for (i = 0; i < 20; ++i)
529: printk ("%02x ", ((unsigned char *) buff)[i]);
530: printk("\n");
531: printk("Status = %02x, message = %02x\n", status, message);
532: #endif
533:
534:
535: if (st0x_aborted)
536: {
537: if (STATUS & STAT_BSY)
538: {
539: seagate_st0x_reset();
540: st0x_aborted = DID_RESET;
541: }
542: abort_confirm = 1;
543: }
544:
545: CONTROL = BASE_CMD;
546:
547: #if (DEBUG & PHASE_EXIT)
548: __asm__("
549: mov 4(%%ebp), %%eax
550: ":"=a" (retaddr):);
551:
552: printk("Exiting seagate_st0x_command() - return address is %08x \n", retaddr);
553: if (retaddr != realretaddr)
554: panic ("Corrupted stack : return address on entry != return address on exit.\n");
555:
556: #endif
557:
558: return retcode (st0x_aborted);
559: }
560:
561: int seagate_st0x_abort (int code)
562: {
563: if (code)
564: st0x_aborted = code;
565: else
566: st0x_aborted = DID_ABORT;
567:
568: return 0;
569: }
570:
571: /*
572: the seagate_st0x_reset function resets the SCSI bus
573: */
574:
575: int seagate_st0x_reset (void)
576: {
577: unsigned clock;
578: /*
579: No timeouts - this command is going to fail because
580: it was reset.
581: */
582:
583: #ifdef DEBUG
584: printk("In seagate_st0x_reset()\n");
585: #endif
586:
587:
588: /* assert RESET signal on SCSI bus. */
589:
590: CONTROL = BASE_CMD | CMD_RST;
591: clock=jiffies+2;
592:
593:
594: /* Wait. */
595:
596: while (jiffies < clock);
597:
598: CONTROL = BASE_CMD;
599:
600: st0x_aborted = DID_RESET;
601:
602: #ifdef DEBUG
603: printk("SCSI bus reset.\n");
604: #endif
605: return 0;
606: }
607: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.