![[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_trunk / src|
Return to scsi.c CVS log | Up to [Previous NeXT emulator] / previous_trunk / src |
1.1 ! root 1: /* SCSI Bus and Disk emulation */ ! 2: #include "main.h" ! 3: #include "ioMem.h" ! 4: #include "ioMemTables.h" ! 5: #include "configuration.h" ! 6: #include "sysdeps.h" ! 7: #include "m68000.h" ! 8: #include "statusbar.h" ! 9: #include "scsi.h" ! 10: #include "file.h" ! 11: ! 12: #define LOG_SCSI_LEVEL LOG_DEBUG /* Print debugging messages */ ! 13: ! 14: ! 15: #define COMMAND_ReadInt16(a, i) (((unsigned) a[i] << 8) | a[i + 1]) ! 16: #define COMMAND_ReadInt24(a, i) (((unsigned) a[i] << 16) | ((unsigned) a[i + 1] << 8) | a[i + 2]) ! 17: #define COMMAND_ReadInt32(a, i) (((unsigned) a[i] << 24) | ((unsigned) a[i + 1] << 16) | ((unsigned) a[i + 2] << 8) | a[i + 3]) ! 18: ! 19: ! 20: #define BLOCKSIZE 512 ! 21: ! 22: #define LUN_DISK 0 // for now only LUN 0 is valid for our phys drives ! 23: ! 24: /* Status Codes */ ! 25: #define STAT_GOOD 0x00 ! 26: #define STAT_CHECK_COND 0x02 ! 27: #define STAT_COND_MET 0x04 ! 28: #define STAT_BUSY 0x08 ! 29: #define STAT_INTERMEDIATE 0x10 ! 30: #define STAT_INTER_COND_MET 0x14 ! 31: #define STAT_RESERV_CONFL 0x18 ! 32: ! 33: /* Messages */ ! 34: #define MSG_COMPLETE 0x00 ! 35: #define MSG_SAVE_PTRS 0x02 ! 36: #define MSG_RESTORE_PTRS 0x03 ! 37: #define MSG_DISCONNECT 0x04 ! 38: #define MSG_INITIATOR_ERR 0x05 ! 39: #define MSG_ABORT 0x06 ! 40: #define MSG_MSG_REJECT 0x07 ! 41: #define MSG_NOP 0x08 ! 42: #define MSG_PARITY_ERR 0x09 ! 43: #define MSG_LINK_CMD_CMPLT 0x0A ! 44: #define MSG_LNKCMDCMPLTFLAG 0x0B ! 45: #define MSG_DEVICE_RESET 0x0C ! 46: ! 47: #define MSG_IDENTIFY_MASK 0x80 ! 48: #define MSG_ID_DISCONN 0x40 ! 49: #define MSG_LUNMASK 0x07 ! 50: ! 51: /* Sense Keys */ ! 52: #define SK_NOSENSE 0x00 ! 53: #define SK_RECOVERED 0x01 ! 54: #define SK_NOTREADY 0x02 ! 55: #define SK_MEDIA 0x03 ! 56: #define SK_HARDWARE 0x04 ! 57: #define SK_ILLEGAL_REQ 0x05 ! 58: #define SK_UNIT_ATN 0x06 ! 59: #define SK_DATAPROTECT 0x07 ! 60: #define SK_ABORTED_CMD 0x0B ! 61: #define SK_VOL_OVERFLOW 0x0D ! 62: #define SK_MISCOMPARE 0x0E ! 63: ! 64: /* Additional Sense Codes */ ! 65: #define SC_NO_ERROR 0x00 // 0 ! 66: #define SC_NO_SECTOR 0x01 // 4 ! 67: #define SC_WRITE_FAULT 0x03 // 5 ! 68: #define SC_NOT_READY 0x04 // 2 ! 69: #define SC_INVALID_CMD 0x20 // 5 ! 70: #define SC_INVALID_LBA 0x21 // 5 ! 71: #define SC_INVALID_CDB 0x24 // 5 ! 72: #define SC_INVALID_LUN 0x25 // 5 ! 73: #define SC_WRITE_PROTECT 0x27 // 7 ! 74: ! 75: ! 76: /* SCSI Commands */ ! 77: ! 78: /* The following are multi-sector transfers with seek implied */ ! 79: #define CMD_VERIFY_TRACK 0x05 /* Verify track */ ! 80: #define CMD_FORMAT_TRACK 0x06 /* Format track */ ! 81: #define CMD_READ_SECTOR 0x08 /* Read sector */ ! 82: #define CMD_READ_SECTOR1 0x28 /* Read sector (class 1) */ ! 83: #define CMD_WRITE_SECTOR 0x0A /* Write sector */ ! 84: #define CMD_WRITE_SECTOR1 0x2A /* Write sector (class 1) */ ! 85: ! 86: /* Other codes */ ! 87: #define CMD_TEST_UNIT_RDY 0x00 /* Test unit ready */ ! 88: #define CMD_FORMAT_DRIVE 0x04 /* Format the whole drive */ ! 89: #define CMD_SEEK 0x0B /* Seek */ ! 90: #define CMD_CORRECTION 0x0D /* Correction */ ! 91: #define CMD_INQUIRY 0x12 /* Inquiry */ ! 92: #define CMD_MODESELECT 0x15 /* Mode select */ ! 93: #define CMD_MODESENSE 0x1A /* Mode sense */ ! 94: #define CMD_REQ_SENSE 0x03 /* Request sense */ ! 95: #define CMD_SHIP 0x1B /* Ship drive */ ! 96: #define CMD_READ_CAPACITY1 0x25 /* Read capacity (class 1) */ ! 97: ! 98: void SCSI_Emulate_Command(Uint8 *cdb); ! 99: ! 100: void SCSI_Inquiry(Uint8 *cdb); ! 101: void SCSI_StartStop(Uint8 *cdb); ! 102: void SCSI_TestUnitReady(Uint8 *cdb); ! 103: void SCSI_ReadCapacity(Uint8 *cdb); ! 104: void SCSI_ReadSector(Uint8 *cdb); ! 105: void SCSI_WriteSector(Uint8 *cdb); ! 106: void SCSI_RequestSense(Uint8 *cdb); ! 107: void SCSI_ModeSense(Uint8 *cdb); ! 108: void SCSI_FormatDrive(Uint8 *cdb); ! 109: ! 110: ! 111: /* Helpers */ ! 112: int SCSI_GetCommandLength(Uint8 opcode); ! 113: int SCSI_GetTransferLength(Uint8 opcode, Uint8 *cdb); ! 114: Uint64 SCSI_GetOffset(Uint8 opcode, Uint8 *cdb); ! 115: int SCSI_GetCount(Uint8 opcode, Uint8 *cdb); ! 116: ! 117: void scsi_read_sector(void); ! 118: void scsi_write_sector(void); ! 119: ! 120: ! 121: /* SCSI disk */ ! 122: struct { ! 123: SCSI_DEVTYPE devtype; ! 124: FILE* dsk; ! 125: Uint64 size; ! 126: bool readonly; ! 127: Uint8 lun; ! 128: Uint8 status; ! 129: Uint8 message; ! 130: ! 131: struct { ! 132: Uint8 key; ! 133: Uint8 code; ! 134: bool valid; ! 135: Uint32 info; ! 136: } sense; ! 137: ! 138: Uint32 lba; ! 139: Uint32 blockcounter; ! 140: Uint32 lastlba; ! 141: ! 142: Uint8** shadow; ! 143: } SCSIdisk[ESP_MAX_DEVS]; ! 144: ! 145: ! 146: /* Mode Pages */ ! 147: #define MODEPAGE_MAX_SIZE 24 ! 148: ! 149: typedef struct { ! 150: Uint8 current[MODEPAGE_MAX_SIZE]; ! 151: Uint8 changeable[MODEPAGE_MAX_SIZE]; ! 152: Uint8 modepage[MODEPAGE_MAX_SIZE]; // default values ! 153: Uint8 saved[MODEPAGE_MAX_SIZE]; ! 154: Uint8 pagesize; ! 155: } MODEPAGE; ! 156: ! 157: MODEPAGE SCSI_GetModePage(Uint8 pagecode); ! 158: ! 159: ! 160: /* Initialize/Uninitialize SCSI disks */ ! 161: void SCSI_Init(void) { ! 162: Log_Printf(LOG_WARN, "Loading SCSI disks:\n"); ! 163: ! 164: int i; ! 165: for (i = 0; i < ESP_MAX_DEVS; i++) { ! 166: SCSIdisk[i].devtype = ConfigureParams.SCSI.target[i].nDeviceType; ! 167: SCSI_Insert(i); ! 168: } ! 169: } ! 170: ! 171: void SCSI_Uninit(void) { ! 172: int i; ! 173: for (i = 0; i < ESP_MAX_DEVS; i++) { ! 174: if (SCSIdisk[i].dsk) { ! 175: SCSI_Eject(i); ! 176: } ! 177: } ! 178: } ! 179: ! 180: void SCSI_Reset(void) { ! 181: SCSI_Uninit(); ! 182: SCSI_Init(); ! 183: } ! 184: ! 185: void SCSI_Eject(Uint8 i) { ! 186: File_Close(SCSIdisk[i].dsk); ! 187: SCSIdisk[i].dsk = NULL; ! 188: SCSIdisk[i].size = 0; ! 189: SCSIdisk[i].readonly = false; ! 190: SCSIdisk[i].shadow = NULL; ! 191: } ! 192: ! 193: static void SCSI_EjectDisk(Uint8 i) { ! 194: ConfigureParams.SCSI.target[i].bDiskInserted = false; ! 195: ConfigureParams.SCSI.target[i].szImageName[0] = '\0'; ! 196: ! 197: SCSI_Eject(i); ! 198: } ! 199: ! 200: void SCSI_Insert(Uint8 i) { ! 201: SCSIdisk[i].lun = SCSIdisk[i].status = SCSIdisk[i].message = 0; ! 202: SCSIdisk[i].sense.code = SCSIdisk[i].sense.key = SCSIdisk[i].sense.info = 0; ! 203: SCSIdisk[i].sense.valid = false; ! 204: SCSIdisk[i].lba = SCSIdisk[i].lastlba = SCSIdisk[i].blockcounter = 0; ! 205: ! 206: SCSIdisk[i].shadow = NULL; ! 207: ! 208: Log_Printf(LOG_WARN, "SCSI Disk%i: %s\n",i,ConfigureParams.SCSI.target[i].szImageName); ! 209: ! 210: if (File_Exists(ConfigureParams.SCSI.target[i].szImageName) && ! 211: ConfigureParams.SCSI.target[i].bDiskInserted) { ! 212: if (ConfigureParams.SCSI.target[i].bWriteProtected || ! 213: ConfigureParams.SCSI.target[i].nDeviceType==DEVTYPE_CD) { ! 214: SCSIdisk[i].dsk = File_Open(ConfigureParams.SCSI.target[i].szImageName, "rb"); ! 215: if (SCSIdisk[i].dsk == NULL) { ! 216: Log_Printf(LOG_WARN, "SCSI Disk%i: Cannot open image file %s\n", ! 217: i, ConfigureParams.SCSI.target[i].szImageName); ! 218: SCSIdisk[i].size = 0; ! 219: SCSIdisk[i].readonly = false; ! 220: if (SCSIdisk[i].devtype == DEVTYPE_HARDDISK) { ! 221: SCSIdisk[i].devtype = DEVTYPE_NONE; ! 222: } ! 223: } else { ! 224: SCSIdisk[i].size = File_Length(ConfigureParams.SCSI.target[i].szImageName); ! 225: SCSIdisk[i].readonly = true; ! 226: } ! 227: } else { ! 228: SCSIdisk[i].dsk = File_Open(ConfigureParams.SCSI.target[i].szImageName, "rb+"); ! 229: if (SCSIdisk[i].dsk == NULL) { ! 230: SCSIdisk[i].dsk = File_Open(ConfigureParams.SCSI.target[i].szImageName, "rb"); ! 231: if (SCSIdisk[i].dsk == NULL) { ! 232: Log_Printf(LOG_WARN, "SCSI Disk%i: Cannot open image file %s\n", ! 233: i, ConfigureParams.SCSI.target[i].szImageName); ! 234: SCSIdisk[i].size = 0; ! 235: SCSIdisk[i].readonly = false; ! 236: if (SCSIdisk[i].devtype == DEVTYPE_HARDDISK) { ! 237: SCSIdisk[i].devtype = DEVTYPE_NONE; ! 238: } ! 239: } else { ! 240: SCSIdisk[i].size = File_Length(ConfigureParams.SCSI.target[i].szImageName); ! 241: SCSIdisk[i].readonly = true; ! 242: Log_Printf(LOG_WARN, "SCSI Disk%i: Image file is not writable. Enabling write protection.\n", i); ! 243: } ! 244: } else { ! 245: SCSIdisk[i].size = File_Length(ConfigureParams.SCSI.target[i].szImageName); ! 246: SCSIdisk[i].readonly = false; ! 247: } ! 248: } ! 249: } else { ! 250: SCSIdisk[i].size = 0; ! 251: SCSIdisk[i].dsk = NULL; ! 252: SCSIdisk[i].readonly = false; ! 253: } ! 254: } ! 255: ! 256: ! 257: ! 258: /* INQUIRY response data */ ! 259: #define DEVTYPE_DISK 0x00 /* read/write disks */ ! 260: #define DEVTYPE_TAPE 0x01 /* tapes and other sequential devices */ ! 261: #define DEVTYPE_PRINTER 0x02 /* printers */ ! 262: #define DEVTYPE_PROCESSOR 0x03 /* cpus */ ! 263: #define DEVTYPE_WORM 0x04 /* write-once optical disks */ ! 264: #define DEVTYPE_READONLY 0x05 /* cd-roms */ ! 265: #define DEVTYPE_NOTPRESENT 0x7f /* logical unit not present */ ! 266: ! 267: ! 268: static unsigned char inquiry_bytes[] = ! 269: { ! 270: 0x00, /* 0: device type: see above */ ! 271: 0x00, /* 1: &0x7F - device type qualifier 0x00 unsupported, &0x80 - rmb: 0x00 = nonremovable, 0x80 = removable */ ! 272: 0x01, /* 2: ANSI SCSI standard (first release) compliant */ ! 273: 0x02, /* 3: Response format (format of following data): 0x01 SCSI-1 compliant */ ! 274: 0x31, /* 4: additional length of the following data */ ! 275: 0x00, 0x00, /* 5,6: reserved */ ! 276: 0x1C, /* 7: RelAdr=0, Wbus32=0, Wbus16=0, Sync=1, Linked=1, RSVD=1, CmdQue=0, SftRe=0 */ ! 277: 'P','r','e','v','i','o','u','s', /* 8-15: Vendor ASCII */ ! 278: 'H','D','D',' ',' ',' ',' ',' ', /* 16-23: Model ASCII */ ! 279: ' ',' ',' ',' ',' ',' ',' ',' ', /* 24-31: Blank space ASCII */ ! 280: '0','0','0','0','0','0','0','1', /* 32-39: Revision ASCII */ ! 281: '0','0','0','0','0','0','0','0', /* 40-47: Serial Number ASCII */ ! 282: ' ',' ',' ',' ',' ',' ' /* 48-53: Blank space ASCII */ ! 283: }; ! 284: ! 285: ! 286: Uint8 SCSIdisk_Send_Status(void) { ! 287: SCSIbus.phase = PHASE_MI; ! 288: return SCSIdisk[SCSIbus.target].status; ! 289: } ! 290: ! 291: Uint8 SCSIdisk_Send_Message(void) { ! 292: return SCSIdisk[SCSIbus.target].message; ! 293: } ! 294: ! 295: ! 296: bool SCSIdisk_Select(Uint8 target) { ! 297: ! 298: /* If there is no disk drive present, return timeout true */ ! 299: if (SCSIdisk[target].devtype==DEVTYPE_NONE) { ! 300: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Selection timeout, target = %i", target); ! 301: SCSIbus.phase = PHASE_ST; ! 302: return true; ! 303: } else { ! 304: SCSIbus.target = target; ! 305: return false; ! 306: } ! 307: } ! 308: ! 309: ! 310: void SCSIdisk_Receive_Command(Uint8 *cdb, Uint8 identify) { ! 311: Uint8 lun = 0; ! 312: ! 313: /* Get logical unit number */ ! 314: if (identify&MSG_IDENTIFY_MASK) { /* if identify message is valid */ ! 315: lun = identify&MSG_LUNMASK; /* use lun from identify message */ ! 316: } else { ! 317: lun = (cdb[1]&0xE0)>>5; /* use lun specified in CDB */ ! 318: } ! 319: ! 320: SCSIdisk[SCSIbus.target].lun = lun; ! 321: ! 322: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Opcode = $%02x, target = %i, lun = %i\n", cdb[0], SCSIbus.target,lun); ! 323: ! 324: SCSI_Emulate_Command(cdb); ! 325: } ! 326: ! 327: ! 328: void SCSI_Emulate_Command(Uint8 *cdb) { ! 329: Uint8 opcode = cdb[0]; ! 330: Uint8 target = SCSIbus.target; ! 331: ! 332: /* First check for lun-independent commands */ ! 333: switch (opcode) { ! 334: case CMD_INQUIRY: ! 335: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Inquiry\n"); ! 336: SCSI_Inquiry(cdb); ! 337: break; ! 338: case CMD_REQ_SENSE: ! 339: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Request sense\n"); ! 340: SCSI_RequestSense(cdb); ! 341: break; ! 342: /* Check if the specified lun is valid for our disk */ ! 343: default: ! 344: if (SCSIdisk[target].lun!=LUN_DISK) { ! 345: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Invalid lun! Check condition.\n"); ! 346: SCSIbus.phase = PHASE_ST; ! 347: SCSIdisk[target].status = STAT_CHECK_COND; /* status: check condition */ ! 348: SCSIdisk[target].message = MSG_COMPLETE; /* TODO: CHECK THIS! */ ! 349: SCSIdisk[target].sense.code = SC_INVALID_LUN; ! 350: SCSIdisk[target].sense.valid = false; ! 351: return; ! 352: } ! 353: ! 354: /* Then check for lun-dependent commands */ ! 355: switch(opcode) { ! 356: case CMD_TEST_UNIT_RDY: ! 357: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Test unit ready\n"); ! 358: SCSI_TestUnitReady(cdb); ! 359: break; ! 360: case CMD_READ_CAPACITY1: ! 361: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Read capacity\n"); ! 362: SCSI_ReadCapacity(cdb); ! 363: break; ! 364: case CMD_READ_SECTOR: ! 365: case CMD_READ_SECTOR1: ! 366: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Read sector\n"); ! 367: SCSI_ReadSector(cdb); ! 368: break; ! 369: case CMD_WRITE_SECTOR: ! 370: case CMD_WRITE_SECTOR1: ! 371: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Write sector\n"); ! 372: SCSI_WriteSector(cdb); ! 373: break; ! 374: case CMD_SEEK: ! 375: Log_Printf(LOG_WARN, "SCSI command: Seek\n"); ! 376: abort(); ! 377: break; ! 378: case CMD_SHIP: ! 379: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Ship\n"); ! 380: SCSI_StartStop(cdb); ! 381: break; ! 382: case CMD_MODESELECT: ! 383: Log_Printf(LOG_WARN, "SCSI command: Mode select\n"); ! 384: abort(); ! 385: break; ! 386: case CMD_MODESENSE: ! 387: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Mode sense\n"); ! 388: SCSI_ModeSense(cdb); ! 389: break; ! 390: case CMD_FORMAT_DRIVE: ! 391: Log_Printf(LOG_SCSI_LEVEL, "SCSI command: Format drive\n"); ! 392: SCSI_FormatDrive(cdb); ! 393: break; ! 394: /* as of yet unsupported commands */ ! 395: case CMD_VERIFY_TRACK: ! 396: case CMD_FORMAT_TRACK: ! 397: case CMD_CORRECTION: ! 398: default: ! 399: Log_Printf(LOG_WARN, "SCSI command: Unknown Command (%02X)\n",opcode); ! 400: SCSIdisk[target].status = STAT_CHECK_COND; ! 401: SCSIdisk[target].sense.code = SC_INVALID_CMD; ! 402: SCSIdisk[target].sense.valid = false; ! 403: SCSIbus.phase = PHASE_ST; ! 404: break; ! 405: } ! 406: break; ! 407: } ! 408: ! 409: SCSIdisk[target].message = MSG_COMPLETE; ! 410: ! 411: /* Update the led each time a command is processed */ ! 412: Statusbar_BlinkLed(DEVICE_LED_SCSI); ! 413: } ! 414: ! 415: ! 416: /* Helpers */ ! 417: ! 418: int SCSI_GetCommandLength(Uint8 opcode) { ! 419: Uint8 group_code = (opcode&0xE0)>>5; ! 420: switch (group_code) { ! 421: case 0: return 6; ! 422: case 1: return 10; ! 423: case 5: return 12; ! 424: default: ! 425: Log_Printf(LOG_WARN, "[SCSI] Unimplemented Group Code!"); ! 426: return 6; ! 427: } ! 428: } ! 429: ! 430: int SCSI_GetTransferLength(Uint8 opcode, Uint8 *cdb) ! 431: { ! 432: return opcode < 0x20? ! 433: // class 0 ! 434: cdb[4] : ! 435: // class 1 ! 436: COMMAND_ReadInt16(cdb, 7); ! 437: } ! 438: ! 439: Uint64 SCSI_GetOffset(Uint8 opcode, Uint8 *cdb) ! 440: { ! 441: return opcode < 0x20? ! 442: // class 0 ! 443: (COMMAND_ReadInt24(cdb, 1) & 0x1FFFFF) : ! 444: // class 1 ! 445: COMMAND_ReadInt32(cdb, 2); ! 446: } ! 447: ! 448: // get reserved count for SCSI reply ! 449: int SCSI_GetCount(Uint8 opcode, Uint8 *cdb) ! 450: { ! 451: return opcode < 0x20? ! 452: // class 0 ! 453: ((cdb[4]==0)?0x100:cdb[4]) : ! 454: // class 1 ! 455: COMMAND_ReadInt16(cdb, 7); ! 456: } ! 457: ! 458: static void SCSI_GuessGeometry(Uint32 size, Uint32 *cylinders, Uint32 *heads, Uint32 *sectors) ! 459: { ! 460: Uint32 c,h,s; ! 461: ! 462: for (h=16; h>0; h--) { ! 463: for (s=63; s>15; s--) { ! 464: if ((size%(s*h))==0) { ! 465: c=size/(s*h); ! 466: *cylinders=c; ! 467: *heads=h; ! 468: *sectors=s; ! 469: return; ! 470: } ! 471: } ! 472: } ! 473: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Disk geometry: No valid geometry found! Using default."); ! 474: ! 475: h=16; ! 476: s=63; ! 477: c=size/(s*h); ! 478: if ((size%(s*h))!=0) { ! 479: c+=1; ! 480: } ! 481: *cylinders=c; ! 482: *heads=h; ! 483: *sectors=s; ! 484: } ! 485: ! 486: #define SCSI_SEEK_TIME_HD 20000 /* 20 ms max seek time */ ! 487: #define SCSI_SECTOR_TIME_HD 350 /* 1.4 MB/sec */ ! 488: #define SCSI_SEEK_TIME_FD 200000 /* 200 ms max seek time */ ! 489: #define SCSI_SECTOR_TIME_FD 5500 /* 90 kB/sec */ ! 490: #define SCSI_SEEK_TIME_CD 500000 /* 500 ms max seek time */ ! 491: #define SCSI_SECTOR_TIME_CD 3250 /* 150 kB/sec */ ! 492: ! 493: Sint64 SCSI_Seek_Time(void) { ! 494: Uint8 target = SCSIbus.target; ! 495: Sint64 seektime, seekoffset, disksize; ! 496: ! 497: if (scsi_buffer.disk) { ! 498: switch (SCSIdisk[target].devtype) { ! 499: case DEVTYPE_HARDDISK: ! 500: seektime = SCSI_SEEK_TIME_HD; ! 501: break; ! 502: case DEVTYPE_CD: ! 503: seektime = SCSI_SEEK_TIME_CD; ! 504: break; ! 505: case DEVTYPE_FLOPPY: ! 506: seektime = SCSI_SEEK_TIME_FD; ! 507: break; ! 508: default: ! 509: return 0; ! 510: } ! 511: if (SCSIdisk[target].lba < SCSIdisk[target].lastlba) { ! 512: seekoffset = SCSIdisk[target].lastlba - SCSIdisk[target].lba; ! 513: } else { ! 514: seekoffset = SCSIdisk[target].lba - SCSIdisk[target].lastlba; ! 515: } ! 516: disksize = SCSIdisk[target].size/BLOCKSIZE; ! 517: ! 518: if (disksize <= 0) { /* make sure no zero divide occurs */ ! 519: return 0; ! 520: } ! 521: seektime *= seekoffset; ! 522: seektime /= disksize; ! 523: ! 524: if (seektime > 500000) { ! 525: seektime = 500000; ! 526: } ! 527: ! 528: return seektime; ! 529: } else { ! 530: return 0; ! 531: } ! 532: } ! 533: ! 534: Sint64 SCSI_Sector_Time(void) { ! 535: int target = SCSIbus.target; ! 536: Sint64 sectors = SCSIdisk[target].blockcounter; ! 537: ! 538: if (sectors <= 0) { ! 539: sectors = 1; ! 540: } ! 541: ! 542: if (scsi_buffer.disk) { ! 543: switch (SCSIdisk[target].devtype) { ! 544: case DEVTYPE_HARDDISK: ! 545: return sectors * SCSI_SECTOR_TIME_HD; ! 546: case DEVTYPE_CD: ! 547: return sectors * SCSI_SECTOR_TIME_CD; ! 548: case DEVTYPE_FLOPPY: ! 549: return sectors * SCSI_SECTOR_TIME_FD; ! 550: default: ! 551: return 1000; ! 552: } ! 553: } else { ! 554: return 100; ! 555: } ! 556: } ! 557: ! 558: MODEPAGE SCSI_GetModePage(Uint8 pagecode) { ! 559: Uint8 target = SCSIbus.target; ! 560: ! 561: MODEPAGE page; ! 562: ! 563: switch (pagecode) { ! 564: case 0x00: // operating page ! 565: page.pagesize = 4; ! 566: page.modepage[0] = 0x00; // &0x80: page savable? (not supported!), &0x7F: page code = 0x00 ! 567: page.modepage[1] = 0x02; // page length = 2 ! 568: page.modepage[2] = 0x80; // &0x80: usage bit = 1, &0x10: disable unit attention = 0 ! 569: page.modepage[3] = 0x00; // &0x7F: device type qualifier = 0x00, see inquiry! ! 570: break; ! 571: ! 572: case 0x01: // error recovery page ! 573: page.pagesize = 8; ! 574: page.modepage[0] = 0x01; // &0x80: page savable? (not supported!), &0x7F: page code = 0x01 ! 575: page.modepage[1] = 0x06; // page length = 6 ! 576: page.modepage[2] = 0x00; // AWRE, ARRE, TB, RC, EER, PER, DTE, DCR ! 577: page.modepage[3] = 0x1B; // retry count ! 578: page.modepage[4] = 0x0B; // correction span in bits ! 579: page.modepage[5] = 0x00; // head offset count ! 580: page.modepage[6] = 0x00; // data strobe offset count ! 581: page.modepage[7] = 0xFF; // recovery time limit ! 582: break; ! 583: ! 584: case 0x03: // format device page ! 585: page.pagesize = 0; ! 586: Log_Printf(LOG_WARN, "[SCSI] Mode Sense: Page %02x not yet emulated!\n", pagecode); ! 587: //abort(); ! 588: break; ! 589: ! 590: case 0x04: // rigid disc geometry page ! 591: { ! 592: Uint32 num_sectors = SCSIdisk[target].size/BLOCKSIZE; ! 593: ! 594: Uint32 cylinders, heads, sectors; ! 595: ! 596: SCSI_GuessGeometry(num_sectors, &cylinders, &heads, §ors); ! 597: ! 598: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Disk geometry: %i sectors, %i cylinders, %i heads\n", sectors, cylinders, heads); ! 599: ! 600: page.pagesize = 20; ! 601: page.modepage[0] = 0x04; // &0x80: page savable? (not supported!), &0x7F: page code = 0x04 ! 602: page.modepage[1] = 0x12; ! 603: page.modepage[2] = (cylinders >> 16) & 0xFF; ! 604: page.modepage[3] = (cylinders >> 8) & 0xFF; ! 605: page.modepage[4] = cylinders & 0xFF; ! 606: page.modepage[5] = heads; ! 607: page.modepage[6] = 0x00; // 6,7,8: starting cylinder - write precomp (not supported) ! 608: page.modepage[7] = 0x00; ! 609: page.modepage[8] = 0x00; ! 610: page.modepage[9] = 0x00; // 9,10,11: starting cylinder - reduced write current (not supported) ! 611: page.modepage[10] = 0x00; ! 612: page.modepage[11] = 0x00; ! 613: page.modepage[12] = 0x00; // 12,13: drive step rate (not supported) ! 614: page.modepage[13] = 0x00; ! 615: page.modepage[14] = 0x00; // 14,15,16: loading zone cylinder (not supported) ! 616: page.modepage[15] = 0x00; ! 617: page.modepage[16] = 0x00; ! 618: page.modepage[17] = 0x00; // &0x03: rotational position locking ! 619: page.modepage[18] = 0x00; // rotational position lock offset ! 620: page.modepage[19] = 0x00; // reserved ! 621: } ! 622: break; ! 623: ! 624: case 0x02: // disconnect/reconnect page ! 625: case 0x08: // caching page ! 626: case 0x0C: // notch page ! 627: case 0x0D: // power condition page ! 628: case 0x38: // cache control page ! 629: case 0x3C: // soft ID page (EEPROM) ! 630: page.pagesize = 0; ! 631: Log_Printf(LOG_WARN, "[SCSI] Mode Sense: Page %02x not yet emulated!\n", pagecode); ! 632: //abort(); ! 633: break; ! 634: ! 635: default: ! 636: page.pagesize = 0; ! 637: Log_Printf(LOG_WARN, "[SCSI] Mode Sense: Invalid page code: %02x!\n", pagecode); ! 638: break; ! 639: } ! 640: return page; ! 641: } ! 642: ! 643: ! 644: ! 645: /* SCSI Commands */ ! 646: ! 647: void SCSI_TestUnitReady(Uint8 *cdb) { ! 648: Uint8 target = SCSIbus.target; ! 649: ! 650: if (SCSIdisk[target].devtype!=DEVTYPE_NONE && ! 651: SCSIdisk[target].devtype!=DEVTYPE_HARDDISK && ! 652: SCSIdisk[target].dsk==NULL) { /* Empty drive */ ! 653: SCSIdisk[target].status = STAT_CHECK_COND; ! 654: SCSIdisk[target].sense.code = SC_NOT_READY; ! 655: SCSIbus.phase = PHASE_ST; ! 656: } else { ! 657: SCSIdisk[target].status = STAT_GOOD; ! 658: SCSIdisk[target].sense.code = SC_NO_ERROR; ! 659: SCSIbus.phase = PHASE_ST; ! 660: } ! 661: } ! 662: ! 663: void SCSI_ReadCapacity(Uint8 *cdb) { ! 664: Uint8 target = SCSIbus.target; ! 665: ! 666: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Read disk image: size = %llu byte\n", SCSIdisk[target].size); ! 667: ! 668: Uint32 sectors = (SCSIdisk[target].size / BLOCKSIZE) - 1; /* last LBA */ ! 669: ! 670: static Uint8 scsi_disksize[8]; ! 671: ! 672: scsi_disksize[0] = (sectors >> 24) & 0xFF; ! 673: scsi_disksize[1] = (sectors >> 16) & 0xFF; ! 674: scsi_disksize[2] = (sectors >> 8) & 0xFF; ! 675: scsi_disksize[3] = sectors & 0xFF; ! 676: scsi_disksize[4] = (BLOCKSIZE >> 24) & 0xFF; ! 677: scsi_disksize[5] = (BLOCKSIZE >> 16) & 0xFF; ! 678: scsi_disksize[6] = (BLOCKSIZE >> 8) & 0xFF; ! 679: scsi_disksize[7] = BLOCKSIZE & 0xFF; ! 680: ! 681: memcpy(scsi_buffer.data, scsi_disksize, 8); ! 682: scsi_buffer.limit=scsi_buffer.size=8; ! 683: scsi_buffer.disk=false; ! 684: ! 685: SCSIdisk[target].status = STAT_GOOD; ! 686: SCSIbus.phase = PHASE_DI; ! 687: SCSIdisk[target].sense.code = SC_NO_ERROR; ! 688: SCSIdisk[target].sense.valid = false; ! 689: } ! 690: ! 691: void SCSI_WriteSector(Uint8 *cdb) { ! 692: Uint8 target = SCSIbus.target; ! 693: ! 694: SCSIdisk[target].lastlba = SCSIdisk[target].lba; ! 695: SCSIdisk[target].lba = SCSI_GetOffset(cdb[0], cdb); ! 696: SCSIdisk[target].blockcounter = SCSI_GetCount(cdb[0], cdb); ! 697: ! 698: if (SCSIdisk[target].readonly) { ! 699: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Write sector: Disk is write protected! Check condition."); ! 700: SCSIdisk[target].status = STAT_CHECK_COND; ! 701: SCSIdisk[target].sense.code = SC_WRITE_PROTECT; ! 702: SCSIdisk[target].sense.valid = false; ! 703: SCSIbus.phase = PHASE_ST; ! 704: return; ! 705: } ! 706: scsi_buffer.disk=true; ! 707: scsi_buffer.size=0; ! 708: scsi_buffer.limit=BLOCKSIZE; ! 709: SCSIbus.phase = PHASE_DO; ! 710: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Write sector: %i block(s) at offset %i (blocksize: %i byte)", ! 711: SCSIdisk[target].blockcounter, SCSIdisk[target].lba, BLOCKSIZE); ! 712: } ! 713: ! 714: void scsi_write_sector(void) { ! 715: Uint8 target = SCSIbus.target; ! 716: Uint64 offset = 0; ! 717: ! 718: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Writing block at offset %i (%i blocks remaining).", ! 719: SCSIdisk[target].lba,SCSIdisk[target].blockcounter-1); ! 720: ! 721: offset = ((Uint64)SCSIdisk[target].lba)*BLOCKSIZE; ! 722: ! 723: if (offset < SCSIdisk[target].size) { ! 724: if (ConfigureParams.SCSI.nWriteProtection != WRITEPROT_ON) { ! 725: File_Write(scsi_buffer.data, BLOCKSIZE, offset, SCSIdisk[target].dsk); ! 726: } else { ! 727: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] WARNING: File write disabled!"); ! 728: if(SCSIdisk[target].shadow) { ! 729: if(!(SCSIdisk[target].shadow[SCSIdisk[target].lba])) ! 730: SCSIdisk[target].shadow[SCSIdisk[target].lba] = malloc(BLOCKSIZE); ! 731: memcpy(SCSIdisk[target].shadow[SCSIdisk[target].lba], scsi_buffer.data, BLOCKSIZE); ! 732: } else { ! 733: Uint32 blocks = SCSIdisk[target].size / BLOCKSIZE; ! 734: SCSIdisk[target].shadow = malloc(sizeof(Uint8*) * blocks); ! 735: for(int i = blocks; --i >= 0;) ! 736: SCSIdisk[target].shadow[i] = NULL; ! 737: } ! 738: } ! 739: scsi_buffer.limit=BLOCKSIZE; ! 740: scsi_buffer.size=0; ! 741: ! 742: SCSIdisk[target].status = STAT_GOOD; ! 743: SCSIdisk[target].sense.code = SC_NO_ERROR; ! 744: SCSIdisk[target].sense.valid = false; ! 745: SCSIdisk[target].lba++; ! 746: SCSIdisk[target].blockcounter--; ! 747: if (SCSIdisk[target].blockcounter==0) { ! 748: SCSIbus.phase = PHASE_ST; ! 749: } ! 750: } else { ! 751: SCSIdisk[target].status = STAT_CHECK_COND; ! 752: SCSIdisk[target].sense.code = SC_INVALID_LBA; ! 753: SCSIdisk[target].sense.valid = true; ! 754: SCSIdisk[target].sense.info = SCSIdisk[target].lba; ! 755: SCSIbus.phase = PHASE_ST; ! 756: } ! 757: } ! 758: ! 759: void SCSIdisk_Receive_Data(Uint8 val) { ! 760: /* Receive one byte. If the transfer is complete, set status phase ! 761: * and write the buffer contents to the disk. */ ! 762: scsi_buffer.data[scsi_buffer.size]=val; ! 763: scsi_buffer.size++; ! 764: if (scsi_buffer.size==scsi_buffer.limit) { ! 765: if (scsi_buffer.disk==true) { ! 766: scsi_write_sector(); /* sets status phase if done or error */ ! 767: } else { ! 768: SCSIbus.phase = PHASE_ST; ! 769: } ! 770: } ! 771: } ! 772: ! 773: ! 774: void SCSI_ReadSector(Uint8 *cdb) { ! 775: Uint8 target = SCSIbus.target; ! 776: ! 777: SCSIdisk[target].lastlba = SCSIdisk[target].lba; ! 778: SCSIdisk[target].lba = SCSI_GetOffset(cdb[0], cdb); ! 779: SCSIdisk[target].blockcounter = SCSI_GetCount(cdb[0], cdb); ! 780: scsi_buffer.disk=true; ! 781: scsi_buffer.size=0; ! 782: SCSIbus.phase = PHASE_DI; ! 783: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Read sector: %i block(s) at offset %i (blocksize: %i byte)", ! 784: SCSIdisk[target].blockcounter, SCSIdisk[target].lba, BLOCKSIZE); ! 785: scsi_read_sector(); ! 786: } ! 787: ! 788: void scsi_read_sector(void) { ! 789: Uint8 target = SCSIbus.target; ! 790: Uint64 offset = 0; ! 791: ! 792: if (SCSIdisk[target].blockcounter==0) { ! 793: SCSIbus.phase = PHASE_ST; ! 794: return; ! 795: } ! 796: ! 797: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Reading block at offset %i (%i blocks remaining).", ! 798: SCSIdisk[target].lba,SCSIdisk[target].blockcounter-1); ! 799: ! 800: offset = ((Uint64)SCSIdisk[target].lba)*BLOCKSIZE; ! 801: ! 802: if (offset < SCSIdisk[target].size) { ! 803: if (SCSIdisk[target].shadow && SCSIdisk[target].shadow[SCSIdisk[target].lba]) { ! 804: memcpy(scsi_buffer.data, SCSIdisk[target].shadow[SCSIdisk[target].lba], BLOCKSIZE); ! 805: } else { ! 806: File_Read(scsi_buffer.data, BLOCKSIZE, offset, SCSIdisk[target].dsk); ! 807: } ! 808: scsi_buffer.limit=scsi_buffer.size=BLOCKSIZE; ! 809: ! 810: SCSIdisk[target].status = STAT_GOOD; ! 811: SCSIdisk[target].sense.code = SC_NO_ERROR; ! 812: SCSIdisk[target].sense.valid = false; ! 813: SCSIdisk[target].lba++; ! 814: SCSIdisk[target].blockcounter--; ! 815: } else { ! 816: SCSIdisk[target].status = STAT_CHECK_COND; ! 817: SCSIdisk[target].sense.code = SC_INVALID_LBA; ! 818: SCSIdisk[target].sense.valid = true; ! 819: SCSIdisk[target].sense.info = SCSIdisk[target].lba; ! 820: SCSIbus.phase = PHASE_ST; ! 821: } ! 822: } ! 823: ! 824: Uint8 SCSIdisk_Send_Data(void) { ! 825: /* Send one byte. If the transfer is complete, set status phase */ ! 826: Uint8 val=scsi_buffer.data[scsi_buffer.limit-scsi_buffer.size]; ! 827: scsi_buffer.size--; ! 828: if (scsi_buffer.size==0) { ! 829: if (scsi_buffer.disk==true) { ! 830: scsi_read_sector(); /* sets status phase if done or error */ ! 831: } else { ! 832: SCSIbus.phase = PHASE_ST; ! 833: } ! 834: } ! 835: return val; ! 836: } ! 837: ! 838: ! 839: void SCSI_Inquiry (Uint8 *cdb) { ! 840: Uint8 target = SCSIbus.target; ! 841: ! 842: switch (SCSIdisk[target].devtype) { ! 843: case DEVTYPE_HARDDISK: ! 844: inquiry_bytes[0] = DEVTYPE_DISK; ! 845: inquiry_bytes[1] &= ~0x80; ! 846: inquiry_bytes[16] = 'H'; ! 847: inquiry_bytes[17] = 'D'; ! 848: inquiry_bytes[18] = 'D'; ! 849: inquiry_bytes[19] = ' '; ! 850: inquiry_bytes[20] = ' '; ! 851: inquiry_bytes[21] = ' '; ! 852: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Disk is HDD\n"); ! 853: break; ! 854: case DEVTYPE_CD: ! 855: inquiry_bytes[0] = DEVTYPE_READONLY; ! 856: inquiry_bytes[1] |= 0x80; ! 857: inquiry_bytes[16] = 'C'; ! 858: inquiry_bytes[17] = 'D'; ! 859: inquiry_bytes[18] = '-'; ! 860: inquiry_bytes[19] = 'R'; ! 861: inquiry_bytes[20] = 'O'; ! 862: inquiry_bytes[21] = 'M'; ! 863: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Disk is CD-ROM\n"); ! 864: break; ! 865: case DEVTYPE_FLOPPY: ! 866: inquiry_bytes[0] = DEVTYPE_DISK; ! 867: inquiry_bytes[1] |= 0x80; ! 868: inquiry_bytes[16] = 'F'; ! 869: inquiry_bytes[17] = 'L'; ! 870: inquiry_bytes[18] = 'O'; ! 871: inquiry_bytes[19] = 'P'; ! 872: inquiry_bytes[20] = 'P'; ! 873: inquiry_bytes[21] = 'Y'; ! 874: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Disk is Floppy\n"); ! 875: break; ! 876: ! 877: default: ! 878: break; ! 879: } ! 880: ! 881: if (SCSIdisk[target].lun!=LUN_DISK) { ! 882: inquiry_bytes[0] = DEVTYPE_NOTPRESENT; ! 883: } ! 884: ! 885: scsi_buffer.disk=false; ! 886: scsi_buffer.limit = scsi_buffer.size = SCSI_GetTransferLength(cdb[0], cdb); ! 887: if (scsi_buffer.limit > (int)sizeof(inquiry_bytes)) { ! 888: scsi_buffer.limit = scsi_buffer.size = sizeof(inquiry_bytes); ! 889: } ! 890: memcpy(scsi_buffer.data, inquiry_bytes, scsi_buffer.limit); ! 891: ! 892: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Inquiry data length: %d", scsi_buffer.limit); ! 893: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Inquiry Data: %c,%c,%c,%c,%c,%c,%c,%c\n",scsi_buffer.data[8], ! 894: scsi_buffer.data[9],scsi_buffer.data[10],scsi_buffer.data[11],scsi_buffer.data[12], ! 895: scsi_buffer.data[13],scsi_buffer.data[14],scsi_buffer.data[15]); ! 896: ! 897: SCSIdisk[target].status = STAT_GOOD; ! 898: SCSIbus.phase = PHASE_DI; ! 899: SCSIdisk[target].sense.code = SC_NO_ERROR; ! 900: SCSIdisk[target].sense.valid = false; ! 901: } ! 902: ! 903: ! 904: void SCSI_StartStop(Uint8 *cdb) { ! 905: Uint8 target = SCSIbus.target; ! 906: ! 907: switch (cdb[4]&0x03) { ! 908: case 0: ! 909: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Stop disk %i", target); ! 910: break; ! 911: case 1: ! 912: Log_Printf(LOG_SCSI_LEVEL, "[SCSI] Start disk %i", target); ! 913: break; ! 914: case 2: ! 915: Log_Printf(LOG_WARN, "[SCSI] Eject disk %i", target); ! 916: if (SCSIdisk[target].devtype!=DEVTYPE_HARDDISK) { ! 917: SCSI_EjectDisk(target); ! 918: Statusbar_AddMessage("Ejecting SCSI media.", 0); ! 919: } ! 920: break; ! 921: default: ! 922: Log_Printf(LOG_WARN, "[SCSI] Invalid start/stop"); ! 923: break; ! 924: } ! 925: ! 926: SCSIdisk[target].status = STAT_GOOD; ! 927: SCSIbus.phase = PHASE_ST; ! 928: } ! 929: ! 930: ! 931: void SCSI_RequestSense(Uint8 *cdb) { ! 932: Uint8 target = SCSIbus.target; ! 933: ! 934: int nRetLen; ! 935: Uint8 retbuf[22]; ! 936: ! 937: nRetLen = SCSI_GetCount(cdb[0], cdb); ! 938: ! 939: if ((nRetLen<4 && nRetLen!=0) || nRetLen>22) { ! 940: Log_Printf(LOG_WARN, "[SCSI] *** Strange REQUEST SENSE *** len=%d!",nRetLen); ! 941: } ! 942: ! 943: /* Limit to sane length */ ! 944: if (nRetLen <= 0) { ! 945: nRetLen = 4; ! 946: } else if (nRetLen > 22) { ! 947: nRetLen = 22; ! 948: } ! 949: ! 950: Log_Printf(LOG_WARN, "[SCSI] REQ SENSE size = %d %s at %d", nRetLen,__FILE__,__LINE__); ! 951: ! 952: memset(retbuf, 0, nRetLen); ! 953: ! 954: retbuf[0] = 0x70; ! 955: if (SCSIdisk[target].sense.valid) { ! 956: retbuf[0] |= 0x80; ! 957: retbuf[3] = SCSIdisk[target].sense.info >> 24; ! 958: retbuf[4] = SCSIdisk[target].sense.info >> 16; ! 959: retbuf[5] = SCSIdisk[target].sense.info >> 8; ! 960: retbuf[6] = SCSIdisk[target].sense.info; ! 961: } ! 962: switch (SCSIdisk[target].sense.code) { ! 963: case SC_NO_ERROR: ! 964: SCSIdisk[target].sense.key = SK_NOSENSE; ! 965: break; ! 966: case SC_NOT_READY: ! 967: SCSIdisk[target].sense.key = SK_NOTREADY; ! 968: break; ! 969: case SC_WRITE_FAULT: ! 970: case SC_INVALID_CMD: ! 971: case SC_INVALID_LBA: ! 972: case SC_INVALID_CDB: ! 973: case SC_INVALID_LUN: ! 974: SCSIdisk[target].sense.key = SK_ILLEGAL_REQ; ! 975: break; ! 976: case SC_WRITE_PROTECT: ! 977: SCSIdisk[target].sense.key = SK_DATAPROTECT; ! 978: break; ! 979: case SC_NO_SECTOR: ! 980: default: ! 981: SCSIdisk[target].sense.key = SK_HARDWARE; ! 982: break; ! 983: } ! 984: retbuf[2] = SCSIdisk[target].sense.key; ! 985: retbuf[7] = 14; ! 986: retbuf[12] = SCSIdisk[target].sense.code; ! 987: ! 988: scsi_buffer.size=scsi_buffer.limit=nRetLen; ! 989: memcpy(scsi_buffer.data, retbuf, scsi_buffer.limit); ! 990: scsi_buffer.disk=false; ! 991: ! 992: SCSIdisk[target].status = STAT_GOOD; ! 993: SCSIbus.phase = PHASE_DI; ! 994: } ! 995: ! 996: ! 997: void SCSI_ModeSense(Uint8 *cdb) { ! 998: Uint8 target = SCSIbus.target; ! 999: ! 1000: Uint8 retbuf[256]; ! 1001: MODEPAGE page; ! 1002: ! 1003: Uint32 sectors = SCSIdisk[target].size / BLOCKSIZE; ! 1004: ! 1005: Uint8 pagecontrol = (cdb[2] & 0x0C) >> 6; ! 1006: Uint8 pagecode = cdb[2] & 0x3F; ! 1007: Uint8 dbd = cdb[1] & 0x08; // disable block descriptor ! 1008: ! 1009: Log_Printf(LOG_WARN, "[SCSI] Mode Sense: page = %02x, page_control = %i, %s\n", pagecode, pagecontrol, dbd == 0x08 ? "block descriptor disabled" : "block descriptor enabled"); ! 1010: ! 1011: /* Header */ ! 1012: retbuf[0] = 0x00; // length of following data ! 1013: retbuf[1] = 0x00; // medium type (always 0) ! 1014: retbuf[2] = SCSIdisk[target].readonly ? 0x80 : 0x00; // if media is read-only 0x80, else 0x00 ! 1015: retbuf[3] = 0x08; // block descriptor length ! 1016: ! 1017: /* Block descriptor data */ ! 1018: Uint8 header_size = 4; ! 1019: if (!dbd) { ! 1020: retbuf[4] = 0x00; // media density code ! 1021: retbuf[5] = sectors >> 16; // Number of blocks, high (?) ! 1022: retbuf[6] = sectors >> 8; // Number of blocks, med (?) ! 1023: retbuf[7] = sectors; // Number of blocks, low (?) ! 1024: retbuf[8] = 0x00; // reserved ! 1025: retbuf[9] = (BLOCKSIZE >> 16) & 0xFF; // Block size in bytes, high ! 1026: retbuf[10] = (BLOCKSIZE >> 8) & 0xFF; // Block size in bytes, med ! 1027: retbuf[11] = BLOCKSIZE & 0xFF; // Block size in bytes, low ! 1028: header_size = 12; ! 1029: Log_Printf(LOG_WARN, "[SCSI] Mode Sense: Block descriptor data: %s, size = %i blocks, blocksize = %i byte\n", ! 1030: SCSIdisk[target].readonly ? "disk is read-only" : "disk is read/write" , sectors, BLOCKSIZE); ! 1031: } ! 1032: retbuf[0] = header_size - 1; ! 1033: ! 1034: /* Mode Pages */ ! 1035: if (pagecode == 0x3F) { // return all pages! ! 1036: Uint8 offset = header_size; ! 1037: Uint8 counter; ! 1038: for (pagecode = 0; pagecode < 0x3F; pagecode++) { ! 1039: page = SCSI_GetModePage(pagecode); ! 1040: switch (pagecontrol) { ! 1041: case 0: // current values (not supported, using default values) ! 1042: memcpy(page.current, page.modepage, page.pagesize); ! 1043: for (counter = 0; counter < page.pagesize; counter++) { ! 1044: retbuf[counter+offset] = page.current[counter]; ! 1045: } ! 1046: break; ! 1047: case 1: // changeable values (not supported, all 0) ! 1048: memset(page.changeable, 0x00, page.pagesize); ! 1049: for (counter = 0; counter < page.pagesize; counter++) { ! 1050: retbuf[counter+offset] = page.changeable[counter]; ! 1051: } ! 1052: break; ! 1053: case 2: // default values ! 1054: for (counter = 0; counter < page.pagesize; counter++) { ! 1055: retbuf[counter+offset] = page.modepage[counter]; ! 1056: } ! 1057: break; ! 1058: case 3: // saved values (not supported, using default values) ! 1059: memcpy(page.saved, page.modepage, page.pagesize); ! 1060: for (counter = 0; counter < page.pagesize; counter++) { ! 1061: retbuf[counter+offset] = page.saved[counter]; ! 1062: } ! 1063: break; ! 1064: ! 1065: default: ! 1066: break; ! 1067: } ! 1068: offset += page.pagesize; ! 1069: retbuf[0] += page.pagesize; ! 1070: } ! 1071: } else { // return only single requested page ! 1072: page = SCSI_GetModePage(pagecode); ! 1073: ! 1074: Uint8 counter; ! 1075: switch (pagecontrol) { ! 1076: case 0: // current values (not supported, using default values) ! 1077: memcpy(page.current, page.modepage, page.pagesize); ! 1078: for (counter = 0; counter < page.pagesize; counter++) { ! 1079: retbuf[counter+header_size] = page.current[counter]; ! 1080: } ! 1081: break; ! 1082: case 1: // changeable values (not supported, all 0) ! 1083: memset(page.changeable, 0x00, page.pagesize); ! 1084: for (counter = 0; counter < page.pagesize; counter++) { ! 1085: retbuf[counter+header_size] = page.changeable[counter]; ! 1086: } ! 1087: break; ! 1088: case 2: // default values ! 1089: for (counter = 0; counter < page.pagesize; counter++) { ! 1090: retbuf[counter+header_size] = page.modepage[counter]; ! 1091: } ! 1092: break; ! 1093: case 3: // saved values (not supported, using default values) ! 1094: memcpy(page.saved, page.modepage, page.pagesize); ! 1095: for (counter = 0; counter < page.pagesize; counter++) { ! 1096: retbuf[counter+header_size] = page.saved[counter]; ! 1097: } ! 1098: break; ! 1099: ! 1100: default: ! 1101: break; ! 1102: } ! 1103: ! 1104: retbuf[0] += page.pagesize; ! 1105: } ! 1106: ! 1107: scsi_buffer.disk=false; ! 1108: scsi_buffer.limit = scsi_buffer.size = retbuf[0]+1; ! 1109: if (scsi_buffer.limit > SCSI_GetTransferLength(cdb[0], cdb)) { ! 1110: scsi_buffer.limit = scsi_buffer.size = SCSI_GetTransferLength(cdb[0], cdb); ! 1111: } ! 1112: memcpy(scsi_buffer.data, retbuf, scsi_buffer.limit); ! 1113: ! 1114: SCSIdisk[target].status = STAT_GOOD; ! 1115: SCSIbus.phase = PHASE_DI; ! 1116: SCSIdisk[target].sense.code = SC_NO_ERROR; ! 1117: SCSIdisk[target].sense.valid = false; ! 1118: } ! 1119: ! 1120: ! 1121: void SCSI_FormatDrive(Uint8 *cdb) { ! 1122: Uint8 format_data = cdb[1]&0x10; ! 1123: ! 1124: Log_Printf(LOG_WARN, "[SCSI] Format drive command with parameters %02X\n",cdb[1]&0x1F); ! 1125: ! 1126: if (format_data) { ! 1127: Log_Printf(LOG_WARN, "[SCSI] Format drive with format data unsupported!\n"); ! 1128: abort(); ! 1129: } else { ! 1130: SCSIdisk[SCSIbus.target].status = STAT_GOOD; ! 1131: SCSIbus.phase = PHASE_ST; ! 1132: } ! 1133: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.