PageRenderTime 47ms CodeModel.GetById 27ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/staging/rts5139/rts51x_scsi.c

https://bitbucket.org/bradfa/linux
C | 2148 lines | 1695 code | 326 blank | 127 comment | 353 complexity | 4e51f5a843fce9d0ae18428d3c55cc6a MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

  1. /* Driver for Realtek RTS51xx USB card reader
  2. *
  3. * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms of the GNU General Public License as published by the
  7. * Free Software Foundation; either version 2, or (at your option) any
  8. * later version.
  9. *
  10. * This program is distributed in the hope that it will be useful, but
  11. * WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13. * General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License along
  16. * with this program; if not, see <http://www.gnu.org/licenses/>.
  17. *
  18. * Author:
  19. * wwang (wei_wang@realsil.com.cn)
  20. * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
  21. * Maintainer:
  22. * Edwin Rong (edwin_rong@realsil.com.cn)
  23. * No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
  24. */
  25. #include <linux/blkdev.h>
  26. #include <linux/kthread.h>
  27. #include <linux/sched.h>
  28. #include <linux/slab.h>
  29. #include <linux/vmalloc.h>
  30. #include <linux/export.h>
  31. #include <scsi/scsi.h>
  32. #include <scsi/scsi_eh.h>
  33. #include <scsi/scsi_device.h>
  34. #include "debug.h"
  35. #include "rts51x.h"
  36. #include "rts51x_chip.h"
  37. #include "rts51x_scsi.h"
  38. #include "rts51x_card.h"
  39. #include "rts51x_transport.h"
  40. #include "sd_cprm.h"
  41. #include "ms_mg.h"
  42. #include "trace.h"
  43. void rts51x_scsi_show_command(struct scsi_cmnd *srb)
  44. {
  45. char *what = NULL;
  46. int i, unknown_cmd = 0;
  47. switch (srb->cmnd[0]) {
  48. case TEST_UNIT_READY:
  49. what = (char *)"TEST_UNIT_READY";
  50. break;
  51. case REZERO_UNIT:
  52. what = (char *)"REZERO_UNIT";
  53. break;
  54. case REQUEST_SENSE:
  55. what = (char *)"REQUEST_SENSE";
  56. break;
  57. case FORMAT_UNIT:
  58. what = (char *)"FORMAT_UNIT";
  59. break;
  60. case READ_BLOCK_LIMITS:
  61. what = (char *)"READ_BLOCK_LIMITS";
  62. break;
  63. case 0x07:
  64. what = (char *)"REASSIGN_BLOCKS";
  65. break;
  66. case READ_6:
  67. what = (char *)"READ_6";
  68. break;
  69. case WRITE_6:
  70. what = (char *)"WRITE_6";
  71. break;
  72. case SEEK_6:
  73. what = (char *)"SEEK_6";
  74. break;
  75. case READ_REVERSE:
  76. what = (char *)"READ_REVERSE";
  77. break;
  78. case WRITE_FILEMARKS:
  79. what = (char *)"WRITE_FILEMARKS";
  80. break;
  81. case SPACE:
  82. what = (char *)"SPACE";
  83. break;
  84. case INQUIRY:
  85. what = (char *)"INQUIRY";
  86. break;
  87. case RECOVER_BUFFERED_DATA:
  88. what = (char *)"RECOVER_BUFFERED_DATA";
  89. break;
  90. case MODE_SELECT:
  91. what = (char *)"MODE_SELECT";
  92. break;
  93. case RESERVE:
  94. what = (char *)"RESERVE";
  95. break;
  96. case RELEASE:
  97. what = (char *)"RELEASE";
  98. break;
  99. case COPY:
  100. what = (char *)"COPY";
  101. break;
  102. case ERASE:
  103. what = (char *)"ERASE";
  104. break;
  105. case MODE_SENSE:
  106. what = (char *)"MODE_SENSE";
  107. break;
  108. case START_STOP:
  109. what = (char *)"START_STOP";
  110. break;
  111. case RECEIVE_DIAGNOSTIC:
  112. what = (char *)"RECEIVE_DIAGNOSTIC";
  113. break;
  114. case SEND_DIAGNOSTIC:
  115. what = (char *)"SEND_DIAGNOSTIC";
  116. break;
  117. case ALLOW_MEDIUM_REMOVAL:
  118. what = (char *)"ALLOW_MEDIUM_REMOVAL";
  119. break;
  120. case SET_WINDOW:
  121. what = (char *)"SET_WINDOW";
  122. break;
  123. case READ_CAPACITY:
  124. what = (char *)"READ_CAPACITY";
  125. break;
  126. case READ_10:
  127. what = (char *)"READ_10";
  128. break;
  129. case WRITE_10:
  130. what = (char *)"WRITE_10";
  131. break;
  132. case SEEK_10:
  133. what = (char *)"SEEK_10";
  134. break;
  135. case WRITE_VERIFY:
  136. what = (char *)"WRITE_VERIFY";
  137. break;
  138. case VERIFY:
  139. what = (char *)"VERIFY";
  140. break;
  141. case SEARCH_HIGH:
  142. what = (char *)"SEARCH_HIGH";
  143. break;
  144. case SEARCH_EQUAL:
  145. what = (char *)"SEARCH_EQUAL";
  146. break;
  147. case SEARCH_LOW:
  148. what = (char *)"SEARCH_LOW";
  149. break;
  150. case SET_LIMITS:
  151. what = (char *)"SET_LIMITS";
  152. break;
  153. case READ_POSITION:
  154. what = (char *)"READ_POSITION";
  155. break;
  156. case SYNCHRONIZE_CACHE:
  157. what = (char *)"SYNCHRONIZE_CACHE";
  158. break;
  159. case LOCK_UNLOCK_CACHE:
  160. what = (char *)"LOCK_UNLOCK_CACHE";
  161. break;
  162. case READ_DEFECT_DATA:
  163. what = (char *)"READ_DEFECT_DATA";
  164. break;
  165. case MEDIUM_SCAN:
  166. what = (char *)"MEDIUM_SCAN";
  167. break;
  168. case COMPARE:
  169. what = (char *)"COMPARE";
  170. break;
  171. case COPY_VERIFY:
  172. what = (char *)"COPY_VERIFY";
  173. break;
  174. case WRITE_BUFFER:
  175. what = (char *)"WRITE_BUFFER";
  176. break;
  177. case READ_BUFFER:
  178. what = (char *)"READ_BUFFER";
  179. break;
  180. case UPDATE_BLOCK:
  181. what = (char *)"UPDATE_BLOCK";
  182. break;
  183. case READ_LONG:
  184. what = (char *)"READ_LONG";
  185. break;
  186. case WRITE_LONG:
  187. what = (char *)"WRITE_LONG";
  188. break;
  189. case CHANGE_DEFINITION:
  190. what = (char *)"CHANGE_DEFINITION";
  191. break;
  192. case WRITE_SAME:
  193. what = (char *)"WRITE_SAME";
  194. break;
  195. case GPCMD_READ_SUBCHANNEL:
  196. what = (char *)"READ SUBCHANNEL";
  197. break;
  198. case READ_TOC:
  199. what = (char *)"READ_TOC";
  200. break;
  201. case GPCMD_READ_HEADER:
  202. what = (char *)"READ HEADER";
  203. break;
  204. case GPCMD_PLAY_AUDIO_10:
  205. what = (char *)"PLAY AUDIO (10)";
  206. break;
  207. case GPCMD_PLAY_AUDIO_MSF:
  208. what = (char *)"PLAY AUDIO MSF";
  209. break;
  210. case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
  211. what = (char *)"GET EVENT/STATUS NOTIFICATION";
  212. break;
  213. case GPCMD_PAUSE_RESUME:
  214. what = (char *)"PAUSE/RESUME";
  215. break;
  216. case LOG_SELECT:
  217. what = (char *)"LOG_SELECT";
  218. break;
  219. case LOG_SENSE:
  220. what = (char *)"LOG_SENSE";
  221. break;
  222. case GPCMD_STOP_PLAY_SCAN:
  223. what = (char *)"STOP PLAY/SCAN";
  224. break;
  225. case GPCMD_READ_DISC_INFO:
  226. what = (char *)"READ DISC INFORMATION";
  227. break;
  228. case GPCMD_READ_TRACK_RZONE_INFO:
  229. what = (char *)"READ TRACK INFORMATION";
  230. break;
  231. case GPCMD_RESERVE_RZONE_TRACK:
  232. what = (char *)"RESERVE TRACK";
  233. break;
  234. case GPCMD_SEND_OPC:
  235. what = (char *)"SEND OPC";
  236. break;
  237. case MODE_SELECT_10:
  238. what = (char *)"MODE_SELECT_10";
  239. break;
  240. case GPCMD_REPAIR_RZONE_TRACK:
  241. what = (char *)"REPAIR TRACK";
  242. break;
  243. case 0x59:
  244. what = (char *)"READ MASTER CUE";
  245. break;
  246. case MODE_SENSE_10:
  247. what = (char *)"MODE_SENSE_10";
  248. break;
  249. case GPCMD_CLOSE_TRACK:
  250. what = (char *)"CLOSE TRACK/SESSION";
  251. break;
  252. case 0x5C:
  253. what = (char *)"READ BUFFER CAPACITY";
  254. break;
  255. case 0x5D:
  256. what = (char *)"SEND CUE SHEET";
  257. break;
  258. case GPCMD_BLANK:
  259. what = (char *)"BLANK";
  260. break;
  261. case REPORT_LUNS:
  262. what = (char *)"REPORT LUNS";
  263. break;
  264. case MOVE_MEDIUM:
  265. what = (char *)"MOVE_MEDIUM or PLAY AUDIO (12)";
  266. break;
  267. case READ_12:
  268. what = (char *)"READ_12";
  269. break;
  270. case WRITE_12:
  271. what = (char *)"WRITE_12";
  272. break;
  273. case WRITE_VERIFY_12:
  274. what = (char *)"WRITE_VERIFY_12";
  275. break;
  276. case SEARCH_HIGH_12:
  277. what = (char *)"SEARCH_HIGH_12";
  278. break;
  279. case SEARCH_EQUAL_12:
  280. what = (char *)"SEARCH_EQUAL_12";
  281. break;
  282. case SEARCH_LOW_12:
  283. what = (char *)"SEARCH_LOW_12";
  284. break;
  285. case SEND_VOLUME_TAG:
  286. what = (char *)"SEND_VOLUME_TAG";
  287. break;
  288. case READ_ELEMENT_STATUS:
  289. what = (char *)"READ_ELEMENT_STATUS";
  290. break;
  291. case GPCMD_READ_CD_MSF:
  292. what = (char *)"READ CD MSF";
  293. break;
  294. case GPCMD_SCAN:
  295. what = (char *)"SCAN";
  296. break;
  297. case GPCMD_SET_SPEED:
  298. what = (char *)"SET CD SPEED";
  299. break;
  300. case GPCMD_MECHANISM_STATUS:
  301. what = (char *)"MECHANISM STATUS";
  302. break;
  303. case GPCMD_READ_CD:
  304. what = (char *)"READ CD";
  305. break;
  306. case 0xE1:
  307. what = (char *)"WRITE CONTINUE";
  308. break;
  309. case WRITE_LONG_2:
  310. what = (char *)"WRITE_LONG_2";
  311. break;
  312. case VENDOR_CMND:
  313. what = (char *)"Realtek's vendor command";
  314. break;
  315. default:
  316. what = (char *)"(unknown command)";
  317. unknown_cmd = 1;
  318. break;
  319. }
  320. if (srb->cmnd[0] != TEST_UNIT_READY)
  321. RTS51X_DEBUGP("Command %s (%d bytes)\n", what, srb->cmd_len);
  322. if (unknown_cmd) {
  323. RTS51X_DEBUGP("");
  324. for (i = 0; i < srb->cmd_len && i < 16; i++)
  325. RTS51X_DEBUGPN(" %02x", srb->cmnd[i]);
  326. RTS51X_DEBUGPN("\n");
  327. }
  328. }
  329. void rts51x_set_sense_type(struct rts51x_chip *chip, unsigned int lun, int sense_type)
  330. {
  331. switch (sense_type) {
  332. case SENSE_TYPE_MEDIA_CHANGE:
  333. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
  334. break;
  335. case SENSE_TYPE_MEDIA_NOT_PRESENT:
  336. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
  337. break;
  338. case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
  339. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
  340. break;
  341. case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
  342. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
  343. break;
  344. case SENSE_TYPE_MEDIA_WRITE_PROTECT:
  345. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
  346. break;
  347. case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
  348. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
  349. break;
  350. case SENSE_TYPE_MEDIA_WRITE_ERR:
  351. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
  352. break;
  353. case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
  354. rts51x_set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
  355. ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
  356. break;
  357. case SENSE_TYPE_FORMAT_CMD_FAILED:
  358. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
  359. break;
  360. #ifdef SUPPORT_MAGIC_GATE
  361. case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
  362. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
  363. break;
  364. case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
  365. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
  366. break;
  367. case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
  368. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
  369. break;
  370. case SENSE_TYPE_MG_WRITE_ERR:
  371. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
  372. break;
  373. #endif
  374. case SENSE_TYPE_NO_SENSE:
  375. default:
  376. rts51x_set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
  377. break;
  378. }
  379. }
  380. void rts51x_set_sense_data(struct rts51x_chip *chip, unsigned int lun, u8 err_code,
  381. u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
  382. u16 sns_key_info1)
  383. {
  384. struct sense_data_t *sense = &(chip->sense_buffer[lun]);
  385. sense->err_code = err_code;
  386. sense->sense_key = sense_key;
  387. sense->info[0] = (u8) (info >> 24);
  388. sense->info[1] = (u8) (info >> 16);
  389. sense->info[2] = (u8) (info >> 8);
  390. sense->info[3] = (u8) info;
  391. sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
  392. sense->asc = asc;
  393. sense->ascq = ascq;
  394. if (sns_key_info0 != 0) {
  395. sense->sns_key_info[0] = SKSV | sns_key_info0;
  396. sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
  397. sense->sns_key_info[2] = sns_key_info1 & 0x0f;
  398. }
  399. }
  400. static int test_unit_ready(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  401. {
  402. unsigned int lun = SCSI_LUN(srb);
  403. rts51x_init_cards(chip);
  404. if (!check_card_ready(chip, lun)) {
  405. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  406. return TRANSPORT_FAILED;
  407. }
  408. if (!check_lun_mc(chip, lun)) {
  409. set_lun_mc(chip, lun);
  410. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
  411. return TRANSPORT_FAILED;
  412. }
  413. return TRANSPORT_GOOD;
  414. }
  415. unsigned char formatter_inquiry_str[20] = {
  416. 'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
  417. '-', 'M', 'G', /* Byte[47:49] */
  418. 0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */
  419. 0x00, /* Byte[51]: Category Specific Commands */
  420. 0x00, /* Byte[52]: Access Control and feature */
  421. 0x20, 0x20, 0x20, /* Byte[53:55] */
  422. };
  423. static int inquiry(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  424. {
  425. unsigned int lun = SCSI_LUN(srb);
  426. char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 ";
  427. char *inquiry_string;
  428. unsigned char sendbytes;
  429. unsigned char *buf;
  430. u8 card = rts51x_get_lun_card(chip, lun);
  431. int pro_formatter_flag = 0;
  432. unsigned char inquiry_buf[] = {
  433. QULIFIRE | DRCT_ACCESS_DEV,
  434. RMB_DISC | 0x0D,
  435. 0x00,
  436. 0x01,
  437. 0x1f,
  438. 0x02,
  439. 0,
  440. REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE,
  441. };
  442. inquiry_string = inquiry_default;
  443. buf = vmalloc(scsi_bufflen(srb));
  444. if (buf == NULL)
  445. TRACE_RET(chip, TRANSPORT_ERROR);
  446. if (MS_FORMATTER_ENABLED(chip) && (get_lun2card(chip, lun) & MS_CARD)) {
  447. if (!card || (card == MS_CARD))
  448. pro_formatter_flag = 1;
  449. }
  450. if (pro_formatter_flag) {
  451. if (scsi_bufflen(srb) < 56)
  452. sendbytes = (unsigned char)(scsi_bufflen(srb));
  453. else
  454. sendbytes = 56;
  455. } else {
  456. if (scsi_bufflen(srb) < 36)
  457. sendbytes = (unsigned char)(scsi_bufflen(srb));
  458. else
  459. sendbytes = 36;
  460. }
  461. if (sendbytes > 8) {
  462. memcpy(buf, inquiry_buf, 8);
  463. memcpy(buf + 8, inquiry_string, sendbytes - 8);
  464. if (pro_formatter_flag)
  465. buf[4] = 0x33; /* Additional Length */
  466. } else {
  467. memcpy(buf, inquiry_buf, sendbytes);
  468. }
  469. if (pro_formatter_flag) {
  470. if (sendbytes > 36)
  471. memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
  472. }
  473. scsi_set_resid(srb, 0);
  474. rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
  475. vfree(buf);
  476. return TRANSPORT_GOOD;
  477. }
  478. static int start_stop_unit(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  479. {
  480. unsigned int lun = SCSI_LUN(srb);
  481. scsi_set_resid(srb, scsi_bufflen(srb));
  482. if (srb->cmnd[1] == 1)
  483. return TRANSPORT_GOOD;
  484. switch (srb->cmnd[0x4]) {
  485. case STOP_MEDIUM:
  486. /* Media disabled */
  487. return TRANSPORT_GOOD;
  488. case UNLOAD_MEDIUM:
  489. /* Media shall be unload */
  490. if (check_card_ready(chip, lun))
  491. rts51x_eject_card(chip, lun);
  492. return TRANSPORT_GOOD;
  493. case MAKE_MEDIUM_READY:
  494. case LOAD_MEDIUM:
  495. if (check_card_ready(chip, lun)) {
  496. return TRANSPORT_GOOD;
  497. } else {
  498. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  499. TRACE_RET(chip, TRANSPORT_FAILED);
  500. }
  501. break;
  502. }
  503. TRACE_RET(chip, TRANSPORT_ERROR);
  504. }
  505. static int allow_medium_removal(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  506. {
  507. int prevent;
  508. prevent = srb->cmnd[4] & 0x1;
  509. scsi_set_resid(srb, 0);
  510. if (prevent) {
  511. rts51x_set_sense_type(chip, SCSI_LUN(srb),
  512. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  513. TRACE_RET(chip, TRANSPORT_FAILED);
  514. }
  515. return TRANSPORT_GOOD;
  516. }
  517. static void ms_mode_sense(struct rts51x_chip *chip, u8 cmd,
  518. int lun, u8 *buf, int buf_len)
  519. {
  520. struct ms_info *ms_card = &(chip->ms_card);
  521. int sys_info_offset;
  522. int data_size = buf_len;
  523. int support_format = 0;
  524. int i = 0;
  525. if (cmd == MODE_SENSE) {
  526. sys_info_offset = 8;
  527. if (data_size > 0x68)
  528. data_size = 0x68;
  529. buf[i++] = 0x67; /* Mode Data Length */
  530. } else {
  531. sys_info_offset = 12;
  532. if (data_size > 0x6C)
  533. data_size = 0x6C;
  534. buf[i++] = 0x00; /* Mode Data Length (MSB) */
  535. buf[i++] = 0x6A; /* Mode Data Length (LSB) */
  536. }
  537. /* Medium Type Code */
  538. if (check_card_ready(chip, lun)) {
  539. if (CHK_MSXC(ms_card)) {
  540. support_format = 1;
  541. buf[i++] = 0x40;
  542. } else if (CHK_MSPRO(ms_card)) {
  543. support_format = 1;
  544. buf[i++] = 0x20;
  545. } else {
  546. buf[i++] = 0x10;
  547. }
  548. /* WP */
  549. if (check_card_wp(chip, lun))
  550. buf[i++] = 0x80;
  551. else
  552. buf[i++] = 0x00;
  553. } else {
  554. buf[i++] = 0x00; /* MediaType */
  555. buf[i++] = 0x00; /* WP */
  556. }
  557. buf[i++] = 0x00; /* Reserved */
  558. if (cmd == MODE_SENSE_10) {
  559. buf[i++] = 0x00; /* Reserved */
  560. buf[i++] = 0x00; /* Block descriptor length(MSB) */
  561. buf[i++] = 0x00; /* Block descriptor length(LSB) */
  562. /* The Following Data is the content of "Page 0x20" */
  563. if (data_size >= 9)
  564. buf[i++] = 0x20; /* Page Code */
  565. if (data_size >= 10)
  566. buf[i++] = 0x62; /* Page Length */
  567. if (data_size >= 11)
  568. buf[i++] = 0x00; /* No Access Control */
  569. if (data_size >= 12) {
  570. if (support_format)
  571. buf[i++] = 0xC0; /* SF, SGM */
  572. else
  573. buf[i++] = 0x00;
  574. }
  575. } else {
  576. /* The Following Data is the content of "Page 0x20" */
  577. if (data_size >= 5)
  578. buf[i++] = 0x20; /* Page Code */
  579. if (data_size >= 6)
  580. buf[i++] = 0x62; /* Page Length */
  581. if (data_size >= 7)
  582. buf[i++] = 0x00; /* No Access Control */
  583. if (data_size >= 8) {
  584. if (support_format)
  585. buf[i++] = 0xC0; /* SF, SGM */
  586. else
  587. buf[i++] = 0x00;
  588. }
  589. }
  590. if (data_size > sys_info_offset) {
  591. /* 96 Bytes Attribute Data */
  592. int len = data_size - sys_info_offset;
  593. len = (len < 96) ? len : 96;
  594. memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
  595. }
  596. }
  597. static int mode_sense(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  598. {
  599. unsigned int lun = SCSI_LUN(srb);
  600. unsigned int dataSize;
  601. int status;
  602. int pro_formatter_flag;
  603. unsigned char pageCode, *buf;
  604. u8 card = rts51x_get_lun_card(chip, lun);
  605. if (!check_card_ready(chip, lun)) {
  606. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  607. scsi_set_resid(srb, scsi_bufflen(srb));
  608. TRACE_RET(chip, TRANSPORT_FAILED);
  609. }
  610. pro_formatter_flag = 0;
  611. dataSize = 8;
  612. /* In Combo mode, device responses ModeSense command as a MS LUN
  613. * when no card is inserted */
  614. if ((get_lun2card(chip, lun) & MS_CARD)) {
  615. if (!card || (card == MS_CARD)) {
  616. dataSize = 108;
  617. if (chip->option.rts51x_mspro_formatter_enable)
  618. pro_formatter_flag = 1;
  619. }
  620. }
  621. buf = kmalloc(dataSize, GFP_KERNEL);
  622. if (buf == NULL)
  623. TRACE_RET(chip, TRANSPORT_ERROR);
  624. pageCode = srb->cmnd[2] & 0x3f;
  625. if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
  626. (pageCode == 0x00) || (pro_formatter_flag && (pageCode == 0x20))) {
  627. if (srb->cmnd[0] == MODE_SENSE) {
  628. if ((pageCode == 0x3F) || (pageCode == 0x20)) {
  629. ms_mode_sense(chip, srb->cmnd[0], lun, buf,
  630. dataSize);
  631. } else {
  632. dataSize = 4;
  633. buf[0] = 0x03;
  634. buf[1] = 0x00;
  635. if (check_card_wp(chip, lun))
  636. buf[2] = 0x80;
  637. else
  638. buf[3] = 0x00;
  639. }
  640. } else {
  641. if ((pageCode == 0x3F) || (pageCode == 0x20)) {
  642. ms_mode_sense(chip, srb->cmnd[0], lun, buf,
  643. dataSize);
  644. } else {
  645. dataSize = 8;
  646. buf[0] = 0x00;
  647. buf[1] = 0x06;
  648. buf[2] = 0x00;
  649. if (check_card_wp(chip, lun))
  650. buf[3] = 0x80;
  651. else
  652. buf[3] = 0x00;
  653. buf[4] = 0x00;
  654. buf[5] = 0x00;
  655. buf[6] = 0x00;
  656. buf[7] = 0x00;
  657. }
  658. }
  659. status = TRANSPORT_GOOD;
  660. } else {
  661. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  662. scsi_set_resid(srb, scsi_bufflen(srb));
  663. status = TRANSPORT_FAILED;
  664. }
  665. if (status == TRANSPORT_GOOD) {
  666. unsigned int len = min(scsi_bufflen(srb), dataSize);
  667. rts51x_set_xfer_buf(buf, len, srb);
  668. scsi_set_resid(srb, scsi_bufflen(srb) - len);
  669. }
  670. kfree(buf);
  671. return status;
  672. }
  673. static int request_sense(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  674. {
  675. struct sense_data_t *sense;
  676. unsigned int lun = SCSI_LUN(srb);
  677. struct ms_info *ms_card = &(chip->ms_card);
  678. unsigned char *tmp, *buf;
  679. sense = &(chip->sense_buffer[lun]);
  680. if ((rts51x_get_lun_card(chip, lun) == MS_CARD)
  681. && PRO_UNDER_FORMATTING(ms_card)) {
  682. rts51x_mspro_format_sense(chip, lun);
  683. }
  684. buf = vmalloc(scsi_bufflen(srb));
  685. if (buf == NULL)
  686. TRACE_RET(chip, TRANSPORT_ERROR);
  687. tmp = (unsigned char *)sense;
  688. memcpy(buf, tmp, scsi_bufflen(srb));
  689. rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
  690. vfree(buf);
  691. scsi_set_resid(srb, 0);
  692. /* Reset Sense Data */
  693. rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
  694. return TRANSPORT_GOOD;
  695. }
  696. static int read_write(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  697. {
  698. unsigned int lun = SCSI_LUN(srb);
  699. int retval;
  700. u32 start_sec;
  701. u16 sec_cnt;
  702. if (!check_card_ready(chip, lun) || (chip->capacity[lun] == 0)) {
  703. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  704. TRACE_RET(chip, TRANSPORT_FAILED);
  705. }
  706. if (!check_lun_mc(chip, lun)) {
  707. set_lun_mc(chip, lun);
  708. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
  709. return TRANSPORT_FAILED;
  710. }
  711. rts51x_prepare_run(chip);
  712. RTS51X_SET_STAT(chip, STAT_RUN);
  713. if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
  714. start_sec =
  715. ((u32) srb->cmnd[2] << 24) |
  716. ((u32) srb->cmnd[3] << 16) |
  717. ((u32) srb->cmnd[4] << 8) |
  718. ((u32) srb->cmnd[5]);
  719. sec_cnt = ((u16) (srb->cmnd[7]) << 8) | srb->cmnd[8];
  720. } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
  721. start_sec = ((u32) (srb->cmnd[1] & 0x1F) << 16) |
  722. ((u32) srb->cmnd[2] << 8) | ((u32) srb->cmnd[3]);
  723. sec_cnt = srb->cmnd[4];
  724. } else if ((srb->cmnd[0] == VENDOR_CMND) &&
  725. (srb->cmnd[1] == SCSI_APP_CMD) &&
  726. ((srb->cmnd[2] == PP_READ10) ||
  727. (srb->cmnd[2] == PP_WRITE10))) {
  728. start_sec = ((u32) srb->cmnd[4] << 24) |
  729. ((u32) srb->cmnd[5] << 16) |
  730. ((u32) srb->cmnd[6] << 8) |
  731. ((u32) srb->cmnd[7]);
  732. sec_cnt = ((u16) (srb->cmnd[9]) << 8) | srb->cmnd[10];
  733. } else {
  734. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  735. TRACE_RET(chip, TRANSPORT_FAILED);
  736. }
  737. if ((start_sec > chip->capacity[lun]) ||
  738. ((start_sec + sec_cnt) > chip->capacity[lun])) {
  739. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
  740. TRACE_RET(chip, TRANSPORT_FAILED);
  741. }
  742. if (sec_cnt == 0) {
  743. scsi_set_resid(srb, 0);
  744. return TRANSPORT_GOOD;
  745. }
  746. if ((srb->sc_data_direction == DMA_TO_DEVICE)
  747. && check_card_wp(chip, lun)) {
  748. RTS51X_DEBUGP("Write protected card!\n");
  749. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
  750. TRACE_RET(chip, TRANSPORT_FAILED);
  751. }
  752. retval = rts51x_card_rw(srb, chip, start_sec, sec_cnt);
  753. if (retval != STATUS_SUCCESS) {
  754. if (srb->sc_data_direction == DMA_FROM_DEVICE) {
  755. rts51x_set_sense_type(chip, lun,
  756. SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
  757. } else {
  758. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
  759. }
  760. TRACE_RET(chip, TRANSPORT_FAILED);
  761. }
  762. scsi_set_resid(srb, 0);
  763. return TRANSPORT_GOOD;
  764. }
  765. static int read_format_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  766. {
  767. unsigned char *buf;
  768. unsigned int lun = SCSI_LUN(srb);
  769. unsigned int buf_len;
  770. u8 card = rts51x_get_lun_card(chip, lun);
  771. int desc_cnt;
  772. int i = 0;
  773. if (!check_card_ready(chip, lun)) {
  774. if (!chip->option.rts51x_mspro_formatter_enable) {
  775. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  776. TRACE_RET(chip, TRANSPORT_FAILED);
  777. }
  778. }
  779. buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
  780. buf = kmalloc(buf_len, GFP_KERNEL);
  781. if (buf == NULL)
  782. TRACE_RET(chip, TRANSPORT_ERROR);
  783. buf[i++] = 0;
  784. buf[i++] = 0;
  785. buf[i++] = 0;
  786. /* Capacity List Length */
  787. if ((buf_len > 12) && chip->option.rts51x_mspro_formatter_enable &&
  788. (chip->lun2card[lun] & MS_CARD) && (!card || (card == MS_CARD))) {
  789. buf[i++] = 0x10;
  790. desc_cnt = 2;
  791. } else {
  792. buf[i++] = 0x08;
  793. desc_cnt = 1;
  794. }
  795. while (desc_cnt) {
  796. if (check_card_ready(chip, lun)) {
  797. buf[i++] = (unsigned char)((chip->capacity[lun]) >> 24);
  798. buf[i++] = (unsigned char)((chip->capacity[lun]) >> 16);
  799. buf[i++] = (unsigned char)((chip->capacity[lun]) >> 8);
  800. buf[i++] = (unsigned char)(chip->capacity[lun]);
  801. if (desc_cnt == 2)
  802. /* Byte[8]: Descriptor Type: Formatted medium */
  803. buf[i++] = 2;
  804. else
  805. buf[i++] = 0; /* Byte[16] */
  806. } else {
  807. buf[i++] = 0xFF;
  808. buf[i++] = 0xFF;
  809. buf[i++] = 0xFF;
  810. buf[i++] = 0xFF;
  811. if (desc_cnt == 2)
  812. /* Byte[8]: Descriptor Type: No medium */
  813. buf[i++] = 3;
  814. else
  815. buf[i++] = 0; /*Byte[16] */
  816. }
  817. buf[i++] = 0x00;
  818. buf[i++] = 0x02;
  819. buf[i++] = 0x00;
  820. desc_cnt--;
  821. }
  822. buf_len = min(scsi_bufflen(srb), buf_len);
  823. rts51x_set_xfer_buf(buf, buf_len, srb);
  824. kfree(buf);
  825. scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
  826. return TRANSPORT_GOOD;
  827. }
  828. static int read_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  829. {
  830. unsigned char *buf;
  831. unsigned int lun = SCSI_LUN(srb);
  832. if (!check_card_ready(chip, lun)) {
  833. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  834. TRACE_RET(chip, TRANSPORT_FAILED);
  835. }
  836. if (!check_lun_mc(chip, lun)) {
  837. set_lun_mc(chip, lun);
  838. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
  839. return TRANSPORT_FAILED;
  840. }
  841. buf = kmalloc(8, GFP_KERNEL);
  842. if (buf == NULL)
  843. TRACE_RET(chip, TRANSPORT_ERROR);
  844. buf[0] = (unsigned char)((chip->capacity[lun] - 1) >> 24);
  845. buf[1] = (unsigned char)((chip->capacity[lun] - 1) >> 16);
  846. buf[2] = (unsigned char)((chip->capacity[lun] - 1) >> 8);
  847. buf[3] = (unsigned char)(chip->capacity[lun] - 1);
  848. buf[4] = 0x00;
  849. buf[5] = 0x00;
  850. buf[6] = 0x02;
  851. buf[7] = 0x00;
  852. rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
  853. kfree(buf);
  854. scsi_set_resid(srb, 0);
  855. return TRANSPORT_GOOD;
  856. }
  857. static int get_dev_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  858. {
  859. unsigned int lun = SCSI_LUN(srb);
  860. unsigned int buf_len;
  861. u8 status[32] = { 0 };
  862. rts51x_pp_status(chip, lun, status, 32);
  863. buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(status));
  864. rts51x_set_xfer_buf(status, buf_len, srb);
  865. scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
  866. return TRANSPORT_GOOD;
  867. }
  868. static int read_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  869. {
  870. u8 rts51x_status[16];
  871. unsigned int buf_len;
  872. unsigned int lun = SCSI_LUN(srb);
  873. rts51x_read_status(chip, lun, rts51x_status, 16);
  874. buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(rts51x_status));
  875. rts51x_set_xfer_buf(rts51x_status, buf_len, srb);
  876. scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
  877. return TRANSPORT_GOOD;
  878. }
  879. static int read_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  880. {
  881. unsigned int lun = SCSI_LUN(srb);
  882. unsigned short addr, len, i;
  883. int retval;
  884. u8 *buf;
  885. rts51x_prepare_run(chip);
  886. RTS51X_SET_STAT(chip, STAT_RUN);
  887. addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
  888. len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
  889. if (addr < 0xe000) {
  890. RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
  891. return TRANSPORT_GOOD;
  892. }
  893. buf = vmalloc(len);
  894. if (!buf)
  895. TRACE_RET(chip, TRANSPORT_ERROR);
  896. for (i = 0; i < len; i++) {
  897. retval = rts51x_ep0_read_register(chip, addr + i, buf + i);
  898. if (retval != STATUS_SUCCESS) {
  899. vfree(buf);
  900. rts51x_set_sense_type(chip, lun,
  901. SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
  902. TRACE_RET(chip, TRANSPORT_FAILED);
  903. }
  904. }
  905. len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
  906. rts51x_set_xfer_buf(buf, len, srb);
  907. scsi_set_resid(srb, scsi_bufflen(srb) - len);
  908. vfree(buf);
  909. return TRANSPORT_GOOD;
  910. }
  911. static int write_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  912. {
  913. unsigned int lun = SCSI_LUN(srb);
  914. unsigned short addr, len, i;
  915. int retval;
  916. u8 *buf;
  917. rts51x_prepare_run(chip);
  918. RTS51X_SET_STAT(chip, STAT_RUN);
  919. addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
  920. len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
  921. if (addr < 0xe000) {
  922. RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
  923. return TRANSPORT_GOOD;
  924. }
  925. len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
  926. buf = vmalloc(len);
  927. if (!buf)
  928. TRACE_RET(chip, TRANSPORT_ERROR);
  929. rts51x_get_xfer_buf(buf, len, srb);
  930. for (i = 0; i < len; i++) {
  931. retval =
  932. rts51x_ep0_write_register(chip, addr + i, 0xFF, buf[i]);
  933. if (retval != STATUS_SUCCESS) {
  934. vfree(buf);
  935. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
  936. TRACE_RET(chip, TRANSPORT_FAILED);
  937. }
  938. }
  939. vfree(buf);
  940. scsi_set_resid(srb, scsi_bufflen(srb) - len);
  941. return TRANSPORT_GOOD;
  942. }
  943. static int get_sd_csd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  944. {
  945. struct sd_info *sd_card = &(chip->sd_card);
  946. unsigned int lun = SCSI_LUN(srb);
  947. if (!check_card_ready(chip, lun)) {
  948. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  949. TRACE_RET(chip, TRANSPORT_FAILED);
  950. }
  951. if (rts51x_get_lun_card(chip, lun) != SD_CARD) {
  952. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
  953. TRACE_RET(chip, TRANSPORT_FAILED);
  954. }
  955. scsi_set_resid(srb, 0);
  956. rts51x_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
  957. return TRANSPORT_GOOD;
  958. }
  959. static int read_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  960. {
  961. int retval;
  962. u8 addr, len, i;
  963. u8 *buf;
  964. rts51x_prepare_run(chip);
  965. RTS51X_SET_STAT(chip, STAT_RUN);
  966. addr = srb->cmnd[5];
  967. len = srb->cmnd[7];
  968. if (len) {
  969. buf = vmalloc(len);
  970. if (!buf)
  971. TRACE_RET(chip, TRANSPORT_ERROR);
  972. for (i = 0; i < len; i++) {
  973. retval =
  974. rts51x_read_phy_register(chip, addr + i, buf + i);
  975. if (retval != STATUS_SUCCESS) {
  976. vfree(buf);
  977. rts51x_set_sense_type(chip, SCSI_LUN(srb),
  978. SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
  979. TRACE_RET(chip, TRANSPORT_FAILED);
  980. }
  981. }
  982. len = min(scsi_bufflen(srb), (unsigned int)len);
  983. rts51x_set_xfer_buf(buf, len, srb);
  984. scsi_set_resid(srb, scsi_bufflen(srb) - len);
  985. vfree(buf);
  986. }
  987. return TRANSPORT_GOOD;
  988. }
  989. static int write_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  990. {
  991. int retval;
  992. u8 addr, len, i;
  993. u8 *buf;
  994. rts51x_prepare_run(chip);
  995. RTS51X_SET_STAT(chip, STAT_RUN);
  996. addr = srb->cmnd[5];
  997. len = srb->cmnd[7];
  998. if (len) {
  999. len = min(scsi_bufflen(srb), (unsigned int)len);
  1000. buf = vmalloc(len);
  1001. if (buf == NULL)
  1002. TRACE_RET(chip, TRANSPORT_ERROR);
  1003. rts51x_get_xfer_buf(buf, len, srb);
  1004. scsi_set_resid(srb, scsi_bufflen(srb) - len);
  1005. for (i = 0; i < len; i++) {
  1006. retval =
  1007. rts51x_write_phy_register(chip, addr + i, buf[i]);
  1008. if (retval != STATUS_SUCCESS) {
  1009. vfree(buf);
  1010. rts51x_set_sense_type(chip, SCSI_LUN(srb),
  1011. SENSE_TYPE_MEDIA_WRITE_ERR);
  1012. TRACE_RET(chip, TRANSPORT_FAILED);
  1013. }
  1014. }
  1015. vfree(buf);
  1016. }
  1017. return TRANSPORT_GOOD;
  1018. }
  1019. static int get_card_bus_width(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1020. {
  1021. unsigned int lun = SCSI_LUN(srb);
  1022. u8 card, bus_width;
  1023. if (!check_card_ready(chip, lun)) {
  1024. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  1025. TRACE_RET(chip, TRANSPORT_FAILED);
  1026. }
  1027. card = rts51x_get_lun_card(chip, lun);
  1028. if ((card == SD_CARD) || (card == MS_CARD)) {
  1029. bus_width = chip->card_bus_width[lun];
  1030. } else {
  1031. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
  1032. TRACE_RET(chip, TRANSPORT_FAILED);
  1033. }
  1034. scsi_set_resid(srb, 0);
  1035. rts51x_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
  1036. return TRANSPORT_GOOD;
  1037. }
  1038. #ifdef _MSG_TRACE
  1039. static int trace_msg_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1040. {
  1041. unsigned char *buf = NULL;
  1042. u8 clear;
  1043. unsigned int buf_len;
  1044. buf_len =
  1045. 4 +
  1046. ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * TRACE_ITEM_CNT);
  1047. if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
  1048. rts51x_set_sense_type(chip, SCSI_LUN(srb),
  1049. SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
  1050. TRACE_RET(chip, TRANSPORT_FAILED);
  1051. }
  1052. clear = srb->cmnd[2];
  1053. buf = vmalloc(scsi_bufflen(srb));
  1054. if (buf == NULL)
  1055. TRACE_RET(chip, TRANSPORT_ERROR);
  1056. rts51x_trace_msg(chip, buf, clear);
  1057. rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
  1058. vfree(buf);
  1059. scsi_set_resid(srb, 0);
  1060. return TRANSPORT_GOOD;
  1061. }
  1062. #endif
  1063. static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1064. {
  1065. int retval = STATUS_SUCCESS;
  1066. unsigned int lun = SCSI_LUN(srb);
  1067. u8 cmd_type, mask, value, idx, mode, len;
  1068. u16 addr;
  1069. u32 timeout;
  1070. rts51x_prepare_run(chip);
  1071. RTS51X_SET_STAT(chip, STAT_RUN);
  1072. switch (srb->cmnd[3]) {
  1073. case INIT_BATCHCMD:
  1074. rts51x_init_cmd(chip);
  1075. break;
  1076. case ADD_BATCHCMD:
  1077. cmd_type = srb->cmnd[4];
  1078. if (cmd_type > 2) {
  1079. rts51x_set_sense_type(chip, lun,
  1080. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1081. TRACE_RET(chip, TRANSPORT_FAILED);
  1082. }
  1083. addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
  1084. mask = srb->cmnd[7];
  1085. value = srb->cmnd[8];
  1086. rts51x_add_cmd(chip, cmd_type, addr, mask, value);
  1087. break;
  1088. case SEND_BATCHCMD:
  1089. mode = srb->cmnd[4];
  1090. len = srb->cmnd[5];
  1091. timeout =
  1092. ((u32) srb->cmnd[6] << 24) | ((u32) srb->
  1093. cmnd[7] << 16) | ((u32) srb->
  1094. cmnd[8] <<
  1095. 8) | ((u32)
  1096. srb->
  1097. cmnd
  1098. [9]);
  1099. retval = rts51x_send_cmd(chip, mode, 1000);
  1100. if (retval != STATUS_SUCCESS) {
  1101. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
  1102. TRACE_RET(chip, TRANSPORT_FAILED);
  1103. }
  1104. if (mode & STAGE_R) {
  1105. retval = rts51x_get_rsp(chip, len, timeout);
  1106. if (retval != STATUS_SUCCESS) {
  1107. rts51x_set_sense_type(chip, lun,
  1108. SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
  1109. TRACE_RET(chip, TRANSPORT_FAILED);
  1110. }
  1111. }
  1112. break;
  1113. case GET_BATCHRSP:
  1114. idx = srb->cmnd[4];
  1115. value = chip->rsp_buf[idx];
  1116. if (scsi_bufflen(srb) < 1) {
  1117. rts51x_set_sense_type(chip, lun,
  1118. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1119. TRACE_RET(chip, TRANSPORT_FAILED);
  1120. }
  1121. rts51x_set_xfer_buf(&value, 1, srb);
  1122. scsi_set_resid(srb, 0);
  1123. break;
  1124. default:
  1125. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1126. TRACE_RET(chip, TRANSPORT_FAILED);
  1127. }
  1128. if (retval != STATUS_SUCCESS) {
  1129. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
  1130. TRACE_RET(chip, TRANSPORT_FAILED);
  1131. }
  1132. return TRANSPORT_GOOD;
  1133. }
  1134. static int suit_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1135. {
  1136. int result;
  1137. switch (srb->cmnd[3]) {
  1138. case INIT_BATCHCMD:
  1139. case ADD_BATCHCMD:
  1140. case SEND_BATCHCMD:
  1141. case GET_BATCHRSP:
  1142. result = rw_mem_cmd_buf(srb, chip);
  1143. break;
  1144. default:
  1145. result = TRANSPORT_ERROR;
  1146. }
  1147. return result;
  1148. }
  1149. static int app_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1150. {
  1151. int result;
  1152. switch (srb->cmnd[2]) {
  1153. case PP_READ10:
  1154. case PP_WRITE10:
  1155. result = read_write(srb, chip);
  1156. break;
  1157. case SUIT_CMD:
  1158. result = suit_cmd(srb, chip);
  1159. break;
  1160. case READ_PHY:
  1161. result = read_phy_register(srb, chip);
  1162. break;
  1163. case WRITE_PHY:
  1164. result = write_phy_register(srb, chip);
  1165. break;
  1166. case GET_DEV_STATUS:
  1167. result = get_dev_status(srb, chip);
  1168. break;
  1169. default:
  1170. rts51x_set_sense_type(chip, SCSI_LUN(srb),
  1171. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1172. TRACE_RET(chip, TRANSPORT_FAILED);
  1173. }
  1174. return result;
  1175. }
  1176. static int vendor_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1177. {
  1178. int result = TRANSPORT_GOOD;
  1179. switch (srb->cmnd[1]) {
  1180. case READ_STATUS:
  1181. result = read_status(srb, chip);
  1182. break;
  1183. case READ_MEM:
  1184. result = read_mem(srb, chip);
  1185. break;
  1186. case WRITE_MEM:
  1187. result = write_mem(srb, chip);
  1188. break;
  1189. case GET_BUS_WIDTH:
  1190. result = get_card_bus_width(srb, chip);
  1191. break;
  1192. case GET_SD_CSD:
  1193. result = get_sd_csd(srb, chip);
  1194. break;
  1195. #ifdef _MSG_TRACE
  1196. case TRACE_MSG:
  1197. result = trace_msg_cmd(srb, chip);
  1198. break;
  1199. #endif
  1200. case SCSI_APP_CMD:
  1201. result = app_cmd(srb, chip);
  1202. break;
  1203. default:
  1204. rts51x_set_sense_type(chip, SCSI_LUN(srb),
  1205. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1206. TRACE_RET(chip, TRANSPORT_FAILED);
  1207. }
  1208. return result;
  1209. }
  1210. static int ms_format_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1211. {
  1212. struct ms_info *ms_card = &(chip->ms_card);
  1213. unsigned int lun = SCSI_LUN(srb);
  1214. int retval, quick_format;
  1215. if (rts51x_get_lun_card(chip, lun) != MS_CARD) {
  1216. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
  1217. TRACE_RET(chip, TRANSPORT_FAILED);
  1218. }
  1219. if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47)
  1220. || (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D)
  1221. || (srb->cmnd[7] != 0x74)) {
  1222. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1223. TRACE_RET(chip, TRANSPORT_FAILED);
  1224. }
  1225. if (srb->cmnd[8] & 0x01)
  1226. quick_format = 0;
  1227. else
  1228. quick_format = 1;
  1229. if (!(chip->card_ready & MS_CARD)) {
  1230. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  1231. TRACE_RET(chip, TRANSPORT_FAILED);
  1232. }
  1233. if (chip->card_wp & MS_CARD) {
  1234. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
  1235. TRACE_RET(chip, TRANSPORT_FAILED);
  1236. }
  1237. if (!CHK_MSPRO(ms_card)) {
  1238. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
  1239. TRACE_RET(chip, TRANSPORT_FAILED);
  1240. }
  1241. rts51x_prepare_run(chip);
  1242. RTS51X_SET_STAT(chip, STAT_RUN);
  1243. retval = rts51x_mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
  1244. if (retval != STATUS_SUCCESS) {
  1245. rts51x_set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
  1246. TRACE_RET(chip, TRANSPORT_FAILED);
  1247. }
  1248. scsi_set_resid(srb, 0);
  1249. return TRANSPORT_GOOD;
  1250. }
  1251. #ifdef SUPPORT_PCGL_1P18
  1252. static int get_ms_information(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1253. {
  1254. struct ms_info *ms_card = &(chip->ms_card);
  1255. unsigned int lun = SCSI_LUN(srb);
  1256. u8 dev_info_id, data_len;
  1257. u8 *buf;
  1258. unsigned int buf_len;
  1259. int i;
  1260. if (!check_card_ready(chip, lun)) {
  1261. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  1262. TRACE_RET(chip, TRANSPORT_FAILED);
  1263. }
  1264. if ((rts51x_get_lun_card(chip, lun) != MS_CARD)) {
  1265. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
  1266. TRACE_RET(chip, TRANSPORT_FAILED);
  1267. }
  1268. if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
  1269. (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
  1270. (srb->cmnd[7] != 0x44)) {
  1271. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1272. TRACE_RET(chip, TRANSPORT_FAILED);
  1273. }
  1274. dev_info_id = srb->cmnd[3];
  1275. if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
  1276. (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
  1277. !CHK_MSPRO(ms_card)) {
  1278. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1279. TRACE_RET(chip, TRANSPORT_FAILED);
  1280. }
  1281. if (dev_info_id == 0x15)
  1282. buf_len = data_len = 0x3A;
  1283. else
  1284. buf_len = data_len = 0x6A;
  1285. buf = kmalloc(buf_len, GFP_KERNEL);
  1286. if (!buf)
  1287. TRACE_RET(chip, TRANSPORT_ERROR);
  1288. i = 0;
  1289. /* GET Memory Stick Media Information Response Header */
  1290. buf[i++] = 0x00; /* Data length MSB */
  1291. buf[i++] = data_len; /* Data length LSB */
  1292. /* Device Information Type Code */
  1293. if (CHK_MSXC(ms_card))
  1294. buf[i++] = 0x03;
  1295. else
  1296. buf[i++] = 0x02;
  1297. /* SGM bit */
  1298. buf[i++] = 0x01;
  1299. /* Reserved */
  1300. buf[i++] = 0x00;
  1301. buf[i++] = 0x00;
  1302. buf[i++] = 0x00;
  1303. /* Number of Device Information */
  1304. buf[i++] = 0x01;
  1305. /* Device Information Body
  1306. * Device Information ID Number */
  1307. buf[i++] = dev_info_id;
  1308. /* Device Information Length */
  1309. if (dev_info_id == 0x15)
  1310. data_len = 0x31;
  1311. else
  1312. data_len = 0x61;
  1313. buf[i++] = 0x00; /* Data length MSB */
  1314. buf[i++] = data_len; /* Data length LSB */
  1315. /* Valid Bit */
  1316. buf[i++] = 0x80;
  1317. if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
  1318. /* System Information */
  1319. memcpy(buf + i, ms_card->raw_sys_info, 96);
  1320. } else {
  1321. /* Model Name */
  1322. memcpy(buf + i, ms_card->raw_model_name, 48);
  1323. }
  1324. rts51x_set_xfer_buf(buf, buf_len, srb);
  1325. if (dev_info_id == 0x15)
  1326. scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
  1327. else
  1328. scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
  1329. kfree(buf);
  1330. return STATUS_SUCCESS;
  1331. }
  1332. #endif
  1333. static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1334. {
  1335. int retval = TRANSPORT_ERROR;
  1336. if (srb->cmnd[2] == MS_FORMAT)
  1337. retval = ms_format_cmnd(srb, chip);
  1338. #ifdef SUPPORT_PCGL_1P18
  1339. else if (srb->cmnd[2] == GET_MS_INFORMATION)
  1340. retval = get_ms_information(srb, chip);
  1341. #endif
  1342. return retval;
  1343. }
  1344. #ifdef SUPPORT_CPRM
  1345. static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1346. {
  1347. unsigned int lun = SCSI_LUN(srb);
  1348. int result;
  1349. rts51x_prepare_run(chip);
  1350. RTS51X_SET_STAT(chip, STAT_RUN);
  1351. rts51x_sd_cleanup_work(chip);
  1352. if (!check_card_ready(chip, lun)) {
  1353. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  1354. TRACE_RET(chip, TRANSPORT_FAILED);
  1355. }
  1356. if ((rts51x_get_lun_card(chip, lun) != SD_CARD)) {
  1357. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
  1358. TRACE_RET(chip, TRANSPORT_FAILED);
  1359. }
  1360. switch (srb->cmnd[0]) {
  1361. case SD_PASS_THRU_MODE:
  1362. result = rts51x_sd_pass_thru_mode(srb, chip);
  1363. break;
  1364. case SD_EXECUTE_NO_DATA:
  1365. result = rts51x_sd_execute_no_data(srb, chip);
  1366. break;
  1367. case SD_EXECUTE_READ:
  1368. result = rts51x_sd_execute_read_data(srb, chip);
  1369. break;
  1370. case SD_EXECUTE_WRITE:
  1371. result = rts51x_sd_execute_write_data(srb, chip);
  1372. break;
  1373. case SD_GET_RSP:
  1374. result = rts51x_sd_get_cmd_rsp(srb, chip);
  1375. break;
  1376. case SD_HW_RST:
  1377. result = rts51x_sd_hw_rst(srb, chip);
  1378. break;
  1379. default:
  1380. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1381. TRACE_RET(chip, TRANSPORT_FAILED);
  1382. }
  1383. return result;
  1384. }
  1385. #endif
  1386. #ifdef SUPPORT_MAGIC_GATE
  1387. static int mg_report_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1388. {
  1389. struct ms_info *ms_card = &(chip->ms_card);
  1390. unsigned int lun = SCSI_LUN(srb);
  1391. int retval;
  1392. u8 key_format;
  1393. rts51x_prepare_run(chip);
  1394. RTS51X_SET_STAT(chip, STAT_RUN);
  1395. rts51x_ms_cleanup_work(chip);
  1396. if (!check_card_ready(chip, lun)) {
  1397. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  1398. TRACE_RET(chip, TRANSPORT_FAILED);
  1399. }
  1400. if ((rts51x_get_lun_card(chip, lun) != MS_CARD)) {
  1401. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
  1402. TRACE_RET(chip, TRANSPORT_FAILED);
  1403. }
  1404. if (srb->cmnd[7] != KC_MG_R_PRO) {
  1405. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1406. TRACE_RET(chip, TRANSPORT_FAILED);
  1407. }
  1408. if (!CHK_MSPRO(ms_card)) {
  1409. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
  1410. TRACE_RET(chip, TRANSPORT_FAILED);
  1411. }
  1412. key_format = srb->cmnd[10] & 0x3F;
  1413. switch (key_format) {
  1414. case KF_GET_LOC_EKB:
  1415. if ((scsi_bufflen(srb) == 0x41C) &&
  1416. (srb->cmnd[8] == 0x04) && (srb->cmnd[9] == 0x1C)) {
  1417. retval = rts51x_mg_get_local_EKB(srb, chip);
  1418. if (retval != STATUS_SUCCESS)
  1419. TRACE_RET(chip, TRANSPORT_FAILED);
  1420. } else {
  1421. rts51x_set_sense_type(chip, lun,
  1422. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1423. TRACE_RET(chip, TRANSPORT_FAILED);
  1424. }
  1425. break;
  1426. case KF_RSP_CHG:
  1427. if ((scsi_bufflen(srb) == 0x24) &&
  1428. (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x24)) {
  1429. retval = rts51x_mg_get_rsp_chg(srb, chip);
  1430. if (retval != STATUS_SUCCESS)
  1431. TRACE_RET(chip, TRANSPORT_FAILED);
  1432. } else {
  1433. rts51x_set_sense_type(chip, lun,
  1434. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1435. TRACE_RET(chip, TRANSPORT_FAILED);
  1436. }
  1437. break;
  1438. case KF_GET_ICV:
  1439. ms_card->mg_entry_num = srb->cmnd[5];
  1440. if ((scsi_bufflen(srb) == 0x404) &&
  1441. (srb->cmnd[8] == 0x04) &&
  1442. (srb->cmnd[9] == 0x04) &&
  1443. (srb->cmnd[2] == 0x00) &&
  1444. (srb->cmnd[3] == 0x00) &&
  1445. (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
  1446. retval = rts51x_mg_get_ICV(srb, chip);
  1447. if (retval != STATUS_SUCCESS)
  1448. TRACE_RET(chip, TRANSPORT_FAILED);
  1449. } else {
  1450. rts51x_set_sense_type(chip, lun,
  1451. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1452. TRACE_RET(chip, TRANSPORT_FAILED);
  1453. }
  1454. break;
  1455. default:
  1456. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1457. TRACE_RET(chip, TRANSPORT_FAILED);
  1458. }
  1459. scsi_set_resid(srb, 0);
  1460. return TRANSPORT_GOOD;
  1461. }
  1462. static int mg_send_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1463. {
  1464. struct ms_info *ms_card = &(chip->ms_card);
  1465. unsigned int lun = SCSI_LUN(srb);
  1466. int retval;
  1467. u8 key_format;
  1468. rts51x_prepare_run(chip);
  1469. RTS51X_SET_STAT(chip, STAT_RUN);
  1470. rts51x_ms_cleanup_work(chip);
  1471. if (!check_card_ready(chip, lun)) {
  1472. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
  1473. TRACE_RET(chip, TRANSPORT_FAILED);
  1474. }
  1475. if (check_card_wp(chip, lun)) {
  1476. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
  1477. TRACE_RET(chip, TRANSPORT_FAILED);
  1478. }
  1479. if ((rts51x_get_lun_card(chip, lun) != MS_CARD)) {
  1480. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
  1481. TRACE_RET(chip, TRANSPORT_FAILED);
  1482. }
  1483. if (srb->cmnd[7] != KC_MG_R_PRO) {
  1484. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1485. TRACE_RET(chip, TRANSPORT_FAILED);
  1486. }
  1487. if (!CHK_MSPRO(ms_card)) {
  1488. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
  1489. TRACE_RET(chip, TRANSPORT_FAILED);
  1490. }
  1491. key_format = srb->cmnd[10] & 0x3F;
  1492. switch (key_format) {
  1493. case KF_SET_LEAF_ID:
  1494. if ((scsi_bufflen(srb) == 0x0C) &&
  1495. (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
  1496. retval = rts51x_mg_set_leaf_id(srb, chip);
  1497. if (retval != STATUS_SUCCESS)
  1498. TRACE_RET(chip, TRANSPORT_FAILED);
  1499. } else {
  1500. rts51x_set_sense_type(chip, lun,
  1501. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1502. TRACE_RET(chip, TRANSPORT_FAILED);
  1503. }
  1504. break;
  1505. case KF_CHG_HOST:
  1506. if ((scsi_bufflen(srb) == 0x0C) &&
  1507. (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
  1508. retval = rts51x_mg_chg(srb, chip);
  1509. if (retval != STATUS_SUCCESS)
  1510. TRACE_RET(chip, TRANSPORT_FAILED);
  1511. } else {
  1512. rts51x_set_sense_type(chip, lun,
  1513. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1514. TRACE_RET(chip, TRANSPORT_FAILED);
  1515. }
  1516. break;
  1517. case KF_RSP_HOST:
  1518. if ((scsi_bufflen(srb) == 0x0C) &&
  1519. (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
  1520. retval = rts51x_mg_rsp(srb, chip);
  1521. if (retval != STATUS_SUCCESS)
  1522. TRACE_RET(chip, TRANSPORT_FAILED);
  1523. } else {
  1524. rts51x_set_sense_type(chip, lun,
  1525. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1526. TRACE_RET(chip, TRANSPORT_FAILED);
  1527. }
  1528. break;
  1529. case KF_SET_ICV:
  1530. ms_card->mg_entry_num = srb->cmnd[5];
  1531. if ((scsi_bufflen(srb) == 0x404) &&
  1532. (srb->cmnd[8] == 0x04) &&
  1533. (srb->cmnd[9] == 0x04) &&
  1534. (srb->cmnd[2] == 0x00) &&
  1535. (srb->cmnd[3] == 0x00) &&
  1536. (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
  1537. retval = rts51x_mg_set_ICV(srb, chip);
  1538. if (retval != STATUS_SUCCESS)
  1539. TRACE_RET(chip, TRANSPORT_FAILED);
  1540. } else {
  1541. rts51x_set_sense_type(chip, lun,
  1542. SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1543. TRACE_RET(chip, TRANSPORT_FAILED);
  1544. }
  1545. break;
  1546. default:
  1547. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1548. TRACE_RET(chip, TRANSPORT_FAILED);
  1549. }
  1550. scsi_set_resid(srb, 0);
  1551. return TRANSPORT_GOOD;
  1552. }
  1553. #endif
  1554. int rts51x_scsi_handler(struct scsi_cmnd *srb, struct rts51x_chip *chip)
  1555. {
  1556. struct ms_info *ms_card = &(chip->ms_card);
  1557. unsigned int lun = SCSI_LUN(srb);
  1558. int result = TRANSPORT_GOOD;
  1559. if ((rts51x_get_lun_card(chip, lun) == MS_CARD) &&
  1560. (ms_card->format_status == FORMAT_IN_PROGRESS)) {
  1561. if ((srb->cmnd[0] != REQUEST_SENSE)
  1562. && (srb->cmnd[0] != INQUIRY)) {
  1563. /* Logical Unit Not Ready Format in Progress */
  1564. rts51x_set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
  1565. 0, (u16) (ms_card->progress));
  1566. TRACE_RET(chip, TRANSPORT_FAILED);
  1567. }
  1568. }
  1569. switch (srb->cmnd[0]) {
  1570. case READ_10:
  1571. case WRITE_10:
  1572. case READ_6:
  1573. case WRITE_6:
  1574. result = read_write(srb, chip);
  1575. break;
  1576. case TEST_UNIT_READY:
  1577. result = test_unit_ready(srb, chip);
  1578. break;
  1579. case INQUIRY:
  1580. result = inquiry(srb, chip);
  1581. break;
  1582. case READ_CAPACITY:
  1583. result = read_capacity(srb, chip);
  1584. break;
  1585. case START_STOP:
  1586. result = start_stop_unit(srb, chip);
  1587. break;
  1588. case ALLOW_MEDIUM_REMOVAL:
  1589. result = allow_medium_removal(srb, chip);
  1590. break;
  1591. case REQUEST_SENSE:
  1592. result = request_sense(srb, chip);
  1593. break;
  1594. case MODE_SENSE:
  1595. case MODE_SENSE_10:
  1596. result = mode_sense(srb, chip);
  1597. break;
  1598. case 0x23:
  1599. result = read_format_capacity(srb, chip);
  1600. break;
  1601. case VENDOR_CMND:
  1602. result = vendor_cmnd(srb, chip);
  1603. break;
  1604. case MS_SP_CMND:
  1605. result = ms_sp_cmnd(srb, chip);
  1606. break;
  1607. #ifdef SUPPORT_CPRM
  1608. case SD_PASS_THRU_MODE:
  1609. case SD_EXECUTE_NO_DATA:
  1610. case SD_EXECUTE_READ:
  1611. case SD_EXECUTE_WRITE:
  1612. case SD_GET_RSP:
  1613. case SD_HW_RST:
  1614. result = sd_extention_cmnd(srb, chip);
  1615. break;
  1616. #endif
  1617. #ifdef SUPPORT_MAGIC_GATE
  1618. case CMD_MSPRO_MG_RKEY:
  1619. result = mg_report_key(srb, chip);
  1620. break;
  1621. case CMD_MSPRO_MG_SKEY:
  1622. result = mg_send_key(srb, chip);
  1623. break;
  1624. #endif
  1625. case FORMAT_UNIT:
  1626. case MODE_SELECT:
  1627. case VERIFY:
  1628. result = TRANSPORT_GOOD;
  1629. break;
  1630. default:
  1631. rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
  1632. result = TRANSPORT_FAILED;
  1633. }
  1634. return result;
  1635. }
  1636. /***********************************************************************
  1637. * Host functions
  1638. ***********************************************************************/
  1639. int slave_alloc(struct scsi_device *sdev)
  1640. {
  1641. /*
  1642. * Set the INQUIRY transfer length to 36. We don't use any of
  1643. * the extra data and many devices choke if asked for more or
  1644. * less than 36 bytes.
  1645. */
  1646. sdev->inquiry_len = 36;
  1647. return 0;
  1648. }
  1649. int slave_configure(struct scsi_device *sdev)
  1650. {
  1651. /* Scatter-gather buffers (all but the last) must have a length
  1652. * divisible by the bulk maxpacket size. Otherwise a data packet
  1653. * would end up being short, causing a premature end to the data
  1654. * transfer. Since high-speed bulk pipes have a maxpacket size
  1655. * of 512, we'll use that as the scsi device queue's DMA alignment
  1656. * mask. Guaranteeing proper alignment of the first buffer will
  1657. * have the desired effect because, except at the beginning and
  1658. * the end, scatter-gather buffers follow page boundaries. */
  1659. blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
  1660. /* Set the SCSI level to at least 2. We'll leave it at 3 if that's
  1661. * what is originally reported. We need this to avoid confusing
  1662. * the SCSI layer with devices that report 0 or 1, but need 10-byte
  1663. * commands (ala ATAPI devices behind certain bridges, or devices
  1664. * which simply have broken INQUIRY data).
  1665. *
  1666. * NOTE: This means /dev/sg programs (ala cdrecord) will get the
  1667. * actual information. This seems to be the preference for
  1668. * programs like that.
  1669. *
  1670. * NOTE: This also means that /proc/scsi/scsi and sysfs may report
  1671. * the actual value or the modified one, depending on where the
  1672. * data comes from.
  1673. */
  1674. if (sdev->scsi_level < SCSI_2)
  1675. sdev->scsi_level = sdev->sdev_target->scsi_level = SCSI_2;
  1676. return 0;
  1677. }
  1678. /***********************************************************************
  1679. * /proc/scsi/ functions
  1680. ***********************************************************************/
  1681. /* we use this macro to help us write into the buffer */
  1682. #undef SPRINTF
  1683. #define SPRINTF(args...) \
  1684. do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
  1685. int proc_info(struct Scsi_Host *host, char *buffer,
  1686. char **start, off_t offset, int length, int inout)
  1687. {
  1688. char *pos = buffer;
  1689. /* if someone is sending us data, just throw it away */
  1690. if (inout)
  1691. return length;
  1692. /* print the controller name */
  1693. SPRINTF(" Host scsi%d: %s\n", host->host_no, RTS51X_NAME);
  1694. /* print product, vendor, and driver version strings */
  1695. SPRINTF(" Vendor: Realtek Corp.\n");
  1696. SPRINTF(" Product: RTS51xx USB Card Reader\n");
  1697. SPRINTF(" Version: %s\n", DRIVER_VERSION);
  1698. SPRINTF(" Build: %s\n", __TIME__);
  1699. /*
  1700. * Calculate start of next buffer, and return value.
  1701. */
  1702. *start = buffer + offset;
  1703. if ((pos - buffer) < offset)
  1704. return 0;
  1705. else if ((pos - buffer - offset) < length)
  1706. return pos - buffer - offset;
  1707. else
  1708. return length;
  1709. }
  1710. /* queue a command */
  1711. /* This is always called with scsi_lock(host) held */
  1712. int queuecommand_lck(struct scsi_cmnd *srb, void (*done) (struct scsi_cmnd *))
  1713. {
  1714. struct rts51x_chip *chip = host_to_rts51x(srb->device->host);
  1715. /* check for state-transition errors */
  1716. if (chip->srb != NULL) {
  1717. RTS51X_DEBUGP("Error in %s: chip->srb = %p\n",
  1718. __func__, chip->srb);
  1719. return SCSI_MLQUEUE_HOST_BUSY;
  1720. }
  1721. /* fail the command if we are disconnecting */
  1722. if (test_bit(FLIDX_DISCONNECTING, &chip->usb->dflags)) {
  1723. RTS51X_DEBUGP("Fail command during disconnect\n");
  1724. srb->result = DID_NO_CONNECT << 16;
  1725. done(srb);
  1726. return 0;
  1727. }
  1728. /* enqueue the command and wake up the control thread */
  1729. srb->scsi_done = done;
  1730. chip->srb = srb;
  1731. complete(&chip->usb->cmnd_ready);
  1732. return 0;
  1733. }
  1734. DEF_SCSI_QCMD(queuecommand)
  1735. /***********************************************************************
  1736. * Error handling functions
  1737. ***********************************************************************/
  1738. /* Command timeout and abort */
  1739. int command_abort(

Large files files are truncated, but you can click here to view the full file