![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to MESH_DBDMA.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvAppleMesh_SCSI|
Return to MESH_DBDMA.h CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvAppleMesh_SCSI |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25:
26: /**
27: * Copyright (c) 1994-1996 NeXT Software, Inc. All rights reserved.
28: * Copyright � 1997 Apple Computer Inc. All Rights Reserved.
29: * @author Martin Minow mailto:[email protected]
30: * @revision 1997.02.13 Initial conversion from AMDPCSCSIDriver sources.
31: *
32: * Set tabs every 4 characters.
33: *
34: * Edit History
35: * 1997.02.13 MM Initial conversion from AMDPCSCSIDriver sources.
36: */
37:
38:
39: #define AUTO_SENSE_ENABLE 1
40:
41: /* These are accessible by SCSIInspector: */
42:
43: #define SYNC_ENABLE "Synchronous"
44: #define FAST_ENABLE "Fast SCSI"
45: #define CMD_QUEUE_ENABLE "Cmd Queueing"
46:
47: /* These are only accessible by Configure's Expert mode: */
48:
49: #define EXTENDED_TIMING "Extended Timing"
50: #define SCSI_CLOCK_RATE "SCSI Clock Rate" /* in MHz */
51:
52:
53: #define USE_ELG FALSE
54: #define CustomMiniMon FALSE
55: //#define CustomMiniMon TRUE
56: //#define USE_ELG TRUE
57: #define kEvLogSize (4096*16) // 16 pages = 64K = 4096 events
58:
59: #if USE_ELG /* (( */
60: #define ELG(A,B,ASCI,STRING) EvLog( (UInt32)(A), (UInt32)(B), (UInt32)(ASCI), STRING )
61: #define PAUSE(A,B,ASCI,STRING) Pause( (UInt32)(A), (UInt32)(B), (UInt32)(ASCI), STRING )
62: #else /* ) not USE_ELG: ( */
63: #define ELG(A,B,ASCI,S)
64: #define PAUSE(A,B,ASCI,S)
65: #define CKSTOP(A,E,ASCI,S)
66: #endif /* USE_ELG )) */
67:
68: #define TIMESTAMP_AT_IOCOMPLETE 0
69:
70: #ifndef TIMESTAMP_AT_IOCOMPLETE
71: #define TIMESTAMP_AT_IOCOMPLETE 0
72: #endif
73:
74:
75: #ifndef TIMESTAMP
76: #define TIMESTAMP 0 // mlj - linking problems with Curio
77: #endif
78:
79: /* These types will ultimately be moved to an implementation-wide header file*/
80: #ifndef __APPLE_TYPES_DEFINED__
81: #define __APPLE_TYPES_DEFINED__ 1
82: typedef unsigned char UInt8; /* An unsigned 8-bit value */
83: typedef unsigned int UInt32; /* An unsigned integer */
84: typedef signed int SInt32; /* An explicitly signed int */
85: typedef void *LogicalAddress; /* A virtual address */
86: typedef UInt32 PhysicalAddress; /* A hardware address */
87: typedef UInt32 ByteCount; /* A transfer length count */
88: typedef UInt32 ItemCount; /* An index or counter */
89: typedef UInt32 Boolean; /* A true/false value */
90: #ifndef TRUE
91: #define TRUE 1
92: #define FALSE 0
93: #endif
94: #endif /* __APPLE_TYPES_DEFINED__ */
95: typedef signed char SInt8;
96: typedef UInt32 OSType;
97:
98: #ifndef SynchronizeIO
99: #define SynchronizeIO() eieio() /* TEMP */
100: #endif /* SynchronizeIO */
101:
102:
103: enum
104: { DBDMA_ReadStartAlignment = 8, // mlj ???
105: DBDMA_WriteStartAlignment = 8
106: };
107:
108: /* Operation flags and options: */
109:
110: typedef enum BusPhase /* These are the real SCSI bus phases (from busStatus0): */
111: {
112: kBusPhaseDATO = 0,
113: kBusPhaseDATI,
114: kBusPhaseCMD,
115: kBusPhaseSTS,
116: kBusPhaseReserved1,
117: kBusPhaseReserved2,
118: kBusPhaseMSGO,
119: kBusPhaseMSGI,
120: kBusPhaseBusFree
121: } BusPhase;
122:
123: /* Command to be executed by IO thread. */
124: /* These are ultimately derived from ioctl control values. */
125:
126: typedef enum
127: { kCommandExecute, /* Execute IOSCSIRequest */
128: kCommandResetBus, /* Reset bus */
129: kCommandAbortRequest /* Abort IO thread */
130: } CommandOperation;
131:
132: /* We read target messages using a simple state machine. */
133: /* On entrance to MSGI phase, gMsgInState = kMsgInInit. */
134: /* Continue reading messages until either */
135: /* gMsgInState == kMsgInReady or the target changes phase */
136: /* (which is an error). */
137: typedef enum MsgInState
138: {
139: kMsgInInit = 0, /* 0 Not reading a message (must be zero) */
140: kMsgInReading, /* 1 MSG input state: reading counted data */
141: kMsgInCounting, /* 2 MSG input state: reading count byte */
142: kMsgInReady /* 3 MSG input state: a msg is now available */
143: } MsgInState;
144:
145:
146: /* This is the maximum number of bytes to be transferred */
147: /* in an autosense request. It is, by inspection, less than 256. */
148: enum { kMaxAutosenseByteCount = sizeof( esense_reply_t ) };
149:
150: /* These values are stored in gCurrentTarget and gCurrentLUN */
151: /* when there is no active request. */
152: enum
153: { kInvalidTarget = 0xFFFF,
154: kInvalidLUN = 0xFFFF
155: };
156:
157: /* The default initiator bus ID (needs to be fetched from NVRAM). */
158: enum { kInitiatorIDDefault = 7 };
159: #define APPLE_SCSI_RESET_DELAY 250 /* Msec */
160:
161: /* Command struct passed to IO thread. */
162: /* One of these are created for each active IO request. */
163:
164: typedef struct CommandBuffer
165: {
166: /* Fields valid when commandBuf is passed to IO thread. */
167: CommandOperation op; /* kCommandExecute, etc. */
168:
169: /* The following 3 fields are only valid if op == kCommandExecute. */
170: /* They are passed into the SCSI driver by executeRequest. */
171:
172: IOSCSIRequest *scsiReq; /* -> The SCSI command parameter block */
173: IOMemoryDescriptor *mem; /* -> Memory to transfer, if any */
174: vm_task_t client; /* == The client task (for vm mapping) */
175:
176: /* These fields are used by the IO thread to manage the IO request: */
177: /* cmdLock Wait for the command to complete */
178: /* link Queue link for the command, disconnect, and */
179: /* pending queues. */
180: /* timeoutPort Port for timeout messages */
181: /* queueTag SCSI tagged request if not QUEUE_TAG_NONTAGGED */
182:
183: NXConditionLock *cmdLock; /* client waits on this */
184: queue_chain_t link; /* for enqueueing on commandQ */
185: // port_t timeoutPort; /* for timeout messages */
186: UInt8 queueTag; /* QUEUE_TAG_NONTAGGED or queue tag */
187: UInt8 cdbLength; /* Actual length of this command */
188:
189: /* SCSI bus state variables. Note that currentDataIndex can exceed */
190: /* scsiReq->maxTransfer if the device sends (receives) more data than */
191: /* we can receive (send). These values are NOT used for autosense. */
192: /* The first byte to transfer is at logical address */
193: /* gActiveCommand->buffer + currentDataIndex. */
194:
195: UInt32 currentDataIndex; /* Where we are in the DATA transfer */
196: UInt32 savedDataIndex; /* For SaveDataPointers */
197:
198: IOMemoryDescriptorState savedDataState;/* saved index for IOMemoryDescriptor*/
199:
200: /* Request management flags */
201: /* flagActive */
202: /* Set if we're in the active array and active count */
203: /* reflects our existance. Managed by [ self activateCmd ] */
204: /* and [ self deactivateCmd : cmdBuf ]. */
205: /* and that IOScheduleFunc() has been called. */
206: /* flagRequestSelectOK */
207: /* Arbitration/selection succeeded for this request. */
208: /* flagIsAutosense */
209: /* Set if we are executing an internally-generated */
210: /* Request Sense command. If this is an autosense, */
211: /* the operation is modified as follows: */
212: /* Arb/Select: Disable disconnects. Re-establish */
213: /* synchronous and fast for this target, */
214: /* use the current tag, if any. */
215: /* Command: Use an internally-generated Request Sense. */
216: /* Data: Read into our wired-down sense buffer. */
217: /* Do not touch the data index and transfer */
218: /* count variables. On completion, copy */
219: /* from our wired-down buffer to the caller's */
220: /* sense array. */
221: /* Completion: Good status, return SR_IOST_CHKSV to client.*/
222: /* Bad status: never set isAutosense. Driver */
223: /* return SR_IOST_CHKSNV. */
224:
225: UInt32 flagActive:1, /* We're in activeArray and activeCount */
226: flagRequestSelectOK:1, /* Did arbitration/selection succeed? */
227: flagIsAutosense:1, /* Set if THIS is an autosense command */
228: pad:29;
229: /* This is set by autosense Status phase. */
230: UInt8 autosenseStatus; /* Did autosense complete ok? */
231: /* Statistics support. */
232: ns_time_t startTime; /* time cmd started */
233: ns_time_t disconnectTime; /* time of last disconnect */
234:
235: } CommandBuffer;
236:
237: /* Condition variable states for commandBuf.cmdLock. */
238:
239: enum { CMD_PENDING = 0, CMD_COMPLETE };
240:
241: /* Value of queueTag for nontagged commands. */
242: /* This value is never used for the tag for tagged commands. */
243:
244: enum { QUEUE_TAG_NONTAGGED = 0 };
245:
246: /* Per-target info. */
247: /* */
248: /* maxQueue is set to a non-zero value when we reach a target's queue size */
249: /* limit, detected by a STAT_QUEUE_FULL status. A value of zero means we */
250: /* have not reached the target's limit and we are free to queue additional */
251: /* commands (if allowed by the overall cmdQueueEnable flag). */
252: /* */
253: /* syncXferPeriod and syncXferOffset are set to non-zero during sync */
254: /* transfer negotiation. Units of syncXferPeriod is NANOSECONDS, which */
255: /* differs from both the chip's register format (dependent on clock */
256: /* frequency and fast SCSI/fast clock enables) and the SCSI bus's format */
257: /* (which is 4 ns per unit). */
258: /* */
259: /* cmdQueueDisable and syncDisable have a default (initial) value of */
260: /* zero regardless of the driver's overall cmdQueueEnable and syncModeEnable */
261: /* flags. They are set to one when a target explicitly tells us that the */
262: /* indicated feature is unsupported. */
263: /* */
264: /* negotiateSDTR has one of the following values (defined in */
265: /* AppleMeshDefinitions.h): */
266: /* kSyncParmsAsync Async with min period */
267: /* kSyncParmsFast Offset = 15, period = Fast (10 MB/s) */
268: /* syncParms Shadow of MESH syncParms register. */
269:
270: typedef struct
271: {
272: UInt8 maxQueue; /* Max queue depth for this target */
273: UInt8 negotiateSDTR; /* Synchronous negotiation control */
274: UInt8 syncParms; /* Synchronous period and offset */
275: UInt8 inquiry_7; /* 7th byte peeked fm Inquiry data */
276: UInt8 syncDisable; /* No synchronous for this target */
277: } PerTargetData;
278:
279: typedef struct MeshRegister /* Mesh registers: */
280: {
281: volatile UInt8 transferCount0; UInt8 pad00[ 0x0F ];
282: volatile UInt8 transferCount1; UInt8 pad01[ 0x0F ];
283: volatile UInt8 xFIFO; UInt8 pad02[ 0x0F ];
284: volatile UInt8 sequence; UInt8 pad03[ 0x0F ];
285: volatile UInt8 busStatus0; UInt8 pad04[ 0x0F ];
286: volatile UInt8 busStatus1; UInt8 pad05[ 0x0F ];
287: volatile UInt8 FIFOCount; UInt8 pad06[ 0x0F ];
288: volatile UInt8 exception; UInt8 pad07[ 0x0F ];
289: volatile UInt8 error; UInt8 pad08[ 0x0F ];
290: volatile UInt8 interruptMask; UInt8 pad09[ 0x0F ];
291: volatile UInt8 interrupt; UInt8 pad10[ 0x0F ];
292: volatile UInt8 sourceID; UInt8 pad11[ 0x0F ];
293: volatile UInt8 destinationID; UInt8 pad12[ 0x0F ];
294: volatile UInt8 syncParms; UInt8 pad13[ 0x0F ];
295: volatile UInt8 MESHID; UInt8 pad14[ 0x0F ];
296: volatile UInt8 selectionTimeOut;
297: } MeshRegister;
298:
299: /* The following structure shadows the MESH chip registers: */
300:
301: typedef union MESHShadow
302: { UInt32 longWord[ 3 ]; /* for debugging ease. */
303: struct
304: { UInt8 interrupt; /* Interrupt */
305: UInt8 error; /* Error register */
306: UInt8 exception; /* Exception register */
307: UInt8 FIFOCount; /* FIFO count */
308:
309: UInt8 busStatus0; /* Bus phase + REQ, ACK, & ATN signals */
310: UInt8 busStatus1; /* RST, BSY, SEL */
311: UInt8 interruptMask; /* Interrupt mask for debugging */
312: UInt8 transferCount0; /* low order byte of transfer count */
313:
314: UInt8 transferCount1; /* high order byte of transfer count */
315: UInt8 sequence; /* Sequence register */
316: UInt8 syncParms; /* syncParms for debugging */
317: UInt8 destinationID; /* Target ID */
318: } mesh;
319: } MESHShadow;
320:
321: /* Mesh Register set offsets */
322:
323: enum
324: {
325: kMeshTransferCount0 = 0x00,
326: kMeshTransferCount1 = 0x10,
327: kMeshFIFO = 0x20,
328: kMeshSequence = 0x30,
329: kMeshBusStatus0 = 0x40,
330: kMeshBusStatus1 = 0x50,
331: kMeshFIFOCount = 0x60,
332: kMeshException = 0x70,
333: kMeshError = 0x80,
334: kMeshInterruptMask = 0x90,
335: kMeshInterrupt = 0xA0,
336: kMeshSourceID = 0xB0,
337: kMeshDestinationID = 0xC0,
338: kMeshSyncParms = 0xD0,
339: kMeshMESHID = 0xE0,
340: kMeshSelTimeOut = 0xF0
341: };
342:
343: enum { kMeshMESHID_Value = 0x02 }; /* Read value of kMESHID lowest 5 bits only */
344:
345:
346: /* MESH commands & modifiers for sequence register: */
347:
348: typedef enum
349: {
350: kMeshNoOpCmd = 0x00,
351:
352: kMeshArbitrateCmd = 0x01,
353: kMeshSelectCmd = 0x02,
354: kMeshCommandCmd = 0x03,
355: kMeshStatusCmd = 0x04,
356: kMeshDataOutCmd = 0x05,
357: kMeshDataInCmd = 0x06,
358: kMeshMessageOutCmd = 0x07,
359: kMeshMessageInCmd = 0x08,
360: kMeshBusFreeCmd = 0x09,
361: /* non interrupting: */
362: kMeshEnableParity = 0x0A,
363: kMeshDisableParity = 0x0B,
364: kMeshEnableReselect = 0x0C,
365: kMeshDisableReselect = 0x0D,
366: kMeshResetMESH = 0x0E,
367: kMeshFlushFIFO = 0x0F,
368: /* Sequence command modifier bits: */
369: kMeshSeqDMA = 0x80, /* Data Xfer for this command will use DMA */
370: kMeshSeqTMode = 0x40, /* Target mode - unused */
371: kMeshSeqAtn = 0x20 /* ATN is to be asserted after command */
372: } MeshCommand;
373:
374: /* The bus Status Registers 0 & 1 have the actual */
375: /* bus signals WHEN READ. */
376:
377: enum /* bus Status Register 0 bits: */
378: {
379: kMeshIO = 0x01, /* phase bit */
380: kMeshCD = 0x02, /* phase bit */
381: kMeshMsg = 0x04, /* phase bit */
382: kMeshAtn = 0x08, /* Attention signal */
383: kMeshAck = 0x10, /* Ack signal */
384: kMeshReq = 0x20, /* Request signal */
385: kMeshAck32 = 0x40, /* unused - 32 bit bus */
386: kMeshReq32 = 0x80 /* unused - 32 bit bus */
387: };
388:
389: enum { kMeshPhaseMask = (kMeshMsg + kMeshCD + kMeshIO) };
390:
391: enum /* bus Status Register 1 bits: */
392: {
393: kMeshSel = 0x20, /* Select signal */
394: kMeshBsy = 0x40, /* Busy signal */
395: kMeshRst = 0x80 /* Reset signal */
396: };
397:
398: enum /* Exception Register bits: */
399: {
400: kMeshExcSelTO = 0x01, /* Selection timeout */
401: kMeshExcPhaseMM = 0x02, /* Phase mismatch */
402: kMeshExcArbLost = 0x04, /* lost arbitration */
403: kMeshExcResel = 0x08, /* reselection occurred */
404: kMeshExcSelected = 0x10,
405: kMeshExcSelectedWAtn = 0x20
406: };
407:
408: enum /* Error Register bits: */
409: {
410: kMeshErrParity0 = 0x01, /* parity error */
411: kMeshErrParity1 = 0x02, /* unused - 32 bit bus */
412: kMeshErrParity2 = 0x04, /* unused - 32 bit bus */
413: kMeshErrParity3 = 0x08, /* unused - 32 bit bus */
414: kMeshErrSequence = 0x10, /* Sequence error */
415: kMeshErrSCSIRst = 0x20, /* Reset signal asserted */
416: kMeshErrDisconnected = 0x40 /* unexpected disconnect */
417: };
418:
419: enum /* Interrupt Register bits: */
420: {
421: kMeshIntrCmdDone = 0x01, /* command done */
422: kMeshIntrException = 0x02, /* exception occurred */
423: kMeshIntrError = 0x04, /* error occurred */
424: kMeshIntrMask = (kMeshIntrCmdDone | kMeshIntrException | kMeshIntrError)
425: };
426:
427:
428: enum /* Values for SyncParms MESH register: */
429: { /* 1st nibble is offset, 2nd is period. */
430: /* Zero offset means async. */
431: kSyncParmsAsync = 0x02, /* Async with min period = 2 */
432: kSyncParmsFast = 0xF0 /* offset = 15, period = Fast (10 MB/s) */
433: };
434:
435: /* The following are specific to the MESH CCL */
436: /* Stage Names. (These were originally 'xxxx' identifiers, */
437: /* which is convenient for debugging, but results in many */
438: /* warning messages from the NeXT compiler. */
439: enum
440: {
441: kcclStageIdle = 0, /* 0 - Idle */
442: kcclStageInit, /* 1 - 'Init' */
443: kcclStageCCLx, /* 2 - 'CCL~' */
444: kcclStageArb, /* 3 - ' Arb' */
445: kcclStageSelA, /* 4 - 'SelA' */
446: kcclStageMsgO, /* 5 - 'MsgO' */
447: kcclStageCmdO, /* 6 - 'CmdO' */
448: kcclStageXfer, /* 7 - 'Xfer' */
449: kcclStageBucket, /* 8 - 'Buck' */
450: kcclStageSyncHack, /* 9 - 'Hack' */
451: kcclStageStat, /* A - ' Sta' */
452: kcclStageMsgI, /* B - 'MsgI' */
453: kcclStageFree, /* C - 'Free' */
454: kcclStageGood, /* D - 'Good' */
455: kcclStageStop, /* E - '++++' */
456: kcclTerminatorWithoutComma
457: };
458:
459: /* offsets into the Channel Command List page: */
460:
461: #define kcclProblem 0x00 // Interrupt & Stop channel commands for anomalies
462: #define kcclCMDOdata 0x20 // reserve for 6, 10, 12 byte commands
463: #define kcclMSGOdata 0x30 // reserve for Identify, Tag stuff
464: #define kcclMSGOLast 0x3F // reserve for last or only msg0ut byte
465: #define kcclMSGIdata 0x40 // reserve for Message In data
466: #define kcclBucket 0x48 // Bit Bucket
467: #define kcclStatusData 0x4F // reserve for Status byte
468: #define kcclSenseCDB 0x50 // CDB for (auto) Sense
469: #define kcclBatchSize 0x60 // Current MESH batch size
470: #define kcclStageLabel 0x6C // storage for label of last stage entered.
471: #define kcclSense 0x70 // Channel Commands for (Auto)Sense
472: #define kcclPrototype 0xC0 // Prototype MESH 4-command Transfer sequence
473: #define kcclStart 0x120 // Channel Program starts here with Arbitrate
474: #define kcclBrProblem 0x140 // channel command to wait for cmdDone & Br if problem
475: #define kcclMsgoStage 0x190 // Branch to single byte Message-Out
476: #define kcclMsgoBranch 0x1B0 // Branch to single byte Message-Out
477: #define kcclMsgoMTC 0x1D8 // MESH Transfer Count for MSGO (low order only)
478: #define kcclMsgoDTC 0x1F0 // DMA Transfer Count for MSGO (low order only)
479: #define kcclLastMsgo 0x210 // Channel commands to put last/only byte of Message-Out
480: #define kcclCmdoStage 0x290 // Start of Command phase
481: #define kcclCmdoMTC 0x2C8 // MESH Transfer Count for CMDO (low order only)
482: #define kcclCmdoDTC 0x2E0 // DMA Transfer Count for CMDO (low order only)
483: #define kcclReselect 0x2F0 // Reselect enters CCL here - Branch to xfer data
484: #define kcclOverrun 0x320 // data overrun - dump the excess in the bit bucket
485: #define kcclOverrunMESH 0x370 // data overrun - patch the MESH Seq Reg I/O
486: #define kcclOverrunDBDMA 0x380 // data overrun - patch the DBDMA I/O
487: #define kcclSyncCleanUp 0x3B0 // clean up at end of Sync xfer
488: #define kcclGetStatus 0x3D0 // Finish up with Status, Message In, and Bus Free
489: #define kcclMESHintr 0x4D0 // transaction done or going well
490: #define kcclSenseBuffer 0x500 // Buffer for Autosense data
491: #define kcclDataXfer 0x600 // INPUT or OUTPUT channel commands for data
492: #define kcclSenseResult 0x63C // Result field in Sense INPUT channel command
493:
494:
495: /* generic relocation types: */
496:
497: #define kRelNone 0x00 /* default - no relocation */
498: #define kRelMESH 0x01 /* Relocate to MESH register area */
499: #define kRelCP 0x02 /* Relocate to Channel Program area */
500: #define kRelCPdata 0x03 /* Relocate to Channel Program data structure */
501: #define kRelPhys 0x04 /* Relocate to user Physical address space */
502: #define kRelNoSwap 0x05 /* don't relocate or swap (Label) */
503:
504: /* Relocatable ADDRESS types: */
505:
506: #define kRelAddress 0xFF <<8 /* relocatable address mask */
507: #define kRelAddressMESH kRelMESH <<8 /* MESH physical address */
508: #define kRelAddressCP kRelCP <<8 /* Channel Program Physical address */
509: #define kRelAddressPhys kRelPhys <<8 /* User data Physical address */
510:
511: /* Relocatable COMMAND-DEPENDENT types: */
512:
513: #define kRelCmdDep 0xFF /* relocatable command-dependent mask */
514: #define kRelCmdDepCP kRelCP /* Channel Program command-dependent (branch) */
515: #define kRelCmdDepLabel kRelNoSwap /* Channel Program label - don't swap */
516:
517:
518: /* Channel Program macros: */
519:
520: #define STAGE(v) STORE_QUAD | KEY_SYSTEM | 4, kcclStageLabel, v, kRelAddressCP | kRelCmdDepLabel
521: #define CLEAR_CMD_DONE STORE_QUAD | KEY_SYSTEM | 1, kMeshInterrupt, kMeshIntrCmdDone, kRelAddressMESH
522: #define CLEAR_INT_REG STORE_QUAD | KEY_SYSTEM | 1, kMeshInterrupt, kMeshIntrMask, kRelAddressMESH
523: #define CLR_PHASEMM STORE_QUAD | KEY_SYSTEM | 1, kMeshInterrupt, kMeshIntrCmdDone | kMeshIntrException, kRelAddressMESH
524: #define MOVE_1(a,v,r) STORE_QUAD | KEY_SYSTEM | 1, a, v, r
525: #define MOVE_4(a,v,r) STORE_QUAD | KEY_SYSTEM | 4, a, v, r
526: #define MESH_REG(a,v) STORE_QUAD | KEY_SYSTEM | 1, a, v, kRelAddressMESH
527: #define MESH_REG_WAIT(a,v) STORE_QUAD | KEY_SYSTEM | kWaitIfTrue | 1, a, v, kRelAddressMESH
528:
529: #define SENSE(c) INPUT_LAST | kBranchIfFalse | kWaitIfTrue | c, kcclSenseBuffer, kcclProblem, kRelAddressCP | kRelCmdDepCP
530: #define MSGO(a,c) OUTPUT_LAST | kBranchIfFalse | kWaitIfTrue | c, a, kcclProblem, kRelAddressCP | kRelCmdDepCP
531: #define CMDO(c) OUTPUT_LAST | kBranchIfFalse | kWaitIfTrue | c, kcclCMDOdata, kcclProblem, kRelAddressCP | kRelCmdDepCP
532: #define MSGI(c) INPUT_LAST | kBranchIfFalse | kWaitIfTrue | c, kcclMSGIdata, kcclProblem, kRelAddressCP | kRelCmdDepCP
533: #define STATUS_IN INPUT_LAST | kBranchIfFalse | kWaitIfTrue | 1, kcclStatusData, kcclProblem, kRelAddressCP | kRelCmdDepCP
534: #define BUCKET INPUT_LAST | kBranchIfFalse | 8, kcclBucket, kcclProblem, kRelAddressCP | kRelCmdDepCP
535:
536: #define BRANCH(a) NOP_CMD | kBranchAlways, 0, a, kRelCmdDepCP
537: #define BR_IF_PROBLEM NOP_CMD | kBranchIfFalse | kWaitIfTrue, 0, kcclProblem, kRelCmdDepCP
538: #define BR_NO_PROBLEM(a) NOP_CMD | kBranchIfTrue , 0, a, kRelCmdDepCP
539: #define STOP(L) STOP_CMD, 0, L, kRelCmdDepLabel
540: #define INTERRUPT(a) NOP_CMD | kIntAlways, 0, a, 0
541: #define RESERVE 0xCEFECEFE, 0xCEFECEFE, 0xCEFECEFE, 0xCEFECEFE
542: #define WAIT_4_CMDDONE NOP_CMD | kWaitIfTrue, 0, 0, 0
543:
544: //#define SWAP(x) (UInt32)EndianSwap32Bit( (UInt32)( x ) )
545: #define SWAP(x) (UInt32)EndianSwap32( (UInt32)( x ) )
546:
547:
548: /* Return values from hardwareStart. */
549:
550: typedef enum
551: { kHardwareStartOK, /* command started successfully */
552: kHardwareStartRejected, /* command rejected, try another */
553: kHardwareStartBusy /* hardware not ready for command */
554: } HardwareStartResult;
555:
556: /* This structure defines the DBDMA Channel Command descriptor. */
557: /***** WARNING: Endian-ness issues must be considered when *****/
558: /***** performing load/store! *****/
559: /***** DBDMA specifies memory organization as quadlets so it *****/
560: /***** is not correct to think of either the operation or *****/
561: /***** result field as two 16-bit fields. This would have *****/
562: /***** undesirable effects on the byte ordering within their *****/
563: /***** respective quadlets. Use the accessor macros provided *****/
564: /***** below. *****/
565:
566: struct DBDMADescriptor
567: {
568: UInt32 operation; /* cmd || key || i || b || w || reqCount */
569: UInt32 address;
570: UInt32 cmdDep;
571: UInt32 result; /* xferStatus || resCount */
572: };
573: typedef struct DBDMADescriptor DBDMADescriptor;
574:
575: typedef DBDMADescriptor *DBDMADescriptorPtr;
576:
577: /* These constants define the DBDMA channel command operations and modifiers.*/
578:
579: enum /* Command.cmd operations */
580: {
581: OUTPUT_MORE = 0x00000000,
582: OUTPUT_LAST = 0x10000000,
583: INPUT_MORE = 0x20000000,
584: INPUT_LAST = 0x30000000,
585: STORE_QUAD = 0x40000000,
586: LOAD_QUAD = 0x50000000,
587: NOP_CMD = 0x60000000,
588: STOP_CMD = 0x70000000,
589: kdbdmaCmdMask = 0xF0000000
590: };
591:
592:
593: enum
594: { /* Command.key modifiers */
595: /* (choose one for INPUT, OUTPUT, LOAD, and STORE) */
596: KEY_STREAM0 = 0x00000000, /* default modifier*/
597: KEY_STREAM1 = 0x01000000,
598: KEY_STREAM2 = 0x02000000,
599: KEY_STREAM3 = 0x03000000,
600: KEY_REGS = 0x05000000,
601: KEY_SYSTEM = 0x06000000,
602: KEY_DEVICE = 0x07000000,
603: kdbdmaKeyMask = 0x07000000, /* Command.i modifiers (choose one for INPUT, OUTPUT, LOAD, STORE, and NOP)*/
604: kIntNever = 0x00000000, /* default modifier */
605: kIntIfTrue = 0x00100000,
606: kIntIfFalse = 0x00200000,
607: kIntAlways = 0x00300000,
608: kdbdmaIMask = 0x00300000, /* Command.b modifiers (choose one for INPUT, OUTPUT, and NOP)*/
609: kBranchNever = 0x00000000, /* default modifier */
610: kBranchIfTrue = 0x00040000,
611: kBranchIfFalse = 0x00080000,
612: kBranchAlways = 0x000C0000,
613: kdbdmaBMask = 0x000C0000, /* Command.w modifiers (choose one for INPUT, OUTPUT, LOAD, STORE, and NOP)*/
614: kWaitNever = 0x00000000, /* default modifier */
615: kWaitIfTrue = 0x00010000,
616: kWaitIfFalse = 0x00020000,
617: kWaitAlways = 0x00030000,
618: kdbdmaWMask = 0x00030000, /* operation masks */
619: };
620:
621:
622: /* This is a temporary implementation of EndianSwap32Bit */
623: /* until the correct library/method is made available. */
624: /* @param value The value to change */
625: /* @result The value endian-swapped. */
626:
627: #ifdef CRAP
628: static inline unsigned EndianSwap32Bit( unsigned value )
629: {
630: register unsigned temp;
631:
632: temp = ((value & 0xFF000000) >> 24);
633: temp |= ((value & 0x00FF0000) >> 8);
634: temp |= ((value & 0x0000FF00) << 8);
635: temp |= ((value & 0x000000FF) << 24);
636: return temp;
637: }
638: #else
639: static __inline__ UInt32 EndianSwap32( UInt32 y )
640: {
641: UInt32 result;
642: volatile UInt32 x;
643:
644: x = y;
645: __asm__ volatile("lwbrx %0, 0, %1" : "=r" (result) : "r" (&x) : "r0");
646: return result;
647: }
648: #endif /* CRAP */
649:
650:
651: typedef struct globals /* Globals for this module (not per instance) */
652: {
653: UInt32 evLogFlag; // debugging only
654: UInt8 *evLogBuf;
655: UInt8 *evLogBufe;
656: UInt8 *evLogBufp;
657: UInt8 intLevel;
658:
659: MESHShadow shadow; // move to per instance??? /* Last MESH register state */
660:
661: UInt32 cclLogAddr, cclPhysAddr; // for debugging/miniMon ease
662: UInt32 meshAddr; // for debugging/miniMon ease
663: } globals;
664:
665:
666: /* "Global" data for each instance of the MESH Host Bus Adapter: */
667:
668: @interface AppleMesh_SCSI : IOSCSIController < IOPower >
669: {
670: /* These globals locate the hardware interfaces in */
671: /* logical and physical address spaces. */
672:
673: MeshRegister *meshAddr; /* -> Mesh registers (logical) */
674: PhysicalAddress gMESHPhysAddr; /* -> Mesh registers (physical) */
675:
676: dbdma_regmap_t *dbdmaAddr; /* -> DBDMA registers (logical) */
677: PhysicalAddress dbdmaAddrPhys; /* -> DBDMA registers (physical) */
678:
679: PhysicalAddress cclPhysAddr; /* -> DBDMA channel area (physical) */
680: DBDMADescriptor *cclLogAddr; /* -> DBDMA channel area (logical) */
681: UInt32 cclLogAddrSize; /* == DBDMA channel allocated size */
682: UInt32 gDBDMADescriptorMax; /* Number of DATA descriptors */
683:
684:
685: /* There are 3 queues: incomingCmdQ, pendingCmdQ, disconnectedCmdQ. */
686: /* Commands are passed from exported methods to the IO thread via */
687: /* incomingCmdQ, which is protected by incomingCmdLock. */
688: /* Commands which are disconnected but not complete are kept in */
689: /* disconnectedCmdQ. */
690: /* Commands which have been dequeued from incomingCmdQ by the IO thread */
691: /* but which have not been started because a command is currently active*/
692: /* on the bus are kept in pendingCmdQ. This queue also holds commands */
693: /* pushed back when we lose arbitration. */
694:
695: /* The currently active command, if any, is kept in gActiveCommand. */
696: /* Only commandBufs with op == kCommandExecute are ever placed in */
697: /* gActiveCommand. */
698: id incomingCmdLock; /* NXLock for incomingCmdQ */
699: queue_head_t incomingCmdQ;
700: queue_head_t pendingCmdQ;
701: queue_head_t disconnectedCmdQ;
702: queue_head_t abortCmdQ;
703:
704: /* This is the command we're currently execution. If NULL, the Mac */
705: /* is idle (or all commands are disconnected). Normally, gCurrentTarget */
706: /* and gCurrentLUN track the values in the active command's associated */
707: /* SCSI request. They are set to kInvalidTarget and kInvalidLUN at */
708: /* initialization, command deactivation, command complete, and command */
709: /* disconnect. They are set to valid values (with no active command) */
710: /* during reselection. This is tricky, so look carefully at the code. */
711: CommandBuffer *gActiveCommand; /* -> The currently executing command */
712: UInt32 gCurrentTarget; /* == The current target bus ID */
713: UInt32 gCurrentLUN; /* == The current target LUN */
714:
715: /* Global option flags, accessible via instance table or setIntValues. Note: some of
716: * these are intended for debugging. However, users may need to disable command
717: * queuing, synchronous, or fast to handle device or bus limitations. The
718: * architecture-specific initialization "looks" at the device to determine whether
719: * specific features (such as synchronous) are supported.
720: * gOptionAutoSenseEnable Debug only, normally set
721: * gOptionCmdQueueEnable Enable tagged queuing.
722: * gOptionSyncModeEnable Enable synchronous transfers (clear if problems)
723: * gOptionFastModeEnable Enable fast transfers (clear if problems)
724: * gOptionExtendTiming Extended selection timing (debug, unused)
725: * gFlagIOThreadRunning Set when IO thread is initialized. Needed
726: * for shutdown.
727: * gFlagIncompleteDBDMA Set in the data transfer setup if there was
728: * so much data that the entire transfer could not
729: * be stored in the CCL area. If so, the interrupt
730: * service routine ("good completion") will restart
731: * the data transfer operation.
732: */
733: UInt32 gOptionAutoSenseEnable : 1,
734: gOptionCmdQueueEnable : 1,
735: gOptionSyncModeEnable : 1,
736: gOptionFastModeEnable : 1,
737: gOptionExtendTiming : 1,
738: gFlagIOThreadRunning : 1, /* Set at init */
739: gFlagIncompleteDBDMA : 1, /* Need more DMA */
740: gFlagReselecting : 1, /* Reselection in progress */
741: pad : 24;
742:
743: /* Array of active IO counters, one counter per LUN per target. */
744: /* If command queueing is disabled, the max value of each counter is 1. */
745: /* gActiveCount is the sum of all elements in activeArray. */
746:
747: UInt8 gActiveArray[ SCSI_NTARGETS ][ SCSI_NLUNS ];
748: UInt32 gActiveCount;
749:
750: /* These variables change during SCSI IO operation. */
751: /* msgOutPtr Points to the next free byte in the MSGO buffer */
752: /* in the shared CCL area. */
753:
754: UInt8 *msgOutPtr; /* ptr to message-out data */
755:
756: /* These variables manage Message-In bus phase. Because the */
757: /* Message-In handler uses programmed IO, gMsgInCount and */
758: /* gMsgInState are actually local variables to the message */
759: /* reader, and are here for debugging convenience. */
760:
761: UInt8 gMsgInBuffer[ 16 ];
762: SInt8 gMsgInCount; /* Message bytes still to read */
763: MsgInState gMsgInState; /* How are we handling messages */
764:
765: #define kFlagMsgIn_Reject 0x01
766: #define kFlagMsgIn_Disconnect 0x02
767: UInt8 gMsgInFlag;
768:
769: #define kFlagMsgOut_SDTR 0x01
770: #define kFlagMsgOut_Queuing 0x02
771: UInt8 gMsgOutFlag;
772:
773: /* These variables are used during reselection to select the correct */
774: /* (tagged) command. msgInTagType is the last Tagged Queue message */
775: /* received from a target during reselection. msgInTag is the */
776: /* tag value. Currently, we should only see a Simple Queue Tag. */
777: UInt8 msgInTagType; /* Last tag type */
778: UInt8 msgInTag; /* Last tag value */
779:
780: /* Hardware related variables: */
781:
782: UInt8 gInitiatorID; /* Our SCSI ID */
783: UInt8 gInitiatorIDMask; /* BusID bitmask for selection */
784: UInt8 gSelectionTimeout; /* In MESH 10 msec units */
785:
786: /* commandBuf->queueTag for next IO. This is never zero; */
787: /* for all requests involving a T/L/Q nexus, a queue tag */
788: /* of zero indicates a nontagged command. */
789: UInt8 gNextQueueTag;
790:
791: PerTargetData gPerTargetData[ SCSI_NTARGETS ];
792:
793: /* Statistics support: */
794:
795: UInt32 gMaxQueueLen;
796: UInt32 gQueueLenTotal;
797: UInt32 gTotalCommands;
798: }
799:
800: /* Public methods (called by higher-level driver functions) */
801:
802: + (Boolean) probe : deviceDescription; /* Initialize the SCSI driver. */
803: - free; /* Shutdown the driver. */
804:
805:
806: - (sc_status_t) executeRequest /* Execute a SCSI IO request */
807: : (IOSCSIRequest*) scsiReq
808: buffer : (void*) buffer
809: client : (vm_task_t) client;
810:
811: /* Execute a SCSI request using an IOMemoryDescriptor. */
812: /* This allows callers to provide (kernel-resident) logical scatter-gather */
813: /* lists. For compatibility with existing implementations, the low-level */
814: /* SCSI device driver must first ensure that */
815: /* executeRequest:ioMemoryDescriptor is supported by executing: */
816: /* [controller respondsToSelector : executeRequest:ioMemoryDescriptor] */
817: /* @param scsiReq The SCSI request command record, including the */
818: /* target device and LUN, the command to execute, and various control flags.*/
819: /* @param ioMemoryDescriptor The data buffer(s), if any. This may be NULL */
820: /* if no data phase is expected. */
821: /* @param client The client task that "owns" the memory buffer. */
822: /* @return Return a bus adaptor specific error status. */
823: - (sc_status_t) executeRequest : (IOSCSIRequest*)scsiReq
824: ioMemoryDescriptor : (IOMemoryDescriptor*)ioMemoryDescriptor;
825:
826: - (sc_status_t) resetSCSIBus; /* Reset the SCSI bus */
827: - (void) resetStatistics; /* Reset statistics buffers */
828: - (unsigned) numQueueSamples;
829: - (unsigned) sumQueueLengths;
830: - (unsigned) maxQueueLength;
831:
832: /* interruptOccurred is a public method called by the */
833: /* IO thread in IODirectDevice when an interrupt occurs. */
834: - (void) interruptOccurred;
835:
836: /* timeoutOccurred is a public method called by the */
837: /* IO thread in IODirectDevice when it receives a */
838: /* timeout message. */
839:
840: - (void) timeoutOccurred;
841:
842: #if APPLE_MESH_ENABLE_GET_SET
843:
844: - (IOReturn) setIntValues : (unsigned*) parameterArray
845: forParameter : (IOParameterName) parameterName
846: count : (unsigned) count;
847:
848: - (IOReturn) getIntValues : (unsigned*) parameterArray
849: forParameter : (IOParameterName) parameterName
850: count : (unsigned*) count; /* in/out */
851:
852: /* get/setIntValues parameters: */
853:
854: #define APPLE_MESH_AUTOSENSE "AutoSense"
855: #define APPLE_MESH_CMD_QUEUE "CmdQueue"
856: #define APPLE_MESH_SYNC "Synchronous"
857: #define APPLE_MESH_FAST_SCSI "FastSCSI"
858: #define APPLE_MESH_RESET_TARGETS "ResetTargets"
859: #define APPLE_MESH_RESET_TIMESTAMP "ResetTimestamp"
860: #define APPLE_MESH_ENABLE_TIMESTAMP "EnableTimestamp"
861: #define APPLE_MESH_DISABLE_TIMESTAMP "DisableTimestamp"
862: #define APPLE_MESH_PRESERVE_FIRST_TIMESTAMP "PreserveFirstTimestamp"
863: #define APPLE_MESH_PRESERVE_LAST_TIMESTAMP "PreserveLastTimestamp"
864: #define APPLE_MESH_READ_TIMESTAMP "ReadTimestamp"
865: #define APPLE_MESH_STORE_TIMESTAMP "StoreTimestamp"
866:
867: /*
868: * Recording and setting timestamps may be done using getIntValues (this permits
869: * access from non-privileged tasks.
870: * ResetTimestamp Clear the timestamp vector - do this before starting
871: * a sequence (no parameters)
872: * EnableTimestamp Start recording (no parameters) (default)
873: * DisableTimestamp Stop recording (no parameters)
874: * PreserveFirstTimestamp Stop recording when the buffer fills (until it is emptied)
875: * PreserveLastTimestamp Discard old values when new arrive (default)
876: * ReadTimestamp Read a vector of timestamps (see sample below)
877: * StoreTimestamp Store a timestamp (from user mode) (see sample below)
878: * ReadTimestamp copies timestamps from the internal database to user-specified vector.
879: * Because getIntValues parameters are defined in int units, the code is slighthly
880: * non-obvious:
881: * TimestampDataRecord myTimestamps[ 123 ];
882: * unsigned count;
883: * count = sizeof (myTimestamps) / sizeof (unsigned);
884: * [scsiDevice getIntValues
885: * : (unsigned int *) myTimestamps
886: * forParameter : APPLE_MESH_READ_TIMESTAMP
887: * count : &count
888: * ];
889: * count = (count * sizeof (unsigned)) / sizeof (TimestampDataRecord);
890: * for (i = 0; i < count; i++) {
891: * Process(myTimestamps[i]);
892: * }
893: * Applications can store timestamps using one of three parameter formats:
894: * unsigned paramVector[4];
895: * Tag only -- the library will supply the event time
896: * paramVector[0] = kMyTagValue;
897: * [scsiDevice getIntValues
898: * : paramVector
899: * forParameter : "StoreTimestamp"
900: * count : 1
901: * ];
902: * Tag plus value:
903: * paramVector[0] = kMyTagValue;
904: * paramVector[1] = 123456;
905: * [scsiDevice getIntValues
906: * : paramVector
907: * forParameter : "StoreTimestamp"
908: * count : 2
909: * ];
910: * Tag plus value + time:
911: * paramVector[0] = kMyTagValue;
912: * paramVector[1] = 123456;
913: * IOGetTimestamp( (ns_time_t*)¶mVector[2] );
914: * [scsiDevice getIntValues
915: * : paramVector
916: * forParameter : "StoreTimestamp"
917: * count : 4
918: * ];
919: * Note that you can combine tag only with tag plus value plus time to measure
920: * user->device latency.
921: */
922:
923: #endif APPLE_MESH_ENABLE_GET_SET
924:
925: @end
926:
927:
928:
929: @interface AppleMesh_SCSI( Hardware )
930:
931: - InitializeHardware : deviceDescription;
932: - (IOReturn) ResetHardware : (Boolean)resetSCSIBus;
933: - (HardwareStartResult) hardwareStart : (CommandBuffer*)cmdBuf;
934:
935: @end
936:
937:
938: /* These macros are used to access words (32 bit) and bytes (8 bit) in */
939: /* the channel command area. They may be used as source or destination. */
940: /* CCLDescriptor is aligned to a descriptor start, CCLAddress is just */
941: /* an address pointer. */
942: #define CCLAddress(offset) (((UInt8*)cclLogAddr) + (offset))
943: #define CCLDescriptor(offset) ((DBDMADescriptor*)CCLAddress(offset))
944: #define CCLWord(offset) (*((UInt32*)CCLAddress(offset)))
945: #define CCLByte(offset) (*((UInt8*)CCLAddress(offset)))
946:
947: @interface AppleMesh_SCSI ( HardwarePrivate )
948:
949: - (IOReturn) AllocHdwAndChanMem : deviceDescription;
950: - (void) InitAutosenseCCL;
951: - (void) UpdateCP : (Boolean) reselecting;
952: - (void) StartBucket;
953: - (void) SetupMsgO;
954: - (void) ClearCPResults;
955: - (void) InitCP;
956:
957: @end
958:
959: @interface AppleMesh_SCSI( MeshInterrupt )
960:
961: - (void) DoHardwareInterrupt; /* Respond to an Interrupt Service message. */
962: - (void) ProcessInterrupt;
963: - (void) DoInterruptStageArb;
964: - (void) DoInterruptStageSelA;
965: - (void) DoInterruptStageMsgO;
966: - (void) DoInterruptStageCmdO;
967: - (void) DoInterruptStageXfer;
968: - (void) DoInterruptStageXferAutosense;
969: - (void) DoInterruptStageGood;
970: - (IOReturn) DoMessageInPhase; /* Handle MSGI phase. */
971: - (void) ProcessMSGI;
972: - (void) HandleReselectionInterrupt; /* Process a reselection interrupt. */
973: - (Boolean) getReselectionTargetID;
974:
975: @end
976:
977:
978: /* SCSI command status (from status phase) */
979:
980: #define kScsiStatusGood 0x00 /* Normal completion */
981: #define kScsiStatusCheckCondition 0x02 /* Need GetExtendedStatus */
982: #define kScsiStatusConditionMet 0x04
983: #define kScsiStatusBusy 0x08 /* Device busy (self-test?) */
984: #define kScsiStatusIntermediate 0x10 /* Intermediate status */
985: #define kScsiStatusIntermediateMet 0x14 /* Intermediate cond. met */
986: #define kScsiStatusResConflict 0x18 /* Reservation conflict */
987: #define kScsiStatusTerminated 0x22 /* Command Terminated */
988: #define kScsiStatusQueueFull 0x28 /* Target can't do command */
989: #define kScsiStatusReservedMask 0x3E /* Vendor specific? */
990:
991: /* SCSI command codes. Commands defined as ...6, ...10, ...12, are */
992: /* six-byte, ten-byte, and twelve-byte variants of the indicated command. */
993:
994: /* These commands are supported for all devices. */
995:
996: #define kScsiCmdChangeDefinition 0x40
997: #define kScsiCmdCompare 0x39
998: #define kScsiCmdCopy 0x18
999: #define kScsiCmdCopyAndVerify 0x3A
1000: #define kScsiCmdInquiry 0x12
1001: #define kScsiCmdLogSelect 0x4C
1002: #define kScsiCmdLogSense 0x4D
1003: #define kScsiCmdModeSelect12 0x55
1004: #define kScsiCmdModeSelect6 0x15
1005: #define kScsiCmdModeSense12 0x5A
1006: #define kScsiCmdModeSense6 0x1A
1007: #define kScsiCmdReadBuffer 0x3C
1008: #define kScsiCmdRecvDiagResult 0x1C
1009: #define kScsiCmdRequestSense 0x03
1010: #define kScsiCmdSendDiagnostic 0x1D
1011: #define kScsiCmdTestUnitReady 0x00
1012: #define kScsiCmdWriteBuffer 0x3B
1013:
1014: /* These commands are supported by direct-access devices only: */
1015:
1016: #define kScsiCmdFormatUnit 0x04
1017: #define kSCSICmdCopy 0x18
1018: #define kSCSICmdCopyAndVerify 0x3A
1019: #define kScsiCmdLockUnlockCache 0x36
1020: #define kScsiCmdPrefetch 0x34
1021: #define kScsiCmdPreventAllowRemoval 0x1E
1022: #define kScsiCmdRead6 0x08
1023: #define kScsiCmdRead10 0x28
1024: #define kScsiCmdReadCapacity 0x25
1025: #define kScsiCmdReadDefectData 0x37
1026: #define kScsiCmdReadLong 0x3E
1027: #define kScsiCmdReassignBlocks 0x07
1028: #define kScsiCmdRelease 0x17
1029: #define kScsiCmdReserve 0x16
1030: #define kScsiCmdRezeroUnit 0x01
1031: #define kScsiCmdSearchDataEql 0x31
1032: #define kScsiCmdSearchDataHigh 0x30
1033: #define kScsiCmdSearchDataLow 0x32
1034: #define kScsiCmdSeek6 0x0B
1035: #define kScsiCmdSeek10 0x2B
1036: #define kScsiCmdSetLimits 0x33
1037: #define kScsiCmdStartStopUnit 0x1B
1038: #define kScsiCmdSynchronizeCache 0x35
1039: #define kScsiCmdVerify 0x2F
1040: #define kScsiCmdWrite6 0x0A
1041: #define kScsiCmdWrite10 0x2A
1042: #define kScsiCmdWriteAndVerify 0x2E
1043: #define kScsiCmdWriteLong 0x3F
1044: #define kScsiCmdWriteSame 0x41
1045:
1046: /* These commands are supported by sequential devices: */
1047:
1048: #define kScsiCmdRewind 0x01
1049: #define kScsiCmdWriteFilemarks 0x10
1050: #define kScsiCmdSpace 0x11
1051: #define kScsiCmdLoadUnload 0x1B
1052:
1053: /* ANSI SCSI-II for CD-ROM devices. */
1054: #define kScsiCmdReadCDTableOfContents 0x43
1055:
1056: /* Message codes (for Msg In and Msg Out phases). */
1057:
1058: #define kScsiMsgAbort 0x06
1059: #define kScsiMsgAbortTag 0x0D
1060: #define kScsiMsgBusDeviceReset 0x0C
1061: #define kScsiMsgClearQueue 0x0E
1062: #define kScsiMsgCmdComplete 0x00
1063: #define kScsiMsgDisconnect 0x04
1064: #define kScsiMsgIdentify 0x80
1065: #define kScsiMsgIdentifyLUNMask 0x07 /* LUN bits in Identify message */
1066: #define kScsiMsgIgnoreWideResdue 0x23
1067: #define kScsiMsgInitiateRecovery 0x0F
1068: #define kScsiMsgInitiatorDetectedErr 0x05
1069: #define kScsiMsgLinkedCmdComplete 0x0A
1070: #define kScsiMsgLinkedCmdCompleteFlag 0x0B
1071: #define kScsiMsgParityErr 0x09
1072: #define kScsiMsgRejectMsg 0x07
1073: #define kScsiMsgModifyDataPtr 0x00 /* Extended msg */
1074: #define kScsiMsgNop 0x08
1075: #define kScsiMsgHeadOfQueueTag 0x21 /* Two byte msg */
1076: #define kScsiMsgOrderedQueueTag 0x22 /* Two byte msg */
1077: #define kScsiMsgSimpleQueueTag 0x20 /* Two byte msg */
1078: #define kScsiMsgReleaseRecovery 0x10
1079: #define kScsiMsgRestorePointers 0x03
1080: #define kScsiMsgSaveDataPointers 0x02
1081: #define kScsiMsgSyncXferReq 0x01 /* Extended msg */
1082: #define kScsiMsgWideDataXferReq 0x03 /* Extended msg */
1083: #define kScsiMsgTerminateIOP 0x11
1084: #define kScsiMsgExtended 0x01
1085: #define kScsiMsgEnableDisconnectMask 0x40
1086:
1087: #define kScsiMsgOneByteMin 0x02
1088: #define kScsiMsgOneByteMax 0x1F
1089: #define kScsiMsgTwoByteMin 0x20
1090: #define kScsiMsgTwoByteMax 0x2F
1091:
1092:
1093:
1094: /* These methods bang on the MESH chip. */
1095: /* Many should be redone as inline functions. */
1096:
1097: @interface AppleMesh_SCSI( Mesh )
1098:
1099: - (IOReturn) ResetMESH : (Boolean) resetSCSIBus;
1100: - (IOReturn) DoHBASelfTest;
1101: - (IOReturn) WaitForMesh : (Boolean) clearInterrupts;
1102: - (IOReturn) WaitForReq;
1103: - (void) SetSeqReg : (MeshCommand) meshCommand;
1104: - (void) RunDBDMA : (UInt32) offset stageLabel : (UInt32) stageLabel;
1105: - (void) GetHBARegsAndClear : (Boolean) clearInts;
1106: - (void) SetIntMask : (UInt8) interruptMask;
1107: - (void) AbortActiveCommand;
1108: - (void) AbortDisconnectedCommand;
1109:
1110: - (void) logTimestamp : (const char*) reason;
1111:
1112: @end
1113:
1114:
1115: @interface AppleMesh_SCSI( Private )
1116:
1117: /* Send a command to the controller thread, and wait for its completion. */
1118: /* Only invoked by publicly exported methods in SCSIController.m. */
1119:
1120: - (IOReturn) executeCmdBuf : (CommandBuffer*) cmdBuf;
1121:
1122: /* Abort all active and disconnected commands with specified status. */
1123: /* No hardware action. Used by threadResetBus and during processing */
1124: /* of a kCommandAbortRequest command. */
1125: - (void) abortAllCommands : (sc_status_t) status;
1126:
1127: /* IO thread version of resetSCSIBus and executeRequest. */
1128: - (void) threadResetBus : (const char*) reason;
1129:
1130:
1131: - (void) threadExecuteRequest : (CommandBuffer*) cmdBuf;
1132:
1133: /* Methods called by other modules in this driver: */
1134:
1135: /* Called when a transaction associated with cmdBuf is complete. Notify
1136: * waiting thread. If cmdBuf->scsiReq exists (i.e., this is not a reset
1137: * or an abort), scsiReq->driverStatus must be valid. If cmdBuf is activeCmd,
1138: * caller must remove from activeCmd.
1139: */
1140: - (void) ioComplete : (CommandBuffer*) cmdBuf;
1141:
1142: /* A target reported a full queue. Push this command back on the pending
1143: * queue and try it again, later. (Return SR_IOST_GOOD if successful,
1144: * SR_IOST_BADST on failure.
1145: */
1146: - (sc_status_t) pushbackFullTargetQueue : (CommandBuffer*) cmdBuf;
1147:
1148: /* A command couldn't be issued (because a target is trying to reselect
1149: * us or we lost arbitration for some other reason). Push this request
1150: * onto the front of the pending request queue.
1151: */
1152: - (void) pushbackCurrentRequest : (CommandBuffer*) cmdBuf;
1153:
1154: /* A command can't be continued. Perhaps there is no target. */
1155: - (void) killCurrentRequest;
1156:
1157: /* IO associated with activeCmd has disconnected. Place it */
1158: /* on disconnectQ and enable another transaction. */
1159: - (void) disconnect;
1160:
1161: /* Specified target, lun, and queueTag is trying to reselect. If we have
1162: * a CommandBuffer for this TLQ nexus on disconnectQ, remove it, make it the
1163: * current activeCmd, and return YES. Else return NO.
1164: * A value of zero for queueTag indicates a nontagged command (zero is never
1165: * used as the queue tag value for a tagged command).
1166: */
1167: - (IOReturn) reselectNexus : (UInt8) target
1168: lun : (UInt8) lun
1169: queueTag : (UInt8) queueTag;
1170: - (Boolean) commandCanBeStarted : (CommandBuffer*) cmdBuf;
1171: - (void) selectNextRequest; /* Choose the next request that can be started. */
1172: - (void) killActiveCommand : (sc_status_t) status; // mlj added
1173: - (void) activateCommand : (CommandBuffer*) cmdBuf;
1174: - (void) deactivateCmd : (CommandBuffer*) cmdBuf;
1175:
1176: /* Kill everything in the indicated queue. Called after bus reset. */
1177: - (void) killQueue : (queue_head_t*)queuePtr finalStatus : (sc_status_t)scsiStatus;
1178: - (void) UpdateCurrentIndex;
1179:
1180: @end
1181:
1182: #if USE_ELG && CustomMiniMon
1183: /* for debugging: */
1184: extern void EvLog( UInt32 a, UInt32 b, UInt32 ascii, char* str );
1185: extern void Pause( UInt32 a, UInt32 b, UInt32 ascii, char* str );
1186: extern void AllocateEventLog( UInt32 ); // defined in miniMon
1187: #endif /* NotMiniMon */
1188: extern void call_kdp(); // for debugging
1189:
1190:
1191: /* Usage:
1192: * 1. In the makefile (or elsewhere), define TIMESTAMP non-zero. If zero, this
1193: * code will be stubbed out.
1194: * 2. In your initialization routine, call MakeTimestampRecord() to create a
1195: * timestamp record. This will be stored in a static, private, variable.
1196: * 3. When you want to time something, call StoreTimestamp() as follows:
1197: * {
1198: * ns_time_t eventTime;
1199: * IOGetTimestamp(&eventTime);
1200: * StoreTimestamp(timestampTag, timestampValue, eventTime);
1201: * }
1202: * Where timestampTag and timestampValue are 32-bit unsigned integers
1203: * that are not otherwise interpreted by the Timestamp library. By
1204: * convention, timestampTag contains a 4-byte character (Macintosh OSType)
1205: * that distinguishes timing events. The OSType and OSTag macros
1206: * can be used to construct tag values. OSTag is useful for recording
1207: * elapsed time:
1208: * StoreTimestamp(OSTag('+', "foo"), 0, startTime);
1209: * ...
1210: * StoreTimestamp(OSTag('-', "foo"), 0, endTime);
1211: */
1212:
1213:
1214: //#ifndef TIMESTAMP
1215: #define TIMESTAMP 0 // mlj - resolve dup symbols with Curio /* TEMP TEMP TEMP */
1216: //#endif
1217:
1218: /* Construct an OSType from four characters. */
1219: #define OSType(c0, c1, c2, c3) ( \
1220: ( ((c0) << 24) \
1221: | ((c1) << 16) \
1222: | ((c2) << 8) \
1223: | ((c3) << 0) ))
1224: /* Construct an OSType from a single character and the */
1225: /* first three characters from a given string. */
1226: #define OSTag(where, what) (OSType((where), (what)[0], (what)[1], (what)[2]))
1227:
1228: /* ._______________________________________________________________________________.
1229: | Each timestamp entry contains the following information: |
1230: | timestampTag A user-specified OSType that identifies this timestamp |
1231: | timestampValue A user-specified additional value |
1232: | eventTime The system UpTime value at the time the data was collected. |
1233: ._______________________________________________________________________________.
1234: */
1235: struct TimestampDataRecord
1236: {
1237: OSType timestampTag; /* Caller's tag parameter */
1238: UInt32 timestampValue; /* Caller's value parameter */
1239: ns_time_t eventTime; /* UpTime() at Timestamp call */
1240: };
1241: typedef struct TimestampDataRecord TimestampDataRecord, *TimestampDataPtr;
1242:
1243: #if TIMESTAMP /* (( */
1244: void MakeTimestampRecord( UInt32 nEntries );
1245: void StoreTimestamp( OSType timestampTag,
1246: UInt32 timestampValue,
1247: ns_time_t timestampEvent );
1248: /**
1249: * Returns the next timestamp, if any, in resultData.
1250: * @param resultData Where to store the data
1251: * @return TRUE Valid data returned
1252: * FALSE No data is available.
1253: */
1254: Boolean ReadTimestamp( TimestampDataPtr resultData );
1255: /**
1256: * Return a vector of timestamps.
1257: * @param resultVector Where to store the data
1258: * @param count On entrance, this has the maximum number of elements
1259: * to return. On exit, this will have the actual number
1260: * of elements that were returned.
1261: * Note that, if the semaphore is blocked, ReadTimestampVector will not return any
1262: * data. Data cannot be collected while ReadTimestampVector is copying data
1263: * to the user's buffer. Note that, since the user's buffer will typically be
1264: * in pageable memory, pageing I/O that might otherwise be timestamped will
1265: * be lost.
1266: */
1267: void ReadTimestampVector( TimestampDataPtr resultVector, UInt32 *count ); /* -> Max count, <-actual */
1268: Boolean EnableTimestamp( Boolean enableTimestamp );
1269: Boolean PreserveTimestamp( Boolean preserveFirst );
1270: void ResetTimestampIndex(void);
1271: UInt32 GetTimestampSemaphoreLostCounter( void );
1272: #else /* )( not TIMESTAMP: */
1273: #define MakeTimestampRecord( nEntries ) /* Nothing */
1274: #define StoreTimestamp( timestampTag, timestampValue, timestampEvent ) /* Nothing */
1275: #define ReadTimestamp(resultData) (0) /* Fails */
1276: #define ReadTimestampVector(resultVector, count) \
1277: do { if ( count ) { *(count) = 0; } } while (0)
1278: #define EnableTimestamp( enableTimestamp ) (enableTimestamp)
1279: #define PreserveTimestamp( preserveFirst ) (preserveFirst)
1280: #define ResetTimestampIndex() /* Nothing */
1281: #define GetTimestampSemaphoreLostCount() (0)
1282: #endif /* )) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.