![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tmscsim.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi|
Return to tmscsim.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 root 1: /***********************************************************************
2: * FILE NAME : TMSCSIM.C *
3: * BY : C.L. Huang, [email protected] *
4: * Description: Device Driver for Tekram DC-390(T) PCI SCSI *
5: * Bus Master Host Adapter *
6: * (C)Copyright 1995-1996 Tekram Technology Co., Ltd. *
7: ***********************************************************************/
8: /* Minor enhancements and bugfixes by *
9: * Kurt Garloff <[email protected]> *
10: ***********************************************************************/
11: /* HISTORY: *
12: * *
13: * REV# DATE NAME DESCRIPTION *
14: * 1.00 04/24/96 CLH First release *
15: * 1.01 06/12/96 CLH Fixed bug of Media Change for Removable *
16: * Device, scan all LUN. Support Pre2.0.10 *
17: * 1.02 06/18/96 CLH Fixed bug of Command timeout ... *
18: * 1.03 09/25/96 KG Added tmscsim_proc_info() *
19: * 1.04 10/11/96 CLH Updating for support KV 2.0.x *
20: * 1.05 10/18/96 KG Fixed bug in DC390_abort(null ptr deref)*
21: * 1.06 10/25/96 KG Fixed module support *
22: * 1.07 11/09/96 KG Fixed tmscsim_proc_info() *
23: * 1.08 11/18/96 KG Fixed null ptr in DC390_Disconnect() *
24: * 1.09 11/30/96 KG Added register the allocated IO space *
25: * 1.10 12/05/96 CLH Modified tmscsim_proc_info(), and reset *
26: * pending interrupt in DC390_detect() *
27: * 1.11 02/05/97 KG/CLH Fixeds problem with partitions greater *
28: * than 1GB *
29: ***********************************************************************/
30:
31:
32: #define DC390_DEBUG
33:
34: #define SCSI_MALLOC
35:
36: #ifdef MODULE
37: #include <linux/module.h>
38: #endif
39:
40: #include <asm/dma.h>
41: #include <asm/io.h>
42: #include <asm/system.h>
43: #include <linux/delay.h>
44: #include <linux/signal.h>
45: #include <linux/sched.h>
46: #include <linux/errno.h>
47: #include <linux/kernel.h>
48: #include <linux/ioport.h>
49: #include <linux/bios32.h>
50: #include <linux/pci.h>
51: #include <linux/proc_fs.h>
52: #include <linux/string.h>
53: #include <linux/mm.h>
54: #include <linux/config.h>
55:
56: #include <linux/version.h>
57: #if LINUX_VERSION_CODE < 66354 /* 1.3.50 */
58: #include "../block/blk.h"
59: #else
60: #include <linux/blk.h>
61: #endif
62:
63: #include "scsi.h"
64: #include "hosts.h"
65: #include "tmscsim.h"
66: #include "constants.h"
67: #include "sd.h"
68: #include <linux/stat.h>
69:
70: #include "dc390.h"
71:
72: #define PCI_DEVICE_ID_AMD53C974 PCI_DEVICE_ID_AMD_SCSI
73:
74:
75: #ifndef VERSION_ELF_1_2_13
76: struct proc_dir_entry proc_scsi_tmscsim ={
77: PROC_SCSI_DC390T, 7 ,"tmscsim",
78: S_IFDIR | S_IRUGO | S_IXUGO, 2
79: };
80: #endif
81:
82: static USHORT DC390_StartSCSI( PACB pACB, PDCB pDCB, PSRB pSRB );
83: static void DC390_DataOut_0( PACB pACB, PSRB pSRB, PUCHAR psstatus);
84: static void DC390_DataIn_0( PACB pACB, PSRB pSRB, PUCHAR psstatus);
85: static void DC390_Command_0( PACB pACB, PSRB pSRB, PUCHAR psstatus);
86: static void DC390_Status_0( PACB pACB, PSRB pSRB, PUCHAR psstatus);
87: static void DC390_MsgOut_0( PACB pACB, PSRB pSRB, PUCHAR psstatus);
88: static void DC390_MsgIn_0( PACB pACB, PSRB pSRB, PUCHAR psstatus);
89: static void DC390_DataOutPhase( PACB pACB, PSRB pSRB, PUCHAR psstatus);
90: static void DC390_DataInPhase( PACB pACB, PSRB pSRB, PUCHAR psstatus);
91: static void DC390_CommandPhase( PACB pACB, PSRB pSRB, PUCHAR psstatus);
92: static void DC390_StatusPhase( PACB pACB, PSRB pSRB, PUCHAR psstatus);
93: static void DC390_MsgOutPhase( PACB pACB, PSRB pSRB, PUCHAR psstatus);
94: static void DC390_MsgInPhase( PACB pACB, PSRB pSRB, PUCHAR psstatus);
95: static void DC390_Nop_0( PACB pACB, PSRB pSRB, PUCHAR psstatus);
96: static void DC390_Nop_1( PACB pACB, PSRB pSRB, PUCHAR psstatus);
97:
98: static void SetXferRate( PACB pACB, PDCB pDCB );
99: static void DC390_Disconnect( PACB pACB );
100: static void DC390_Reselect( PACB pACB );
101: static void SRBdone( PACB pACB, PDCB pDCB, PSRB pSRB );
102: static void DoingSRB_Done( PACB pACB );
103: static void DC390_ScsiRstDetect( PACB pACB );
104: static void DC390_ResetSCSIBus( PACB pACB );
105: static void RequestSense( PACB pACB, PDCB pDCB, PSRB pSRB );
106: static void EnableMsgOut2( PACB pACB, PSRB pSRB );
107: static void EnableMsgOut( PACB pACB, PSRB pSRB );
108: static void DC390_InvalidCmd( PACB pACB );
109:
110: int DC390_initAdapter( PSH psh, ULONG io_port, UCHAR Irq, USHORT index );
111: void DC390_initDCB( PACB pACB, PDCB pDCB, PSCSICMD cmd );
112:
113: #ifdef MODULE
114: static int DC390_release(struct Scsi_Host *host);
115: static int DC390_shutdown (struct Scsi_Host *host);
116: #endif
117:
118:
119: static PSHT pSHT_start = NULL;
120: static PSH pSH_start = NULL;
121: static PSH pSH_current = NULL;
122: static PACB pACB_start= NULL;
123: static PACB pACB_current = NULL;
124: static PDCB pPrevDCB = NULL;
125: static USHORT adapterCnt = 0;
126: static USHORT InitialTime = 0;
127: static USHORT CurrSyncOffset = 0;
128: static ULONG mech1addr;
129: static UCHAR mech2bus, mech2Agent, mech2CfgSPenR;
130:
131: static PVOID DC390_phase0[]={
132: DC390_DataOut_0,
133: DC390_DataIn_0,
134: DC390_Command_0,
135: DC390_Status_0,
136: DC390_Nop_0,
137: DC390_Nop_0,
138: DC390_MsgOut_0,
139: DC390_MsgIn_0,
140: DC390_Nop_1
141: };
142:
143: static PVOID DC390_phase1[]={
144: DC390_DataOutPhase,
145: DC390_DataInPhase,
146: DC390_CommandPhase,
147: DC390_StatusPhase,
148: DC390_Nop_0,
149: DC390_Nop_0,
150: DC390_MsgOutPhase,
151: DC390_MsgInPhase,
152: DC390_Nop_1,
153: };
154:
155: UCHAR eepromBuf[MAX_ADAPTER_NUM][128];
156:
157:
158: UCHAR clock_period1[] = {4, 5, 6, 7, 8, 10, 13, 20};
159:
160: UCHAR baddevname1[2][28] ={
161: "SEAGATE ST3390N 9546",
162: "HP C3323-300 4269"};
163:
164: #define BADDEVCNT 2
165:
166:
167: /***********************************************************************
168: *
169: *
170: *
171: **********************************************************************/
172: static void
173: QLinkcmd( PSCSICMD cmd, PDCB pDCB )
174: {
175: ULONG flags;
176: PSCSICMD pcmd;
177:
178: save_flags(flags);
179: cli();
180:
181: if( !pDCB->QIORBCnt )
182: {
183: pDCB->pQIORBhead = cmd;
184: pDCB->pQIORBtail = cmd;
185: pDCB->QIORBCnt++;
186: cmd->next = NULL;
187: }
188: else
189: {
190: pcmd = pDCB->pQIORBtail;
191: pcmd->next = cmd;
192: pDCB->pQIORBtail = cmd;
193: pDCB->QIORBCnt++;
194: cmd->next = NULL;
195: }
196:
197: restore_flags(flags);
198: }
199:
200:
201: static PSCSICMD
202: Getcmd( PDCB pDCB )
203: {
204: ULONG flags;
205: PSCSICMD pcmd;
206:
207: save_flags(flags);
208: cli();
209:
210: pcmd = pDCB->pQIORBhead;
211: pDCB->pQIORBhead = pcmd->next;
212: pcmd->next = NULL;
213: pDCB->QIORBCnt--;
214:
215: restore_flags(flags);
216: return( pcmd );
217: }
218:
219:
220: static PSRB
221: GetSRB( PACB pACB )
222: {
223: ULONG flags;
224: PSRB pSRB;
225:
226: save_flags(flags);
227: cli();
228:
229: pSRB = pACB->pFreeSRB;
230: if( pSRB )
231: {
232: pACB->pFreeSRB = pSRB->pNextSRB;
233: pSRB->pNextSRB = NULL;
234: }
235: restore_flags(flags);
236: return( pSRB );
237: }
238:
239:
240: static void
241: RewaitSRB0( PDCB pDCB, PSRB pSRB )
242: {
243: PSRB psrb1;
244: ULONG flags;
245:
246: save_flags(flags);
247: cli();
248:
249: if( (psrb1 = pDCB->pWaitingSRB) )
250: {
251: pSRB->pNextSRB = psrb1;
252: pDCB->pWaitingSRB = pSRB;
253: }
254: else
255: {
256: pSRB->pNextSRB = NULL;
257: pDCB->pWaitingSRB = pSRB;
258: pDCB->pWaitLast = pSRB;
259: }
260: restore_flags(flags);
261: }
262:
263:
264: static void
265: RewaitSRB( PDCB pDCB, PSRB pSRB )
266: {
267: PSRB psrb1;
268: ULONG flags;
269: UCHAR bval;
270:
271: save_flags(flags);
272: cli();
273: pDCB->GoingSRBCnt--;
274: psrb1 = pDCB->pGoingSRB;
275: if( pSRB == psrb1 )
276: {
277: pDCB->pGoingSRB = psrb1->pNextSRB;
278: }
279: else
280: {
281: while( pSRB != psrb1->pNextSRB )
282: psrb1 = psrb1->pNextSRB;
283: psrb1->pNextSRB = pSRB->pNextSRB;
284: if( pSRB == pDCB->pGoingLast )
285: pDCB->pGoingLast = psrb1;
286: }
287: if( (psrb1 = pDCB->pWaitingSRB) )
288: {
289: pSRB->pNextSRB = psrb1;
290: pDCB->pWaitingSRB = pSRB;
291: }
292: else
293: {
294: pSRB->pNextSRB = NULL;
295: pDCB->pWaitingSRB = pSRB;
296: pDCB->pWaitLast = pSRB;
297: }
298:
299: bval = pSRB->TagNumber;
300: pDCB->TagMask &= (~(1 << bval)); /* Free TAG number */
301: restore_flags(flags);
302: }
303:
304:
305: static void
306: DoWaitingSRB( PACB pACB )
307: {
308: ULONG flags;
309: PDCB ptr, ptr1;
310: PSRB pSRB;
311:
312: save_flags(flags);
313: cli();
314:
315: if( !(pACB->pActiveDCB) && !(pACB->ACBFlag & (RESET_DETECT+RESET_DONE+RESET_DEV) ) )
316: {
317: ptr = pACB->pDCBRunRobin;
318: if( !ptr )
319: {
320: ptr = pACB->pLinkDCB;
321: pACB->pDCBRunRobin = ptr;
322: }
323: ptr1 = ptr;
324: for( ;ptr1; )
325: {
326: pACB->pDCBRunRobin = ptr1->pNextDCB;
327: if( !( ptr1->MaxCommand > ptr1->GoingSRBCnt ) ||
328: !( pSRB = ptr1->pWaitingSRB ) )
329: {
330: if(pACB->pDCBRunRobin == ptr)
331: break;
332: ptr1 = ptr1->pNextDCB;
333: }
334: else
335: {
336: if( !DC390_StartSCSI(pACB, ptr1, pSRB) )
337: {
338: ptr1->GoingSRBCnt++;
339: if( ptr1->pWaitLast == pSRB )
340: {
341: ptr1->pWaitingSRB = NULL;
342: ptr1->pWaitLast = NULL;
343: }
344: else
345: {
346: ptr1->pWaitingSRB = pSRB->pNextSRB;
347: }
348: pSRB->pNextSRB = NULL;
349:
350: if( ptr1->pGoingSRB )
351: ptr1->pGoingLast->pNextSRB = pSRB;
352: else
353: ptr1->pGoingSRB = pSRB;
354: ptr1->pGoingLast = pSRB;
355: }
356: break;
357: }
358: }
359: }
360: restore_flags(flags);
361: return;
362: }
363:
364:
365: static void
366: SRBwaiting( PDCB pDCB, PSRB pSRB)
367: {
368: if( pDCB->pWaitingSRB )
369: {
370: pDCB->pWaitLast->pNextSRB = pSRB;
371: pDCB->pWaitLast = pSRB;
372: pSRB->pNextSRB = NULL;
373: }
374: else
375: {
376: pDCB->pWaitingSRB = pSRB;
377: pDCB->pWaitLast = pSRB;
378: }
379: }
380:
381:
382: static void
383: SendSRB( PSCSICMD pcmd, PACB pACB, PSRB pSRB )
384: {
385: ULONG flags;
386: PDCB pDCB;
387:
388: save_flags(flags);
389: cli();
390:
391: pDCB = pSRB->pSRBDCB;
392: if( !(pDCB->MaxCommand > pDCB->GoingSRBCnt) || (pACB->pActiveDCB) ||
393: (pACB->ACBFlag & (RESET_DETECT+RESET_DONE+RESET_DEV)) )
394: {
395: SRBwaiting(pDCB, pSRB);
396: goto SND_EXIT;
397: }
398:
399: if( pDCB->pWaitingSRB )
400: {
401: SRBwaiting(pDCB, pSRB);
402: /* pSRB = GetWaitingSRB(pDCB); */
403: pSRB = pDCB->pWaitingSRB;
404: pDCB->pWaitingSRB = pSRB->pNextSRB;
405: pSRB->pNextSRB = NULL;
406: }
407:
408: if( !DC390_StartSCSI(pACB, pDCB, pSRB) )
409: {
410: pDCB->GoingSRBCnt++;
411: if( pDCB->pGoingSRB )
412: {
413: pDCB->pGoingLast->pNextSRB = pSRB;
414: pDCB->pGoingLast = pSRB;
415: }
416: else
417: {
418: pDCB->pGoingSRB = pSRB;
419: pDCB->pGoingLast = pSRB;
420: }
421: }
422: else
423: RewaitSRB0( pDCB, pSRB );
424:
425: SND_EXIT:
426: restore_flags(flags);
427: return;
428: }
429:
430:
431: /***********************************************************************
432: * Function : static int DC390_queue_command (Scsi_Cmnd *cmd,
433: * void (*done)(Scsi_Cmnd *))
434: *
435: * Purpose : enqueues a SCSI command
436: *
437: * Inputs : cmd - SCSI command, done - function called on completion, with
438: * a pointer to the command descriptor.
439: *
440: * Returns : 0
441: *
442: ***********************************************************************/
443:
444: int
445: DC390_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *))
446: {
447: USHORT ioport, i;
448: Scsi_Cmnd *pcmd;
449: struct Scsi_Host *psh;
450: PACB pACB;
451: PDCB pDCB;
452: PSRB pSRB;
453: ULONG flags;
454: PUCHAR ptr,ptr1;
455:
456: psh = cmd->host;
457: pACB = (PACB ) psh->hostdata;
458: ioport = pACB->IOPortBase;
459:
460: #ifdef DC390_DEBUG0
461: /* if(pACB->scan_devices) */
462: printk("Cmd=%2x,ID=%d,LUN=%d,",cmd->cmnd[0],cmd->target,cmd->lun);
463: #endif
464:
465: if( (pACB->scan_devices == END_SCAN) && (cmd->cmnd[0] != INQUIRY) )
466: {
467: pACB->scan_devices = 0;
468: pPrevDCB->pNextDCB = pACB->pLinkDCB;
469: }
470: else if( (pACB->scan_devices) && (cmd->cmnd[0] == 8) )
471: {
472: pACB->scan_devices = 0;
473: pPrevDCB->pNextDCB = pACB->pLinkDCB;
474: }
475:
476: if ( ( cmd->target > pACB->max_id ) || (cmd->lun > pACB->max_lun) )
477: {
478: /* printk("DC390: Ignore target %d lun %d\n",
479: cmd->target, cmd->lun); */
480: cmd->result = (DID_BAD_TARGET << 16);
481: done(cmd);
482: return( 0 );
483: }
484:
485: if( (pACB->scan_devices) && !(pACB->DCBmap[cmd->target] & (1 << cmd->lun)) )
486: {
487: if( pACB->DeviceCnt < MAX_DEVICES )
488: {
489: pACB->DCBmap[cmd->target] |= (1 << cmd->lun);
490: pDCB = pACB->pDCB_free;
491: #ifdef DC390_DEBUG0
492: printk("pDCB=%8x,ID=%2x,", (UINT) pDCB, cmd->target);
493: #endif
494: DC390_initDCB( pACB, pDCB, cmd );
495: }
496: else /* ???? */
497: {
498: /* printk("DC390: Ignore target %d lun %d\n",
499: cmd->target, cmd->lun); */
500: cmd->result = (DID_BAD_TARGET << 16);
501: done(cmd);
502: return(0);
503: }
504: }
505: else if( !(pACB->scan_devices) && !(pACB->DCBmap[cmd->target] & (1 << cmd->lun)) )
506: {
507: /* printk("DC390: Ignore target %d lun %d\n",
508: cmd->target, cmd->lun); */
509: cmd->result = (DID_BAD_TARGET << 16);
510: done(cmd);
511: return(0);
512: }
513: else
514: {
515: pDCB = pACB->pLinkDCB;
516: while( (pDCB->UnitSCSIID != cmd->target) ||
517: (pDCB->UnitSCSILUN != cmd->lun) )
518: {
519: pDCB = pDCB->pNextDCB;
520: }
521: #ifdef DC390_DEBUG0
522: printk("pDCB=%8x,ID=%2x,", (UINT) pDCB, cmd->target);
523: #endif
524: }
525:
526: cmd->scsi_done = done;
527: cmd->result = 0;
528:
529: save_flags(flags);
530: cli();
531:
532: if( pDCB->QIORBCnt )
533: {
534: QLinkcmd( cmd, pDCB );
535: pcmd = Getcmd( pDCB );
536: }
537: else
538: pcmd = cmd;
539:
540: pSRB = GetSRB( pACB );
541:
542: if( !pSRB )
543: {
544: QLinkcmd( pcmd, pDCB );
545: restore_flags(flags);
546: return(0);
547: }
548:
549: /* BuildSRB(pSRB); */
550:
551: pSRB->pSRBDCB = pDCB;
552: pSRB->pcmd = pcmd;
553: ptr = (PUCHAR) pSRB->CmdBlock;
554: ptr1 = (PUCHAR) pcmd->cmnd;
555: pSRB->ScsiCmdLen = pcmd->cmd_len;
556: for(i=0; i< pcmd->cmd_len; i++)
557: {
558: *ptr = *ptr1;
559: ptr++;
560: ptr1++;
561: }
562: if( pcmd->use_sg )
563: {
564: pSRB->SGcount = (UCHAR) pcmd->use_sg;
565: pSRB->pSegmentList = (PSGL) pcmd->request_buffer;
566: }
567: else if( pcmd->request_buffer )
568: {
569: pSRB->SGcount = 1;
570: pSRB->pSegmentList = (PSGL) &pSRB->Segmentx;
571: pSRB->Segmentx.address = (PUCHAR) pcmd->request_buffer;
572: pSRB->Segmentx.length = pcmd->request_bufflen;
573: }
574: else
575: pSRB->SGcount = 0;
576:
577: pSRB->SGIndex = 0;
578: pSRB->AdaptStatus = 0;
579: pSRB->TargetStatus = 0;
580: pSRB->MsgCnt = 0;
581: if( pDCB->DevType != TYPE_TAPE )
582: pSRB->RetryCnt = 1;
583: else
584: pSRB->RetryCnt = 0;
585: pSRB->SRBStatus = 0;
586: pSRB->SRBFlag = 0;
587: pSRB->SRBState = 0;
588: pSRB->TotalXferredLen = 0;
589: pSRB->SGPhysAddr = 0;
590: pSRB->SGToBeXferLen = 0;
591: pSRB->ScsiPhase = 0;
592: pSRB->EndMessage = 0;
593: SendSRB( pcmd, pACB, pSRB );
594:
595: restore_flags(flags);
596: return(0);
597: }
598:
599:
600: static void
601: DoNextCmd( PACB pACB, PDCB pDCB )
602: {
603: Scsi_Cmnd *pcmd;
604: PSRB pSRB;
605: ULONG flags;
606: PUCHAR ptr,ptr1;
607: USHORT i;
608:
609:
610: if( pACB->ACBFlag & (RESET_DETECT+RESET_DONE+RESET_DEV) )
611: return;
612: save_flags(flags);
613: cli();
614:
615: pcmd = Getcmd( pDCB );
616: pSRB = GetSRB( pACB );
617: if( !pSRB )
618: {
619: QLinkcmd( pcmd, pDCB );
620: restore_flags(flags);
621: return;
622: }
623:
624: pSRB->pSRBDCB = pDCB;
625: pSRB->pcmd = pcmd;
626: ptr = (PUCHAR) pSRB->CmdBlock;
627: ptr1 = (PUCHAR) pcmd->cmnd;
628: pSRB->ScsiCmdLen = pcmd->cmd_len;
629: for(i=0; i< pcmd->cmd_len; i++)
630: {
631: *ptr = *ptr1;
632: ptr++;
633: ptr1++;
634: }
635: if( pcmd->use_sg )
636: {
637: pSRB->SGcount = (UCHAR) pcmd->use_sg;
638: pSRB->pSegmentList = (PSGL) pcmd->request_buffer;
639: }
640: else if( pcmd->request_buffer )
641: {
642: pSRB->SGcount = 1;
643: pSRB->pSegmentList = (PSGL) &pSRB->Segmentx;
644: pSRB->Segmentx.address = (PUCHAR) pcmd->request_buffer;
645: pSRB->Segmentx.length = pcmd->request_bufflen;
646: }
647: else
648: pSRB->SGcount = 0;
649:
650: pSRB->SGIndex = 0;
651: pSRB->AdaptStatus = 0;
652: pSRB->TargetStatus = 0;
653: pSRB->MsgCnt = 0;
654: if( pDCB->DevType != TYPE_TAPE )
655: pSRB->RetryCnt = 1;
656: else
657: pSRB->RetryCnt = 0;
658: pSRB->SRBStatus = 0;
659: pSRB->SRBFlag = 0;
660: pSRB->SRBState = 0;
661: pSRB->TotalXferredLen = 0;
662: pSRB->SGPhysAddr = 0;
663: pSRB->SGToBeXferLen = 0;
664: pSRB->ScsiPhase = 0;
665: pSRB->EndMessage = 0;
666: SendSRB( pcmd, pACB, pSRB );
667:
668: restore_flags(flags);
669: return;
670: }
671:
672:
673: /***********************************************************************
674: * Function:
675: * DC390_bios_param
676: *
677: * Description:
678: * Return the disk geometry for the given SCSI device.
679: ***********************************************************************/
680: #ifdef VERSION_ELF_1_2_13
681: int DC390_bios_param(Disk *disk, int devno, int geom[])
682: #else
683: int DC390_bios_param(Disk *disk, kdev_t devno, int geom[])
684: #endif
685: {
686: int heads, sectors, cylinders;
687: PACB pACB;
688:
689: pACB = (PACB) disk->device->host->hostdata;
690: heads = 64;
691: sectors = 32;
692: cylinders = disk->capacity / (heads * sectors);
693:
694: if ( (pACB->Gmode2 & GREATER_1G) && (cylinders > 1024) )
695: {
696: heads = 255;
697: sectors = 63;
698: cylinders = disk->capacity / (heads * sectors);
699: }
700:
701: geom[0] = heads;
702: geom[1] = sectors;
703: geom[2] = cylinders;
704:
705: return (0);
706: }
707:
708:
709: /***********************************************************************
710: * Function : int DC390_abort (Scsi_Cmnd *cmd)
711: *
712: * Purpose : Abort an errant SCSI command
713: *
714: * Inputs : cmd - command to abort
715: *
716: * Returns : 0 on success, -1 on failure.
717: ***********************************************************************/
718:
719: int
720: DC390_abort (Scsi_Cmnd *cmd)
721: {
722: ULONG flags;
723: PACB pACB;
724: PDCB pDCB, pdcb;
725: PSRB pSRB, psrb;
726: USHORT count, i;
727: PSCSICMD pcmd, pcmd1;
728: int status;
729:
730:
731: #ifdef DC390_DEBUG0
732: printk("DC390 : Abort Cmd.");
733: #endif
734:
735: save_flags(flags);
736: cli();
737:
738: pACB = (PACB) cmd->host->hostdata;
739: pDCB = pACB->pLinkDCB;
740: pdcb = pDCB;
741: while( (pDCB->UnitSCSIID != cmd->target) ||
742: (pDCB->UnitSCSILUN != cmd->lun) )
743: {
744: pDCB = pDCB->pNextDCB;
745: if( pDCB == pdcb )
746: goto NOT_RUN;
747: }
748:
749: if( pDCB->QIORBCnt )
750: {
751: pcmd = pDCB->pQIORBhead;
752: if( pcmd == cmd )
753: {
754: pDCB->pQIORBhead = pcmd->next;
755: pcmd->next = NULL;
756: pDCB->QIORBCnt--;
757: status = SCSI_ABORT_SUCCESS;
758: goto ABO_X;
759: }
760: for( count = pDCB->QIORBCnt, i=0; i<count-1; i++)
761: {
762: if( pcmd->next == cmd )
763: {
764: pcmd1 = pcmd->next;
765: pcmd->next = pcmd1->next;
766: pcmd1->next = NULL;
767: pDCB->QIORBCnt--;
768: status = SCSI_ABORT_SUCCESS;
769: goto ABO_X;
770: }
771: else
772: {
773: pcmd = pcmd->next;
774: }
775: }
776: }
777:
778: pSRB = pDCB->pWaitingSRB;
779: if( !pSRB )
780: goto ON_GOING;
781: if( pSRB->pcmd == cmd )
782: {
783: pDCB->pWaitingSRB = pSRB->pNextSRB;
784: goto IN_WAIT;
785: }
786: else
787: {
788: psrb = pSRB;
789: if( !(psrb->pNextSRB) )
790: goto ON_GOING;
791: while( psrb->pNextSRB->pcmd != cmd )
792: {
793: psrb = psrb->pNextSRB;
794: if( !(psrb->pNextSRB) )
795: goto ON_GOING;
796: }
797: pSRB = psrb->pNextSRB;
798: psrb->pNextSRB = pSRB->pNextSRB;
799: if( pSRB == pDCB->pWaitLast )
800: pDCB->pWaitLast = psrb; /* No check for psrb == NULL ? */
801: IN_WAIT:
802: pSRB->pNextSRB = pACB->pFreeSRB;
803: pACB->pFreeSRB = pSRB;
804: cmd->next = NULL;
805: status = SCSI_ABORT_SUCCESS;
806: goto ABO_X;
807: }
808:
809: ON_GOING:
810: pSRB = pDCB->pGoingSRB;
811: for( count = pDCB->GoingSRBCnt, i=0; i<count; i++)
812: {
813: if( pSRB->pcmd != cmd )
814: pSRB = pSRB->pNextSRB;
815: else
816: {
817: if( (pACB->pActiveDCB == pDCB) && (pDCB->pActiveSRB == pSRB) )
818: {
819: status = SCSI_ABORT_BUSY;
820: goto ABO_X;
821: }
822: else
823: {
824: status = SCSI_ABORT_SNOOZE;
825: goto ABO_X;
826: }
827: }
828: }
829:
830: NOT_RUN:
831: status = SCSI_ABORT_NOT_RUNNING;
832:
833: ABO_X:
834: cmd->result = DID_ABORT << 16;
835: cmd->scsi_done(cmd);
836: restore_flags(flags);
837: return( status );
838: }
839:
840:
841: static void
842: ResetDevParam( PACB pACB )
843: {
844: PDCB pDCB, pdcb;
845:
846: pDCB = pACB->pLinkDCB;
847: if( pDCB == NULL )
848: return;
849: pdcb = pDCB;
850: do
851: {
852: pDCB->SyncMode &= ~SYNC_NEGO_DONE;
853: pDCB->SyncPeriod = 0;
854: pDCB->SyncOffset = 0;
855: pDCB->CtrlR3 = FAST_CLK;
856: pDCB->CtrlR4 &= NEGATE_REQACKDATA;
857: pDCB->CtrlR4 |= EATER_25NS;
858: pDCB = pDCB->pNextDCB;
859: }
860: while( pdcb != pDCB );
861: }
862:
863:
864: static void
865: RecoverSRB( PACB pACB )
866: {
867: PDCB pDCB, pdcb;
868: PSRB psrb, psrb2;
869: USHORT cnt, i;
870:
871: pDCB = pACB->pLinkDCB;
872: if( pDCB == NULL )
873: return;
874: pdcb = pDCB;
875: do
876: {
877: cnt = pdcb->GoingSRBCnt;
878: psrb = pdcb->pGoingSRB;
879: for (i=0; i<cnt; i++)
880: {
881: psrb2 = psrb;
882: psrb = psrb->pNextSRB;
883: /* RewaitSRB( pDCB, psrb ); */
884: if( pdcb->pWaitingSRB )
885: {
886: psrb2->pNextSRB = pdcb->pWaitingSRB;
887: pdcb->pWaitingSRB = psrb2;
888: }
889: else
890: {
891: pdcb->pWaitingSRB = psrb2;
892: pdcb->pWaitLast = psrb2;
893: psrb2->pNextSRB = NULL;
894: }
895: }
896: pdcb->GoingSRBCnt = 0;
897: pdcb->pGoingSRB = NULL;
898: pdcb->TagMask = 0;
899: pdcb = pdcb->pNextDCB;
900: }
901: while( pdcb != pDCB );
902: }
903:
904:
905: /***********************************************************************
906: * Function : int DC390_reset (Scsi_Cmnd *cmd, ...)
907: *
908: * Purpose : perform a hard reset on the SCSI bus
909: *
910: * Inputs : cmd - command which caused the SCSI RESET
911: *
912: * Returns : 0 on success.
913: ***********************************************************************/
914:
915: #ifdef VERSION_2_0_0
916: int DC390_reset(Scsi_Cmnd *cmd, unsigned int resetFlags)
917: #else
918: int DC390_reset (Scsi_Cmnd *cmd)
919: #endif
920: {
921: USHORT ioport;
922: unsigned long flags;
923: PACB pACB;
924: UCHAR bval;
925: USHORT i;
926:
927:
928: #ifdef DC390_DEBUG1
929: printk("DC390: RESET,");
930: #endif
931:
932: pACB = (PACB ) cmd->host->hostdata;
933: ioport = pACB->IOPortBase;
934: save_flags(flags);
935: cli();
936: bval = inb(ioport+CtrlReg1);
937: bval |= DIS_INT_ON_SCSI_RST;
938: outb(bval,ioport+CtrlReg1); /* disable interrupt */
939: DC390_ResetSCSIBus( pACB );
940: for( i=0; i<500; i++ )
941: udelay(1000);
942: bval = inb(ioport+CtrlReg1);
943: bval &= ~DIS_INT_ON_SCSI_RST;
944: outb(bval,ioport+CtrlReg1); /* re-enable interrupt */
945:
946: bval = DMA_IDLE_CMD;
947: outb(bval,ioport+DMA_Cmd);
948: bval = CLEAR_FIFO_CMD;
949: outb(bval,ioport+ScsiCmd);
950:
951: ResetDevParam( pACB );
952: DoingSRB_Done( pACB );
953: pACB->pActiveDCB = NULL;
954:
955: pACB->ACBFlag = 0;
956: DoWaitingSRB( pACB );
957:
958: restore_flags(flags);
959: #ifdef DC390_DEBUG1
960: printk("DC390: RESET1,");
961: #endif
962: return( SCSI_RESET_SUCCESS );
963: }
964:
965:
966: #include "scsiiom.c"
967:
968:
969: /***********************************************************************
970: * Function : static void DC390_initDCB
971: *
972: * Purpose : initialize the internal structures for a given DCB
973: *
974: * Inputs : cmd - pointer to this scsi cmd request block structure
975: *
976: ***********************************************************************/
977: void DC390_initDCB( PACB pACB, PDCB pDCB, PSCSICMD cmd )
978: {
979: PEEprom prom;
980: UCHAR bval;
981: USHORT index;
982:
983: if( pACB->DeviceCnt == 0 )
984: {
985: pACB->pLinkDCB = pDCB;
986: pACB->pDCBRunRobin = pDCB;
987: pDCB->pNextDCB = pDCB;
988: pPrevDCB = pDCB;
989: }
990: else
991: pPrevDCB->pNextDCB = pDCB;
992:
993: pDCB->pDCBACB = pACB;
994: pDCB->QIORBCnt = 0;
995: pDCB->UnitSCSIID = cmd->target;
996: pDCB->UnitSCSILUN = cmd->lun;
997: pDCB->pWaitingSRB = NULL;
998: pDCB->pGoingSRB = NULL;
999: pDCB->GoingSRBCnt = 0;
1000: pDCB->pActiveSRB = NULL;
1001: pDCB->TagMask = 0;
1002: pDCB->MaxCommand = 1;
1003: pDCB->AdaptIndex = pACB->AdapterIndex;
1004: index = pACB->AdapterIndex;
1005: pDCB->DCBFlag = 0;
1006:
1007: prom = (PEEprom) &eepromBuf[index][cmd->target << 2];
1008: pDCB->DevMode = prom->EE_MODE1;
1009: pDCB->AdpMode = eepromBuf[index][EE_MODE2];
1010:
1011: if( pDCB->DevMode & EN_DISCONNECT_ )
1012: bval = 0xC0;
1013: else
1014: bval = 0x80;
1015: bval |= cmd->lun;
1016: pDCB->IdentifyMsg = bval;
1017:
1018: pDCB->SyncMode = 0;
1019: if( pDCB->DevMode & SYNC_NEGO_ )
1020: {
1021: if( !(cmd->lun) || CurrSyncOffset )
1022: pDCB->SyncMode = SYNC_ENABLE;
1023: }
1024:
1025: pDCB->SyncPeriod = 0;
1026: pDCB->SyncOffset = 0;
1027: pDCB->NegoPeriod = (clock_period1[prom->EE_SPEED] * 25) >> 2;
1028:
1029: pDCB->CtrlR1 = pACB->AdaptSCSIID;
1030: if( pDCB->DevMode & PARITY_CHK_ )
1031: pDCB->CtrlR1 |= PARITY_ERR_REPO;
1032:
1033: pDCB->CtrlR3 = FAST_CLK;
1034:
1035: pDCB->CtrlR4 = EATER_25NS;
1036: if( pDCB->AdpMode & ACTIVE_NEGATION)
1037: pDCB->CtrlR4 |= NEGATE_REQACKDATA;
1038: }
1039:
1040:
1041: /***********************************************************************
1042: * Function : static void DC390_initSRB
1043: *
1044: * Purpose : initialize the internal structures for a given SRB
1045: *
1046: * Inputs : psrb - pointer to this scsi request block structure
1047: *
1048: ***********************************************************************/
1049: void DC390_initSRB( PSRB psrb )
1050: {
1051: #ifndef VERSION_ELF_1_2_13
1052: #ifdef DC390_DEBUG0
1053: printk("DC390 init: %08lx %08lx,",(ULONG)psrb,(ULONG)virt_to_bus(psrb));
1054: #endif
1055: psrb->PhysSRB = virt_to_bus( psrb );
1056: #else
1057: psrb->PhysSRB = (ULONG) psrb;
1058: #endif
1059: }
1060:
1061:
1062: void DC390_linkSRB( PACB pACB )
1063: {
1064: USHORT count, i;
1065: PSRB psrb;
1066:
1067: count = pACB->SRBCount;
1068:
1069: for( i=0; i< count; i++)
1070: {
1071: if( i != count - 1)
1072: pACB->SRB_array[i].pNextSRB = &pACB->SRB_array[i+1];
1073: else
1074: pACB->SRB_array[i].pNextSRB = NULL;
1075: psrb = (PSRB) &pACB->SRB_array[i];
1076: DC390_initSRB( psrb );
1077: }
1078: }
1079:
1080:
1081: /***********************************************************************
1082: * Function : static void DC390_initACB
1083: *
1084: * Purpose : initialize the internal structures for a given SCSI host
1085: *
1086: * Inputs : psh - pointer to this host adapter's structure
1087: *
1088: ***********************************************************************/
1089: void DC390_initACB( PSH psh, ULONG io_port, UCHAR Irq, USHORT index )
1090: {
1091: PACB pACB;
1092: USHORT i;
1093:
1094: psh->can_queue = MAX_CMD_QUEUE;
1095: psh->cmd_per_lun = MAX_CMD_PER_LUN;
1096: psh->this_id = (int) eepromBuf[index][EE_ADAPT_SCSI_ID];
1097: psh->io_port = io_port;
1098: psh->n_io_port = 0x80;
1099: psh->irq = Irq;
1100:
1101: pACB = (PACB) psh->hostdata;
1102:
1103: #ifndef VERSION_ELF_1_2_13
1104: psh->max_id = 8;
1105: #ifdef CONFIG_SCSI_MULTI_LUN
1106: if( eepromBuf[index][EE_MODE2] & LUN_CHECK )
1107: psh->max_lun = 8;
1108: else
1109: #endif
1110: psh->max_lun = 1;
1111: #endif
1112:
1113: pACB->max_id = 7;
1114: if( pACB->max_id == eepromBuf[index][EE_ADAPT_SCSI_ID] )
1115: pACB->max_id--;
1116: #ifdef CONFIG_SCSI_MULTI_LUN
1117: if( eepromBuf[index][EE_MODE2] & LUN_CHECK )
1118: pACB->max_lun = 7;
1119: else
1120: #endif
1121: pACB->max_lun = 0;
1122:
1123: pACB->pScsiHost = psh;
1124: pACB->IOPortBase = (USHORT) io_port;
1125: pACB->pLinkDCB = NULL;
1126: pACB->pDCBRunRobin = NULL;
1127: pACB->pActiveDCB = NULL;
1128: pACB->pFreeSRB = pACB->SRB_array;
1129: pACB->SRBCount = MAX_SRB_CNT;
1130: pACB->AdapterIndex = index;
1131: pACB->status = 0;
1132: pACB->AdaptSCSIID = eepromBuf[index][EE_ADAPT_SCSI_ID];
1133: pACB->HostID_Bit = (1 << pACB->AdaptSCSIID);
1134: pACB->AdaptSCSILUN = 0;
1135: pACB->DeviceCnt = 0;
1136: pACB->IRQLevel = Irq;
1137: pACB->TagMaxNum = eepromBuf[index][EE_TAG_CMD_NUM] << 2;
1138: pACB->ACBFlag = 0;
1139: pACB->scan_devices = 1;
1140: pACB->Gmode2 = eepromBuf[index][EE_MODE2];
1141: if( eepromBuf[index][EE_MODE2] & LUN_CHECK )
1142: pACB->LUNchk = 1;
1143: pACB->pDCB_free = &pACB->DCB_array[0];
1144: DC390_linkSRB( pACB );
1145: pACB->pTmpSRB = &pACB->TmpSRB;
1146: DC390_initSRB( pACB->pTmpSRB );
1147: for(i=0; i<MAX_SCSI_ID; i++)
1148: pACB->DCBmap[i] = 0;
1149: }
1150:
1151:
1152: /***********************************************************************
1153: * Function : static int DC390_initAdapter
1154: *
1155: * Purpose : initialize the SCSI chip ctrl registers
1156: *
1157: * Inputs : psh - pointer to this host adapter's structure
1158: *
1159: ***********************************************************************/
1160: int DC390_initAdapter( PSH psh, ULONG io_port, UCHAR Irq, USHORT index )
1161: {
1162: USHORT ioport;
1163: UCHAR bval;
1164: PACB pACB, pacb;
1165: USHORT used_irq = 0;
1166:
1167: pacb = pACB_start;
1168: if( pacb != NULL )
1169: {
1170: for ( ; (pacb != (PACB) -1) ; )
1171: {
1172: if( pacb->IRQLevel == Irq )
1173: {
1174: used_irq = 1;
1175: break;
1176: }
1177: else
1178: pacb = pacb->pNextACB;
1179: }
1180: }
1181:
1182: if( !used_irq )
1183: {
1184: #ifdef VERSION_ELF_1_2_13
1185: if( request_irq(Irq, DC390_Interrupt, SA_INTERRUPT, "tmscsim"))
1186: #else
1187: if( request_irq(Irq, DC390_Interrupt, SA_INTERRUPT | SA_SHIRQ, "tmscsim", NULL))
1188: #endif
1189: {
1190: printk("DC390: register IRQ error!\n");
1191: return( -1 );
1192: }
1193: }
1194:
1195: request_region(io_port,psh->n_io_port,"tmscsim");
1196:
1197: ioport = (USHORT) io_port;
1198:
1199: pACB = (PACB) psh->hostdata;
1200: bval = SEL_TIMEOUT; /* 250ms selection timeout */
1201: outb(bval,ioport+Scsi_TimeOut);
1202:
1203: bval = CLK_FREQ_40MHZ; /* Conversion factor = 0 , 40MHz clock */
1204: outb(bval,ioport+Clk_Factor);
1205:
1206: bval = NOP_CMD; /* NOP cmd - clear command register */
1207: outb(bval,ioport+ScsiCmd);
1208:
1209: bval = EN_FEATURE+EN_SCSI2_CMD; /* Enable Feature and SCSI-2 */
1210: outb(bval,ioport+CtrlReg2);
1211:
1212: bval = FAST_CLK; /* fast clock */
1213: outb(bval,ioport+CtrlReg3);
1214:
1215: bval = EATER_25NS;
1216: if( eepromBuf[index][EE_MODE2] & ACTIVE_NEGATION )
1217: bval |= NEGATE_REQACKDATA;
1218: outb(bval,ioport+CtrlReg4);
1219:
1220: bval = DIS_INT_ON_SCSI_RST; /* Disable SCSI bus reset interrupt */
1221: outb(bval,ioport+CtrlReg1);
1222:
1223: return(0);
1224: }
1225:
1226:
1227: void
1228: DC390_EnableCfg( USHORT mechnum, UCHAR regval )
1229: {
1230: ULONG wlval;
1231:
1232: if(mechnum == 2)
1233: {
1234: outb(mech2bus, PCI_CFG2_FORWARD_REG);
1235: outb(mech2CfgSPenR, PCI_CFG2_ENABLE_REG);
1236: }
1237: else
1238: {
1239: regval &= 0xFC;
1240: wlval = mech1addr;
1241: wlval |= (((ULONG)regval) & 0xff);
1242: outl(wlval, PCI_CFG1_ADDRESS_REG);
1243: }
1244: }
1245:
1246:
1247: void
1248: DC390_DisableCfg( USHORT mechnum )
1249: {
1250:
1251: if(mechnum == 2)
1252: outb(0, PCI_CFG2_ENABLE_REG);
1253: else
1254: outl(0, PCI_CFG1_ADDRESS_REG);
1255: }
1256:
1257:
1258: UCHAR
1259: DC390_inByte( USHORT mechnum, UCHAR regval )
1260: {
1261: UCHAR bval;
1262: ULONG wval;
1263: ULONG flags;
1264:
1265: save_flags(flags);
1266: cli();
1267: DC390_EnableCfg( mechnum, regval );
1268: if(mechnum == 2)
1269: {
1270: wval = mech2Agent;
1271: wval <<= 8;
1272: wval |= ((USHORT) regval) & 0xff;
1273: bval = inb(wval);
1274: }
1275: else
1276: {
1277: regval &= 3;
1278: bval = inb(PCI_CFG1_DATA_REG | regval);
1279: }
1280: DC390_DisableCfg(mechnum);
1281: restore_flags(flags);
1282: return(bval);
1283: }
1284:
1285:
1286: USHORT
1287: DC390_inWord( USHORT mechnum, UCHAR regval )
1288: {
1289: USHORT wval;
1290: ULONG flags;
1291:
1292: save_flags(flags);
1293: cli();
1294: DC390_EnableCfg(mechnum,regval);
1295: if(mechnum == 2)
1296: {
1297: wval = mech2Agent;
1298: wval <<= 8;
1299: wval |= regval;
1300: wval = inw(wval);
1301: }
1302: else
1303: {
1304: regval &= 3;
1305: wval = inw(PCI_CFG1_DATA_REG | regval);
1306: }
1307: DC390_DisableCfg(mechnum);
1308: restore_flags(flags);
1309: return(wval);
1310: }
1311:
1312:
1313: ULONG
1314: DC390_inDword(USHORT mechnum, UCHAR regval )
1315: {
1316: ULONG wlval;
1317: ULONG flags;
1318: USHORT wval;
1319:
1320: save_flags(flags);
1321: cli();
1322: DC390_EnableCfg(mechnum,regval);
1323: if(mechnum == 2)
1324: {
1325: wval = mech2Agent;
1326: wval <<= 8;
1327: wval |= regval;
1328: wlval = inl(wval);
1329: }
1330: else
1331: {
1332: wlval = inl(PCI_CFG1_DATA_REG);
1333: }
1334: DC390_DisableCfg(mechnum);
1335: restore_flags(flags);
1336: return(wlval);
1337: }
1338:
1339:
1340: void
1341: DC390_OutB(USHORT mechnum, UCHAR regval, UCHAR bval )
1342: {
1343:
1344: USHORT wval;
1345: ULONG flags;
1346:
1347: save_flags(flags);
1348: cli();
1349: DC390_EnableCfg(mechnum,regval);
1350: if(mechnum == 2)
1351: {
1352: wval = mech2Agent;
1353: wval <<= 8;
1354: wval |= regval;
1355: outb(bval, wval);
1356: }
1357: else
1358: {
1359: regval &= 3;
1360: outb(bval, PCI_CFG1_DATA_REG | regval);
1361: }
1362: DC390_DisableCfg(mechnum);
1363: restore_flags(flags);
1364: }
1365:
1366:
1367: void
1368: DC390_EnDisableCE( UCHAR mode, USHORT mechnum, PUCHAR regval )
1369: {
1370:
1371: UCHAR bval;
1372:
1373: bval = 0;
1374: if(mode == ENABLE_CE)
1375: *regval = 0xc0;
1376: else
1377: *regval = 0x80;
1378: DC390_OutB(mechnum,*regval,bval);
1379: if(mode == DISABLE_CE)
1380: DC390_OutB(mechnum,*regval,bval);
1381: udelay(160);
1382: }
1383:
1384:
1385: void
1386: DC390_EEpromOutDI( USHORT mechnum, PUCHAR regval, USHORT Carry )
1387: {
1388: UCHAR bval;
1389:
1390: bval = 0;
1391: if(Carry)
1392: {
1393: bval = 0x40;
1394: *regval = 0x80;
1395: DC390_OutB(mechnum,*regval,bval);
1396: }
1397: udelay(160);
1398: bval |= 0x80;
1399: DC390_OutB(mechnum,*regval,bval);
1400: udelay(160);
1401: bval = 0;
1402: DC390_OutB(mechnum,*regval,bval);
1403: udelay(160);
1404: }
1405:
1406:
1407: UCHAR
1408: DC390_EEpromInDO( USHORT mechnum )
1409: {
1410: UCHAR bval,regval;
1411:
1412: regval = 0x80;
1413: bval = 0x80;
1414: DC390_OutB(mechnum,regval,bval);
1415: udelay(160);
1416: bval = 0x40;
1417: DC390_OutB(mechnum,regval,bval);
1418: udelay(160);
1419: regval = 0x0;
1420: bval = DC390_inByte(mechnum,regval);
1421: if(bval == 0x22)
1422: return(1);
1423: else
1424: return(0);
1425: }
1426:
1427:
1428: USHORT
1429: EEpromGetData1( USHORT mechnum )
1430: {
1431: UCHAR i;
1432: UCHAR carryFlag;
1433: USHORT wval;
1434:
1435: wval = 0;
1436: for(i=0; i<16; i++)
1437: {
1438: wval <<= 1;
1439: carryFlag = DC390_EEpromInDO(mechnum);
1440: wval |= carryFlag;
1441: }
1442: return(wval);
1443: }
1444:
1445:
1446: void
1447: DC390_Prepare( USHORT mechnum, PUCHAR regval, UCHAR EEpromCmd )
1448: {
1449: UCHAR i,j;
1450: USHORT carryFlag;
1451:
1452: carryFlag = 1;
1453: j = 0x80;
1454: for(i=0; i<9; i++)
1455: {
1456: DC390_EEpromOutDI(mechnum,regval,carryFlag);
1457: carryFlag = (EEpromCmd & j) ? 1 : 0;
1458: j >>= 1;
1459: }
1460: }
1461:
1462:
1463: void
1464: DC390_ReadEEprom( USHORT mechnum, USHORT index )
1465: {
1466: UCHAR regval,cmd;
1467: PUSHORT ptr;
1468: USHORT i;
1469:
1470: ptr = (PUSHORT) &eepromBuf[index][0];
1471: cmd = EEPROM_READ;
1472: for(i=0; i<0x40; i++)
1473: {
1474: DC390_EnDisableCE(ENABLE_CE, mechnum, ®val);
1475: DC390_Prepare(mechnum, ®val, cmd);
1476: *ptr = EEpromGetData1(mechnum);
1477: ptr++;
1478: cmd++;
1479: DC390_EnDisableCE(DISABLE_CE,mechnum,®val);
1480: }
1481: }
1482:
1483:
1484: USHORT
1485: DC390_CheckEEpromCheckSum( USHORT MechNum, USHORT index )
1486: {
1487: USHORT wval, rc, *ptr;
1488: UCHAR i;
1489:
1490: DC390_ReadEEprom( MechNum, index );
1491: wval = 0;
1492: ptr = (PUSHORT) &eepromBuf[index][0];
1493: for(i=0; i<128 ;i+=2, ptr++)
1494: wval += *ptr;
1495: if( wval == 0x1234 )
1496: rc = 0;
1497: else
1498: rc = -1;
1499: return( rc );
1500: }
1501:
1502:
1503: USHORT
1504: DC390_ToMech( USHORT Mechnum, USHORT BusDevFunNum )
1505: {
1506: USHORT devnum;
1507:
1508: devnum = BusDevFunNum;
1509:
1510: if(Mechnum == 2)
1511: {
1512: if(devnum & 0x80)
1513: return(-1);
1514: mech2bus = (UCHAR)((devnum & 0xff00) >> 8); /* Bus num */
1515: mech2Agent = ((UCHAR)(devnum & 0xff)) >> 3; /* Dev num */
1516: mech2Agent |= 0xc0;
1517: mech2CfgSPenR = ((UCHAR)(devnum & 0xff)) & 0x07; /* Fun num */
1518: mech2CfgSPenR = (mech2CfgSPenR << 1) | 0x20;
1519: }
1520: else /* use mech #1 method */
1521: {
1522: mech1addr = 0x80000000 | ((ULONG)devnum << 8);
1523: }
1524: return(0);
1525: }
1526:
1527: /***********************************************************************
1528: * Function : static int DC390_init (struct Scsi_Host *host)
1529: *
1530: * Purpose : initialize the internal structures for a given SCSI host
1531: *
1532: * Inputs : host - pointer to this host adapter's structure/
1533: *
1534: * Preconditions : when this function is called, the chip_type
1535: * field of the pACB structure MUST have been set.
1536: ***********************************************************************/
1537:
1538: static int
1539: DC390_init (PSHT psht, ULONG io_port, UCHAR Irq, USHORT index, USHORT MechNum)
1540: {
1541: PSH psh;
1542: PACB pACB;
1543:
1544: if( !DC390_CheckEEpromCheckSum( MechNum, index) )
1545: {
1546: psh = scsi_register( psht, sizeof(DC390_ACB) );
1547: if( !psh )
1548: return( -1 );
1549: if( !pSH_start )
1550: {
1551: pSH_start = psh;
1552: pSH_current = psh;
1553: }
1554: else
1555: {
1556: pSH_current->next = psh;
1557: pSH_current = psh;
1558: }
1559:
1560: #ifdef DC390_DEBUG0
1561: printk("DC390: pSH = %8x,", (UINT) psh);
1562: printk("DC390: Index %02i,", index);
1563: #endif
1564:
1565: DC390_initACB( psh, io_port, Irq, index );
1566: if( !DC390_initAdapter( psh, io_port, Irq, index ) )
1567: {
1568: pACB = (PACB) psh->hostdata;
1569: if( !pACB_start )
1570: {
1571: pACB_start = pACB;
1572: pACB_current = pACB;
1573: pACB->pNextACB = (PACB) -1;
1574: }
1575: else
1576: {
1577: pACB_current->pNextACB = pACB;
1578: pACB_current = pACB;
1579: pACB->pNextACB = (PACB) -1;
1580: }
1581:
1582: #ifdef DC390_DEBUG0
1583: printk("DC390: pACB = %8x, pDCB_array = %8x, pSRB_array = %8x\n",
1584: (UINT) pACB, (UINT) pACB->DCB_array, (UINT) pACB->SRB_array);
1585: printk("DC390: ACB size= %4x, DCB size= %4x, SRB size= %4x\n",
1586: sizeof(DC390_ACB), sizeof(DC390_DCB), sizeof(DC390_SRB) );
1587: #endif
1588:
1589: }
1590: else
1591: {
1592: pSH_start = NULL;
1593: scsi_unregister( psh );
1594: return( -1 );
1595: }
1596: return( 0 );
1597: }
1598: else
1599: {
1600: printk("DC390_init: EEPROM reading error!\n");
1601: return( -1 );
1602: }
1603: }
1604:
1605:
1606: /***********************************************************************
1607: * Function : int DC390_detect(Scsi_Host_Template *psht)
1608: *
1609: * Purpose : detects and initializes AMD53C974 SCSI chips
1610: * that were autoprobed, overridden on the LILO command line,
1611: * or specified at compile time.
1612: *
1613: * Inputs : psht - template for this SCSI adapter
1614: *
1615: * Returns : number of host adapters detected
1616: *
1617: ***********************************************************************/
1618:
1619: int
1620: DC390_detect(Scsi_Host_Template *psht)
1621: {
1622: #ifdef FOR_PCI_OK
1623: UCHAR pci_bus, pci_device_fn;
1624: int error = 0;
1625: USHORT chipType = 0;
1626: USHORT i;
1627: #endif
1628:
1629: UCHAR irq;
1630: UCHAR istatus;
1631: #ifndef VERSION_ELF_1_2_13
1632: UINT io_port;
1633: #else
1634: ULONG io_port;
1635: #endif
1636: USHORT adaptCnt = 0; /* Number of boards detected */
1637: USHORT pci_index = 0; /* Device index to PCI BIOS calls */
1638: USHORT MechNum, BusDevFunNum;
1639: ULONG wlval;
1640:
1641: #ifndef VERSION_ELF_1_2_13
1642: psht->proc_dir = &proc_scsi_tmscsim;
1643: #endif
1644:
1645: InitialTime = 1;
1646: pSHT_start = psht;
1647: pACB_start = NULL;
1648:
1649: MechNum = 1;
1650: for( ; (MechNum < 3) && (!adaptCnt); MechNum++)
1651: {
1652: BusDevFunNum = 0;
1653: for (; adaptCnt < MAX_ADAPTER_NUM ;)
1654: {
1655: if( !DC390_ToMech( MechNum, BusDevFunNum) )
1656: {
1657: wlval = DC390_inDword( MechNum, PCI_VENDOR_ID);
1658: if(wlval == ( (PCI_DEVICE_ID_AMD53C974 << 16)+
1659: PCI_VENDOR_ID_AMD) )
1660: {
1661: io_port =DC390_inDword(MechNum,PCI_BASE_ADDRESS_0) & 0xFFFE;
1662: irq = DC390_inByte( MechNum, PCI_INTERRUPT_LINE);
1663: #ifdef DC390_DEBUG0
1664: printk("DC390: IO_PORT=%4x,IRQ=%x,\n",(UINT) io_port, irq);
1665: #endif
1666: if( !DC390_init(psht, io_port, irq, pci_index, MechNum) )
1667: {
1668: adaptCnt++;
1669: pci_index++;
1670: istatus = inb( (USHORT)io_port+INT_Status ); /* Reset Pending INT */
1671: #ifdef DC390_DEBUG0
1672: printk("DC390: Mech=%2x,\n",(UCHAR) MechNum);
1673: #endif
1674: }
1675: }
1676: }
1677: if( BusDevFunNum != 0xfff8 )
1678: BusDevFunNum += 8; /* next device # */
1679: else
1680: break;
1681: }
1682: }
1683:
1684: #ifdef FOR_PCI_OK
1685: if ( pcibios_present() )
1686: {
1687: for (i = 0; i < MAX_ADAPTER_NUM; ++i)
1688: {
1689: if( !pcibios_find_device( PCI_VENDOR_ID_AMD,
1690: PCI_DEVICE_ID_AMD53C974,
1691: pci_index, &pci_bus, &pci_device_fn) )
1692: {
1693: chipType = PCI_DEVICE_ID_AMD53C974;
1694: pci_index++;
1695: }
1696:
1697: if( chipType )
1698: {
1699:
1700: error = pcibios_read_config_dword(pci_bus, pci_device_fn,
1701: PCI_BASE_ADDRESS_0, &io_port);
1702: error |= pcibios_read_config_byte(pci_bus, pci_device_fn,
1703: PCI_INTERRUPT_LINE, &irq);
1704: if( error )
1705: {
1706: printk("DC390_detect: reading configuration registers error!\n");
1707: InitialTime = 0;
1708: return( 0 );
1709: }
1710:
1711: (USHORT) io_port = (USHORT) io_port & 0xFFFE;
1712: #ifdef DC390_DEBUG0
1713: printk("DC390: IO_PORT=%4x,IRQ=%x,\n",(UINT) io_port, irq);
1714: #endif
1715: if( !DC390_init(psht, io_port, irq, i) )
1716: adaptCnt++;
1717: chipType = 0;
1718: }
1719: else
1720: break;
1721: }
1722: }
1723: #endif
1724:
1725: InitialTime = 0;
1726: adapterCnt = adaptCnt;
1727: return( adaptCnt );
1728: }
1729:
1730:
1731: #ifndef VERSION_ELF_1_2_13
1732:
1733: /********************************************************************
1734: * Function: tmscsim_set_info()
1735: *
1736: * Purpose: Set adapter info (!)
1737: *
1738: * Not yet implemented
1739: *
1740: *******************************************************************/
1741:
1742: int tmscsim_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
1743: {
1744: return(-ENOSYS); /* Currently this is a no-op */
1745: }
1746:
1747: /********************************************************************
1748: * Function: tmscsim_proc_info(char* buffer, char **start,
1749: * off_t offset, int length, int hostno, int inout)
1750: *
1751: * Purpose: return SCSI Adapter/Device Info
1752: *
1753: * Input: buffer: Pointer to a buffer where to write info
1754: * start :
1755: * offset:
1756: * hostno: Host adapter index
1757: * inout : Read (=0) or set(!=0) info
1758: *
1759: * Output: buffer: contains info
1760: * length; length of info in buffer
1761: *
1762: * return value: length
1763: *
1764: ********************************************************************/
1765:
1766: /* KG: proc_info taken from driver aha152x.c */
1767:
1768: #undef SPRINTF
1769: #define SPRINTF(args...) pos += sprintf(pos, ## args)
1770:
1771: #define YESNO(YN)\
1772: if (YN) SPRINTF(" Yes ");\
1773: else SPRINTF(" No ")
1774:
1775: int tmscsim_proc_info(char *buffer, char **start,
1776: off_t offset, int length, int hostno, int inout)
1777: {
1778: int dev, spd, spd1;
1779: char *pos = buffer;
1780: PSH shpnt;
1781: PACB acbpnt;
1782: PDCB dcbpnt;
1783: unsigned long flags;
1784: /* Scsi_Cmnd *ptr; */
1785:
1786: acbpnt = pACB_start;
1787:
1788: while(acbpnt != (PACB)-1)
1789: {
1790: shpnt = acbpnt->pScsiHost;
1791: if (shpnt->host_no == hostno) break;
1792: acbpnt = acbpnt->pNextACB;
1793: }
1794:
1795: if (acbpnt == (PACB)-1) return(-ESRCH);
1796: if(!shpnt) return(-ESRCH);
1797:
1798: if(inout) /* Has data been written to the file ? */
1799: return(tmscsim_set_info(buffer, length, shpnt));
1800:
1801: SPRINTF("Tekram DC390(T) PCI SCSI Host Adadpter, ");
1802: SPRINTF("Driver Version 1.10, 1996/12/05\n");
1803:
1804: save_flags(flags);
1805: cli();
1806:
1807: SPRINTF("SCSI Host Nr %i, ", shpnt->host_no);
1808: SPRINTF("DC390 Adapter Nr %i\n", acbpnt->AdapterIndex);
1809: SPRINTF("IOPortBase 0x%04x, ", acbpnt->IOPortBase);
1810: SPRINTF("IRQLevel 0x%02x\n", acbpnt->IRQLevel);
1811:
1812: SPRINTF("MaxID %i, MaxLUN %i, ",acbpnt->max_id, acbpnt->max_lun);
1813: SPRINTF("AdapterID %i, AdapterLUN %i\n", acbpnt->AdaptSCSIID, acbpnt->AdaptSCSILUN);
1814:
1815: SPRINTF("TagMaxNum %i, Status %i\n", acbpnt->TagMaxNum, acbpnt->status);
1816:
1817: SPRINTF("Nr of attached devices: %i\n", acbpnt->DeviceCnt);
1818:
1819: SPRINTF("Un ID LUN Prty Sync DsCn SndS TagQ NegoPeriod SyncSpeed SyncOffs\n");
1820:
1821: dcbpnt = acbpnt->pLinkDCB;
1822: for (dev = 0; dev < acbpnt->DeviceCnt; dev++)
1823: {
1824: SPRINTF("%02i %02i %02i ", dev, dcbpnt->UnitSCSIID, dcbpnt->UnitSCSILUN);
1825: YESNO(dcbpnt->DevMode & PARITY_CHK_);
1826: YESNO(dcbpnt->SyncMode & SYNC_NEGO_DONE);
1827: YESNO(dcbpnt->DevMode & EN_DISCONNECT_);
1828: YESNO(dcbpnt->DevMode & SEND_START_);
1829: YESNO(dcbpnt->SyncMode & EN_TAG_QUEUING);
1830: SPRINTF(" %03i ns ", (dcbpnt->NegoPeriod) << 2);
1831: if (dcbpnt->SyncOffset & 0x0f)
1832: {
1833: spd = 1000/(dcbpnt->NegoPeriod <<2);
1834: spd1 = 1000%(dcbpnt->NegoPeriod <<2);
1835: spd1 = (spd1 * 10)/(dcbpnt->NegoPeriod <<2);
1836: SPRINTF(" %2i.%1i M %02i\n", spd, spd1, (dcbpnt->SyncOffset & 0x0f));
1837: }
1838: else SPRINTF("\n");
1839: /* Add more info ...*/
1840: dcbpnt = dcbpnt->pNextDCB;
1841: }
1842:
1843: restore_flags(flags);
1844: *start = buffer + offset;
1845:
1846: if (pos - buffer < offset)
1847: return 0;
1848: else if (pos - buffer - offset < length)
1849: return pos - buffer - offset;
1850: else
1851: return length;
1852: }
1853: #endif /* VERSION_ELF_1_2_13 */
1854:
1855:
1856: #ifdef MODULE
1857:
1858: /***********************************************************************
1859: * Function : static int DC390_shutdown (struct Scsi_Host *host)
1860: *
1861: * Purpose : does a clean (we hope) shutdown of the SCSI chip.
1862: * Use prior to dumping core, unloading the driver, etc.
1863: *
1864: * Returns : 0 on success
1865: ***********************************************************************/
1866: static int
1867: DC390_shutdown (struct Scsi_Host *host)
1868: {
1869: UCHAR bval;
1870: USHORT ioport;
1871: unsigned long flags;
1872: PACB pACB = (PACB)(host->hostdata);
1873:
1874: ioport = (unsigned int) pACB->IOPortBase;
1875:
1876: save_flags (flags);
1877: cli();
1878:
1879: /* pACB->soft_reset(host); */
1880:
1881: #ifdef DC390_DEBUG0
1882: printk("DC390: shutdown,");
1883: #endif
1884:
1885: bval = inb(ioport+CtrlReg1);
1886: bval |= DIS_INT_ON_SCSI_RST;
1887: outb(bval,ioport+CtrlReg1); /* disable interrupt */
1888: DC390_ResetSCSIBus( pACB );
1889:
1890: restore_flags (flags);
1891: return( 0 );
1892: }
1893:
1894:
1895: int DC390_release(struct Scsi_Host *host)
1896: {
1897: int irq_count;
1898: struct Scsi_Host *tmp;
1899:
1900: DC390_shutdown (host);
1901:
1902: if (host->irq != IRQ_NONE)
1903: {
1904: for (irq_count = 0, tmp = pSH_start; tmp; tmp = tmp->next)
1905: {
1906: if ( tmp->irq == host->irq )
1907: ++irq_count;
1908: }
1909: if (irq_count == 1)
1910: {
1911: #ifdef DC390_DEBUG0
1912: printk("DC390: Free IRQ %i.",host->irq);
1913: #endif
1914: #ifndef VERSION_ELF_1_2_13
1915: free_irq(host->irq,NULL);
1916: #else
1917: free_irq(host->irq);
1918: #endif
1919: }
1920: }
1921:
1922: release_region(host->io_port,host->n_io_port);
1923:
1924: return( 1 );
1925: }
1926:
1927: Scsi_Host_Template driver_template = DC390_T;
1928: #include "scsi_module.c"
1929: #endif /* def MODULE */
1930:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.