![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_NCR5380.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 g_NCR5380.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /*
2: * Generic Generic NCR5380 driver
3: *
4: * Copyright 1993, Drew Eckhardt
5: * Visionary Computing
6: * (Unix and Linux consulting and custom programming)
7: * [email protected]
8: * +1 (303) 440-4894
9: *
10: * NCR53C400 extensions (c) 1994,1995,1996, Kevin Lentin
11: * [email protected]
12: *
13: * ALPHA RELEASE 1.
14: *
15: * For more information, please consult
16: *
17: * NCR 5380 Family
18: * SCSI Protocol Controller
19: * Databook
20: *
21: * NCR Microelectronics
22: * 1635 Aeroplaza Drive
23: * Colorado Springs, CO 80916
24: * 1+ (719) 578-3400
25: * 1+ (800) 334-5454
26: */
27:
28: /*
29: * TODO : flesh out DMA support, find some one actually using this (I have
30: * a memory mapped Trantor board that works fine)
31: */
32:
33: /*
34: * Options :
35: *
36: * PARITY - enable parity checking. Not supported.
37: *
38: * SCSI2 - enable support for SCSI-II tagged queueing. Untested.
39: *
40: * USLEEP - enable support for devices that don't disconnect. Untested.
41: *
42: * The card is detected and initialized in one of several ways :
43: * 1. With command line overrides - NCR5380=port,irq may be
44: * used on the LILO command line to override the defaults.
45: *
46: * 2. With the GENERIC_NCR5380_OVERRIDE compile time define. This is
47: * specified as an array of address, irq, dma, board tuples. Ie, for
48: * one board at 0x350, IRQ5, no dma, I could say
49: * -DGENERIC_NCR5380_OVERRIDE={{0xcc000, 5, DMA_NONE, BOARD_NCR5380}}
50: *
51: * -1 should be specified for no or DMA interrupt, -2 to autoprobe for an
52: * IRQ line if overridden on the command line.
53: */
54:
55: /*
56: * $Log: g_NCR5380.c,v $
57: * Revision 1.1.1.1 1997/02/25 21:27:49 thomas
58: * Initial source
59: *
60: * Revision 1.1.1.1 1996/10/30 01:40:05 thomas
61: * Imported from UK22
62: *
63: * Revision 1.1 1996/03/25 20:25:35 goel
64: * Linux driver merge.
65: *
66: */
67:
68: #define AUTOPROBE_IRQ
69: #define AUTOSENSE
70:
71: #include <linux/config.h>
72:
73: #ifdef MACH
74: #define CONFIG_SCSI_G_NCR5380_MEM
75: #endif
76:
77: #ifdef CONFIG_SCSI_GENERIC_NCR53C400
78: #define NCR53C400_PSEUDO_DMA 1
79: #define PSEUDO_DMA
80: #define NCR53C400
81: #endif
82: #if defined(CONFIG_SCSI_G_NCR5380_PORT) && defined(CONFIG_SCSI_G_NCR5380_MEM)
83: #error You can not configure the Generic NCR 5380 SCSI Driver for memory mapped I/O and port mapped I/O at the same time (yet)
84: #endif
85: #if !defined(CONFIG_SCSI_G_NCR5380_PORT) && !defined(CONFIG_SCSI_G_NCR5380_MEM)
86: #error You must configure the Generic NCR 5380 SCSI Driver for one of memory mapped I/O and port mapped I/O.
87: #endif
88:
89: #include <asm/system.h>
90: #include <asm/io.h>
91: #include <linux/signal.h>
92: #include <linux/sched.h>
93: #include <linux/blk.h>
94: #include "scsi.h"
95: #include "hosts.h"
96: #include "g_NCR5380.h"
97: #include "NCR5380.h"
98: #include "constants.h"
99: #include "sd.h"
100: #include<linux/stat.h>
101:
102: struct proc_dir_entry proc_scsi_g_ncr5380 = {
103: PROC_SCSI_GENERIC_NCR5380, 9, "g_NCR5380",
104: S_IFDIR | S_IRUGO | S_IXUGO, 2
105: };
106:
107: static struct override {
108: NCR5380_implementation_fields;
109: int irq;
110: int dma;
111: int board; /* Use NCR53c400, Ricoh, etc. extensions ? */
112: } overrides
113: #ifdef GENERIC_NCR5380_OVERRIDE
114: [] = GENERIC_NCR5380_OVERRIDE
115: #else
116: [1] = {{0,},};
117: #endif
118:
119: #define NO_OVERRIDES (sizeof(overrides) / sizeof(struct override))
120:
121: /*
122: * Function : static internal_setup(int board, char *str, int *ints)
123: *
124: * Purpose : LILO command line initialization of the overrides array,
125: *
126: * Inputs : board - either BOARD_NCR5380 for a normal NCR5380 board,
127: * or BOARD_NCR53C400 for a NCR53C400 board. str - unused, ints -
128: * array of integer parameters with ints[0] equal to the number of ints.
129: *
130: */
131:
132: static void internal_setup(int board, char *str, int *ints) {
133: static int commandline_current = 0;
134: switch (board) {
135: case BOARD_NCR5380:
136: if (ints[0] != 2 && ints[0] != 3)
137: printk("generic_NCR5380_setup : usage ncr5380=" STRVAL(NCR5380_map_name) ",irq,dma\n");
138: return;
139: case BOARD_NCR53C400:
140: if (ints[0] != 2)
141: printk("generic_NCR53C400_setup : usage ncr53c400= " STRVAL(NCR5380_map_name) ",irq\n");
142: return;
143: }
144:
145: if (commandline_current < NO_OVERRIDES) {
146: overrides[commandline_current].NCR5380_map_name = (NCR5380_map_type)ints[1];
147: overrides[commandline_current].irq = ints[2];
148: if (ints[0] == 3)
149: overrides[commandline_current].dma = ints[3];
150: else
151: overrides[commandline_current].dma = DMA_NONE;
152: overrides[commandline_current].board = board;
153: ++commandline_current;
154: }
155: }
156:
157: /*
158: * Function : generic_NCR5380_setup (char *str, int *ints)
159: *
160: * Purpose : LILO command line initialization of the overrides array,
161: *
162: * Inputs : str - unused, ints - array of integer paramters with ints[0]
163: * equal to the number of ints.
164: */
165:
166: void generic_NCR5380_setup (char *str, int *ints) {
167: internal_setup (BOARD_NCR5380, str, ints);
168: }
169:
170: /*
171: * Function : generic_NCR53C400_setup (char *str, int *ints)
172: *
173: * Purpose : LILO command line initialization of the overrides array,
174: *
175: * Inputs : str - unused, ints - array of integer paramters with ints[0]
176: * equal to the number of ints.
177: */
178:
179: void generic_NCR53C400_setup (char *str, int *ints) {
180: internal_setup (BOARD_NCR53C400, str, ints);
181: }
182:
183: /*
184: * Function : int generic_NCR5380_detect(Scsi_Host_Template * tpnt)
185: *
186: * Purpose : initializes generic NCR5380 driver based on the
187: * command line / compile time port and irq definitions.
188: *
189: * Inputs : tpnt - template for this SCSI adapter.
190: *
191: * Returns : 1 if a host adapter was found, 0 if not.
192: *
193: */
194:
195: int generic_NCR5380_detect(Scsi_Host_Template * tpnt) {
196: static int current_override = 0;
197: int count;
198: int flags = 0;
199: struct Scsi_Host *instance;
200:
201: tpnt->proc_dir = &proc_scsi_g_ncr5380;
202:
203: for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
204: if (!(overrides[current_override].NCR5380_map_name))
205: continue;
206:
207: switch (overrides[current_override].board) {
208: case BOARD_NCR5380:
209: flags = FLAG_NO_PSEUDO_DMA;
210: break;
211: case BOARD_NCR53C400:
212: flags = FLAG_NCR53C400;
213: break;
214: }
215:
216: instance = scsi_register (tpnt, sizeof(struct NCR5380_hostdata));
217: instance->NCR5380_instance_name = overrides[current_override].NCR5380_map_name;
218:
219: NCR5380_init(instance, flags);
220:
221: if (overrides[current_override].irq != IRQ_AUTO)
222: instance->irq = overrides[current_override].irq;
223: else
224: instance->irq = NCR5380_probe_irq(instance, 0xffff);
225:
226: if (instance->irq != IRQ_NONE)
227: if (request_irq(instance->irq, generic_NCR5380_intr, SA_INTERRUPT, "NCR5380")) {
228: printk("scsi%d : IRQ%d not free, interrupts disabled\n",
229: instance->host_no, instance->irq);
230: instance->irq = IRQ_NONE;
231: }
232:
233: if (instance->irq == IRQ_NONE) {
234: printk("scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
235: printk("scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
236: }
237:
238: printk("scsi%d : at " STRVAL(NCR5380_map_name) " 0x%x", instance->host_no, (unsigned int)instance->NCR5380_instance_name);
239: if (instance->irq == IRQ_NONE)
240: printk (" interrupts disabled");
241: else
242: printk (" irq %d", instance->irq);
243: printk(" options CAN_QUEUE=%d CMD_PER_LUN=%d release=%d",
244: CAN_QUEUE, CMD_PER_LUN, GENERIC_NCR5380_PUBLIC_RELEASE);
245: NCR5380_print_options(instance);
246: printk("\n");
247:
248: ++current_override;
249: ++count;
250: }
251: return count;
252: }
253:
254: const char * generic_NCR5380_info (void) {
255: static const char string[]="Generic NCR5380/53C400 Info";
256: return string;
257: }
258:
259: int generic_NCR5380_release_resources(struct Scsi_Host * instance)
260: {
261: NCR5380_local_declare();
262:
263: NCR5380_setup(instance);
264:
265: free_irq(instance->irq);
266:
267: return 0;
268: }
269:
270: #ifdef BIOSPARAM
271: /*
272: * Function : int generic_NCR5380_biosparam(Disk * disk, kdev_t dev, int *ip)
273: *
274: * Purpose : Generates a BIOS / DOS compatable H-C-S mapping for
275: * the specified device / size.
276: *
277: * Inputs : size = size of device in sectors (512 bytes), dev = block device
278: * major / minor, ip[] = {heads, sectors, cylinders}
279: *
280: * Returns : allways 0 (success), initializes ip
281: *
282: */
283:
284: /*
285: * XXX Most SCSI boards use this mapping, I could be incorrect. Some one
286: * using hard disks on a trantor should verify that this mapping corresponds
287: * to that used by the BIOS / ASPI driver by running the linux fdisk program
288: * and matching the H_C_S coordinates to what DOS uses.
289: */
290:
291: int generic_NCR5380_biosparam(Disk * disk, kdev_t dev, int *ip)
292: {
293: int size = disk->capacity;
294: ip[0] = 64;
295: ip[1] = 32;
296: ip[2] = size >> 11;
297: return 0;
298: }
299: #endif
300:
301: int generic_NCR5380_proc_info(char* buffer, char** start, off_t offset, int length, int hostno, int inout)
302: {
303: int len = 0;
304: struct Scsi_Host *scsi_ptr;
305:
306: for (scsi_ptr = first_instance; scsi_ptr; scsi_ptr=scsi_ptr->next)
307: if (scsi_ptr->host_no == hostno)
308: break;
309:
310: len += sprintf(buffer+len, "SCSI host number %d : %s\n", scsi_ptr->host_no, scsi_ptr->hostt->name);
311: len += sprintf(buffer+len, "Generic NCR5380 driver version %d\n", GENERIC_NCR5380_PUBLIC_RELEASE);
312: len += sprintf(buffer+len, "NCR5380 driver core version %d\n", NCR5380_PUBLIC_RELEASE);
313: #ifdef NCR53C400
314: len += sprintf(buffer+len, "NCR53C400 driver extension version %d\n", NCR53C400_PUBLIC_RELEASE);
315: len += sprintf(buffer+len, "NCR53C400 card%s detected\n", (((struct NCR5380_hostdata *)scsi_ptr->hostdata)->flags & FLAG_NCR53C400)?"":" not");
316: # if NCR53C400_PSEUDO_DMA
317: len += sprintf(buffer+len, "NCR53C400 pseudo DMA being used\n");
318: # endif
319: #else
320: len += sprintf(buffer+len, "NO NCR53C400 driver extensions\n");
321: #endif
322: len += sprintf(buffer+len, "Using %s mapping at %s 0x%x, ", STRVAL(NCR5380_map_config), STRVAL(NCR5380_map_name), scsi_ptr->NCR5380_instance_name);
323: if (scsi_ptr->irq == IRQ_NONE)
324: len += sprintf(buffer+len, "interrupts disabled\n");
325: else
326: len += sprintf(buffer+len, "on interrupt %d\n", scsi_ptr->irq);
327:
328: *start = buffer + offset;
329: len -= offset;
330: if (len > length)
331: len = length;
332: return len;
333: }
334:
335: #if NCR53C400_PSEUDO_DMA
336: static inline int NCR5380_pread (struct Scsi_Host *instance, unsigned char *dst, int len)
337: {
338: int blocks = len / 128;
339: int start = 0;
340: int i;
341: int bl;
342: NCR5380_local_declare();
343:
344: NCR5380_setup(instance);
345:
346: #if (NDEBUG & NDEBUG_C400_PREAD)
347: printk("53C400r: About to read %d blocks for %d bytes\n", blocks, len);
348: #endif
349:
350: NCR5380_write(C400_CONTROL_STATUS_REG, CSR_BASE | CSR_TRANS_DIR);
351: NCR5380_write(C400_BLOCK_COUNTER_REG, blocks);
352: while (1) {
353:
354: #if (NDEBUG & NDEBUG_C400_PREAD)
355: printk("53C400r: %d blocks left\n", blocks);
356: #endif
357:
358: if ((bl=NCR5380_read(C400_BLOCK_COUNTER_REG)) == 0) {
359: #if (NDEBUG & NDEBUG_C400_PREAD)
360: if (blocks)
361: printk("53C400r: blocks still == %d\n", blocks);
362: else
363: printk("53C400r: Exiting loop\n");
364: #endif
365: break;
366: }
367:
368: #if 1
369: if (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ) {
370: printk("53C400r: Got 53C80_IRQ start=%d, blocks=%d\n", start, blocks);
371: return -1;
372: }
373: #endif
374:
375: #if (NDEBUG & NDEBUG_C400_PREAD)
376: printk("53C400r: Waiting for buffer, bl=%d\n", bl);
377: #endif
378:
379: while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
380: ;
381: #if (NDEBUG & NDEBUG_C400_PREAD)
382: printk("53C400r: Transferring 128 bytes\n");
383: #endif
384:
385: #ifdef CONFIG_SCSI_G_NCR5380_PORT
386: for (i=0; i<128; i++)
387: dst[start+i] = NCR5380_read(C400_HOST_BUFFER);
388: #else
389: /* implies CONFIG_SCSI_G_NCR5380_MEM */
390: memmove(dst+start,NCR53C400_host_buffer+NCR5380_map_name,128);
391: #endif
392: start+=128;
393: blocks--;
394: }
395:
396: #if (NDEBUG & NDEBUG_C400_PREAD)
397: printk("53C400r: EXTRA: Waiting for buffer\n");
398: #endif
399: while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
400: ;
401:
402: #if (NDEBUG & NDEBUG_C400_PREAD)
403: printk("53C400r: Transferring EXTRA 128 bytes\n");
404: #endif
405: #ifdef CONFIG_SCSI_G_NCR5380_PORT
406: for (i=0; i<128; i++)
407: dst[start+i] = NCR5380_read(C400_HOST_BUFFER);
408: #else
409: /* implies CONFIG_SCSI_G_NCR5380_MEM */
410: memmove(dst+start,NCR53C400_host_buffer+NCR5380_map_name,128);
411: #endif
412: start+=128;
413: blocks--;
414:
415: #if (NDEBUG & NDEBUG_C400_PREAD)
416: printk("53C400r: Final values: blocks=%d start=%d\n", blocks, start);
417: #endif
418:
419: if (!(NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ))
420: printk("53C400r: no 53C80 gated irq after transfer");
421: #if (NDEBUG & NDEBUG_C400_PREAD)
422: else
423: printk("53C400r: Got 53C80 interupt and tried to clear it\n");
424: #endif
425:
426: /* DON'T DO THIS - THEY NEVER ARRIVE!
427: printk("53C400r: Waiting for 53C80 registers\n");
428: while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_53C80_REG)
429: ;
430: */
431:
432: if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_END_DMA_TRANSFER))
433: printk("53C400r: no end dma signal\n");
434: #if (NDEBUG & NDEBUG_C400_PREAD)
435: else
436: printk("53C400r: end dma as expected\n");
437: #endif
438:
439: NCR5380_write(MODE_REG, MR_BASE);
440: NCR5380_read(RESET_PARITY_INTERRUPT_REG);
441: return 0;
442: }
443:
444: static inline int NCR5380_pwrite (struct Scsi_Host *instance, unsigned char *src, int len)
445: {
446: int blocks = len / 128;
447: int start = 0;
448: int i;
449: int bl;
450: NCR5380_local_declare();
451:
452: NCR5380_setup(instance);
453:
454: #if (NDEBUG & NDEBUG_C400_PWRITE)
455: printk("53C400w: About to write %d blocks for %d bytes\n", blocks, len);
456: #endif
457:
458: NCR5380_write(C400_CONTROL_STATUS_REG, CSR_BASE);
459: NCR5380_write(C400_BLOCK_COUNTER_REG, blocks);
460: while (1) {
461: if (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ) {
462: printk("53C400w: Got 53C80_IRQ start=%d, blocks=%d\n", start, blocks);
463: return -1;
464: }
465:
466: if ((bl=NCR5380_read(C400_BLOCK_COUNTER_REG)) == 0) {
467: #if (NDEBUG & NDEBUG_C400_PWRITE)
468: if (blocks)
469: printk("53C400w: exiting loop, blocks still == %d\n", blocks);
470: else
471: printk("53C400w: exiting loop\n");
472: #endif
473: break;
474: }
475:
476: #if (NDEBUG & NDEBUG_C400_PWRITE)
477: printk("53C400w: %d blocks left\n", blocks);
478:
479: printk("53C400w: waiting for buffer, bl=%d\n", bl);
480: #endif
481: while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
482: ;
483:
484: #if (NDEBUG & NDEBUG_C400_PWRITE)
485: printk("53C400w: transferring 128 bytes\n");
486: #endif
487: #ifdef CONFIG_SCSI_G_NCR5380_PORT
488: for (i=0; i<128; i++)
489: NCR5380_write(C400_HOST_BUFFER, src[start+i]);
490: #else
491: /* implies CONFIG_SCSI_G_NCR5380_MEM */
492: memmove(NCR53C400_host_buffer+NCR5380_map_name,src+start,128);
493: #endif
494: start+=128;
495: blocks--;
496: }
497: if (blocks) {
498: #if (NDEBUG & NDEBUG_C400_PWRITE)
499: printk("53C400w: EXTRA waiting for buffer\n");
500: #endif
501: while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
502: ;
503:
504: #if (NDEBUG & NDEBUG_C400_PWRITE)
505: printk("53C400w: transferring EXTRA 128 bytes\n");
506: #endif
507: #ifdef CONFIG_SCSI_G_NCR5380_PORT
508: for (i=0; i<128; i++)
509: NCR5380_write(C400_HOST_BUFFER, src[start+i]);
510: #else
511: /* implies CONFIG_SCSI_G_NCR5380_MEM */
512: memmove(NCR53C400_host_buffer+NCR5380_map_name,src+start,128);
513: #endif
514: start+=128;
515: blocks--;
516: }
517: #if (NDEBUG & NDEBUG_C400_PWRITE)
518: else
519: printk("53C400w: No EXTRA required\n");
520: #endif
521:
522: #if (NDEBUG & NDEBUG_C400_PWRITE)
523: printk("53C400w: Final values: blocks=%d start=%d\n", blocks, start);
524: #endif
525:
526: #if 0
527: printk("53C400w: waiting for registers to be available\n");
528: THEY NEVER DO!
529: while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_53C80_REG)
530: ;
531: printk("53C400w: Got em\n");
532: #endif
533:
534: /* Let's wait for this instead - could be ugly */
535: /* All documentation says to check for this. Maybe my hardware is too
536: * fast. Waiting for it seems to work fine! KLL
537: */
538: while (!(i = NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_GATED_53C80_IRQ))
539: ;
540:
541: /*
542: * I know. i is certainly != 0 here but the loop is new. See previous
543: * comment.
544: */
545: if (i) {
546: #if (NDEBUG & NDEBUG_C400_PWRITE)
547: prink("53C400w: got 53C80 gated irq (last block)\n");
548: #endif
549: if (!((i=NCR5380_read(BUS_AND_STATUS_REG)) & BASR_END_DMA_TRANSFER))
550: printk("53C400w: No END OF DMA bit - WHOOPS! BASR=%0x\n",i);
551: #if (NDEBUG & NDEBUG_C400_PWRITE)
552: else
553: printk("53C400w: Got END OF DMA\n");
554: #endif
555: }
556: else
557: printk("53C400w: no 53C80 gated irq after transfer (last block)\n");
558:
559: #if 0
560: if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_END_DMA_TRANSFER)) {
561: printk("53C400w: no end dma signal\n");
562: }
563: #endif
564:
565: #if (NDEBUG & NDEBUG_C400_PWRITE)
566: printk("53C400w: waiting for last byte...\n");
567: #endif
568: while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT))
569: ;
570:
571: #if (NDEBUG & NDEBUG_C400_PWRITE)
572: printk("53C400w: got last byte.\n");
573: printk("53C400w: pwrite exiting with status 0, whoopee!\n");
574: #endif
575: return 0;
576: }
577: #endif /* PSEUDO_DMA */
578:
579: #ifdef MACH
580: #include "NCR5380.src"
581: #else
582: #include "NCR5380.c"
583: #endif
584:
585: #ifdef MODULE
586: /* Eventually this will go into an include file, but this will be later */
587: Scsi_Host_Template driver_template = GENERIC_NCR5380;
588:
589: #include <linux/module.h>
590: #include "scsi_module.c"
591: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.