1 // Copyright (C) 2014 Michael McMaster <michael@codesrc.com>
\r
3 // This file is part of SCSI2SD.
\r
5 // SCSI2SD is free software: you can redistribute it and/or modify
\r
6 // it under the terms of the GNU General Public License as published by
\r
7 // the Free Software Foundation, either version 3 of the License, or
\r
8 // (at your option) any later version.
\r
10 // SCSI2SD is distributed in the hope that it will be useful,
\r
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
13 // GNU General Public License for more details.
\r
15 // You should have received a copy of the GNU General Public License
\r
16 // along with SCSI2SD. If not, see <http://www.gnu.org/licenses/>.
\r
22 #include "scsiPhy.h"
\r
26 #include "bootloader.h"
\r
29 #include "../../include/scsi2sd.h"
\r
30 #include "../../include/hidpacket.h"
\r
32 #include "usb_device/usb_device.h"
\r
33 #include "usb_device/usbd_hid.h"
\r
34 #include "usb_device/usbd_composite.h"
\r
35 #include "bsp_driver_sd.h"
\r
40 static const uint16_t FIRMWARE_VERSION = 0x0603;
\r
43 static const uint8_t DEFAULT_CONFIG[128] =
\r
45 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3F, 0x00,
\r
46 0x00, 0x02, 0x3F, 0x00, 0xFF, 0x00, 0x20, 0x63, 0x6F, 0x64, 0x65, 0x73,
\r
47 0x72, 0x63, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x53,
\r
48 0x43, 0x53, 0x49, 0x32, 0x53, 0x44, 0x20, 0x31, 0x2E, 0x30, 0x31, 0x32,
\r
49 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
\r
50 0x37, 0x38, 0x00, 0x00
\r
54 static uint8_t s2s_cfg[S2S_CFG_SIZE] S2S_DMA_ALIGN;
\r
64 static int usbInEpState;
\r
66 static int usbDebugEpState;
\r
68 static int usbReady; // TODO MM REMOVE. Unused ?
\r
70 void s2s_configInit(S2S_BoardCfg* config)
\r
73 usbInEpState = USB_IDLE;
\r
74 usbReady = 0; // We don't know if host is connected yet.
\r
77 if ((blockDev.state & DISK_PRESENT) && sdDev.capacity)
\r
79 int cfgSectors = (S2S_CFG_SIZE + 511) / 512;
\r
80 BSP_SD_ReadBlocks_DMA(
\r
81 (uint32_t*) &s2s_cfg[0],
\r
82 (sdDev.capacity - cfgSectors) * 512ll,
\r
86 memcpy(config, s2s_cfg, sizeof(S2S_BoardCfg));
\r
88 if (memcmp(config->magic, "BCFG", 4))
\r
90 // Invalid SD card config, use default.
\r
91 memset(&s2s_cfg[0], 0, S2S_CFG_SIZE);
\r
92 memcpy(config, s2s_cfg, sizeof(S2S_BoardCfg));
\r
93 memcpy(config->magic, "BCFG", 4);
\r
94 config->selectionDelay = 255; // auto
\r
95 config->flags6 = S2S_CFG_ENABLE_TERMINATOR;
\r
98 &s2s_cfg[0] + sizeof(S2S_BoardCfg),
\r
100 sizeof(S2S_TargetCfg));
\r
105 // No SD card, use existing config if valid
\r
106 if (memcmp(config->magic, "BCFG", 4))
\r
108 // Not valid, use empty config with no disks.
\r
109 memset(&s2s_cfg[0], 0, S2S_CFG_SIZE);
\r
110 memcpy(config, s2s_cfg, sizeof(S2S_BoardCfg));
\r
111 config->selectionDelay = 255; // auto
\r
112 config->flags6 = S2S_CFG_ENABLE_TERMINATOR;
\r
122 uint8_t response[] =
\r
124 S2S_CFG_STATUS_GOOD
\r
126 hidPacket_send(response, sizeof(response));
\r
132 uint8_t response[sizeof(sdDev.csd) + sizeof(sdDev.cid)];
\r
133 memcpy(response, sdDev.csd, sizeof(sdDev.csd));
\r
134 memcpy(response + sizeof(sdDev.csd), sdDev.cid, sizeof(sdDev.cid));
\r
136 hidPacket_send(response, sizeof(response));
\r
143 int resultCode = 0; // TODO scsiSelfTest();
\r
144 uint8_t response[] =
\r
146 resultCode == 0 ? S2S_CFG_STATUS_GOOD : S2S_CFG_STATUS_ERR,
\r
149 hidPacket_send(response, sizeof(response));
\r
153 scsiDevInfoCommand()
\r
155 uint8_t response[] =
\r
157 FIRMWARE_VERSION >> 8,
\r
158 FIRMWARE_VERSION & 0xff,
\r
159 sdDev.capacity >> 24,
\r
160 sdDev.capacity >> 16,
\r
161 sdDev.capacity >> 8,
\r
164 hidPacket_send(response, sizeof(response));
\r
170 uint8_t response[32];
\r
171 memcpy(&response, &scsiDev.cdb, 12);
\r
172 response[12] = scsiDev.msgIn;
\r
173 response[13] = scsiDev.msgOut;
\r
174 response[14] = scsiDev.lastStatus;
\r
175 response[15] = scsiDev.lastSense;
\r
176 response[16] = scsiDev.phase;
\r
177 response[17] = scsiStatusBSY();
\r
178 response[18] = scsiStatusSEL();
\r
179 response[19] = scsiStatusATN();
\r
180 response[20] = scsiStatusRST();
\r
181 response[21] = scsiDev.rstCount;
\r
182 response[22] = scsiDev.selCount;
\r
183 response[23] = scsiDev.msgCount;
\r
184 response[24] = scsiDev.cmdCount;
\r
185 response[25] = scsiDev.watchdogTick;
\r
186 response[26] = blockDev.state;
\r
187 response[27] = scsiDev.lastSenseASC >> 8;
\r
188 response[28] = scsiDev.lastSenseASC;
\r
189 response[29] = *SCSI_STS_DBX;
\r
190 response[30] = LastTrace;
\r
191 response[31] = scsiStatusACK();
\r
192 hidPacket_send(response, sizeof(response));
\r
196 sdWriteCommand(const uint8_t* cmd, size_t cmdSize)
\r
203 (((uint32_t)cmd[1]) << 24) |
\r
204 (((uint32_t)cmd[2]) << 16) |
\r
205 (((uint32_t)cmd[3]) << 8) |
\r
206 ((uint32_t)cmd[4]);
\r
208 // Must be aligned.
\r
209 uint8_t buf[512] S2S_DMA_ALIGN;
\r
210 memcpy(buf, &cmd[5], 512);
\r
211 BSP_SD_WriteBlocks_DMA((uint32_t*) buf, lba * 512ll, 512, 1);
\r
213 uint8_t response[] =
\r
215 S2S_CFG_STATUS_GOOD
\r
217 hidPacket_send(response, sizeof(response));
\r
221 sdReadCommand(const uint8_t* cmd, size_t cmdSize)
\r
228 (((uint32_t)cmd[1]) << 24) |
\r
229 (((uint32_t)cmd[2]) << 16) |
\r
230 (((uint32_t)cmd[3]) << 8) |
\r
231 ((uint32_t)cmd[4]);
\r
233 BSP_SD_ReadBlocks_DMA((uint32_t*) cmd, lba * 512ll, 512, 1);
\r
234 hidPacket_send(cmd, 512);
\r
238 processCommand(const uint8_t* cmd, size_t cmdSize)
\r
246 case S2S_CMD_REBOOT:
\r
247 s2s_enterBootloader();
\r
250 case S2S_CMD_SDINFO:
\r
254 case S2S_CMD_SCSITEST:
\r
258 case S2S_CMD_DEVINFO:
\r
259 scsiDevInfoCommand();
\r
262 case S2S_CMD_SD_WRITE:
\r
263 sdWriteCommand(cmd, cmdSize);
\r
266 case S2S_CMD_SD_READ:
\r
267 sdReadCommand(cmd, cmdSize);
\r
270 case S2S_CMD_DEBUG:
\r
274 case S2S_CMD_NONE: // invalid
\r
280 void s2s_configPoll()
\r
282 if (!USBD_Composite_IsConfigured(&hUsbDeviceFS))
\r
284 usbInEpState = USB_IDLE;
\r
288 if (USBD_HID_IsReportReady(&hUsbDeviceFS))
\r
292 // The host sent us some data!
\r
293 uint8_t hidBuffer[USBHID_LEN];
\r
294 int byteCount = USBD_HID_GetReport(&hUsbDeviceFS, hidBuffer, sizeof(hidBuffer));
\r
295 hidPacket_recv(hidBuffer, byteCount);
\r
298 const uint8_t* cmd = hidPacket_getPacket(&cmdSize);
\r
299 if (cmd && (cmdSize > 0))
\r
301 processCommand(cmd, cmdSize);
\r
307 switch (usbInEpState)
\r
311 uint8_t hidBuffer[USBHID_LEN];
\r
312 const uint8_t* nextChunk = hidPacket_getHIDBytes(hidBuffer);
\r
316 USBD_HID_SendReport (&hUsbDeviceFS, nextChunk, sizeof(hidBuffer));
\r
317 usbInEpState = USB_DATA_SENT;
\r
322 case USB_DATA_SENT:
\r
323 if (!USBD_HID_IsBusy(&hUsbDeviceFS))
\r
326 usbInEpState = USB_IDLE;
\r
335 // Public method for storing MODE SELECT results.
\r
336 void s2s_configSave(int scsiId, uint16_t bytesPerSector)
\r
338 S2S_TargetCfg* cfg = (S2S_TargetCfg*) s2s_getConfigById(scsiId);
\r
339 cfg->bytesPerSector = bytesPerSector;
\r
341 BSP_SD_WriteBlocks_DMA(
\r
342 (uint32_t*) &s2s_cfg[0],
\r
343 (sdDev.capacity - S2S_CFG_SIZE) * 512ll,
\r
345 (S2S_CFG_SIZE + 511) / 512);
\r
349 const S2S_TargetCfg* s2s_getConfigByIndex(int i)
\r
351 return (const S2S_TargetCfg*)
\r
352 (s2s_cfg + sizeof(S2S_BoardCfg) + (i * sizeof(S2S_TargetCfg)));
\r
355 const S2S_TargetCfg* s2s_getConfigById(int scsiId)
\r
358 for (i = 0; i < S2S_MAX_TARGETS; ++i)
\r
360 const S2S_TargetCfg* tgt = s2s_getConfigByIndex(i);
\r
361 if ((tgt->scsiId & S2S_CFG_TARGET_ID_BITS) == scsiId)
\r