src/firmware/mode.c

   1 //      Copyright (C) 2013 Michael McMaster <michael@codesrc.com>\r
   2 //  Copyright (C) 2014 Doug Brown <doug@downtowndougbrown.com>\r
   3 //\r
   4 //      This file is part of SCSI2SD.\r
   5 //\r
   6 //      SCSI2SD is free software: you can redistribute it and/or modify\r
   7 //      it under the terms of the GNU General Public License as published by\r
   8 //      the Free Software Foundation, either version 3 of the License, or\r
   9 //      (at your option) any later version.\r
  10 //\r
  11 //      SCSI2SD is distributed in the hope that it will be useful,\r
  12 //      but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13 //      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14 //      GNU General Public License for more details.\r
  15 //\r
  16 //      You should have received a copy of the GNU General Public License\r
  17 //      along with SCSI2SD.  If not, see <http://www.gnu.org/licenses/>.\r
  18 \r
  19 #include "scsi.h"\r
  20 #include "mode.h"\r
  21 #include "disk.h"\r
  22 \r
  23 #include <string.h>\r
  24 \r
  25 static const uint8_t ReadWriteErrorRecoveryPage[] =\r
  26 {\r
  27 0x01, // Page code\r
  28 0x0A, // Page length\r
  29 \r
  30 // VMS 5.5-2 is very particular regarding the mode page values.\r
  31 // The required values for a SCSI2/NoTCQ device are:\r
  32 // AWRE=0 ARRE=0 TB=1 RC=0 EER=? PER=1 DTE=1 DCR=?\r
  33 // See ftp://www.digiater.nl/openvms/decus/vms94b/net94b/scsi_params_dkdriver.txt\r
  34 // X-Newsgroups: comp.os.vms\r
  35 // Subject: Re: VMS 6.1 vs. Seagate Disk Drives\r
  36 // Message-Id: <32g87h$8q@nntpd.lkg.dec.com>\r
  37 // From: weber@evms.enet.dec.com (Ralph O. Weber -- OpenVMS AXP)\r
  38 // Date: 12 Aug 1994 16:32:49 GMT\r
  39 0x26,\r
  40 \r
  41 0x00, // Don't try recovery algorithm during reads\r
  42 0x00, // Correction span 0\r
  43 0x00, // Head offset count 0,\r
  44 0x00, // Data strobe offset count 0,\r
  45 0x00, // Reserved\r
  46 0x00, // Don't try recovery algorithm during writes\r
  47 0x00, // Reserved\r
  48 0x00, 0x00 // Recovery time limit 0 (use default)*/\r
  49 };\r
  50 \r
  51 static const uint8_t ReadWriteErrorRecoveryPage_SCSI1[] =\r
  52 {\r
  53 0x01, // Page code\r
  54 0x06, // Page length\r
  55 0x26,\r
  56 0x00, // Don't try recovery algorithm during reads\r
  57 0x00, // Correction span 0\r
  58 0x00, // Head offset count 0,\r
  59 0x00, // Data strobe offset count 0,\r
  60 0xFF // Reserved\r
  61 };\r
  62 \r
  63 static const uint8_t DisconnectReconnectPage[] =\r
  64 {\r
  65 0x02, // Page code\r
  66 0x0E, // Page length\r
  67 0, // Buffer full ratio\r
  68 0, // Buffer empty ratio\r
  69 0x00, 10, // Bus inactivity limit, 100us increments. Allow 1ms.\r
  70 0x00, 0x00, // Disconnect time limit\r
  71 0x00, 0x00, // Connect time limit\r
  72 0x00, 0x00, // Maximum burst size\r
  73 0x00 ,// DTDC. Not used.\r
  74 0x00, 0x00, 0x00 // Reserved\r
  75 };\r
  76 \r
  77 static const uint8_t DisconnectReconnectPage_SCSI1[] =\r
  78 {\r
  79 0x02, // Page code\r
  80 0x0A, // Page length\r
  81 0, // Buffer full ratio\r
  82 0, // Buffer empty ratio\r
  83 0x00, 10, // Bus inactivity limit, 100us increments. Allow 1ms.\r
  84 0x00, 0x00, // Disconnect time limit\r
  85 0x00, 0x00, // Connect time limit\r
  86 0x00, 0x00 // Maximum burst size\r
  87 };\r
  88 \r
  89 static const uint8_t FormatDevicePage[] =\r
  90 {\r
  91 0x03 | 0x80, // Page code | PS (persist) bit.\r
  92 0x16, // Page length\r
  93 0x00, 0x00, // Single zone\r
  94 0x00, 0x00, // No alternate sectors\r
  95 0x00, 0x00, // No alternate tracks\r
  96 0x00, 0x00, // No alternate tracks per lun\r
  97 0x00, 0x00, // Sectors per track, configurable\r
  98 0xFF, 0xFF, // Data bytes per physical sector. Configurable.\r
  99 0x00, 0x01, // Interleave\r
 100 0x00, 0x00, // Track skew factor\r
 101 0x00, 0x00, // Cylinder skew factor\r
 102 0xC0, // SSEC(set) HSEC(set) RMB SURF\r
 103 0x00, 0x00, 0x00 // Reserved\r
 104 };\r
 105 \r
 106 static const uint8_t RigidDiskDriveGeometry[] =\r
 107 {\r
 108 0x04, // Page code\r
 109 0x16, // Page length\r
 110 0xFF, 0xFF, 0xFF, // Number of cylinders\r
 111 0x00, // Number of heads (replaced by configured value)\r
 112 0xFF, 0xFF, 0xFF, // Starting cylinder-write precompensation\r
 113 0xFF, 0xFF, 0xFF, // Starting cylinder-reduced write current\r
 114 0x00, 0x1, // Drive step rate (units of 100ns)\r
 115 0x00, 0x00, 0x00, // Landing zone cylinder\r
 116 0x00, // RPL\r
 117 0x00, // Rotational offset\r
 118 0x00, // Reserved\r
 119 5400 >> 8, 5400 & 0xFF, // Medium rotation rate (RPM)\r
 120 0x00, 0x00 // Reserved\r
 121 };\r
 122 \r
 123 static const uint8_t FlexibleDiskDriveGeometry[] =\r
 124 {\r
 125 0x05, // Page code\r
 126 0x1E, // Page length\r
 127 0x01, 0xF4, // Transfer Rate (500kbits)\r
 128 0x01, // heads\r
 129 18, // sectors per track\r
 130 0x20,0x00, // bytes per sector\r
 131 0x00, 80, // Cylinders\r
 132 0x00, 0x80, // Write-precomp\r
 133 0x00, 0x80, // reduced current,\r
 134 0x00, 0x00, // Drive step rate\r
 135 0x00, // pulse width\r
 136 0x00, 0x00, // Head settle delay\r
 137 0x00, // motor on delay\r
 138 0x00,  // motor off delay\r
 139 0x00,\r
 140 0x00,\r
 141 0x00,\r
 142 0x00,\r
 143 0x00,\r
 144 0x00,\r
 145 0x00,\r
 146 0x00,\r
 147 0x00,\r
 148 0x00,\r
 149 0x00\r
 150 };\r
 151 \r
 152 static const uint8_t RigidDiskDriveGeometry_SCSI1[] =\r
 153 {\r
 154 0x04, // Page code\r
 155 0x12, // Page length\r
 156 0xFF, 0xFF, 0xFF, // Number of cylinders\r
 157 0x00, // Number of heads (replaced by configured value)\r
 158 0xFF, 0xFF, 0xFF, // Starting cylinder-write precompensation\r
 159 0xFF, 0xFF, 0xFF, // Starting cylinder-reduced write current\r
 160 0x00, 0x1, // Drive step rate (units of 100ns)\r
 161 0x00, 0x00, 0x00, // Landing zone cylinder\r
 162 0x00, // RPL\r
 163 0x00, // Rotational offset\r
 164 0x00 // Reserved\r
 165 };\r
 166 \r
 167 static const uint8_t CachingPage[] =\r
 168 {\r
 169 0x08, // Page Code\r
 170 0x0A, // Page length\r
 171 0x01, // Read cache disable\r
 172 0x00, // No useful rention policy.\r
 173 0x00, 0x00, // Pre-fetch always disabled\r
 174 0x00, 0x00, // Minimum pre-fetch\r
 175 0x00, 0x00, // Maximum pre-fetch\r
 176 0x00, 0x00, // Maximum pre-fetch ceiling\r
 177 };\r
 178 \r
 179 // Old CCS SCSI-1 cache page\r
 180 static const uint8_t CCSCachingPage[] =\r
 181 {\r
 182 0x38, // Page Code\r
 183 0x0E, // Page length\r
 184 0x00, // Read cache disable\r
 185 0x00, // Prefetch threshold\r
 186 0x00, 0x00, // Max threshold / multiplier\r
 187 0x00, 0x00, // Min threshold / multiplier\r
 188 0x00, 0x00, // Reserved\r
 189 0x00, 0x00,\r
 190 0x00, 0x00,\r
 191 0x00, 0x00,\r
 192 };\r
 193 \r
 194 static const uint8_t ControlModePage[] =\r
 195 {\r
 196 0x0A, // Page code\r
 197 0x06, // Page length\r
 198 0x00, // No logging\r
 199 0x01, // Disable tagged queuing\r
 200 0x00, // No async event notifications\r
 201 0x00, // Reserved\r
 202 0x00, 0x00 // AEN holdoff period.\r
 203 };\r
 204 \r
 205 static const uint8_t SequentialDeviceConfigPage[] =\r
 206 {\r
 207 0x10, // page code\r
 208 0x0E, // Page length\r
 209 0x00, // CAP, CAF, Active Format\r
 210 0x00, // Active partition\r
 211 0x00, // Write buffer full ratio\r
 212 0x00, // Read buffer empty ratio\r
 213 0x00,0x01, // Write delay time, in 100ms units\r
 214 0x00, // Default gap size\r
 215 0x10, // auto-generation of default eod (end of data)\r
 216 0x00,0x00,0x00, // buffer-size at early warning\r
 217 0x00, // No data compression\r
 218 0x00 // reserved\r
 219 };\r
 220 \r
 221 // Allow Apple 68k Drive Setup to format this drive.\r
 222 // Code\r
 223 static const uint8_t AppleVendorPage[] =\r
 224 {\r
 225 0x30, // Page code\r
 226 28, // Page length\r
 227 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 228 'A','P','P','L','E',' ','C','O','M','P','U','T','E','R',',',' ','I','N','C','.'\r
 229 };\r
 230 \r
 231 static void pageIn(int pc, int dataIdx, const uint8_t* pageData, int pageLen)\r
 232 {\r
 233         memcpy(&scsiDev.data[dataIdx], pageData, pageLen);\r
 234 \r
 235         if (pc == 0x01) // Mask out (un)changable values\r
 236         {\r
 237                 memset(&scsiDev.data[dataIdx+2], 0, pageLen - 2);\r
 238         }\r
 239 }\r
 240 \r
 241 static void doModeSense(\r
 242         int sixByteCmd, int dbd, int pc, int pageCode, int allocLength)\r
 243 {\r
 244         ////////////// Mode Parameter Header\r
 245         ////////////////////////////////////\r
 246 \r
 247         // Skip the Mode Data Length, we set that last.\r
 248         int idx = 1;\r
 249         if (!sixByteCmd) ++idx;\r
 250 \r
 251         uint8_t mediumType = 0;\r
 252         uint8_t deviceSpecificParam = 0;\r
 253         uint8_t density = 0;\r
 254         switch (scsiDev.target->cfg->deviceType)\r
 255         {\r
 256         case S2S_CFG_FIXED:\r
 257         case S2S_CFG_REMOVEABLE:\r
 258                 mediumType = 0; // We should support various floppy types here!\r
 259                 // Contains cache bits (0) and a Write-Protect bit.\r
 260                 deviceSpecificParam =\r
 261                         (blockDev.state & DISK_WP) ? 0x80 : 0;\r
 262                 density = 0; // reserved for direct access\r
 263                 break;\r
 264 \r
 265         case S2S_CFG_FLOPPY_14MB:\r
 266                 mediumType = 0x1E; // 90mm/3.5"\r
 267                 deviceSpecificParam =\r
 268                         (blockDev.state & DISK_WP) ? 0x80 : 0;\r
 269                 density = 0; // reserved for direct access\r
 270                 break;\r
 271 \r
 272         case S2S_CFG_OPTICAL:\r
 273                 mediumType = 0x02; // 120mm CDROM, data only.\r
 274                 deviceSpecificParam = 0;\r
 275                 density = 0x01; // User data only, 2048bytes per sector.\r
 276                 break;\r
 277 \r
 278         case S2S_CFG_SEQUENTIAL:\r
 279                 mediumType = 0; // reserved\r
 280                 deviceSpecificParam =\r
 281                         (blockDev.state & DISK_WP) ? 0x80 : 0;\r
 282                 density = 0x13; // DAT Data Storage, X3B5/88-185A \r
 283                 break;\r
 284 \r
 285         case S2S_CFG_MO:\r
 286         mediumType = 0x03; // Optical reversible or erasable medium\r
 287                 deviceSpecificParam =\r
 288                         (blockDev.state & DISK_WP) ? 0x80 : 0;\r
 289                 density = 0x00; // Default\r
 290                 break;\r
 291 \r
 292         };\r
 293 \r
 294         scsiDev.data[idx++] = mediumType;\r
 295         scsiDev.data[idx++] = deviceSpecificParam;\r
 296 \r
 297         if (sixByteCmd)\r
 298         {\r
 299                 if (dbd)\r
 300                 {\r
 301                         scsiDev.data[idx++] = 0; // No block descriptor\r
 302                 }\r
 303                 else\r
 304                 {\r
 305                         // One block descriptor of length 8 bytes.\r
 306                         scsiDev.data[idx++] = 8;\r
 307                 }\r
 308         }\r
 309         else\r
 310         {\r
 311                 scsiDev.data[idx++] = 0; // Reserved\r
 312                 scsiDev.data[idx++] = 0; // Reserved\r
 313                 if (dbd)\r
 314                 {\r
 315                         scsiDev.data[idx++] = 0; // No block descriptor\r
 316                         scsiDev.data[idx++] = 0; // No block descriptor\r
 317                 }\r
 318                 else\r
 319                 {\r
 320                         // One block descriptor of length 8 bytes.\r
 321                         scsiDev.data[idx++] = 0;\r
 322                         scsiDev.data[idx++] = 8;\r
 323                 }\r
 324         }\r
 325 \r
 326         ////////////// Block Descriptor\r
 327         ////////////////////////////////////\r
 328         if (!dbd)\r
 329         {\r
 330                 scsiDev.data[idx++] = density;\r
 331                 // Number of blocks\r
 332                 // Zero == all remaining blocks shall have the medium\r
 333                 // characteristics specified.\r
 334                 scsiDev.data[idx++] = 0;\r
 335                 scsiDev.data[idx++] = 0;\r
 336                 scsiDev.data[idx++] = 0;\r
 337 \r
 338                 scsiDev.data[idx++] = 0; // reserved\r
 339 \r
 340                 // Block length\r
 341                 uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector;\r
 342                 scsiDev.data[idx++] = bytesPerSector >> 16;\r
 343                 scsiDev.data[idx++] = bytesPerSector >> 8;\r
 344                 scsiDev.data[idx++] = bytesPerSector & 0xFF;\r
 345         }\r
 346 \r
 347         int pageFound = 0;\r
 348 \r
 349         if (pageCode == 0x01 || pageCode == 0x3F)\r
 350         {\r
 351                 pageFound = 1;\r
 352                 if ((scsiDev.compatMode >= COMPAT_SCSI2))\r
 353                 {\r
 354                         pageIn(pc, idx, ReadWriteErrorRecoveryPage, sizeof(ReadWriteErrorRecoveryPage));\r
 355                         idx += sizeof(ReadWriteErrorRecoveryPage);\r
 356                 }\r
 357                 else\r
 358                 {\r
 359                         pageIn(pc, idx, ReadWriteErrorRecoveryPage_SCSI1, sizeof(ReadWriteErrorRecoveryPage_SCSI1));\r
 360                         idx += sizeof(ReadWriteErrorRecoveryPage_SCSI1);\r
 361                 }\r
 362         }\r
 363 \r
 364         if (pageCode == 0x02 || pageCode == 0x3F)\r
 365         {\r
 366                 pageFound = 1;\r
 367                 if ((scsiDev.compatMode >= COMPAT_SCSI2))\r
 368                 {\r
 369                         pageIn(pc, idx, DisconnectReconnectPage, sizeof(DisconnectReconnectPage));\r
 370                         idx += sizeof(DisconnectReconnectPage);\r
 371                 }\r
 372                 else\r
 373                 {\r
 374                         pageIn(pc, idx, DisconnectReconnectPage_SCSI1, sizeof(DisconnectReconnectPage_SCSI1));\r
 375                         idx += sizeof(DisconnectReconnectPage_SCSI1);\r
 376                 }\r
 377         }\r
 378 \r
 379         if (pageCode == 0x03 || pageCode == 0x3F)\r
 380         {\r
 381                 pageFound = 1;\r
 382                 pageIn(pc, idx, FormatDevicePage, sizeof(FormatDevicePage));\r
 383                 if (pc != 0x01)\r
 384                 {\r
 385                         uint16_t sectorsPerTrack = scsiDev.target->cfg->sectorsPerTrack;\r
 386                         scsiDev.data[idx+10] = sectorsPerTrack >> 8;\r
 387                         scsiDev.data[idx+11] = sectorsPerTrack & 0xFF;\r
 388 \r
 389                         // Fill out the configured bytes-per-sector\r
 390                         uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector;\r
 391                         scsiDev.data[idx+12] = bytesPerSector >> 8;\r
 392                         scsiDev.data[idx+13] = bytesPerSector & 0xFF;\r
 393                 }\r
 394                 else\r
 395                 {\r
 396                         // Set a mask for the changeable values.\r
 397                         scsiDev.data[idx+12] = 0xFF;\r
 398                         scsiDev.data[idx+13] = 0xFF;\r
 399                 }\r
 400 \r
 401                 idx += sizeof(FormatDevicePage);\r
 402         }\r
 403 \r
 404         if (pageCode == 0x04 || pageCode == 0x3F)\r
 405         {\r
 406                 pageFound = 1;\r
 407                 if ((scsiDev.compatMode >= COMPAT_SCSI2))\r
 408                 {\r
 409                         pageIn(pc, idx, RigidDiskDriveGeometry, sizeof(RigidDiskDriveGeometry));\r
 410                 }\r
 411                 else\r
 412                 {\r
 413                         pageIn(pc, idx, RigidDiskDriveGeometry_SCSI1, sizeof(RigidDiskDriveGeometry_SCSI1));\r
 414                 }\r
 415 \r
 416                 if (pc != 0x01)\r
 417                 {\r
 418                         // Need to fill out the number of cylinders.\r
 419                         uint32_t cyl;\r
 420                         uint8_t head;\r
 421                         uint32_t sector;\r
 422                         LBA2CHS(\r
 423                                 getScsiCapacity(\r
 424                                         scsiDev.target->cfg->sdSectorStart,\r
 425                                         scsiDev.target->liveCfg.bytesPerSector,\r
 426                                         scsiDev.target->cfg->scsiSectors),\r
 427                                 &cyl,\r
 428                                 &head,\r
 429                                 &sector,\r
 430                                 scsiDev.target->cfg->headsPerCylinder,\r
 431                                 scsiDev.target->cfg->sectorsPerTrack);\r
 432 \r
 433                         scsiDev.data[idx+2] = cyl >> 16;\r
 434                         scsiDev.data[idx+3] = cyl >> 8;\r
 435                         scsiDev.data[idx+4] = cyl;\r
 436 \r
 437                         memcpy(&scsiDev.data[idx+6], &scsiDev.data[idx+2], 3);\r
 438                         memcpy(&scsiDev.data[idx+9], &scsiDev.data[idx+2], 3);\r
 439 \r
 440                         scsiDev.data[idx+5] = scsiDev.target->cfg->headsPerCylinder;\r
 441                 }\r
 442 \r
 443                 if ((scsiDev.compatMode >= COMPAT_SCSI2))\r
 444                 {\r
 445                         idx += sizeof(RigidDiskDriveGeometry);\r
 446                 }\r
 447                 else\r
 448                 {\r
 449                         idx += sizeof(RigidDiskDriveGeometry_SCSI1);\r
 450                 }\r
 451         }\r
 452 \r
 453         if (pageCode == 0x05 || pageCode == 0x3F)\r
 454         {\r
 455                 pageFound = 1;\r
 456                 pageIn(pc, idx, FlexibleDiskDriveGeometry, sizeof(FlexibleDiskDriveGeometry));\r
 457                 idx += sizeof(FlexibleDiskDriveGeometry);\r
 458         }\r
 459 \r
 460         // DON'T output the following pages for SCSI1 hosts. They get upset when\r
 461         // we have more data to send than the allocation length provided.\r
 462         // (ie. Try not to output any more pages below this comment)\r
 463 \r
 464 \r
 465         if ((scsiDev.compatMode >= COMPAT_SCSI2) &&\r
 466                 (pageCode == 0x08 || pageCode == 0x3F))\r
 467         {\r
 468                 pageFound = 1;\r
 469                 pageIn(pc, idx, CachingPage, sizeof(CachingPage));\r
 470                 idx += sizeof(CachingPage);\r
 471         }\r
 472 \r
 473         if ((scsiDev.compatMode >= COMPAT_SCSI2)\r
 474                 && (pageCode == 0x0A || pageCode == 0x3F))\r
 475         {\r
 476                 pageFound = 1;\r
 477                 pageIn(pc, idx, ControlModePage, sizeof(ControlModePage));\r
 478                 idx += sizeof(ControlModePage);\r
 479         }\r
 480 \r
 481         if ((scsiDev.target->cfg->deviceType == S2S_CFG_SEQUENTIAL) &&\r
 482                 (pageCode == 0x10 || pageCode == 0x3F))\r
 483         {\r
 484                 pageFound = 1;\r
 485                 pageIn(\r
 486                         pc,\r
 487                         idx,\r
 488                         SequentialDeviceConfigPage,\r
 489                         sizeof(SequentialDeviceConfigPage));\r
 490                 idx += sizeof(SequentialDeviceConfigPage);\r
 491         }\r
 492 \r
 493         if ((\r
 494                         (scsiDev.target->cfg->quirks == S2S_CFG_QUIRKS_APPLE) ||\r
 495                         (idx + sizeof(AppleVendorPage) <= allocLength)\r
 496                 ) &&\r
 497                 (pageCode == 0x30 || pageCode == 0x3F))\r
 498         {\r
 499                 pageFound = 1;\r
 500                 pageIn(pc, idx, AppleVendorPage, sizeof(AppleVendorPage));\r
 501                 idx += sizeof(AppleVendorPage);\r
 502         }\r
 503 \r
 504         if (pageCode == 0x38) // Don't send unless requested\r
 505         {\r
 506                 pageFound = 1;\r
 507                 pageIn(pc, idx, CCSCachingPage, sizeof(CCSCachingPage));\r
 508                 idx += sizeof(CCSCachingPage);\r
 509         }\r
 510 \r
 511         if (!pageFound)\r
 512         {\r
 513                 // Unknown Page Code\r
 514                 pageFound = 0;\r
 515                 scsiDev.status = CHECK_CONDITION;\r
 516                 scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
 517                 scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB;\r
 518                 scsiDev.phase = STATUS;\r
 519         }\r
 520         else\r
 521         {\r
 522                 // Go back and fill out the mode data length\r
 523                 if (sixByteCmd)\r
 524                 {\r
 525                         // Cannot currently exceed limits. yay\r
 526                         scsiDev.data[0] = idx - 1;\r
 527                 }\r
 528                 else\r
 529                 {\r
 530                         scsiDev.data[0] = ((idx - 2) >> 8);\r
 531                         scsiDev.data[1] = (idx - 2);\r
 532                 }\r
 533 \r
 534                 scsiDev.dataLen = idx > allocLength ? allocLength : idx;\r
 535                 scsiDev.phase = DATA_IN;\r
 536         }\r
 537 }\r
 538 \r
 539 \r
 540 // Callback after the DATA OUT phase is complete.\r
 541 static void doModeSelect(void)\r
 542 {\r
 543         if (scsiDev.status == GOOD) // skip if we've already encountered an error\r
 544         {\r
 545                 // scsiDev.dataLen bytes are in scsiDev.data\r
 546 \r
 547                 int idx;\r
 548                 int blockDescLen;\r
 549                 if (scsiDev.cdb[0] == 0x55)\r
 550                 {\r
 551                         blockDescLen =\r
 552                                 (((uint16_t)scsiDev.data[6]) << 8) |scsiDev.data[7];\r
 553                         idx = 8;\r
 554                 }\r
 555                 else\r
 556                 {\r
 557                         blockDescLen = scsiDev.data[3];\r
 558                         idx = 4;\r
 559                 }\r
 560 \r
 561                 // The unwritten rule.  Blocksizes are normally set using the\r
 562                 // block descriptor value, not by changing page 0x03.\r
 563                 if (blockDescLen >= 8)\r
 564                 {\r
 565                         uint32_t bytesPerSector =\r
 566                                 (((uint32_t)scsiDev.data[idx+5]) << 16) |\r
 567                                 (((uint32_t)scsiDev.data[idx+6]) << 8) |\r
 568                                 scsiDev.data[idx+7];\r
 569                         if ((bytesPerSector < MIN_SECTOR_SIZE) ||\r
 570                                 (bytesPerSector > MAX_SECTOR_SIZE))\r
 571                         {\r
 572                                 goto bad;\r
 573                         }\r
 574                         else\r
 575                         {\r
 576                                 scsiDev.target->liveCfg.bytesPerSector = bytesPerSector;\r
 577                                 if (bytesPerSector != scsiDev.target->cfg->bytesPerSector)\r
 578                                 {\r
 579                                         s2s_configSave(scsiDev.target->targetId, bytesPerSector);\r
 580                                 }\r
 581                         }\r
 582                 }\r
 583                 idx += blockDescLen;\r
 584 \r
 585                 while (idx < scsiDev.dataLen)\r
 586                 {\r
 587                         int pageLen = scsiDev.data[idx + 1];\r
 588                         if (idx + 2 + pageLen > scsiDev.dataLen) goto bad;\r
 589 \r
 590                         int pageCode = scsiDev.data[idx] & 0x3F;\r
 591                         switch (pageCode)\r
 592                         {\r
 593                         case 0x03: // Format Device Page\r
 594                         {\r
 595                                 if (pageLen != 0x16) goto bad;\r
 596 \r
 597                                 // Fill out the configured bytes-per-sector\r
 598                                 uint16_t bytesPerSector =\r
 599                                         (((uint16_t)scsiDev.data[idx+12]) << 8) |\r
 600                                         scsiDev.data[idx+13];\r
 601 \r
 602                                 // Sane values only, ok ?\r
 603                                 if ((bytesPerSector < MIN_SECTOR_SIZE) ||\r
 604                                         (bytesPerSector > MAX_SECTOR_SIZE))\r
 605                                 {\r
 606                                         goto bad;\r
 607                                 }\r
 608 \r
 609                                 scsiDev.target->liveCfg.bytesPerSector = bytesPerSector;\r
 610                                 if (scsiDev.cdb[1] & 1) // SP Save Pages flag\r
 611                                 {\r
 612                                         s2s_configSave(scsiDev.target->targetId, bytesPerSector);\r
 613                                 }\r
 614                         }\r
 615                         break;\r
 616                         //default:\r
 617 \r
 618                                 // Easiest to just ignore for now. We'll get here when changing\r
 619                                 // the SCSI block size via the descriptor header.\r
 620                         }\r
 621                         idx += 2 + pageLen;\r
 622                 }\r
 623         }\r
 624 \r
 625         goto out;\r
 626 bad:\r
 627         scsiDev.status = CHECK_CONDITION;\r
 628         scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
 629         scsiDev.target->sense.asc = INVALID_FIELD_IN_PARAMETER_LIST;\r
 630 \r
 631 out:\r
 632         scsiDev.phase = STATUS;\r
 633 }\r
 634 \r
 635 int scsiModeCommand()\r
 636 {\r
 637         int commandHandled = 1;\r
 638 \r
 639         uint8_t command = scsiDev.cdb[0];\r
 640 \r
 641         // We don't currently support the setting of any parameters.\r
 642         // (ie. no MODE SELECT(6) or MODE SELECT(10) commands)\r
 643 \r
 644         if (command == 0x1A)\r
 645         {\r
 646                 // MODE SENSE(6)\r
 647                 int dbd = scsiDev.cdb[1] & 0x08; // Disable block descriptors\r
 648                 int pc = scsiDev.cdb[2] >> 6; // Page Control\r
 649                 int pageCode = scsiDev.cdb[2] & 0x3F;\r
 650                 int allocLength = scsiDev.cdb[4];\r
 651 \r
 652                 // SCSI1 standard: (CCS X3T9.2/86-52)\r
 653                 // "An Allocation Length of zero indicates that no MODE SENSE data shall\r
 654                 // be transferred. This condition shall not be considered as an error."\r
 655                 doModeSense(1, dbd, pc, pageCode, allocLength);\r
 656         }\r
 657         else if (command == 0x5A)\r
 658         {\r
 659                 // MODE SENSE(10)\r
 660                 int dbd = scsiDev.cdb[1] & 0x08; // Disable block descriptors\r
 661                 int pc = scsiDev.cdb[2] >> 6; // Page Control\r
 662                 int pageCode = scsiDev.cdb[2] & 0x3F;\r
 663                 int allocLength =\r
 664                         (((uint16_t) scsiDev.cdb[7]) << 8) +\r
 665                         scsiDev.cdb[8];\r
 666                 doModeSense(0, dbd, pc, pageCode, allocLength);\r
 667         }\r
 668         else if (command == 0x15)\r
 669         {\r
 670                 // MODE SELECT(6)\r
 671                 int len = scsiDev.cdb[4];\r
 672                 if (len == 0)\r
 673                 {\r
 674                         // If len == 0, then transfer no data. From the SCSI 2 standard:\r
 675                         //      A parameter list length of zero indicates that no data shall\r
 676                         //      be transferred. This condition shall not be considered as an\r
 677                         //              error.\r
 678                         scsiDev.phase = STATUS;\r
 679                 }\r
 680                 else\r
 681                 {\r
 682                         scsiDev.dataLen = len;\r
 683                         scsiDev.phase = DATA_OUT;\r
 684                         scsiDev.postDataOutHook = doModeSelect;\r
 685                 }\r
 686         }\r
 687         else if (command == 0x55)\r
 688         {\r
 689                 // MODE SELECT(10)\r
 690                 int allocLength = (((uint16_t) scsiDev.cdb[7]) << 8) + scsiDev.cdb[8];\r
 691                 if (allocLength == 0)\r
 692                 {\r
 693                         // If len == 0, then transfer no data. From the SCSI 2 standard:\r
 694                         //      A parameter list length of zero indicates that no data shall\r
 695                         //      be transferred. This condition shall not be considered as an\r
 696                         //              error.\r
 697                         scsiDev.phase = STATUS;\r
 698                 }\r
 699                 else\r
 700                 {\r
 701                         scsiDev.dataLen = allocLength;\r
 702                         scsiDev.phase = DATA_OUT;\r
 703                         scsiDev.postDataOutHook = doModeSelect;\r
 704                 }\r
 705         }\r
 706         else\r
 707         {\r
 708                 commandHandled = 0;\r
 709         }\r
 710 \r
 711         return commandHandled;\r
 712 }\r
 713 \r