visus
/
teensy-usbhost
Obserwuj 1
Polub 0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
309 Commity
1 Gałąź
Drzewo: 1b764f29fa
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '1b764f29fa'
${ noResults }
teensy-usbhost/MassStorageDriver.cpp

572 lines
19KB
Czysty Wina Historia 

  1. /* MSC Teensy36 USB Host Mass Storage library

  2.  * Copyright (c) 2017-2019 Warren Watson.

  3.  *

  4.  * Permission is hereby granted, free of charge, to any person obtaining

  5.  * a copy of this software and associated documentation files (the

  6.  * "Software"), to deal in the Software without restriction, including

  7.  * without limitation the rights to use, copy, modify, merge, publish,

  8.  * distribute, sublicense, and/or sell copies of the Software, and to

  9.  * permit persons to whom the Software is furnished to do so, subject to

  10.  * the following conditions:

  11.  *

  12.  * The above copyright notice and this permission notice shall be

  13.  * included in all copies or substantial portions of the Software.

  14.  *

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  16.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  17.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  18.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  19.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  20.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  21.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  22.  * SOFTWARE.

  23.  */

  24. 

  25. //MassStorageDriver.cpp

  26. 

  27. #include <Arduino.h>

  28. #include "USBHost_t36.h"  // Read this header first for key info

  29. 

  30. #define print   USBHost::print_

  31. #define println USBHost::println_

  32. 

  33. // Uncomment this to display function usage and sequencing.

  34. //#define DBGprint 1

  35. 

  36. // Big Endian/Little Endian

  37. #define swap32(x) ((x >> 24) & 0xff) | \

  38. 				  ((x << 8) & 0xff0000) | \

  39. 				  ((x >> 8) & 0xff00) |  \

  40.                   ((x << 24) & 0xff000000)

  41. 

  42. void msController::init()

  43. {

  44. 	contribute_Pipes(mypipes, sizeof(mypipes)/sizeof(Pipe_t));

  45. 	contribute_Transfers(mytransfers, sizeof(mytransfers)/sizeof(Transfer_t));

  46. 	contribute_String_Buffers(mystring_bufs, sizeof(mystring_bufs)/sizeof(strbuf_t));

  47. 	driver_ready_for_device(this);

  48. }

  49. 

  50. bool msController::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len)

  51. {

  52. 	println("msController claim this=", (uint32_t)this, HEX);

  53. 	// only claim at interface level

  54. 

  55. 	if (type != 1) return false;

  56. 	if (len < 9+7+7) return false; // Interface descriptor + 2 endpoint decriptors 

  57. 

  58. 	print_hexbytes(descriptors, len);

  59. 

  60. 	uint32_t numendpoint = descriptors[4];

  61. 	if (numendpoint < 1) return false; 

  62. 	if (descriptors[5] != 8) return false; // bInterfaceClass, 8 = MASS Storage class

  63. 	if (descriptors[6] != 6) return false; // bInterfaceSubClass, 6 = SCSI transparent command set (SCSI Standards)

  64. 	if (descriptors[7] != 80) return false; // bInterfaceProtocol, 80 = BULK-ONLY TRANSPORT

  65. 

  66. 	uint8_t desc_index = 9;

  67. 	uint8_t in_index = 0xff, out_index = 0xff;

  68. 

  69. 	println("numendpoint=", numendpoint, HEX);

  70. 	while (numendpoint--) {

  71. 		if ((descriptors[desc_index] != 7) || (descriptors[desc_index+1] != 5)) return false; // not an end point

  72. 		if (descriptors[desc_index+3] == 2) {  // Bulk end point

  73. 			if (descriptors[desc_index+2] & 0x80)

  74. 				in_index = desc_index;

  75. 			else

  76. 				out_index = desc_index;

  77. 		}

  78. 		desc_index += 7;	// point to next one...

  79. 	}

  80. 	if ((in_index == 0xff) || (out_index == 0xff)) return false;	// did not find end point

  81. 	endpointIn = descriptors[in_index+2]; // bulk-in descriptor 1 81h

  82. 	endpointOut = descriptors[out_index+2]; // bulk-out descriptor 2 02h

  83. 

  84. 	println("endpointIn=", endpointIn, HEX);

  85. 	println("endpointOut=", endpointOut, HEX);

  86. 

  87. 	uint32_t sizeIn = descriptors[in_index+4] | (descriptors[in_index+5] << 8);

  88. 	println("packet size in (msController) = ", sizeIn);

  89. 

  90. 	uint32_t sizeOut = descriptors[out_index+4] | (descriptors[out_index+5] << 8);

  91. 	println("packet size out (msController) = ", sizeOut);

  92. 	packetSizeIn = sizeIn;	

  93. 	packetSizeOut = sizeOut;	

  94. 

  95. 	uint32_t intervalIn = descriptors[in_index+6];

  96. 	uint32_t intervalOut = descriptors[out_index+6];

  97. 

  98. 	println("polling intervalIn = ", intervalIn);

  99. 	println("polling intervalOut = ", intervalOut);

  100. 	datapipeIn = new_Pipe(dev, 2, endpointIn, 1, packetSizeIn, intervalIn);

  101. 	datapipeOut = new_Pipe(dev, 2, endpointOut, 0, packetSizeOut, intervalOut);

  102. 	datapipeIn->callback_function = callbackIn;

  103. 	datapipeOut->callback_function = callbackOut;

  104. 

  105. 	idVendor = dev->idVendor;

  106. 	idProduct = dev->idProduct;

  107. 	hubNumber = dev->hub_address;

  108. 	deviceAddress = dev->address;

  109. 	hubPort = dev->hub_port; // Used for device ID with multiple drives.

  110. 

  111. 	msOutCompleted = false;

  112. 	msInCompleted = false;

  113. 	msControlCompleted = false;

  114. 	deviceAvailable = true;

  115. 	msDriveInfo.initialized = false;

  116. 	msDriveInfo.connected = true;

  117. #ifdef DBGprint

  118. 	Serial.printf("   connected %d\n",msDriveInfo.connected);

  119. 	Serial.printf("   initialized %d\n",msDriveInfo.initialized);

  120. #endif	

  121. 	return true;

  122. }

  123. 

  124. void msController::disconnect()

  125. {

  126. 	deviceAvailable = false;

  127. 	println("Device Disconnected...");

  128. 	msDriveInfo.connected = false;

  129. 	msDriveInfo.initialized = false;

  130. 	memset(&msDriveInfo, 0, sizeof(msDriveInfo_t));

  131. 

  132. #ifdef DBGprint

  133. 	Serial.printf("   connected %d\n",msDriveInfo.connected);

  134. 	Serial.printf("   initialized %d\n",msDriveInfo.initialized);

  135. #endif

  136. }

  137. 

  138. void msController::control(const Transfer_t *transfer)

  139. {

  140. 	println("control CallbackIn (msController)");

  141. 	print_hexbytes(report, 8);

  142. 	msControlCompleted = true;

  143. 

  144. }

  145. 

  146. void msController::callbackIn(const Transfer_t *transfer)

  147. {

  148. 	println("msController CallbackIn (static)");

  149. 	if (transfer->driver) {

  150. 		print("transfer->qtd.token = ");

  151. 		println(transfer->qtd.token & 255);

  152. 		((msController *)(transfer->driver))->new_dataIn(transfer);

  153. 	}

  154. }

  155. 

  156. void msController::callbackOut(const Transfer_t *transfer)

  157. {

  158. 	println("msController CallbackOut (static)");

  159. 	if (transfer->driver) {

  160. 		print("transfer->qtd.token = ");

  161. 		println(transfer->qtd.token & 255);

  162. 		((msController *)(transfer->driver))->new_dataOut(transfer);

  163. 	}

  164. }

  165. 

  166. void msController::new_dataOut(const Transfer_t *transfer)

  167. {

  168. 	uint32_t len = transfer->length - ((transfer->qtd.token >> 16) & 0x7FFF);

  169. 	println("msController dataOut (static)", len, DEC);

  170. 	print_hexbytes((uint8_t*)transfer->buffer, (len < 32)? len : 32 );

  171. 	msOutCompleted = true; // Last out transaction is completed.

  172. }

  173. 

  174. void msController::new_dataIn(const Transfer_t *transfer)

  175. {

  176. 	uint32_t len = transfer->length - ((transfer->qtd.token >> 16) & 0x7FFF);

  177. 	println("msController dataIn (static): ", len, DEC);

  178. 	print_hexbytes((uint8_t*)transfer->buffer, (len < 32)? len : 32 );

  179. 	msInCompleted = true; // Last in transaction is completed.

  180. }

  181. 

  182. // Initialize Mass Storage Device

  183. uint8_t msController::mscInit(void) {

  184. #ifdef DBGprint

  185. 	Serial.printf("mscIint()\n");

  186. #endif

  187. 	uint8_t msResult = MS_CBW_PASS;

  188. 

  189. 	CBWTag = 0;

  190. 	uint32_t start = millis();

  191. 	// Check if device is connected.

  192. 	do {

  193. 		if((millis() - start) >= MSC_CONNECT_TIMEOUT) {

  194. 			return MS_NO_MEDIA_ERR;  // Not connected Error.

  195. 		}

  196. 		yield();

  197. 	} while(!available()); 

  198. 	

  199. 	msReset(0); // Assume bNumInterfaces = 1 for now.

  200. 	delay(500);

  201. 	maxLUN = msGetMaxLun(0); // Assume bNumInterfaces = 1 for now

  202. 

  203. //	msResult = msReportLUNs(&maxLUN);

  204. //Serial.printf("maxLUN = %d\n",maxLUN);

  205. //	delay(150);

  206. 	//-------------------------------------------------------

  207. //	msResult = msStartStopUnit(1);

  208. 	msResult = WaitMediaReady();

  209. 	if(msResult)

  210. 		return msResult;

  211. 		

  212. 	// Retrieve drive information.

  213. 	msDriveInfo.initialized = true;

  214. 	msDriveInfo.hubNumber = getHubNumber();			// Which HUB.

  215. 	msDriveInfo.hubPort = getHubPort();				// Which HUB port.

  216. 	msDriveInfo.deviceAddress = getDeviceAddress();	// Device addreess.

  217. 	msDriveInfo.idVendor = getIDVendor();  			// USB Vendor ID.

  218. 	msDriveInfo.idProduct = getIDProduct();  		// USB Product ID.

  219. 	msResult = msDeviceInquiry(&msInquiry);			// Config Info.

  220. 	if(msResult)

  221. 		return msResult;

  222. 	msResult = msReadDeviceCapacity(&msCapacity);	// Size Info.

  223. 	if(msResult)

  224. 		return msResult;

  225. 	memcpy(&msDriveInfo.inquiry, &msInquiry, sizeof(msInquiryResponse_t));

  226. 	memcpy(&msDriveInfo.capacity, &msCapacity, sizeof(msSCSICapacity_t));

  227. 	return msResult;

  228. }

  229. 

  230. //---------------------------------------------------------------------------

  231. // Perform Mass Storage Reset

  232. void msController::msReset(uint32_t interfaceNumber) {

  233. #ifdef DBGprint

  234. 	Serial.printf("msReset()\n");

  235. #endif

  236. 	mk_setup(setup, 0x21, 0xff, 0, interfaceNumber, 0);

  237. 	queue_Control_Transfer(device, &setup, NULL, this);

  238. 	while (!msControlCompleted) yield();

  239. 	msControlCompleted = false;

  240. }

  241. 

  242. //---------------------------------------------------------------------------

  243. // Get MAX LUN

  244. uint8_t msController::msGetMaxLun(uint32_t interfaceNumber) {

  245. #ifdef DBGprint

  246. 	Serial.printf("msGetMaxLun()\n");

  247. #endif

  248. 	report[0] = 0;

  249. 	mk_setup(setup, 0xa1, 0xfe, 0, interfaceNumber, 1);

  250. 	queue_Control_Transfer(device, &setup, report, this);

  251. 	while (!msControlCompleted) yield();

  252. 	msControlCompleted = false;

  253. 	maxLUN = report[0];

  254. 	return maxLUN;

  255. }

  256. 

  257. uint8_t msController::WaitMediaReady() {

  258. 	uint8_t msResult;

  259. 	uint32_t start = millis();

  260. #ifdef DBGprint

  261. 	Serial.printf("WaitMediaReady()\n");

  262. #endif

  263. 	do {

  264. 		if((millis() - start) >= MEDIA_READY_TIMEOUT) {

  265. 			return MS_UNIT_NOT_READY;  // Not Ready Error.

  266. 		}

  267. 		msResult = msTestReady();

  268. 		yield();

  269. 	 } while(msResult == 1);

  270. 	return msResult;

  271. }

  272. 

  273. // Check if drive is connected and Initialized.

  274. uint8_t msController::checkConnectedInitialized(void) {

  275. 	uint8_t msResult = MS_CBW_PASS;

  276. #ifdef DBGprint

  277. 	Serial.printf("checkConnectedInitialized()\n");

  278. #endif

  279. 	if(!msDriveInfo.connected) {

  280. 		return MS_NO_MEDIA_ERR;

  281. 	}

  282. 	if(!msDriveInfo.initialized) {

  283. 		msResult = mscInit();

  284. 		if(msResult != MS_CBW_PASS) return MS_UNIT_NOT_READY; // Not Initialized

  285. 	}

  286. 	return MS_CBW_PASS;

  287. }

  288. 

  289. //---------------------------------------------------------------------------

  290. // Send SCSI Command

  291. // Do a complete 3 stage transfer.

  292. uint8_t msController::msDoCommand(msCommandBlockWrapper_t *CBW,	void *buffer)

  293. {

  294. 	uint8_t CSWResult = 0;

  295. 	mscTransferComplete = false;

  296. #ifdef DBGprint

  297. 	Serial.printf("msDoCommand():\n");

  298. #endif	

  299. 	if(CBWTag == 0xFFFFFFFF) CBWTag = 1;

  300. 	queue_Data_Transfer(datapipeOut, CBW, sizeof(msCommandBlockWrapper_t), this); // Command stage.

  301. 	while(!msOutCompleted) yield();

  302. 	msOutCompleted = false;

  303. 	if((CBW->Flags == CMD_DIR_DATA_IN)) { // Data stage from device.

  304. 		queue_Data_Transfer(datapipeIn, buffer, CBW->TransferLength, this);

  305. 	while(!msInCompleted) yield();

  306. 	msInCompleted = false;

  307. 	} else {							  // Data stage to device.

  308. 		queue_Data_Transfer(datapipeOut, buffer, CBW->TransferLength, this);

  309. 	while(!msOutCompleted) yield();

  310. 	msOutCompleted = false;

  311. 	}

  312. 	CSWResult = msGetCSW(); // Status stage.

  313. 	// All stages of this transfer have completed.

  314. 	//Check for special cases. 

  315. 	//If test for unit ready command is given then

  316. 	//  return the CSW status byte.

  317. 	//Bit 0 == 1 == not ready else

  318. 	//Bit 0 == 0 == ready.

  319. 	//And the Start/Stop Unit command as well.

  320. 	if((CBW->CommandData[0] == CMD_TEST_UNIT_READY) ||

  321. 	   (CBW->CommandData[0] == CMD_START_STOP_UNIT))

  322. 		return CSWResult;

  323. 	else // Process possible SCSI errors.

  324. 		return msProcessError(CSWResult);

  325. }

  326. 

  327. //---------------------------------------------------------------------------

  328. // Get Command Status Wrapper

  329. uint8_t msController::msGetCSW(void) {

  330. #ifdef DBGprint

  331. 	Serial.printf("msGetCSW()\n");

  332. #endif

  333. 	msCommandStatusWrapper_t StatusBlockWrapper = (msCommandStatusWrapper_t)

  334. 	{

  335. 		.Signature = CSW_SIGNATURE,

  336. 		.Tag = 0,

  337. 		.DataResidue = 0, // TODO: Proccess this if received.

  338. 		.Status = 0

  339. 	};

  340. 	queue_Data_Transfer(datapipeIn, &StatusBlockWrapper, sizeof(StatusBlockWrapper), this);

  341. 	while(!msInCompleted) yield();

  342. 	msInCompleted = false;

  343. 	mscTransferComplete = true;

  344. 	if(StatusBlockWrapper.Signature != CSW_SIGNATURE) return msProcessError(MS_CSW_SIG_ERROR); // Signature error

  345. 	if(StatusBlockWrapper.Tag != CBWTag) return msProcessError(MS_CSW_TAG_ERROR); // Tag mismatch error

  346. 	return StatusBlockWrapper.Status;

  347. }

  348. 

  349. //---------------------------------------------------------------------------

  350. // Test Unit Ready

  351. uint8_t msController::msTestReady() {

  352. #ifdef DBGprint

  353. 	Serial.printf("msTestReady()\n");

  354. #endif

  355. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  356. 	{

  357. 		.Signature          = CBW_SIGNATURE,

  358. 		.Tag                = ++CBWTag,

  359. 		.TransferLength     = 0,

  360. 		.Flags              = CMD_DIR_DATA_IN,

  361. 		.LUN                = currentLUN,

  362. 		.CommandLength      = 6,

  363. 		.CommandData        = {CMD_TEST_UNIT_READY, 0x00, 0x00, 0x00, 0x00, 0x00}

  364. 	};

  365. 	queue_Data_Transfer(datapipeOut, &CommandBlockWrapper, sizeof(CommandBlockWrapper), this);

  366. 	while(!msOutCompleted) yield();

  367. 	msOutCompleted = false;

  368. 	return msGetCSW();

  369. }

  370. 

  371. //---------------------------------------------------------------------------

  372. // Start/Stop unit

  373. uint8_t msController::msStartStopUnit(uint8_t mode) {

  374. #ifdef DBGprint

  375. 	Serial.printf("msStartStopUnit()\n");

  376. #endif

  377. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  378. 	{

  379. 		.Signature          = CBW_SIGNATURE,

  380. 		.Tag                = ++CBWTag,

  381. 		.TransferLength     = 0,

  382. 		.Flags              = CMD_DIR_DATA_IN,

  383. 		.LUN                = currentLUN,

  384. 		.CommandLength      = 6,

  385. 		.CommandData        = {CMD_START_STOP_UNIT, 0x01, 0x00, 0x00, mode, 0x00}

  386. 	};

  387. 	queue_Data_Transfer(datapipeOut, &CommandBlockWrapper, sizeof(CommandBlockWrapper), this);

  388. 	while(!msOutCompleted) yield();

  389. 	msOutCompleted = false;

  390. 	return msGetCSW();

  391. }

  392. 

  393. //---------------------------------------------------------------------------

  394. // Read Mass Storage Device Capacity (Number of Blocks and Block Size)

  395. uint8_t msController::msReadDeviceCapacity(msSCSICapacity_t * const Capacity) {

  396. #ifdef DBGprint

  397. 	Serial.printf("msReadDeviceCapacity()\n");

  398. #endif

  399. 	uint8_t result = 0;

  400. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  401. 	{

  402. 		.Signature          = CBW_SIGNATURE,

  403. 		.Tag                = ++CBWTag,

  404. 		.TransferLength     = sizeof(msSCSICapacity_t),

  405. 		.Flags              = CMD_DIR_DATA_IN,

  406. 		.LUN                = currentLUN,

  407. 		.CommandLength      = 10,

  408. 		.CommandData        = {CMD_RD_CAPACITY_10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}

  409. 	};

  410. 	result = msDoCommand(&CommandBlockWrapper, Capacity);

  411. 	Capacity->Blocks = swap32(Capacity->Blocks);

  412. 	Capacity->BlockSize = swap32(Capacity->BlockSize);

  413. 	return result;

  414. }

  415. 

  416. //---------------------------------------------------------------------------

  417. // Do Mass Storage Device Inquiry

  418. uint8_t msController::msDeviceInquiry(msInquiryResponse_t * const Inquiry)

  419. {

  420. #ifdef DBGprint

  421. 	Serial.printf("msDeviceInquiry()\n");

  422. #endif

  423. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  424. 	{

  425. 		.Signature          = CBW_SIGNATURE,

  426. 		.Tag                = ++CBWTag,

  427. 		.TransferLength     = sizeof(msInquiryResponse_t),

  428. 		.Flags              = CMD_DIR_DATA_IN,

  429. 		.LUN                = currentLUN,

  430. 		.CommandLength      = 6,

  431. 		.CommandData        = {CMD_INQUIRY,0x00,0x00,0x00,sizeof(msInquiryResponse_t),0x00}

  432. 	};

  433. 	return msDoCommand(&CommandBlockWrapper, Inquiry);

  434. }

  435. 

  436. //---------------------------------------------------------------------------

  437. // Request Sense Data

  438. uint8_t msController::msRequestSense(msRequestSenseResponse_t * const Sense)

  439. {

  440. #ifdef DBGprint

  441. 	Serial.printf("msRequestSense()\n");

  442. #endif

  443. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  444. 	{

  445. 		.Signature          = CBW_SIGNATURE,

  446. 		.Tag                = ++CBWTag,

  447. 		.TransferLength     = sizeof(msRequestSenseResponse_t),

  448. 		.Flags              = CMD_DIR_DATA_IN,

  449. 		.LUN                = currentLUN,

  450. 		.CommandLength      = 6,

  451. 		.CommandData        = {CMD_REQUEST_SENSE, 0x00, 0x00, 0x00, sizeof(msRequestSenseResponse_t), 0x00}

  452. 	};

  453. 	return msDoCommand(&CommandBlockWrapper, Sense);

  454. }

  455. 

  456. //---------------------------------------------------------------------------

  457. // Report LUNs

  458. uint8_t msController::msReportLUNs(uint8_t *Buffer)

  459. {

  460. #ifdef DBGprint

  461. 	Serial.printf("msReportLuns()\n");

  462. #endif

  463. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  464. 	{

  465. 		.Signature          = CBW_SIGNATURE,

  466. 		.Tag                = ++CBWTag,

  467. 		.TransferLength     = MAXLUNS,

  468. 		.Flags              = CMD_DIR_DATA_IN,

  469. 		.LUN                = currentLUN,

  470. 		.CommandLength      = 12,

  471. 		.CommandData        = {CMD_REPORT_LUNS, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, MAXLUNS, 0x00, 0x00}

  472. 	};

  473. 	return msDoCommand(&CommandBlockWrapper, Buffer);

  474. }

  475. 

  476. 

  477. //---------------------------------------------------------------------------

  478. // Read Sectors (Multi Sector Capable)

  479. uint8_t msController::msReadBlocks(

  480. 									const uint32_t BlockAddress,

  481. 									const uint16_t Blocks,

  482. 									const uint16_t BlockSize,

  483. 									void * sectorBuffer)

  484. 	{

  485. #ifdef DBGprint

  486. 	Serial.printf("msReadBlocks()\n");

  487. #endif

  488. 	uint8_t BlockHi = (Blocks >> 8) & 0xFF;

  489. 	uint8_t BlockLo = Blocks & 0xFF;

  490. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  491. 	{

  492. 	

  493. 		.Signature          = CBW_SIGNATURE,

  494. 		.Tag                = ++CBWTag,

  495. 		.TransferLength     = (uint32_t)(Blocks * BlockSize),

  496. 		.Flags              = CMD_DIR_DATA_IN,

  497. 		.LUN                = currentLUN,

  498. 		.CommandLength      = 10,

  499. 		.CommandData        = {CMD_RD_10, 0x00,

  500. 							  (uint8_t)(BlockAddress >> 24),

  501. 							  (uint8_t)(BlockAddress >> 16),

  502. 							  (uint8_t)(BlockAddress >> 8),

  503. 							  (uint8_t)(BlockAddress & 0xFF),

  504. 							   0x00, BlockHi, BlockLo, 0x00}

  505. 	};

  506. 	return msDoCommand(&CommandBlockWrapper, sectorBuffer);

  507. }

  508. 

  509. //---------------------------------------------------------------------------

  510. // Write Sectors (Multi Sector Capable)

  511. uint8_t msController::msWriteBlocks(

  512.                                   const uint32_t BlockAddress,

  513.                                   const uint16_t Blocks,

  514.                                   const uint16_t BlockSize,

  515. 								  const void * sectorBuffer)

  516. 	{

  517. #ifdef DBGprint

  518. 	Serial.printf("msWriteBlocks()\n");

  519. #endif

  520. 	uint8_t BlockHi = (Blocks >> 8) & 0xFF;

  521. 	uint8_t BlockLo = Blocks & 0xFF;

  522. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  523. 	{

  524. 		.Signature          = CBW_SIGNATURE,

  525. 		.Tag                = ++CBWTag,

  526. 		.TransferLength     = (uint32_t)(Blocks * BlockSize),

  527. 		.Flags              = CMD_DIR_DATA_OUT,

  528. 		.LUN                = currentLUN,

  529. 		.CommandLength      = 10,

  530. 		.CommandData        = {CMD_WR_10, 0x00,

  531. 		                      (uint8_t)(BlockAddress >> 24),

  532. 							  (uint8_t)(BlockAddress >> 16),

  533. 							  (uint8_t)(BlockAddress >> 8),

  534. 							  (uint8_t)(BlockAddress & 0xFF),

  535. 							  0x00, BlockHi, BlockLo, 0x00}

  536. 	};

  537. 	return msDoCommand(&CommandBlockWrapper, (void *)sectorBuffer);

  538. }

  539. 

  540. // Proccess Possible SCSI errors

  541. uint8_t msController::msProcessError(uint8_t msStatus) {

  542. #ifdef DBGprint

  543. 	Serial.printf("msProcessError()\n");

  544. #endif

  545. 	uint8_t msResult = 0;

  546. 	switch(msStatus) {

  547. 		case MS_CBW_PASS:

  548. 			return MS_CBW_PASS;

  549. 			break;

  550. 		case MS_CBW_PHASE_ERROR:

  551. 			Serial.printf("SCSI Phase Error: %d\n",msStatus);

  552. 			return MS_SCSI_ERROR;

  553. 			break;

  554. 		case MS_CSW_TAG_ERROR:

  555. 			Serial.printf("CSW Tag Error: %d\n",MS_CSW_TAG_ERROR);

  556. 			return MS_CSW_TAG_ERROR;

  557. 			break;

  558. 		case MS_CSW_SIG_ERROR:

  559. 			Serial.printf("CSW Signature Error: %d\n",MS_CSW_SIG_ERROR);

  560. 			return MS_CSW_SIG_ERROR;

  561. 			break;

  562. 		case MS_CBW_FAIL:

  563. 			if(msResult = msRequestSense(&msSense))

  564. 				Serial.printf("Failed to get sense codes. Returned code: %d\n",msResult);

  565. 			return MS_CBW_FAIL;

  566. 			break;

  567. 		default:

  568. 			Serial.printf("SCSI Error: %d\n",msStatus);

  569. 			return msStatus;

  570. 	}

  571. }