visus
/
teensy-usbhost
보기 1
좋아요 0
포크 0
코드 이슈 0 풀 리퀘스트 0 릴리즈 0 위키 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
312 커밋
1 브렌치
트리: 052bab70c0
브랜치 태그
${ item.name }
Create branch ${ searchTerm }
from '052bab70c0'
${ noResults }
teensy-usbhost/MassStorageDriver.cpp

583 lines
19KB
Raw Blame 히스토리 

  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. 	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. 	print("   connected = ");

  119. 	println(msDriveInfo.connected);

  120. 	print("   initialized = ");

  121. 	println(msDriveInfo.initialized);

  122. #endif	

  123. 	return true;

  124. }

  125. 

  126. void msController::disconnect()

  127. {

  128. 	deviceAvailable = false;

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

  130. 	msDriveInfo.connected = false;

  131. 	msDriveInfo.initialized = false;

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

  133. 

  134. #ifdef DBGprint

  135. 	print("   connected ");

  136. 	println(msDriveInfo.connected);

  137. 	print("   initialized ");

  138. 	println(msDriveInfo.initialized);

  139. #endif

  140. }

  141. 

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

  143. {

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

  145. 	print_hexbytes(report, 8);

  146. 	msControlCompleted = true;

  147. 

  148. }

  149. 

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

  151. {

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

  153. 	if (transfer->driver) {

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

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

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

  157. 	}

  158. }

  159. 

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

  161. {

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

  163. 	if (transfer->driver) {

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

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

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

  167. 	}

  168. }

  169. 

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

  171. {

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

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

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

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

  176. }

  177. 

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

  179. {

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

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

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

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

  184. }

  185. 

  186. // Initialize Mass Storage Device

  187. uint8_t msController::mscInit(void) {

  188. #ifdef DBGprint

  189. 	println("mscIint()");

  190. #endif

  191. 	uint8_t msResult = MS_CBW_PASS;

  192. 

  193. 	CBWTag = 0;

  194. 	uint32_t start = millis();

  195. 	// Check if device is connected.

  196. 	do {

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

  198. 			return MS_NO_MEDIA_ERR;  // Not connected Error.

  199. 		}

  200. 		yield();

  201. 	} while(!available()); 

  202. 	

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

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

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

  206. 

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

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

  209. //println(maxLUN);

  210. //	delay(150);

  211. 	//-------------------------------------------------------

  212. 	msResult = msStartStopUnit(1);

  213. 	msResult = WaitMediaReady();

  214. 	if(msResult)

  215. 		return msResult;

  216. 		

  217. 	// Retrieve drive information.

  218. 	msDriveInfo.initialized = true;

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

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

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

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

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

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

  225. 	if(msResult)

  226. 		return msResult;

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

  228. 	if(msResult)

  229. 		return msResult;

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

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

  232. 	return msResult;

  233. }

  234. 

  235. //---------------------------------------------------------------------------

  236. // Perform Mass Storage Reset

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

  238. #ifdef DBGprint

  239. 	println("msReset()");

  240. #endif

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

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

  243. 	while (!msControlCompleted) yield();

  244. 	msControlCompleted = false;

  245. }

  246. 

  247. //---------------------------------------------------------------------------

  248. // Get MAX LUN

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

  250. #ifdef DBGprint

  251. 	println("msGetMaxLun()");

  252. #endif

  253. 	report[0] = 0;

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

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

  256. 	while (!msControlCompleted) yield();

  257. 	msControlCompleted = false;

  258. 	maxLUN = report[0];

  259. 	return maxLUN;

  260. }

  261. 

  262. uint8_t msController::WaitMediaReady() {

  263. 	uint8_t msResult;

  264. 	uint32_t start = millis();

  265. #ifdef DBGprint

  266. 	println("WaitMediaReady()");

  267. #endif

  268. 	do {

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

  270. 			return MS_UNIT_NOT_READY;  // Not Ready Error.

  271. 		}

  272. 		msResult = msTestReady();

  273. 		yield();

  274. 	 } while(msResult == 1);

  275. 	return msResult;

  276. }

  277. 

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

  279. uint8_t msController::checkConnectedInitialized(void) {

  280. 	uint8_t msResult = MS_CBW_PASS;

  281. #ifdef DBGprint

  282. 	print("checkConnectedInitialized()");

  283. #endif

  284. 	if(!msDriveInfo.connected) {

  285. 		return MS_NO_MEDIA_ERR;

  286. 	}

  287. 	if(!msDriveInfo.initialized) {

  288. 		msResult = mscInit();

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

  290. 	}

  291. 	return MS_CBW_PASS;

  292. }

  293. 

  294. //---------------------------------------------------------------------------

  295. // Send SCSI Command

  296. // Do a complete 3 stage transfer.

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

  298. {

  299. 	uint8_t CSWResult = 0;

  300. 	mscTransferComplete = false;

  301. #ifdef DBGprint

  302. 	println("msDoCommand()");

  303. #endif	

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

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

  306. 	while(!msOutCompleted) yield();

  307. 	msOutCompleted = false;

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

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

  310. 	while(!msInCompleted) yield();

  311. 	msInCompleted = false;

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

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

  314. 	while(!msOutCompleted) yield();

  315. 	msOutCompleted = false;

  316. 	}

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

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

  319. 	//Check for special cases. 

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

  321. 	//  return the CSW status byte.

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

  323. 	//Bit 0 == 0 == ready.

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

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

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

  327. 		return CSWResult;

  328. 	else // Process possible SCSI errors.

  329. 		return msProcessError(CSWResult);

  330. }

  331. 

  332. //---------------------------------------------------------------------------

  333. // Get Command Status Wrapper

  334. uint8_t msController::msGetCSW(void) {

  335. #ifdef DBGprint

  336. 	println("msGetCSW()");

  337. #endif

  338. 	msCommandStatusWrapper_t StatusBlockWrapper = (msCommandStatusWrapper_t)

  339. 	{

  340. 		.Signature = CSW_SIGNATURE,

  341. 		.Tag = 0,

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

  343. 		.Status = 0

  344. 	};

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

  346. 	while(!msInCompleted) yield();

  347. 	msInCompleted = false;

  348. 	mscTransferComplete = true;

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

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

  351. 	return StatusBlockWrapper.Status;

  352. }

  353. 

  354. //---------------------------------------------------------------------------

  355. // Test Unit Ready

  356. uint8_t msController::msTestReady() {

  357. #ifdef DBGprint

  358. 	println("msTestReady()");

  359. #endif

  360. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  361. 	{

  362. 		.Signature          = CBW_SIGNATURE,

  363. 		.Tag                = ++CBWTag,

  364. 		.TransferLength     = 0,

  365. 		.Flags              = CMD_DIR_DATA_IN,

  366. 		.LUN                = currentLUN,

  367. 		.CommandLength      = 6,

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

  369. 	};

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

  371. 	while(!msOutCompleted) yield();

  372. 	msOutCompleted = false;

  373. 	return msGetCSW();

  374. }

  375. 

  376. //---------------------------------------------------------------------------

  377. // Start/Stop unit

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

  379. #ifdef DBGprint

  380. 	println("msStartStopUnit()");

  381. #endif

  382. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  383. 	{

  384. 		.Signature          = CBW_SIGNATURE,

  385. 		.Tag                = ++CBWTag,

  386. 		.TransferLength     = 0,

  387. 		.Flags              = CMD_DIR_DATA_IN,

  388. 		.LUN                = currentLUN,

  389. 		.CommandLength      = 6,

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

  391. 	};

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

  393. 	while(!msOutCompleted) yield();

  394. 	msOutCompleted = false;

  395. 	return msGetCSW();

  396. }

  397. 

  398. //---------------------------------------------------------------------------

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

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

  401. #ifdef DBGprint

  402. 	println("msReadDeviceCapacity()");

  403. #endif

  404. 	uint8_t result = 0;

  405. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  406. 	{

  407. 		.Signature          = CBW_SIGNATURE,

  408. 		.Tag                = ++CBWTag,

  409. 		.TransferLength     = sizeof(msSCSICapacity_t),

  410. 		.Flags              = CMD_DIR_DATA_IN,

  411. 		.LUN                = currentLUN,

  412. 		.CommandLength      = 10,

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

  414. 	};

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

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

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

  418. 	return result;

  419. }

  420. 

  421. //---------------------------------------------------------------------------

  422. // Do Mass Storage Device Inquiry

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

  424. {

  425. #ifdef DBGprint

  426. 	println("msDeviceInquiry()");

  427. #endif

  428. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  429. 	{

  430. 		.Signature          = CBW_SIGNATURE,

  431. 		.Tag                = ++CBWTag,

  432. 		.TransferLength     = sizeof(msInquiryResponse_t),

  433. 		.Flags              = CMD_DIR_DATA_IN,

  434. 		.LUN                = currentLUN,

  435. 		.CommandLength      = 6,

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

  437. 	};

  438. 	return msDoCommand(&CommandBlockWrapper, Inquiry);

  439. }

  440. 

  441. //---------------------------------------------------------------------------

  442. // Request Sense Data

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

  444. {

  445. #ifdef DBGprint

  446. 	println("msRequestSense()");

  447. #endif

  448. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  449. 	{

  450. 		.Signature          = CBW_SIGNATURE,

  451. 		.Tag                = ++CBWTag,

  452. 		.TransferLength     = sizeof(msRequestSenseResponse_t),

  453. 		.Flags              = CMD_DIR_DATA_IN,

  454. 		.LUN                = currentLUN,

  455. 		.CommandLength      = 6,

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

  457. 	};

  458. 	return msDoCommand(&CommandBlockWrapper, Sense);

  459. }

  460. 

  461. //---------------------------------------------------------------------------

  462. // Report LUNs

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

  464. {

  465. #ifdef DBGprint

  466. 	println("msReportLuns()");

  467. #endif

  468. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  469. 	{

  470. 		.Signature          = CBW_SIGNATURE,

  471. 		.Tag                = ++CBWTag,

  472. 		.TransferLength     = MAXLUNS,

  473. 		.Flags              = CMD_DIR_DATA_IN,

  474. 		.LUN                = currentLUN,

  475. 		.CommandLength      = 12,

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

  477. 	};

  478. 	return msDoCommand(&CommandBlockWrapper, Buffer);

  479. }

  480. 

  481. 

  482. //---------------------------------------------------------------------------

  483. // Read Sectors (Multi Sector Capable)

  484. uint8_t msController::msReadBlocks(

  485. 									const uint32_t BlockAddress,

  486. 									const uint16_t Blocks,

  487. 									const uint16_t BlockSize,

  488. 									void * sectorBuffer)

  489. 	{

  490. #ifdef DBGprint

  491. 	println("msReadBlocks()");

  492. #endif

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

  494. 	uint8_t BlockLo = Blocks & 0xFF;

  495. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  496. 	{

  497. 	

  498. 		.Signature          = CBW_SIGNATURE,

  499. 		.Tag                = ++CBWTag,

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

  501. 		.Flags              = CMD_DIR_DATA_IN,

  502. 		.LUN                = currentLUN,

  503. 		.CommandLength      = 10,

  504. 		.CommandData        = {CMD_RD_10, 0x00,

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

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

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

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

  509. 							   0x00, BlockHi, BlockLo, 0x00}

  510. 	};

  511. 	return msDoCommand(&CommandBlockWrapper, sectorBuffer);

  512. }

  513. 

  514. //---------------------------------------------------------------------------

  515. // Write Sectors (Multi Sector Capable)

  516. uint8_t msController::msWriteBlocks(

  517.                                   const uint32_t BlockAddress,

  518.                                   const uint16_t Blocks,

  519.                                   const uint16_t BlockSize,

  520. 								  const void * sectorBuffer)

  521. 	{

  522. #ifdef DBGprint

  523. 	println("msWriteBlocks()");

  524. #endif

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

  526. 	uint8_t BlockLo = Blocks & 0xFF;

  527. 	msCommandBlockWrapper_t CommandBlockWrapper = (msCommandBlockWrapper_t)

  528. 	{

  529. 		.Signature          = CBW_SIGNATURE,

  530. 		.Tag                = ++CBWTag,

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

  532. 		.Flags              = CMD_DIR_DATA_OUT,

  533. 		.LUN                = currentLUN,

  534. 		.CommandLength      = 10,

  535. 		.CommandData        = {CMD_WR_10, 0x00,

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

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

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

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

  540. 							  0x00, BlockHi, BlockLo, 0x00}

  541. 	};

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

  543. }

  544. 

  545. // Proccess Possible SCSI errors

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

  547. #ifdef DBGprint

  548. 	println("msProcessError()");

  549. #endif

  550. 	uint8_t msResult = 0;

  551. 	switch(msStatus) {

  552. 		case MS_CBW_PASS:

  553. 			return MS_CBW_PASS;

  554. 			break;

  555. 		case MS_CBW_PHASE_ERROR:

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

  557. 			println(msStatus);

  558. 			return MS_SCSI_ERROR;

  559. 			break;

  560. 		case MS_CSW_TAG_ERROR:

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

  562. 			println(MS_CSW_TAG_ERROR);

  563. 			return MS_CSW_TAG_ERROR;

  564. 			break;

  565. 		case MS_CSW_SIG_ERROR:

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

  567. 			println(MS_CSW_SIG_ERROR);

  568. 			return MS_CSW_SIG_ERROR;

  569. 			break;

  570. 		case MS_CBW_FAIL:

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

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

  573. 				println(msResult);

  574. 			}

  575. 			return MS_CBW_FAIL;

  576. 			break;

  577. 		default:

  578. 			print("SCSI Error: ");

  579. 			println(msStatus);

  580. 			return msStatus;

  581. 	}

  582. }