visus
/
teensy-usbhost
Sledovat 1
Oblíbit 0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
318 Revize
1 Větev
Strom: 75da1d410a
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „75da1d410a“
${ noResults }
teensy-usbhost/MassStorageDriver.cpp

585 lines
19KB
Surový Blame Historie 

  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 0

  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. 	bInterfaceNumber = descriptors[2];

  67. 

  68. 	uint8_t desc_index = 9;

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

  70. 

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

  72. 	while (numendpoint--) {

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

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

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

  76. 				in_index = desc_index;

  77. 			else

  78. 				out_index = desc_index;

  79. 		}

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

  81. 	}

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

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

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

  85. 

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

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

  88. 

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

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

  91. 

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

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

  94. 	packetSizeIn = sizeIn;	

  95. 	packetSizeOut = sizeOut;	

  96. 

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

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

  99. 

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

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

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

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

  104. 	datapipeIn->callback_function = callbackIn;

  105. 	datapipeOut->callback_function = callbackOut;

  106. 

  107. 	idVendor = dev->idVendor;

  108. 	idProduct = dev->idProduct;

  109. 	hubNumber = dev->hub_address;

  110. 	deviceAddress = dev->address;

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

  112. 

  113. 	msOutCompleted = false;

  114. 	msInCompleted = false;

  115. 	msControlCompleted = false;

  116. 	deviceAvailable = true;

  117. 	msDriveInfo.initialized = false;

  118. 	msDriveInfo.connected = true;

  119. #ifdef DBGprint

  120. 	print("   connected = ");

  121. 	println(msDriveInfo.connected);

  122. 	print("   initialized = ");

  123. 	println(msDriveInfo.initialized);

  124. #endif	

  125. 	return true;

  126. }

  127. 

  128. void msController::disconnect()

  129. {

  130. 	deviceAvailable = false;

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

  132. 	msDriveInfo.connected = false;

  133. 	msDriveInfo.initialized = false;

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

  135. 

  136. #ifdef DBGprint

  137. 	print("   connected ");

  138. 	println(msDriveInfo.connected);

  139. 	print("   initialized ");

  140. 	println(msDriveInfo.initialized);

  141. #endif

  142. }

  143. 

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

  145. {

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

  147. 	print_hexbytes(report, 8);

  148. 	msControlCompleted = true;

  149. 

  150. }

  151. 

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

  153. {

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

  155. 	if (transfer->driver) {

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

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

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

  159. 	}

  160. }

  161. 

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

  163. {

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

  165. 	if (transfer->driver) {

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

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

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

  169. 	}

  170. }

  171. 

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

  173. {

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

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

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

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

  178. }

  179. 

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

  181. {

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

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

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

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

  186. }

  187. 

  188. // Initialize Mass Storage Device

  189. uint8_t msController::mscInit(void) {

  190. #ifdef DBGprint

  191. 	println("mscIint()");

  192. #endif

  193. 	uint8_t msResult = MS_CBW_PASS;

  194. 

  195. 	CBWTag = 0;

  196. 	uint32_t start = millis();

  197. 	// Check if device is connected.

  198. 	do {

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

  200. 			return MS_NO_MEDIA_ERR;  // Not connected Error.

  201. 		}

  202. 		yield();

  203. 	} while(!available());

  204.   

  205. 	msReset();

  206. 	// delay(500); // Not needed any more.

  207. 	maxLUN = msGetMaxLun();

  208. 

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

  210. //println("maxLUN = ");

  211. //println(maxLUN);

  212. //	delay(150);

  213. 	//-------------------------------------------------------

  214. 	msResult = msStartStopUnit(1);

  215. 	msResult = WaitMediaReady();

  216. 	if(msResult)

  217. 		return msResult;

  218. 		

  219. 	// Retrieve drive information.

  220. 	msDriveInfo.initialized = true;

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

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

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

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

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

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

  227. 	if(msResult)

  228. 		return msResult;

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

  230. 	if(msResult)

  231. 		return msResult;

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

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

  234. 	return msResult;

  235. }

  236. 

  237. //---------------------------------------------------------------------------

  238. // Perform Mass Storage Reset

  239. void msController::msReset(void) {

  240. #ifdef DBGprint

  241. 	println("msReset()");

  242. #endif

  243. 	mk_setup(setup, 0x21, 0xff, 0, bInterfaceNumber, 0);

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

  245. 	while (!msControlCompleted) yield();

  246. 	msControlCompleted = false;

  247. }

  248. 

  249. //---------------------------------------------------------------------------

  250. // Get MAX LUN

  251. uint8_t msController::msGetMaxLun(void) {

  252. #ifdef DBGprint

  253. 	println("msGetMaxLun()");

  254. #endif

  255. 	report[0] = 0;

  256. 	mk_setup(setup, 0xa1, 0xfe, 0, bInterfaceNumber, 1);

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

  258. 	while (!msControlCompleted) yield();

  259. 	msControlCompleted = false;

  260. 	maxLUN = report[0];

  261. 	return maxLUN;

  262. }

  263. 

  264. uint8_t msController::WaitMediaReady() {

  265. 	uint8_t msResult;

  266. 	uint32_t start = millis();

  267. #ifdef DBGprint

  268. 	println("WaitMediaReady()");

  269. #endif

  270. 	do {

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

  272. 			return MS_UNIT_NOT_READY;  // Not Ready Error.

  273. 		}

  274. 		msResult = msTestReady();

  275. 		yield();

  276. 	 } while(msResult == 1);

  277. 	return msResult;

  278. }

  279. 

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

  281. uint8_t msController::checkConnectedInitialized(void) {

  282. 	uint8_t msResult = MS_CBW_PASS;

  283. #ifdef DBGprint

  284. 	print("checkConnectedInitialized()");

  285. #endif

  286. 	if(!msDriveInfo.connected) {

  287. 		return MS_NO_MEDIA_ERR;

  288. 	}

  289. 	if(!msDriveInfo.initialized) {

  290. 		msResult = mscInit();

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

  292. 	}

  293. 	return MS_CBW_PASS;

  294. }

  295. 

  296. //---------------------------------------------------------------------------

  297. // Send SCSI Command

  298. // Do a complete 3 stage transfer.

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

  300. {

  301. 	uint8_t CSWResult = 0;

  302. 	mscTransferComplete = false;

  303. #ifdef DBGprint

  304. 	println("msDoCommand()");

  305. #endif	

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

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

  308. 	while(!msOutCompleted) yield();

  309. 	msOutCompleted = false;

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

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

  312. 	while(!msInCompleted) yield();

  313. 	msInCompleted = false;

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

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

  316. 	while(!msOutCompleted) yield();

  317. 	msOutCompleted = false;

  318. 	}

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

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

  321. 	//Check for special cases. 

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

  323. 	//  return the CSW status byte.

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

  325. 	//Bit 0 == 0 == ready.

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

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

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

  329. 		return CSWResult;

  330. 	else // Process possible SCSI errors.

  331. 		return msProcessError(CSWResult);

  332. }

  333. 

  334. //---------------------------------------------------------------------------

  335. // Get Command Status Wrapper

  336. uint8_t msController::msGetCSW(void) {

  337. #ifdef DBGprint

  338. 	println("msGetCSW()");

  339. #endif

  340. 	msCommandStatusWrapper_t StatusBlockWrapper = (msCommandStatusWrapper_t)

  341. 	{

  342. 		.Signature = CSW_SIGNATURE,

  343. 		.Tag = 0,

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

  345. 		.Status = 0

  346. 	};

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

  348. 	while(!msInCompleted) yield();

  349. 	msInCompleted = false;

  350. 	mscTransferComplete = true;

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

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

  353. 	return StatusBlockWrapper.Status;

  354. }

  355. 

  356. //---------------------------------------------------------------------------

  357. // Test Unit Ready

  358. uint8_t msController::msTestReady() {

  359. #ifdef DBGprint

  360. 	println("msTestReady()");

  361. #endif

  362. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  363. 	{

  364. 		.Signature          = CBW_SIGNATURE,

  365. 		.Tag                = ++CBWTag,

  366. 		.TransferLength     = 0,

  367. 		.Flags              = CMD_DIR_DATA_IN,

  368. 		.LUN                = currentLUN,

  369. 		.CommandLength      = 6,

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

  371. 	};

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

  373. 	while(!msOutCompleted) yield();

  374. 	msOutCompleted = false;

  375. 	return msGetCSW();

  376. }

  377. 

  378. //---------------------------------------------------------------------------

  379. // Start/Stop unit

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

  381. #ifdef DBGprint

  382. 	println("msStartStopUnit()");

  383. #endif

  384. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  385. 	{

  386. 		.Signature          = CBW_SIGNATURE,

  387. 		.Tag                = ++CBWTag,

  388. 		.TransferLength     = 0,

  389. 		.Flags              = CMD_DIR_DATA_IN,

  390. 		.LUN                = currentLUN,

  391. 		.CommandLength      = 6,

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

  393. 	};

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

  395. 	while(!msOutCompleted) yield();

  396. 	msOutCompleted = false;

  397. 	return msGetCSW();

  398. }

  399. 

  400. //---------------------------------------------------------------------------

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

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

  403. #ifdef DBGprint

  404. 	println("msReadDeviceCapacity()");

  405. #endif

  406. 	uint8_t result = 0;

  407. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  408. 	{

  409. 		.Signature          = CBW_SIGNATURE,

  410. 		.Tag                = ++CBWTag,

  411. 		.TransferLength     = sizeof(msSCSICapacity_t),

  412. 		.Flags              = CMD_DIR_DATA_IN,

  413. 		.LUN                = currentLUN,

  414. 		.CommandLength      = 10,

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

  416. 	};

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

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

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

  420. 	return result;

  421. }

  422. 

  423. //---------------------------------------------------------------------------

  424. // Do Mass Storage Device Inquiry

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

  426. {

  427. #ifdef DBGprint

  428. 	println("msDeviceInquiry()");

  429. #endif

  430. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  431. 	{

  432. 		.Signature          = CBW_SIGNATURE,

  433. 		.Tag                = ++CBWTag,

  434. 		.TransferLength     = sizeof(msInquiryResponse_t),

  435. 		.Flags              = CMD_DIR_DATA_IN,

  436. 		.LUN                = currentLUN,

  437. 		.CommandLength      = 6,

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

  439. 	};

  440. 	return msDoCommand(&CommandBlockWrapper, Inquiry);

  441. }

  442. 

  443. //---------------------------------------------------------------------------

  444. // Request Sense Data

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

  446. {

  447. #ifdef DBGprint

  448. 	println("msRequestSense()");

  449. #endif

  450. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  451. 	{

  452. 		.Signature          = CBW_SIGNATURE,

  453. 		.Tag                = ++CBWTag,

  454. 		.TransferLength     = sizeof(msRequestSenseResponse_t),

  455. 		.Flags              = CMD_DIR_DATA_IN,

  456. 		.LUN                = currentLUN,

  457. 		.CommandLength      = 6,

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

  459. 	};

  460. 	return msDoCommand(&CommandBlockWrapper, Sense);

  461. }

  462. 

  463. //---------------------------------------------------------------------------

  464. // Report LUNs

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

  466. {

  467. #ifdef DBGprint

  468. 	println("msReportLuns()");

  469. #endif

  470. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  471. 	{

  472. 		.Signature          = CBW_SIGNATURE,

  473. 		.Tag                = ++CBWTag,

  474. 		.TransferLength     = MAXLUNS,

  475. 		.Flags              = CMD_DIR_DATA_IN,

  476. 		.LUN                = currentLUN,

  477. 		.CommandLength      = 12,

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

  479. 	};

  480. 	return msDoCommand(&CommandBlockWrapper, Buffer);

  481. }

  482. 

  483. 

  484. //---------------------------------------------------------------------------

  485. // Read Sectors (Multi Sector Capable)

  486. uint8_t msController::msReadBlocks(

  487. 									const uint32_t BlockAddress,

  488. 									const uint16_t Blocks,

  489. 									const uint16_t BlockSize,

  490. 									void * sectorBuffer)

  491. 	{

  492. #ifdef DBGprint

  493. 	println("msReadBlocks()");

  494. #endif

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

  496. 	uint8_t BlockLo = Blocks & 0xFF;

  497. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  498. 	{

  499. 	

  500. 		.Signature          = CBW_SIGNATURE,

  501. 		.Tag                = ++CBWTag,

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

  503. 		.Flags              = CMD_DIR_DATA_IN,

  504. 		.LUN                = currentLUN,

  505. 		.CommandLength      = 10,

  506. 		.CommandData        = {CMD_RD_10, 0x00,

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

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

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

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

  511. 							   0x00, BlockHi, BlockLo, 0x00}

  512. 	};

  513. 	return msDoCommand(&CommandBlockWrapper, sectorBuffer);

  514. }

  515. 

  516. //---------------------------------------------------------------------------

  517. // Write Sectors (Multi Sector Capable)

  518. uint8_t msController::msWriteBlocks(

  519.                                   const uint32_t BlockAddress,

  520.                                   const uint16_t Blocks,

  521.                                   const uint16_t BlockSize,

  522. 								  const void * sectorBuffer)

  523. 	{

  524. #ifdef DBGprint

  525. 	println("msWriteBlocks()");

  526. #endif

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

  528. 	uint8_t BlockLo = Blocks & 0xFF;

  529. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  530. 	{

  531. 		.Signature          = CBW_SIGNATURE,

  532. 		.Tag                = ++CBWTag,

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

  534. 		.Flags              = CMD_DIR_DATA_OUT,

  535. 		.LUN                = currentLUN,

  536. 		.CommandLength      = 10,

  537. 		.CommandData        = {CMD_WR_10, 0x00,

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

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

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

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

  542. 							  0x00, BlockHi, BlockLo, 0x00}

  543. 	};

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

  545. }

  546. 

  547. // Proccess Possible SCSI errors

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

  549. #ifdef DBGprint

  550. 	println("msProcessError()");

  551. #endif

  552. 	uint8_t msResult = 0;

  553. 	switch(msStatus) {

  554. 		case MS_CBW_PASS:

  555. 			return MS_CBW_PASS;

  556. 			break;

  557. 		case MS_CBW_PHASE_ERROR:

  558. 			print("SCSI Phase Error: ");

  559. 			println(msStatus);

  560. 			return MS_SCSI_ERROR;

  561. 			break;

  562. 		case MS_CSW_TAG_ERROR:

  563. 			print("CSW Tag Error: ");

  564. 			println(MS_CSW_TAG_ERROR);

  565. 			return MS_CSW_TAG_ERROR;

  566. 			break;

  567. 		case MS_CSW_SIG_ERROR:

  568. 			print("CSW Signature Error: ");

  569. 			println(MS_CSW_SIG_ERROR);

  570. 			return MS_CSW_SIG_ERROR;

  571. 			break;

  572. 		case MS_CBW_FAIL:

  573. 			if(msResult = msRequestSense(&msSense)) {

  574. 				print("Failed to get sense codes. Returned code: ");

  575. 				println(msResult);

  576. 			}

  577. 			return MS_CBW_FAIL;

  578. 			break;

  579. 		default:

  580. 			print("SCSI Error: ");

  581. 			println(msStatus);

  582. 			return msStatus;

  583. 	}

  584. }