![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src|
Return to scsi.c CVS log | Up to [Previous NeXT emulator] / previous / src |
1.1 root 1: /* SCSI Bus and Disk emulation */
2: #include "main.h"
3: #include "ioMem.h"
4: #include "ioMemTables.h"
5: #include "video.h"
6: #include "configuration.h"
7: #include "sysdeps.h"
8: #include "m68000.h"
9: #include "sysReg.h"
10: #include "statusbar.h"
11: #include "scsi.h"
12: #include "dma.h"
13: #include "esp.h"
14: #include "dialog.h"
15: #include "file.h"
16:
17:
18: #define COMMAND_ReadInt16(a, i) (((unsigned) a[i] << 8) | a[i + 1])
19: #define COMMAND_ReadInt24(a, i) (((unsigned) a[i] << 16) | ((unsigned) a[i + 1] << 8) | a[i + 2])
20: #define COMMAND_ReadInt32(a, i) (((unsigned) a[i] << 24) | ((unsigned) a[i + 1] << 16) | ((unsigned) a[i + 2] << 8) | a[i + 3])
21:
22:
23: #define BLOCKSIZE 512
24:
25: #define LUN_DISC 0 // for now only LUN 0 is valid for our phys drives
26:
27: static Uint32 nLastBlockAddr;
28: static bool bSetLastBlockAddr;
29: static Uint8 nLastError;
30:
31: /* Disk Infos */
32:
33: bool bCDROM;
34: bool bTargetDevice;
35: Uint32 nDiskSize;
36:
37:
38: static FILE *scsidisk = NULL;
39:
40: FILE* scsiimage[ESP_MAX_DEVS];
41: Uint32 nFileSize[ESP_MAX_DEVS];
42:
43:
44: /* Initialize/Uninitialize SCSI disks */
45: void SCSI_Init(void) {
46: Log_Printf(LOG_WARN, "CALL SCSI INIT\n");
47:
48: /* Check if files exist. Present dialog to re-select missing files. */
49: int target;
50: for (target = 0; target < ESP_MAX_DEVS; target++) {
51: if (File_Exists(ConfigureParams.SCSI.target[target].szImageName) && ConfigureParams.SCSI.target[target].bAttached) {
52: nFileSize[target] = File_Length(ConfigureParams.SCSI.target[target].szImageName);
53: scsiimage[target] = ConfigureParams.SCSI.target[target].bCDROM == true ? File_Open(ConfigureParams.SCSI.target[target].szImageName, "r") : File_Open(ConfigureParams.SCSI.target[target].szImageName, "r+");
54: } else {
55: nFileSize[target] = 0;
56: scsiimage[target]=NULL;
57: }
58: }
59:
60: for (target = 0; target < ESP_MAX_DEVS; target++) {
61: Log_Printf(LOG_WARN, "Disk0: %s\n", ConfigureParams.SCSI.target[target].szImageName);
62: }
63: }
64:
65: void SCSI_Uninit(void) {
66: int target;
67: for (target = 0; target < ESP_MAX_DEVS; target++) {
68: if (scsiimage[target])
69: File_Close(scsiimage[target]);
70: }
71:
72: scsidisk = NULL;
73: }
74:
75: void SCSI_Reset(void) {
76: SCSI_Uninit();
77: SCSI_Init();
78: }
79:
80:
81:
82: /* INQUIRY response data */
83: static unsigned char inquiry_bytes[] =
84: {
85: 0x00, /* 0: device type: 0x00 = direct access device, 0x05 = cd-rom, 0x07 = mo-disk */
86: 0x00, /* 1: &0x7F - device type qulifier 0x00 unsupported, &0x80 - rmb: 0x00 = nonremovable, 0x80 = removable */
87: 0x01, /* 2: ANSI SCSI standard (first release) compliant */
88: 0x02, /* 3: Restponse format (format of following data): 0x01 SCSI-1 compliant */
89: 0x31, /* 4: additional length of the following data */
90: 0x00, 0x00, /* 5,6: reserved */
91: 0x1C, /* 7: RelAdr=0, Wbus32=0, Wbus16=0, Sync=1, Linked=1, RSVD=1, CmdQue=0, SftRe=0 */
92: 'P','r','e','v','i','o','u','s', /* 8-15: Vendor ASCII */
93: 'H','D','D',' ',' ',' ',' ',' ', /* 16-23: Model ASCII */
94: ' ',' ',' ',' ',' ',' ',' ',' ', /* 24-31: Blank space ASCII */
95: '0','0','0','0','0','0','0','1', /* 32-39: Revision ASCII */
96: '0','0','0','0','0','0','0','0', /* 40-47: Serial Number ASCII */
97: ' ',' ',' ',' ',' ',' ' /* 48-53: Blank space ASCII */
98: };
99:
100:
101:
102: void scsi_command_analyzer(Uint8 commandbuf[], int size, int target, int lun) {
103: int i;
104: SCSIcommand.source_busid = commandbuf[0];
105: for (i = 1; i < size; i++) {
106: SCSIcommand.command[i-1] = commandbuf[i];
107: }
108:
109: SCSIcommand.opcode = SCSIcommand.command[0];
110: if (target >= ESP_MAX_DEVS) {
111: Log_Printf(LOG_WARN, "Invalid target: %i!\n", target);
112: abort();
113: }
114: SCSIcommand.target = target;
115: SCSIcommand.lun = lun;
116: Log_Printf(LOG_WARN, "SCSI command: Length = %i, Opcode = $%02x, target = %i, lun=%i\n", size, SCSIcommand.opcode, SCSIcommand.target,SCSIcommand.lun);
117:
118: scsidisk = scsiimage[target];
119: nDiskSize = nFileSize[target];
120: bCDROM = ConfigureParams.SCSI.target[target].bCDROM;
121: bTargetDevice = ConfigureParams.SCSI.target[target].bAttached;
122:
123: //bTargetDevice |= bCDROM; // handle empty cd-rom drive - does not work yet!
124: if(scsidisk) { // experimental!
125: SCSIcommand.nodevice = false;
126: SCSIcommand.timeout = false;
127: if ((SCSIcommand.lun!=LUN_DISC) && (SCSIcommand.opcode!=HD_REQ_SENSE) && (SCSIcommand.opcode!=HD_INQUIRY))
128: {
129: Log_Printf(LOG_WARN, "SCSI command: No device at target %i\n", SCSIcommand.target);
130: SCSIcommand.nodevice = true;
131: SCSIcommand.timeout = false;
132: SCSIcommand.transferdirection_todevice = 0;
133: SCSIcommand.transfer_data_len=0;
134: SCSIcommand.returnCode = HD_STATUS_ERROR;
135: nLastError= HD_REQSENS_NODRIVE;
136: return;
137: }
138: SCSI_Emulate_Command();
139: } else {
140: // hacks for NeXT (to be tested on real life...)
141: // question is : what an SCSI controler should answer for missing drives (and if SCSI controler is aware of SCSI opcodes)
142: // if (SCSIcommand.opcode==HD_TEST_UNIT_RDY) {SCSI_TestMissingUnitReady();SCSIcommand.nodevice = false;return;}
143: // SCSIcommand.nodevice = false;
144: // SCSIcommand.timeout = false;
145: // if (SCSIcommand.opcode==HD_REQ_SENSE) {SCSI_Emulate_Command();return;}
146: Log_Printf(LOG_WARN, "SCSI command: No target %i %s at %d", SCSIcommand.target,__FILE__,__LINE__);
147: SCSIcommand.nodevice = false;
148: SCSIcommand.timeout = true;
149: SCSIcommand.transferdirection_todevice = 0;
150: }
151: }
152:
153: void SCSI_Emulate_Command(void)
154: {
155:
156: switch(SCSIcommand.opcode)
157: {
158:
159: case HD_TEST_UNIT_RDY:
160: Log_Printf(LOG_WARN, "SCSI command: Test unit ready\n");
161: SCSI_TestUnitReady();
162: break;
163:
164: case HD_READ_CAPACITY1:
165: Log_Printf(LOG_WARN, "SCSI command: Read capacity\n");
166: SCSI_ReadCapacity();
167: break;
168:
169: case HD_READ_SECTOR:
170: case HD_READ_SECTOR1:
171: Log_Printf(LOG_WARN, "SCSI command: Read sector\n");
172: SCSI_ReadSector();
173: break;
174:
175: case HD_WRITE_SECTOR:
176: case HD_WRITE_SECTOR1:
177: Log_Printf(LOG_WARN, "SCSI command: Write sector\n");
178: // HDC_Cmd_WriteSector();
179: abort();
180: break;
181:
182: case HD_INQUIRY:
183: Log_Printf(LOG_WARN, "SCSI command: Inquiry\n");
184: SCSI_Inquiry();
185: break;
186:
187: case HD_SEEK:
188: Log_Printf(LOG_WARN, "SCSI command: Seek\n");
189: // HDC_Cmd_Seek();
190: abort();
191: break;
192:
193: case HD_SHIP:
194: Log_Printf(LOG_WARN, "SCSI command: Ship\n");
195: SCSI_StartStop();
196: break;
197:
198: case HD_REQ_SENSE:
199: Log_Printf(LOG_WARN, "SCSI command: Request sense\n");
200: SCSI_RequestSense();
201: break;
202:
203: case HD_MODESELECT:
204: Log_Printf(LOG_WARN, "MODE SELECT call not implemented yet.\n");
205: SCSIcommand.returnCode = HD_STATUS_OK;
206: nLastError = HD_REQSENS_OK;
207: bSetLastBlockAddr = false;
208: // FDC_SetDMAStatus(false);
209: // FDC_AcknowledgeInterrupt();
210: abort();
211: break;
212:
213: case HD_MODESENSE:
214: Log_Printf(LOG_WARN, "SCSI command: Mode sense\n");
215: SCSI_ModeSense();
216: break;
217:
218: case HD_FORMAT_DRIVE:
219: Log_Printf(LOG_WARN, "SCSI command: Format drive\n");
220: // HDC_Cmd_FormatDrive();
221: abort();
222: break;
223:
224: /* as of yet unsupported commands */
225: case HD_VERIFY_TRACK:
226: case HD_FORMAT_TRACK:
227: case HD_CORRECTION:
228:
229: default:
230: Log_Printf(LOG_WARN, "Unknown Command\n");
231: SCSIcommand.returnCode = HD_STATUS_ERROR;
232: nLastError = HD_REQSENS_OPCODE;
233: bSetLastBlockAddr = false;
234: // FDC_AcknowledgeInterrupt();
235: break;
236: }
237: esp_command_complete();
238:
239: /* Update the led each time a command is processed */
240: Statusbar_EnableHDLed();
241: }
242:
243:
244: /* Helpers */
245:
246: int SCSI_GetTransferLength(void)
247: {
248: return SCSIcommand.opcode < 0x20?
249: // class 0
250: SCSIcommand.command[4] :
251: // class 1
252: COMMAND_ReadInt16(SCSIcommand.command, 7);
253: }
254:
255: unsigned long SCSI_GetOffset(void)
256: {
257: return SCSIcommand.opcode < 0x20?
258: // class 0
259: (COMMAND_ReadInt24(SCSIcommand.command, 1) & 0x1FFFFF) :
260: // class 1
261: COMMAND_ReadInt32(SCSIcommand.command, 2);
262: }
263:
264: // get reserved count for SCSI reply
265: int SCSI_GetCount(void)
266: {
267: return SCSIcommand.opcode < 0x20?
268: // class 0
269: SCSIcommand.command[4] :
270: // class 1
271: COMMAND_ReadInt16(SCSIcommand.command, 7);
272: }
273:
274: MODEPAGE SCSI_GetModePage(Uint8 pagecode) {
275: MODEPAGE page;
276: Uint32 sectors;
277: Uint32 cylinders;
278: Uint8 heads;
279:
280: switch (pagecode) {
281: case 0x01: // error recovery page
282: page.pagesize = 8;
283: page.modepage[0] = 0x01; // &0x80: page savable? (not supported!), &0x7F: page code = 0x01
284: page.modepage[1] = 0x06; // page length = 6
285: page.modepage[2] = 0x00; // AWRE, ARRE, TB, RC, EER, PER, DTE, DCR
286: page.modepage[3] = 0x1B; // retry count
287: page.modepage[4] = 0x0B; // correction span in bits
288: page.modepage[5] = 0x00; // head offset count
289: page.modepage[6] = 0x00; // data strobe offset count
290: page.modepage[7] = 0xFF; // recovery time limit
291: break;
292:
293: case 0x02: // disconnect/reconnect page
294: case 0x03: // format device page
295: page.pagesize = 0;
296: Log_Printf(LOG_WARN, "Mode Sense: Page %02x not yet emulated!\n", pagecode);
297: break;
298:
299: case 0x04: // rigid disc geometry page
300: sectors = nDiskSize / BLOCKSIZE;
301: heads = 16; // max heads per cylinder: 16
302: cylinders = sectors / (63 * heads); // max sectors per track: 63
303: if ((sectors % (63 * heads)) != 0) {
304: cylinders += 1;
305: }
306: Log_Printf(LOG_WARN, "Disk geometry: %i sectors, %i cylinders, %i heads\n", sectors, cylinders, heads);
307:
308: page.pagesize = 0; //20;
309: Log_Printf(LOG_WARN, "Disk geometry page disabled!\n"); abort();
310: page.modepage[0] = 0x04; // &0x80: page savable? (not supported!), &0x7F: page code = 0x04
311: page.modepage[1] = 0x12;
312: page.modepage[2] = (cylinders >> 16) & 0xFF;
313: page.modepage[3] = (cylinders >> 8) & 0xFF;
314: page.modepage[4] = cylinders & 0xFF;
315: page.modepage[5] = heads;
316: page.modepage[6] = 0x00; // 6,7,8: starting cylinder - write precomp (not supported)
317: page.modepage[7] = 0x00;
318: page.modepage[8] = 0x00;
319: page.modepage[9] = 0x00; // 9,10,11: starting cylinder - reduced write current (not supported)
320: page.modepage[10] = 0x00;
321: page.modepage[11] = 0x00;
322: page.modepage[12] = 0x00; // 12,13: drive step rate (not supported)
323: page.modepage[13] = 0x00;
324: page.modepage[14] = 0x00; // 14,15,16: loading zone cylinder (not supported)
325: page.modepage[15] = 0x00;
326: page.modepage[16] = 0x00;
327: page.modepage[17] = 0x00; // &0x03: rotational position locking
328: page.modepage[18] = 0x00; // rotational position lock offset
329: page.modepage[19] = 0x00; // reserved
330: break;
331:
332: case 0x08: // caching page
333: case 0x0C: // notch page
334: case 0x0D: // power condition page
335: case 0x38: // cache control page
336: case 0x3C: // soft ID page (EEPROM)
337: page.pagesize = 0;
338: Log_Printf(LOG_WARN, "Mode Sense: Page %02x not yet emulated!\n", pagecode);
339: break;
340:
341: case 0x00: // operating page
342: page.pagesize = 4;
343: page.modepage[0] = 0x00; // &0x80: page savable? (not supported!), &0x7F: page code = 0x00
344: page.modepage[1] = 0x02; // page length = 2
345: page.modepage[2] = 0x80; // &0x80: usage bit = 1, &0x10: disable unit attention = 0
346: page.modepage[3] = 0x00; // &0x7F: device type qualifier = 0x00, see inquiry!
347: break;
348:
349: default:
350: page.pagesize = 0;
351: Log_Printf(LOG_WARN, "Mode Sense: Invalid page code: %02x!\n", pagecode);
352: break;
353: }
354: return page;
355: }
356:
357:
358:
359: /* SCSI Commands */
360:
361: void SCSI_TestUnitReady(void)
362: {
363: SCSIcommand.transfer_data_len = 0;
364: SCSIcommand.returnCode = HD_STATUS_OK;
365: }
366:
367:
368: void SCSI_ReadCapacity(void)
369: {
370: Log_Printf(LOG_WARN, "Read disk image: size = %i\n", nDiskSize);
371:
372: SCSIcommand.transfer_data_len = 8;
373:
374: Uint32 sectors = nDiskSize / BLOCKSIZE;
375:
376: static Uint8 scsi_disksize[8];
377:
378: scsi_disksize[0] = (sectors >> 24) & 0xFF;
379: scsi_disksize[1] = (sectors >> 16) & 0xFF;
380: scsi_disksize[2] = (sectors >> 8) & 0xFF;
381: scsi_disksize[3] = sectors & 0xFF;
382: scsi_disksize[4] = (BLOCKSIZE >> 24) & 0xFF;
383: scsi_disksize[5] = (BLOCKSIZE >> 16) & 0xFF;
384: scsi_disksize[6] = (BLOCKSIZE >> 8) & 0xFF;
385: scsi_disksize[7] = BLOCKSIZE & 0xFF;
386:
387: memcpy(dma_write_buffer, scsi_disksize, SCSIcommand.transfer_data_len);
388: SCSIcommand.returnCode = HD_STATUS_OK;
389: nLastError = HD_REQSENS_OK;
390:
391: bSetLastBlockAddr = false;
392: }
393:
394:
395: void SCSI_ReadSector(void)
396: {
397: int n=0;
398:
399: nLastBlockAddr = SCSI_GetOffset() * BLOCKSIZE;
400: SCSIcommand.transfer_data_len = SCSI_GetCount() * BLOCKSIZE;
401:
402:
403: /* seek to the position */
404: if ((scsidisk==NULL) || (fseek(scsidisk, nLastBlockAddr, SEEK_SET) != 0))
405: {
406: SCSIcommand.returnCode = HD_STATUS_ERROR;
407: nLastError = HD_REQSENS_INVADDR;
408: }
409: else
410: {
411: n = fread(dma_write_buffer, SCSIcommand.transfer_data_len, 1, scsidisk);
412:
413: /* Test to check if we read correct data */
414: // Log_Printf(LOG_WARN, "Disk Read Test: $%02x,$%02x,$%02x,$%02x,$%02x,$%02x,$%02x,$%02x\n", dma_write_buffer[0],dma_write_buffer[1],dma_write_buffer[2],dma_write_buffer[3],dma_write_buffer[4],dma_write_buffer[5],dma_write_buffer[6],dma_write_buffer[07]);
415: }
416:
417: if (n == 1) {
418: SCSIcommand.returnCode = HD_STATUS_OK;
419: nLastError = HD_REQSENS_OK;
420: }
421: else
422: {
423: SCSIcommand.returnCode = HD_STATUS_ERROR;
424: nLastError = HD_REQSENS_NOSECTOR;
425: }
426:
427: /* Update DMA counter */
428: // FDC_WriteDMAAddress(nDmaAddr + 512*n);
429: // }
430:
431: // FDC_SetDMAStatus(false); /* no DMA error */
432: // FDC_AcknowledgeInterrupt();
433: bSetLastBlockAddr = true;
434: //FDCSectorCountRegister = 0;
435: }
436:
437:
438:
439: void SCSI_Inquiry (void) {
440:
441: if (bCDROM) {
442: inquiry_bytes[0] = 0x05;
443: inquiry_bytes[1] |= 0x80;
444: inquiry_bytes[16] = 'C';
445: inquiry_bytes[18] = '-';
446: inquiry_bytes[19] = 'R';
447: inquiry_bytes[20] = 'O';
448: inquiry_bytes[21] = 'M';
449: Log_Printf(LOG_WARN, "Disk is CD-ROM\n");
450: } else {
451: inquiry_bytes[0] = 0x00;
452: inquiry_bytes[1] &= ~0x80;
453: inquiry_bytes[16] = 'H';
454: inquiry_bytes[18] = 'D';
455: inquiry_bytes[19] = ' ';
456: inquiry_bytes[20] = ' ';
457: inquiry_bytes[21] = ' ';
458: Log_Printf(LOG_WARN, "Disk is HDD\n");
459: }
460:
461: if (SCSIcommand.lun!=LUN_DISC) { inquiry_bytes[0] = 0x1F;}
462:
463: SCSIcommand.transfer_data_len = SCSI_GetTransferLength();
464: Log_Printf(LOG_WARN, "return length: %d", SCSIcommand.transfer_data_len);
465: SCSIcommand.transferdirection_todevice = 0;
466: memcpy(dma_write_buffer, inquiry_bytes, SCSIcommand.transfer_data_len);
467:
468: Log_Printf(LOG_WARN, "Inquiry Data: %c,%c,%c,%c,%c,%c,%c,%c\n",dma_write_buffer[8],dma_write_buffer[9],dma_write_buffer[10],dma_write_buffer[11],dma_write_buffer[12],dma_write_buffer[13],dma_write_buffer[14],dma_write_buffer[15]);
469:
470: if (SCSIcommand.transfer_data_len > (int)sizeof(inquiry_bytes))
471: SCSIcommand.transfer_data_len = sizeof(inquiry_bytes);
472:
473: SCSIcommand.returnCode = HD_STATUS_OK;
474: nLastError = HD_REQSENS_OK;
475: bSetLastBlockAddr = false;
476: }
477:
478:
479: void SCSI_StartStop(void) {
480: SCSIcommand.transfer_data_len = 0;
481: SCSIcommand.transferdirection_todevice = 0;
482: SCSIcommand.returnCode = HD_STATUS_OK;
483: }
484:
485:
486: void SCSI_RequestSense(void) {
487: int nRetLen;
488: Uint8 retbuf[22];
489:
490: SCSIcommand.returnCode = HD_STATUS_OK;
491:
492: nRetLen = SCSI_GetCount();
493:
494: if ((nRetLen < 4 && nRetLen != 0) || nRetLen > 22)
495: {
496: Log_Printf(LOG_WARN, "SCSI: *** Strange REQUEST SENSE *** len=%d!",nRetLen);
497: }
498:
499: /* Limit to sane length */
500: if (nRetLen <= 0)
501: {
502: nRetLen = 4;
503: }
504: else if (nRetLen > 22)
505: {
506: nRetLen = 22;
507: }
508:
509: Log_Printf(LOG_WARN, "[SCSI] REQ SENSE size = %d %s at %d", nRetLen,__FILE__,__LINE__);
510:
511: memset(retbuf, 0, nRetLen);
512:
513: if (nRetLen <= 4)
514: {
515: retbuf[0] = nLastError;
516: if (bSetLastBlockAddr)
517: {
518: retbuf[0] |= 0x80;
519: retbuf[1] = nLastBlockAddr >> 16;
520: retbuf[2] = nLastBlockAddr >> 8;
521: retbuf[3] = nLastBlockAddr;
522: }
523: }
524: else
525: {
526: retbuf[0] = 0x70;
527: if (bSetLastBlockAddr)
528: {
529: retbuf[0] |= 0x80;
530: retbuf[4] = nLastBlockAddr >> 16;
531: retbuf[5] = nLastBlockAddr >> 8;
532: retbuf[6] = nLastBlockAddr;
533: }
534: switch (nLastError)
535: {
536: case HD_REQSENS_OK: retbuf[2] = 0; break;
537: case HD_REQSENS_OPCODE: retbuf[2] = 5; break;
538: case HD_REQSENS_INVADDR: retbuf[2] = 5; break;
539: case HD_REQSENS_INVARG: retbuf[2] = 5; break;
540: case HD_REQSENS_NODRIVE: retbuf[2] = 2; break;
541: default: retbuf[2] = 4; break;
542: }
543: retbuf[7] = 14;
544: retbuf[12] = nLastError;
545: retbuf[19] = nLastBlockAddr >> 16;
546: retbuf[20] = nLastBlockAddr >> 8;
547: retbuf[21] = nLastBlockAddr;
548: }
549:
550: SCSIcommand.transfer_data_len = nRetLen;
551: memcpy(dma_write_buffer, retbuf, SCSIcommand.transfer_data_len);
552: SCSIcommand.returnCode = HD_STATUS_OK;
553: }
554:
555:
556: void SCSI_ModeSense(void) {
557: Uint8 retbuf[256];
558: MODEPAGE page;
559:
560: Uint32 sectors = nDiskSize / BLOCKSIZE;
561:
562: Uint8 pagecontrol = (SCSIcommand.command[2] & 0x0C) >> 6;
563: Uint8 pagecode = SCSIcommand.command[2] & 0x3F;
564: Uint8 dbd = SCSIcommand.command[1] & 0x08; // disable block descriptor
565:
566: Log_Printf(LOG_WARN, "Mode Sense: page = %02x, page_control = %i, %s\n", pagecode, pagecontrol, dbd == 0x08 ? "block descriptor disabled" : "block descriptor enabled");
567:
568: /* Header */
569: retbuf[0] = 0x00; // length of following data
570: retbuf[1] = 0x00; // medium type (always 0)
571: retbuf[2] = bCDROM == true ? 0x80 : 0x00; // if media is read-only 0x80, else 0x00
572: retbuf[3] = 0x08; // block descriptor length
573:
574: /* Block descriptor data */
575: Uint8 header_size = 4;
576: if (!dbd) {
577: retbuf[4] = 0x00; // media density code
578: retbuf[5] = sectors >> 16; // Number of blocks, high (?)
579: retbuf[6] = sectors >> 8; // Number of blocks, med (?)
580: retbuf[7] = sectors; // Number of blocks, low (?)
581: retbuf[8] = 0x00; // reserved
582: retbuf[9] = (BLOCKSIZE >> 16) & 0xFF; // Block size in bytes, high
583: retbuf[10] = (BLOCKSIZE >> 8) & 0xFF; // Block size in bytes, med
584: retbuf[11] = BLOCKSIZE & 0xFF; // Block size in bytes, low
585: header_size = 12;
586: Log_Printf(LOG_WARN, "Mode Sense: Block descriptor data: %s, size = %i blocks, blocksize = %i byte\n", bCDROM == true ? "disk is read-only" : "disk is read/write" , sectors, BLOCKSIZE);
587: }
588: retbuf[0] = header_size - 1;
589:
590: /* Mode Pages */
591: if (pagecode == 0x3F) { // return all pages!
592: Uint8 offset = header_size;
593: Uint8 counter;
594: for (pagecode = 0; pagecode < 0x3F; pagecode++) {
595: page = SCSI_GetModePage(pagecode);
596: switch (pagecontrol) {
597: case 0: // current values (not supported, using default values)
598: memcpy(page.current, page.modepage, page.pagesize);
599: for (counter = 0; counter < page.pagesize; counter++) {
600: retbuf[counter+offset] = page.current[counter];
601: }
602: break;
603: case 1: // changeable values (not supported, all 0)
604: memset(page.changeable, 0x00, page.pagesize);
605: for (counter = 0; counter < page.pagesize; counter++) {
606: retbuf[counter+offset] = page.changeable[counter];
607: }
608: break;
609: case 2: // default values
610: for (counter = 0; counter < page.pagesize; counter++) {
611: retbuf[counter+offset] = page.modepage[counter];
612: }
613: break;
614: case 3: // saved values (not supported, using default values)
615: memcpy(page.saved, page.modepage, page.pagesize);
616: for (counter = 0; counter < page.pagesize; counter++) {
617: retbuf[counter+offset] = page.saved[counter];
618: }
619: break;
620:
621: default:
622: break;
623: }
624: offset += page.pagesize;
625: retbuf[0] += page.pagesize;
626: }
627: } else { // return only single requested page
628: page = SCSI_GetModePage(pagecode);
629:
630: Uint8 counter;
631: switch (pagecontrol) {
632: case 0: // current values (not supported, using default values)
633: memcpy(page.current, page.modepage, page.pagesize);
634: for (counter = 0; counter < page.pagesize; counter++) {
635: retbuf[counter+header_size] = page.current[counter];
636: }
637: break;
638: case 1: // changeable values (not supported, all 0)
639: memset(page.changeable, 0x00, page.pagesize);
640: for (counter = 0; counter < page.pagesize; counter++) {
641: retbuf[counter+header_size] = page.changeable[counter];
642: }
643: break;
644: case 2: // default values
645: for (counter = 0; counter < page.pagesize; counter++) {
646: retbuf[counter+header_size] = page.modepage[counter];
647: }
648: break;
649: case 3: // saved values (not supported, using default values)
650: memcpy(page.saved, page.modepage, page.pagesize);
651: for (counter = 0; counter < page.pagesize; counter++) {
652: retbuf[counter+header_size] = page.saved[counter];
653: }
654: break;
655:
656: default:
657: break;
658: }
659:
660: retbuf[0] += page.pagesize;
661: }
662:
663:
664: SCSIcommand.transfer_data_len = retbuf[0] + 1;
665: if (SCSIcommand.transfer_data_len > SCSI_GetTransferLength())
666: SCSIcommand.transfer_data_len = SCSI_GetTransferLength();
667:
668: memcpy(dma_write_buffer, retbuf, SCSIcommand.transfer_data_len);
669:
670: SCSIcommand.returnCode = HD_STATUS_OK;
671: nLastError = HD_REQSENS_OK;
672:
673: bSetLastBlockAddr = false;
674: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.