1	// SPDX-License-Identifier: GPL-2.0+
2	/*
3	* Driver for Realtek PCI-Express card reader
4	*
5	* Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
6	*
7	* Author:
8	* Wei WANG (wei_wang@realsil.com.cn)
9	* Micky Ching (micky_ching@realsil.com.cn)
10	*/
11
12	#include <linux/blkdev.h>
13	#include <linux/kthread.h>
14	#include <linux/sched.h>
15	#include <linux/vmalloc.h>
16
17	#include "rtsx.h"
18	#include "sd.h"
19	#include "ms.h"
20	#include "spi.h"
21
22	void scsi_show_command(struct rtsx_chip *chip)
23	{
24	struct scsi_cmnd *srb = chip->srb;
25	char *what = NULL;
26	bool unknown_cmd = false;
27	int len;
28
29	switch (srb->cmnd[0]) {
30	case TEST_UNIT_READY:
31	what = "TEST_UNIT_READY";
32	break;
33	case REZERO_UNIT:
34	what = "REZERO_UNIT";
35	break;
36	case REQUEST_SENSE:
37	what = "REQUEST_SENSE";
38	break;
39	case FORMAT_UNIT:
40	what = "FORMAT_UNIT";
41	break;
42	case READ_BLOCK_LIMITS:
43	what = "READ_BLOCK_LIMITS";
44	break;
45	case REASSIGN_BLOCKS:
46	what = "REASSIGN_BLOCKS";
47	break;
48	case READ_6:
49	what = "READ_6";
50	break;
51	case WRITE_6:
52	what = "WRITE_6";
53	break;
54	case SEEK_6:
55	what = "SEEK_6";
56	break;
57	case READ_REVERSE:
58	what = "READ_REVERSE";
59	break;
60	case WRITE_FILEMARKS:
61	what = "WRITE_FILEMARKS";
62	break;
63	case SPACE:
64	what = "SPACE";
65	break;
66	case INQUIRY:
67	what = "INQUIRY";
68	break;
69	case RECOVER_BUFFERED_DATA:
70	what = "RECOVER_BUFFERED_DATA";
71	break;
72	case MODE_SELECT:
73	what = "MODE_SELECT";
74	break;
75	case RESERVE:
76	what = "RESERVE";
77	break;
78	case RELEASE:
79	what = "RELEASE";
80	break;
81	case COPY:
82	what = "COPY";
83	break;
84	case ERASE:
85	what = "ERASE";
86	break;
87	case MODE_SENSE:
88	what = "MODE_SENSE";
89	break;
90	case START_STOP:
91	what = "START_STOP";
92	break;
93	case RECEIVE_DIAGNOSTIC:
94	what = "RECEIVE_DIAGNOSTIC";
95	break;
96	case SEND_DIAGNOSTIC:
97	what = "SEND_DIAGNOSTIC";
98	break;
99	case ALLOW_MEDIUM_REMOVAL:
100	what = "ALLOW_MEDIUM_REMOVAL";
101	break;
102	case SET_WINDOW:
103	what = "SET_WINDOW";
104	break;
105	case READ_CAPACITY:
106	what = "READ_CAPACITY";
107	break;
108	case READ_10:
109	what = "READ_10";
110	break;
111	case WRITE_10:
112	what = "WRITE_10";
113	break;
114	case SEEK_10:
115	what = "SEEK_10";
116	break;
117	case WRITE_VERIFY:
118	what = "WRITE_VERIFY";
119	break;
120	case VERIFY:
121	what = "VERIFY";
122	break;
123	case SEARCH_HIGH:
124	what = "SEARCH_HIGH";
125	break;
126	case SEARCH_EQUAL:
127	what = "SEARCH_EQUAL";
128	break;
129	case SEARCH_LOW:
130	what = "SEARCH_LOW";
131	break;
132	case SET_LIMITS:
133	what = "SET_LIMITS";
134	break;
135	case READ_POSITION:
136	what = "READ_POSITION";
137	break;
138	case SYNCHRONIZE_CACHE:
139	what = "SYNCHRONIZE_CACHE";
140	break;
141	case LOCK_UNLOCK_CACHE:
142	what = "LOCK_UNLOCK_CACHE";
143	break;
144	case READ_DEFECT_DATA:
145	what = "READ_DEFECT_DATA";
146	break;
147	case MEDIUM_SCAN:
148	what = "MEDIUM_SCAN";
149	break;
150	case COMPARE:
151	what = "COMPARE";
152	break;
153	case COPY_VERIFY:
154	what = "COPY_VERIFY";
155	break;
156	case WRITE_BUFFER:
157	what = "WRITE_BUFFER";
158	break;
159	case READ_BUFFER:
160	what = "READ_BUFFER";
161	break;
162	case UPDATE_BLOCK:
163	what = "UPDATE_BLOCK";
164	break;
165	case READ_LONG:
166	what = "READ_LONG";
167	break;
168	case WRITE_LONG:
169	what = "WRITE_LONG";
170	break;
171	case CHANGE_DEFINITION:
172	what = "CHANGE_DEFINITION";
173	break;
174	case WRITE_SAME:
175	what = "WRITE_SAME";
176	break;
177	case GPCMD_READ_SUBCHANNEL:
178	what = "READ SUBCHANNEL";
179	break;
180	case READ_TOC:
181	what = "READ_TOC";
182	break;
183	case GPCMD_READ_HEADER:
184	what = "READ HEADER";
185	break;
186	case GPCMD_PLAY_AUDIO_10:
187	what = "PLAY AUDIO (10)";
188	break;
189	case GPCMD_PLAY_AUDIO_MSF:
190	what = "PLAY AUDIO MSF";
191	break;
192	case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
193	what = "GET EVENT/STATUS NOTIFICATION";
194	break;
195	case GPCMD_PAUSE_RESUME:
196	what = "PAUSE/RESUME";
197	break;
198	case LOG_SELECT:
199	what = "LOG_SELECT";
200	break;
201	case LOG_SENSE:
202	what = "LOG_SENSE";
203	break;
204	case GPCMD_STOP_PLAY_SCAN:
205	what = "STOP PLAY/SCAN";
206	break;
207	case GPCMD_READ_DISC_INFO:
208	what = "READ DISC INFORMATION";
209	break;
210	case GPCMD_READ_TRACK_RZONE_INFO:
211	what = "READ TRACK INFORMATION";
212	break;
213	case GPCMD_RESERVE_RZONE_TRACK:
214	what = "RESERVE TRACK";
215	break;
216	case GPCMD_SEND_OPC:
217	what = "SEND OPC";
218	break;
219	case MODE_SELECT_10:
220	what = "MODE_SELECT_10";
221	break;
222	case GPCMD_REPAIR_RZONE_TRACK:
223	what = "REPAIR TRACK";
224	break;
225	case 0x59:
226	what = "READ MASTER CUE";
227	break;
228	case MODE_SENSE_10:
229	what = "MODE_SENSE_10";
230	break;
231	case GPCMD_CLOSE_TRACK:
232	what = "CLOSE TRACK/SESSION";
233	break;
234	case 0x5C:
235	what = "READ BUFFER CAPACITY";
236	break;
237	case 0x5D:
238	what = "SEND CUE SHEET";
239	break;
240	case GPCMD_BLANK:
241	what = "BLANK";
242	break;
243	case REPORT_LUNS:
244	what = "REPORT LUNS";
245	break;
246	case MOVE_MEDIUM:
247	what = "MOVE_MEDIUM or PLAY AUDIO (12)";
248	break;
249	case READ_12:
250	what = "READ_12";
251	break;
252	case WRITE_12:
253	what = "WRITE_12";
254	break;
255	case WRITE_VERIFY_12:
256	what = "WRITE_VERIFY_12";
257	break;
258	case SEARCH_HIGH_12:
259	what = "SEARCH_HIGH_12";
260	break;
261	case SEARCH_EQUAL_12:
262	what = "SEARCH_EQUAL_12";
263	break;
264	case SEARCH_LOW_12:
265	what = "SEARCH_LOW_12";
266	break;
267	case SEND_VOLUME_TAG:
268	what = "SEND_VOLUME_TAG";
269	break;
270	case READ_ELEMENT_STATUS:
271	what = "READ_ELEMENT_STATUS";
272	break;
273	case GPCMD_READ_CD_MSF:
274	what = "READ CD MSF";
275	break;
276	case GPCMD_SCAN:
277	what = "SCAN";
278	break;
279	case GPCMD_SET_SPEED:
280	what = "SET CD SPEED";
281	break;
282	case GPCMD_MECHANISM_STATUS:
283	what = "MECHANISM STATUS";
284	break;
285	case GPCMD_READ_CD:
286	what = "READ CD";
287	break;
288	case 0xE1:
289	what = "WRITE CONTINUE";
290	break;
291	case WRITE_LONG_2:
292	what = "WRITE_LONG_2";
293	break;
294	case VENDOR_CMND:
295	what = "Realtek's vendor command";
296	break;
297	default:
298	what = "(unknown command)";
299	unknown_cmd = true;
300	break;
301	}
302
303	if (srb->cmnd[0] != TEST_UNIT_READY)
304	dev_dbg(rtsx_dev(chip), "Command %s (%d bytes)\n",
305	what, srb->cmd_len);
306
307	if (unknown_cmd) {
308	len = min_t(unsigned short, srb->cmd_len, 16);
309	dev_dbg(rtsx_dev(chip), "%*ph\n", len, srb->cmnd);
310	}
311	}
312
313	void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
314	{
315	switch (sense_type) {
316	case SENSE_TYPE_MEDIA_CHANGE:
317	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x06, info: 0, asc: 0x28, ascq: 0, sns_key_info0: 0, sns_key_info1: 0);
318	break;
319
320	case SENSE_TYPE_MEDIA_NOT_PRESENT:
321	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x02, info: 0, asc: 0x3A, ascq: 0, sns_key_info0: 0, sns_key_info1: 0);
322	break;
323
324	case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
325	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x05, info: 0, asc: 0x21, ascq: 0, sns_key_info0: 0, sns_key_info1: 0);
326	break;
327
328	case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
329	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x05, info: 0, asc: 0x25, ascq: 0, sns_key_info0: 0, sns_key_info1: 0);
330	break;
331
332	case SENSE_TYPE_MEDIA_WRITE_PROTECT:
333	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x07, info: 0, asc: 0x27, ascq: 0, sns_key_info0: 0, sns_key_info1: 0);
334	break;
335
336	case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
337	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x03, info: 0, asc: 0x11, ascq: 0, sns_key_info0: 0, sns_key_info1: 0);
338	break;
339
340	case SENSE_TYPE_MEDIA_WRITE_ERR:
341	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x03, info: 0, asc: 0x0C, ascq: 0x02, sns_key_info0: 0, sns_key_info1: 0);
342	break;
343
344	case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
345	set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, info: 0,
346	ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, sns_key_info1: 1);
347	break;
348
349	case SENSE_TYPE_FORMAT_IN_PROGRESS:
350	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x02, info: 0, asc: 0x04, ascq: 0x04, sns_key_info0: 0, sns_key_info1: 0);
351	break;
352
353	case SENSE_TYPE_FORMAT_CMD_FAILED:
354	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x03, info: 0, asc: 0x31, ascq: 0x01, sns_key_info0: 0, sns_key_info1: 0);
355	break;
356
357	#ifdef SUPPORT_MAGIC_GATE
358	case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
359	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x05, info: 0, asc: 0x6F, ascq: 0x02, sns_key_info0: 0, sns_key_info1: 0);
360	break;
361
362	case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
363	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x05, info: 0, asc: 0x6F, ascq: 0x00, sns_key_info0: 0, sns_key_info1: 0);
364	break;
365
366	case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
367	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x02, info: 0, asc: 0x30, ascq: 0x00, sns_key_info0: 0, sns_key_info1: 0);
368	break;
369
370	case SENSE_TYPE_MG_WRITE_ERR:
371	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x03, info: 0, asc: 0x0C, ascq: 0x00, sns_key_info0: 0, sns_key_info1: 0);
372	break;
373	#endif
374
375	#ifdef SUPPORT_SD_LOCK
376	case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
377	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x07, info: 0, asc: 0x11, ascq: 0x13, sns_key_info0: 0, sns_key_info1: 0);
378	break;
379	#endif
380
381	case SENSE_TYPE_NO_SENSE:
382	default:
383	set_sense_data(chip, lun, CUR_ERR, sense_key: 0, info: 0, asc: 0, ascq: 0, sns_key_info0: 0, sns_key_info1: 0);
384	break;
385	}
386	}
387
388	void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code,
389	u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
390	u16 sns_key_info1)
391	{
392	struct sense_data_t *sense = &chip->sense_buffer[lun];
393
394	sense->err_code = err_code;
395	sense->sense_key = sense_key;
396	sense->info[0] = (u8)(info >> 24);
397	sense->info[1] = (u8)(info >> 16);
398	sense->info[2] = (u8)(info >> 8);
399	sense->info[3] = (u8)info;
400
401	sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
402	sense->asc = asc;
403	sense->ascq = ascq;
404	if (sns_key_info0 != 0) {
405	sense->sns_key_info[0] = SKSV | sns_key_info0;
406	sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 4;
407	sense->sns_key_info[2] = sns_key_info1 & 0x0f;
408	}
409	}
410
411	static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
412	{
413	unsigned int lun = SCSI_LUN(srb);
414
415	if (!check_card_ready(chip, lun)) {
416	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
417	return TRANSPORT_FAILED;
418	}
419
420	if (!(CHK_BIT(chip->lun_mc, lun))) {
421	SET_BIT(chip->lun_mc, lun);
422	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
423	return TRANSPORT_FAILED;
424	}
425
426	#ifdef SUPPORT_SD_LOCK
427	if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
428	struct sd_info *sd_card = &chip->sd_card;
429
430	if (sd_card->sd_lock_notify) {
431	sd_card->sd_lock_notify = 0;
432	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
433	return TRANSPORT_FAILED;
434	} else if (sd_card->sd_lock_status & SD_LOCKED) {
435	set_sense_type(chip, lun,
436	SENSE_TYPE_MEDIA_READ_FORBIDDEN);
437	return TRANSPORT_FAILED;
438	}
439	}
440	#endif
441
442	return TRANSPORT_GOOD;
443	}
444
445	static unsigned char formatter_inquiry_str[20] = {
446	'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
447	#ifdef SUPPORT_MAGIC_GATE
448	'-', 'M', 'G', /* Byte[47:49] */
449	#else
450	0x20, 0x20, 0x20, /* Byte[47:49] */
451	#endif
452
453	#ifdef SUPPORT_MAGIC_GATE
454	0x0B, /* Byte[50]: MG, MS, MSPro, MSXC */
455	#else
456	0x09, /* Byte[50]: MS, MSPro, MSXC */
457	#endif
458	0x00, /* Byte[51]: Category Specific Commands */
459	0x00, /* Byte[52]: Access Control and feature */
460	0x20, 0x20, 0x20, /* Byte[53:55] */
461	};
462
463	static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
464	{
465	unsigned int lun = SCSI_LUN(srb);
466	char *inquiry_default = (char *)"Generic-xD/SD/M.S. 1.00 ";
467	char *inquiry_sdms = (char *)"Generic-SD/MemoryStick 1.00 ";
468	char *inquiry_sd = (char *)"Generic-SD/MMC 1.00 ";
469	char *inquiry_ms = (char *)"Generic-MemoryStick 1.00 ";
470	char *inquiry_string;
471	unsigned char sendbytes;
472	unsigned char *buf;
473	u8 card = get_lun_card(chip, lun);
474	bool pro_formatter_flag = false;
475	unsigned char inquiry_buf[] = {
476	QULIFIRE | DRCT_ACCESS_DEV,
477	RMB_DISC | 0x0D,
478	0x00,
479	0x01,
480	0x1f,
481	0x02,
482	0,
483	REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE,
484	};
485
486	if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
487	if (chip->lun2card[lun] == SD_CARD)
488	inquiry_string = inquiry_sd;
489	else
490	inquiry_string = inquiry_ms;
491
492	} else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
493	inquiry_string = inquiry_sdms;
494	} else {
495	inquiry_string = inquiry_default;
496	}
497
498	buf = vmalloc(size: scsi_bufflen(cmd: srb));
499	if (!buf)
500	return TRANSPORT_ERROR;
501
502	#ifdef SUPPORT_MAGIC_GATE
503	if (chip->mspro_formatter_enable &&
504	(chip->lun2card[lun] & MS_CARD))
505	#else
506	if (chip->mspro_formatter_enable)
507	#endif
508	if (!card || card == MS_CARD)
509	pro_formatter_flag = true;
510
511	if (pro_formatter_flag) {
512	if (scsi_bufflen(cmd: srb) < 56)
513	sendbytes = (unsigned char)(scsi_bufflen(cmd: srb));
514	else
515	sendbytes = 56;
516
517	} else {
518	if (scsi_bufflen(cmd: srb) < 36)
519	sendbytes = (unsigned char)(scsi_bufflen(cmd: srb));
520	else
521	sendbytes = 36;
522	}
523
524	if (sendbytes > 8) {
525	memcpy(buf, inquiry_buf, 8);
526	strncpy(p: buf + 8, q: inquiry_string, size: sendbytes - 8);
527	if (pro_formatter_flag) {
528	/* Additional Length */
529	buf[4] = 0x33;
530	}
531	} else {
532	memcpy(buf, inquiry_buf, sendbytes);
533	}
534
535	if (pro_formatter_flag) {
536	if (sendbytes > 36)
537	memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
538	}
539
540	scsi_set_resid(cmd: srb, resid: 0);
541
542	rtsx_stor_set_xfer_buf(buffer: buf, buflen: scsi_bufflen(cmd: srb), srb);
543	vfree(addr: buf);
544
545	return TRANSPORT_GOOD;
546	}
547
548	static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
549	{
550	unsigned int lun = SCSI_LUN(srb);
551
552	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb));
553
554	if (srb->cmnd[1] == 1)
555	return TRANSPORT_GOOD;
556
557	switch (srb->cmnd[0x4]) {
558	case STOP_MEDIUM:
559	/* Media disabled */
560	return TRANSPORT_GOOD;
561
562	case UNLOAD_MEDIUM:
563	/* Media shall be unload */
564	if (check_card_ready(chip, lun))
565	eject_card(chip, lun);
566	return TRANSPORT_GOOD;
567
568	case MAKE_MEDIUM_READY:
569	case LOAD_MEDIUM:
570	if (check_card_ready(chip, lun))
571	return TRANSPORT_GOOD;
572	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
573	return TRANSPORT_FAILED;
574
575	break;
576	}
577
578	return TRANSPORT_ERROR;
579	}
580
581	static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
582	{
583	int prevent;
584
585	prevent = srb->cmnd[4] & 0x1;
586
587	scsi_set_resid(cmd: srb, resid: 0);
588
589	if (prevent) {
590	set_sense_type(chip, SCSI_LUN(srb),
591	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
592	return TRANSPORT_FAILED;
593	}
594
595	return TRANSPORT_GOOD;
596	}
597
598	static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
599	{
600	struct sense_data_t *sense;
601	unsigned int lun = SCSI_LUN(srb);
602	struct ms_info *ms_card = &chip->ms_card;
603	unsigned char *tmp, *buf;
604
605	sense = &chip->sense_buffer[lun];
606
607	if ((get_lun_card(chip, lun) == MS_CARD) &&
608	ms_card->pro_under_formatting) {
609	if (ms_card->format_status == FORMAT_SUCCESS) {
610	set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
611	ms_card->pro_under_formatting = 0;
612	ms_card->progress = 0;
613	} else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
614	/* Logical Unit Not Ready Format in Progress */
615	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x02, info: 0, asc: 0x04, ascq: 0x04,
616	sns_key_info0: 0, sns_key_info1: (u16)(ms_card->progress));
617	} else {
618	/* Format Command Failed */
619	set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
620	ms_card->pro_under_formatting = 0;
621	ms_card->progress = 0;
622	}
623
624	rtsx_set_stat(chip, RTSX_STAT_RUN);
625	}
626
627	buf = vmalloc(size: scsi_bufflen(cmd: srb));
628	if (!buf)
629	return TRANSPORT_ERROR;
630
631	tmp = (unsigned char *)sense;
632	memcpy(buf, tmp, scsi_bufflen(srb));
633
634	rtsx_stor_set_xfer_buf(buffer: buf, buflen: scsi_bufflen(cmd: srb), srb);
635	vfree(addr: buf);
636
637	scsi_set_resid(cmd: srb, resid: 0);
638	/* Reset Sense Data */
639	set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
640	return TRANSPORT_GOOD;
641	}
642
643	static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
644	int lun, u8 *buf, int buf_len)
645	{
646	struct ms_info *ms_card = &chip->ms_card;
647	int sys_info_offset;
648	int data_size = buf_len;
649	bool support_format = false;
650	int i = 0;
651
652	if (cmd == MODE_SENSE) {
653	sys_info_offset = 8;
654	if (data_size > 0x68)
655	data_size = 0x68;
656
657	buf[i++] = 0x67; /* Mode Data Length */
658	} else {
659	sys_info_offset = 12;
660	if (data_size > 0x6C)
661	data_size = 0x6C;
662
663	buf[i++] = 0x00; /* Mode Data Length (MSB) */
664	buf[i++] = 0x6A; /* Mode Data Length (LSB) */
665	}
666
667	/* Medium Type Code */
668	if (check_card_ready(chip, lun)) {
669	if (CHK_MSXC(ms_card)) {
670	support_format = true;
671	buf[i++] = 0x40;
672	} else if (CHK_MSPRO(ms_card)) {
673	support_format = true;
674	buf[i++] = 0x20;
675	} else {
676	buf[i++] = 0x10;
677	}
678
679	/* WP */
680	if (check_card_wp(chip, lun))
681	buf[i++] = 0x80;
682	else
683	buf[i++] = 0x00;
684
685	} else {
686	buf[i++] = 0x00; /* MediaType */
687	buf[i++] = 0x00; /* WP */
688	}
689
690	buf[i++] = 0x00; /* Reserved */
691
692	if (cmd == MODE_SENSE_10) {
693	buf[i++] = 0x00; /* Reserved */
694	buf[i++] = 0x00; /* Block descriptor length(MSB) */
695	buf[i++] = 0x00; /* Block descriptor length(LSB) */
696
697	/* The Following Data is the content of "Page 0x20" */
698	if (data_size >= 9)
699	buf[i++] = 0x20; /* Page Code */
700	if (data_size >= 10)
701	buf[i++] = 0x62; /* Page Length */
702	if (data_size >= 11)
703	buf[i++] = 0x00; /* No Access Control */
704	if (data_size >= 12) {
705	if (support_format)
706	buf[i++] = 0xC0; /* SF, SGM */
707	else
708	buf[i++] = 0x00;
709	}
710	} else {
711	/* The Following Data is the content of "Page 0x20" */
712	if (data_size >= 5)
713	buf[i++] = 0x20; /* Page Code */
714	if (data_size >= 6)
715	buf[i++] = 0x62; /* Page Length */
716	if (data_size >= 7)
717	buf[i++] = 0x00; /* No Access Control */
718	if (data_size >= 8) {
719	if (support_format)
720	buf[i++] = 0xC0; /* SF, SGM */
721	else
722	buf[i++] = 0x00;
723	}
724	}
725
726	if (data_size > sys_info_offset) {
727	/* 96 Bytes Attribute Data */
728	int len = data_size - sys_info_offset;
729
730	len = (len < 96) ? len : 96;
731
732	memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
733	}
734	}
735
736	static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
737	{
738	unsigned int lun = SCSI_LUN(srb);
739	unsigned int data_size;
740	int status;
741	bool pro_formatter_flag;
742	unsigned char page_code, *buf;
743	u8 card = get_lun_card(chip, lun);
744
745	#ifndef SUPPORT_MAGIC_GATE
746	if (!check_card_ready(chip, lun)) {
747	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
748	scsi_set_resid(srb, scsi_bufflen(srb));
749	return TRANSPORT_FAILED;
750	}
751	#endif
752
753	pro_formatter_flag = false;
754	data_size = 8;
755	#ifdef SUPPORT_MAGIC_GATE
756	if ((chip->lun2card[lun] & MS_CARD)) {
757	if (!card || card == MS_CARD) {
758	data_size = 108;
759	if (chip->mspro_formatter_enable)
760	pro_formatter_flag = true;
761	}
762	}
763	#else
764	if (card == MS_CARD) {
765	if (chip->mspro_formatter_enable) {
766	pro_formatter_flag = true;
767	data_size = 108;
768	}
769	}
770	#endif
771
772	buf = kmalloc(size: data_size, GFP_KERNEL);
773	if (!buf)
774	return TRANSPORT_ERROR;
775
776	page_code = srb->cmnd[2] & 0x3f;
777
778	if (page_code == 0x3F || page_code == 0x1C ||
779	page_code == 0x00 ||
780	(pro_formatter_flag && page_code == 0x20)) {
781	if (srb->cmnd[0] == MODE_SENSE) {
782	if (page_code == 0x3F || page_code == 0x20) {
783	ms_mode_sense(chip, cmd: srb->cmnd[0],
784	lun, buf, buf_len: data_size);
785	} else {
786	data_size = 4;
787	buf[0] = 0x03;
788	buf[1] = 0x00;
789	if (check_card_wp(chip, lun))
790	buf[2] = 0x80;
791	else
792	buf[2] = 0x00;
793
794	buf[3] = 0x00;
795	}
796	} else {
797	if (page_code == 0x3F || page_code == 0x20) {
798	ms_mode_sense(chip, cmd: srb->cmnd[0],
799	lun, buf, buf_len: data_size);
800	} else {
801	data_size = 8;
802	buf[0] = 0x00;
803	buf[1] = 0x06;
804	buf[2] = 0x00;
805	if (check_card_wp(chip, lun))
806	buf[3] = 0x80;
807	else
808	buf[3] = 0x00;
809	buf[4] = 0x00;
810	buf[5] = 0x00;
811	buf[6] = 0x00;
812	buf[7] = 0x00;
813	}
814	}
815	status = TRANSPORT_GOOD;
816	} else {
817	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
818	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb));
819	status = TRANSPORT_FAILED;
820	}
821
822	if (status == TRANSPORT_GOOD) {
823	unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
824	data_size);
825	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
826	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
827	}
828	kfree(objp: buf);
829
830	return status;
831	}
832
833	static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
834	{
835	#ifdef SUPPORT_SD_LOCK
836	struct sd_info *sd_card = &chip->sd_card;
837	#endif
838	unsigned int lun = SCSI_LUN(srb);
839	int retval;
840	u32 start_sec;
841	u16 sec_cnt;
842
843	rtsx_disable_aspm(chip);
844
845	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
846	rtsx_exit_ss(chip);
847	wait_timeout(100);
848	}
849	rtsx_set_stat(chip, RTSX_STAT_RUN);
850
851	if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
852	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
853	return TRANSPORT_FAILED;
854	}
855
856	if (!(CHK_BIT(chip->lun_mc, lun))) {
857	SET_BIT(chip->lun_mc, lun);
858	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
859	return TRANSPORT_FAILED;
860	}
861
862	#ifdef SUPPORT_SD_LOCK
863	if (sd_card->sd_erase_status) {
864	/* Accessing to any card is forbidden
865	* until the erase procedure of SD is completed
866	*/
867	dev_dbg(rtsx_dev(chip), "SD card being erased!\n");
868	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
869	return TRANSPORT_FAILED;
870	}
871
872	if (get_lun_card(chip, lun) == SD_CARD) {
873	if (sd_card->sd_lock_status & SD_LOCKED) {
874	dev_dbg(rtsx_dev(chip), "SD card locked!\n");
875	set_sense_type(chip, lun,
876	SENSE_TYPE_MEDIA_READ_FORBIDDEN);
877	return TRANSPORT_FAILED;
878	}
879	}
880	#endif
881
882	if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10) {
883	start_sec = ((u32)srb->cmnd[2] << 24) |
884	((u32)srb->cmnd[3] << 16) |
885	((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
886	sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
887	} else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
888	start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
889	((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
890	sec_cnt = srb->cmnd[4];
891	if (sec_cnt == 0)
892	sec_cnt = 256;
893	} else if ((srb->cmnd[0] == VENDOR_CMND) &&
894	(srb->cmnd[1] == SCSI_APP_CMD) &&
895	((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
896	start_sec = ((u32)srb->cmnd[4] << 24) |
897	((u32)srb->cmnd[5] << 16) |
898	((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
899	sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
900	} else {
901	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
902	return TRANSPORT_FAILED;
903	}
904
905	/* In some test, we will receive a start_sec like 0xFFFFFFFF.
906	* In this situation, start_sec + sec_cnt will overflow, so we
907	* need to judge start_sec at first
908	*/
909	if (start_sec > get_card_size(chip, lun) ||
910	((start_sec + sec_cnt) > get_card_size(chip, lun))) {
911	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
912	return TRANSPORT_FAILED;
913	}
914
915	if (sec_cnt == 0) {
916	scsi_set_resid(cmd: srb, resid: 0);
917	return TRANSPORT_GOOD;
918	}
919
920	if (chip->rw_fail_cnt[lun] == 3) {
921	dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
922	if (srb->sc_data_direction == DMA_FROM_DEVICE)
923	set_sense_type(chip, lun,
924	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
925	else
926	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
927
928	return TRANSPORT_FAILED;
929	}
930
931	if (srb->sc_data_direction == DMA_TO_DEVICE) {
932	if (check_card_wp(chip, lun)) {
933	dev_dbg(rtsx_dev(chip), "Write protected card!\n");
934	set_sense_type(chip, lun,
935	SENSE_TYPE_MEDIA_WRITE_PROTECT);
936	return TRANSPORT_FAILED;
937	}
938	}
939
940	retval = card_rw(srb, chip, sec_addr: start_sec, sec_cnt);
941	if (retval != STATUS_SUCCESS) {
942	if (chip->need_release & chip->lun2card[lun]) {
943	chip->rw_fail_cnt[lun] = 0;
944	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
945	} else {
946	chip->rw_fail_cnt[lun]++;
947	if (srb->sc_data_direction == DMA_FROM_DEVICE)
948	set_sense_type
949	(chip, lun,
950	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
951	else
952	set_sense_type(chip, lun,
953	SENSE_TYPE_MEDIA_WRITE_ERR);
954	}
955	retval = TRANSPORT_FAILED;
956	goto exit;
957	} else {
958	chip->rw_fail_cnt[lun] = 0;
959	retval = TRANSPORT_GOOD;
960	}
961
962	scsi_set_resid(cmd: srb, resid: 0);
963
964	exit:
965	return retval;
966	}
967
968	static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
969	{
970	unsigned char *buf;
971	unsigned int lun = SCSI_LUN(srb);
972	unsigned int buf_len;
973	u8 card = get_lun_card(chip, lun);
974	u32 card_size;
975	int desc_cnt;
976	int i = 0;
977
978	if (!check_card_ready(chip, lun)) {
979	if (!chip->mspro_formatter_enable) {
980	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
981	return TRANSPORT_FAILED;
982	}
983	}
984
985	buf_len = (scsi_bufflen(cmd: srb) > 12) ? 0x14 : 12;
986
987	buf = kmalloc(size: buf_len, GFP_KERNEL);
988	if (!buf)
989	return TRANSPORT_ERROR;
990
991	buf[i++] = 0;
992	buf[i++] = 0;
993	buf[i++] = 0;
994
995	/* Capacity List Length */
996	if (buf_len > 12 && chip->mspro_formatter_enable &&
997	(chip->lun2card[lun] & MS_CARD) &&
998	(!card || card == MS_CARD)) {
999	buf[i++] = 0x10;
1000	desc_cnt = 2;
1001	} else {
1002	buf[i++] = 0x08;
1003	desc_cnt = 1;
1004	}
1005
1006	while (desc_cnt) {
1007	if (check_card_ready(chip, lun)) {
1008	card_size = get_card_size(chip, lun);
1009	buf[i++] = (unsigned char)(card_size >> 24);
1010	buf[i++] = (unsigned char)(card_size >> 16);
1011	buf[i++] = (unsigned char)(card_size >> 8);
1012	buf[i++] = (unsigned char)card_size;
1013
1014	if (desc_cnt == 2)
1015	buf[i++] = 2;
1016	else
1017	buf[i++] = 0;
1018	} else {
1019	buf[i++] = 0xFF;
1020	buf[i++] = 0xFF;
1021	buf[i++] = 0xFF;
1022	buf[i++] = 0xFF;
1023
1024	if (desc_cnt == 2)
1025	buf[i++] = 3;
1026	else
1027	buf[i++] = 0;
1028	}
1029
1030	buf[i++] = 0x00;
1031	buf[i++] = 0x02;
1032	buf[i++] = 0x00;
1033
1034	desc_cnt--;
1035	}
1036
1037	buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1038	rtsx_stor_set_xfer_buf(buffer: buf, buflen: buf_len, srb);
1039	kfree(objp: buf);
1040
1041	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - buf_len);
1042
1043	return TRANSPORT_GOOD;
1044	}
1045
1046	static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1047	{
1048	unsigned char *buf;
1049	unsigned int lun = SCSI_LUN(srb);
1050	u32 card_size;
1051
1052	if (!check_card_ready(chip, lun)) {
1053	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1054	return TRANSPORT_FAILED;
1055	}
1056
1057	if (!(CHK_BIT(chip->lun_mc, lun))) {
1058	SET_BIT(chip->lun_mc, lun);
1059	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1060	return TRANSPORT_FAILED;
1061	}
1062
1063	buf = kmalloc(size: 8, GFP_KERNEL);
1064	if (!buf)
1065	return TRANSPORT_ERROR;
1066
1067	card_size = get_card_size(chip, lun);
1068	buf[0] = (unsigned char)((card_size - 1) >> 24);
1069	buf[1] = (unsigned char)((card_size - 1) >> 16);
1070	buf[2] = (unsigned char)((card_size - 1) >> 8);
1071	buf[3] = (unsigned char)(card_size - 1);
1072
1073	buf[4] = 0x00;
1074	buf[5] = 0x00;
1075	buf[6] = 0x02;
1076	buf[7] = 0x00;
1077
1078	rtsx_stor_set_xfer_buf(buffer: buf, buflen: scsi_bufflen(cmd: srb), srb);
1079	kfree(objp: buf);
1080
1081	scsi_set_resid(cmd: srb, resid: 0);
1082
1083	return TRANSPORT_GOOD;
1084	}
1085
1086	static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1087	{
1088	unsigned short len, i;
1089	int retval;
1090	u8 *buf;
1091
1092	rtsx_disable_aspm(chip);
1093
1094	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1095	rtsx_exit_ss(chip);
1096	wait_timeout(100);
1097	}
1098	rtsx_set_stat(chip, RTSX_STAT_RUN);
1099
1100	len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1101
1102	buf = vmalloc(size: len);
1103	if (!buf)
1104	return TRANSPORT_ERROR;
1105
1106	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1107	if (retval != STATUS_SUCCESS) {
1108	vfree(addr: buf);
1109	set_sense_type(chip, SCSI_LUN(srb),
1110	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1111	return TRANSPORT_FAILED;
1112	}
1113
1114	for (i = 0; i < len; i++) {
1115	retval = spi_read_eeprom(chip, addr: i, val: buf + i);
1116	if (retval != STATUS_SUCCESS) {
1117	vfree(addr: buf);
1118	set_sense_type(chip, SCSI_LUN(srb),
1119	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1120	return TRANSPORT_FAILED;
1121	}
1122	}
1123
1124	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1125	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
1126	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1127
1128	vfree(addr: buf);
1129
1130	return TRANSPORT_GOOD;
1131	}
1132
1133	static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1134	{
1135	unsigned short len, i;
1136	int retval;
1137	u8 *buf;
1138
1139	rtsx_disable_aspm(chip);
1140
1141	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1142	rtsx_exit_ss(chip);
1143	wait_timeout(100);
1144	}
1145	rtsx_set_stat(chip, RTSX_STAT_RUN);
1146
1147	len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1148
1149	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1150	if (retval != STATUS_SUCCESS) {
1151	set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1152	return TRANSPORT_FAILED;
1153	}
1154
1155	if (len == 511) {
1156	retval = spi_erase_eeprom_chip(chip);
1157	if (retval != STATUS_SUCCESS) {
1158	set_sense_type(chip, SCSI_LUN(srb),
1159	SENSE_TYPE_MEDIA_WRITE_ERR);
1160	return TRANSPORT_FAILED;
1161	}
1162	} else {
1163	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1164	len);
1165	buf = vmalloc(size: len);
1166	if (!buf)
1167	return TRANSPORT_ERROR;
1168
1169	rtsx_stor_get_xfer_buf(buffer: buf, buflen: len, srb);
1170	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1171
1172	for (i = 0; i < len; i++) {
1173	retval = spi_write_eeprom(chip, addr: i, val: buf[i]);
1174	if (retval != STATUS_SUCCESS) {
1175	vfree(addr: buf);
1176	set_sense_type(chip, SCSI_LUN(srb),
1177	SENSE_TYPE_MEDIA_WRITE_ERR);
1178	return TRANSPORT_FAILED;
1179	}
1180	}
1181
1182	vfree(addr: buf);
1183	}
1184
1185	return TRANSPORT_GOOD;
1186	}
1187
1188	static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1189	{
1190	unsigned short addr, len, i;
1191	int retval;
1192	u8 *buf;
1193
1194	rtsx_disable_aspm(chip);
1195
1196	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1197	rtsx_exit_ss(chip);
1198	wait_timeout(100);
1199	}
1200	rtsx_set_stat(chip, RTSX_STAT_RUN);
1201
1202	addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1203	len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1204
1205	if (addr < 0xFC00) {
1206	set_sense_type(chip, SCSI_LUN(srb),
1207	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1208	return TRANSPORT_FAILED;
1209	}
1210
1211	buf = vmalloc(size: len);
1212	if (!buf)
1213	return TRANSPORT_ERROR;
1214
1215	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1216	if (retval != STATUS_SUCCESS) {
1217	vfree(addr: buf);
1218	set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1219	return TRANSPORT_FAILED;
1220	}
1221
1222	for (i = 0; i < len; i++) {
1223	retval = rtsx_read_register(chip, addr: addr + i, data: buf + i);
1224	if (retval != STATUS_SUCCESS) {
1225	vfree(addr: buf);
1226	set_sense_type(chip, SCSI_LUN(srb),
1227	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1228	return TRANSPORT_FAILED;
1229	}
1230	}
1231
1232	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1233	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
1234	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1235
1236	vfree(addr: buf);
1237
1238	return TRANSPORT_GOOD;
1239	}
1240
1241	static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1242	{
1243	unsigned short addr, len, i;
1244	int retval;
1245	u8 *buf;
1246
1247	rtsx_disable_aspm(chip);
1248
1249	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1250	rtsx_exit_ss(chip);
1251	wait_timeout(100);
1252	}
1253	rtsx_set_stat(chip, RTSX_STAT_RUN);
1254
1255	addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1256	len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1257
1258	if (addr < 0xFC00) {
1259	set_sense_type(chip, SCSI_LUN(srb),
1260	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1261	return TRANSPORT_FAILED;
1262	}
1263
1264	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1265	buf = vmalloc(size: len);
1266	if (!buf)
1267	return TRANSPORT_ERROR;
1268
1269	rtsx_stor_get_xfer_buf(buffer: buf, buflen: len, srb);
1270	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1271
1272	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1273	if (retval != STATUS_SUCCESS) {
1274	vfree(addr: buf);
1275	set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1276	return TRANSPORT_FAILED;
1277	}
1278
1279	for (i = 0; i < len; i++) {
1280	retval = rtsx_write_register(chip, addr: addr + i, mask: 0xFF, data: buf[i]);
1281	if (retval != STATUS_SUCCESS) {
1282	vfree(addr: buf);
1283	set_sense_type(chip, SCSI_LUN(srb),
1284	SENSE_TYPE_MEDIA_WRITE_ERR);
1285	return TRANSPORT_FAILED;
1286	}
1287	}
1288
1289	vfree(addr: buf);
1290
1291	return TRANSPORT_GOOD;
1292	}
1293
1294	static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1295	{
1296	struct sd_info *sd_card = &chip->sd_card;
1297	unsigned int lun = SCSI_LUN(srb);
1298
1299	if (!check_card_ready(chip, lun)) {
1300	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1301	return TRANSPORT_FAILED;
1302	}
1303
1304	if (get_lun_card(chip, lun) != SD_CARD) {
1305	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1306	return TRANSPORT_FAILED;
1307	}
1308
1309	scsi_set_resid(cmd: srb, resid: 0);
1310	rtsx_stor_set_xfer_buf(buffer: sd_card->raw_csd, buflen: scsi_bufflen(cmd: srb), srb);
1311
1312	return TRANSPORT_GOOD;
1313	}
1314
1315	static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1316	{
1317	u8 gpio = srb->cmnd[2];
1318
1319	rtsx_disable_aspm(chip);
1320
1321	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1322	rtsx_exit_ss(chip);
1323	wait_timeout(100);
1324	}
1325	rtsx_set_stat(chip, RTSX_STAT_RUN);
1326
1327	if (gpio > 3)
1328	gpio = 1;
1329	toggle_gpio(chip, gpio);
1330
1331	return TRANSPORT_GOOD;
1332	}
1333
1334	static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1335	{
1336	u8 addr, buf[4];
1337	u32 val;
1338	unsigned int len;
1339
1340	rtsx_disable_aspm(chip);
1341
1342	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1343	rtsx_exit_ss(chip);
1344	wait_timeout(100);
1345	}
1346	rtsx_set_stat(chip, RTSX_STAT_RUN);
1347
1348	addr = srb->cmnd[4];
1349
1350	val = rtsx_readl(chip, reg: addr);
1351	dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1352
1353	buf[0] = (u8)(val >> 24);
1354	buf[1] = (u8)(val >> 16);
1355	buf[2] = (u8)(val >> 8);
1356	buf[3] = (u8)val;
1357
1358	len = min_t(unsigned int, scsi_bufflen(srb), 4);
1359	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
1360	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1361
1362	return TRANSPORT_GOOD;
1363	}
1364
1365	static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1366	{
1367	u8 addr, buf[4];
1368	u32 val;
1369	unsigned int len;
1370
1371	rtsx_disable_aspm(chip);
1372
1373	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1374	rtsx_exit_ss(chip);
1375	wait_timeout(100);
1376	}
1377	rtsx_set_stat(chip, RTSX_STAT_RUN);
1378
1379	addr = srb->cmnd[4];
1380
1381	len = min_t(unsigned int, scsi_bufflen(srb), 4);
1382	rtsx_stor_get_xfer_buf(buffer: buf, buflen: len, srb);
1383	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1384
1385	val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1386	<< 8) | buf[3];
1387
1388	rtsx_writel(chip, reg: addr, value: val);
1389
1390	return TRANSPORT_GOOD;
1391	}
1392
1393	static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1394	{
1395	unsigned int lun = SCSI_LUN(srb);
1396
1397	if (srb->cmnd[3] == 1) {
1398	/* Variable Clock */
1399	struct xd_info *xd_card = &chip->xd_card;
1400	struct sd_info *sd_card = &chip->sd_card;
1401	struct ms_info *ms_card = &chip->ms_card;
1402
1403	switch (srb->cmnd[4]) {
1404	case XD_CARD:
1405	xd_card->xd_clock = srb->cmnd[5];
1406	break;
1407
1408	case SD_CARD:
1409	sd_card->sd_clock = srb->cmnd[5];
1410	break;
1411
1412	case MS_CARD:
1413	ms_card->ms_clock = srb->cmnd[5];
1414	break;
1415
1416	default:
1417	set_sense_type(chip, lun,
1418	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1419	return TRANSPORT_FAILED;
1420	}
1421	} else if (srb->cmnd[3] == 2) {
1422	if (srb->cmnd[4]) {
1423	chip->blink_led = 1;
1424	} else {
1425	int retval;
1426
1427	chip->blink_led = 0;
1428
1429	rtsx_disable_aspm(chip);
1430
1431	if (chip->ss_en &&
1432	(rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1433	rtsx_exit_ss(chip);
1434	wait_timeout(100);
1435	}
1436	rtsx_set_stat(chip, RTSX_STAT_RUN);
1437
1438	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1439	if (retval != STATUS_SUCCESS) {
1440	set_sense_type(chip, SCSI_LUN(srb),
1441	SENSE_TYPE_MEDIA_WRITE_ERR);
1442	return TRANSPORT_FAILED;
1443	}
1444
1445	turn_off_led(chip, LED_GPIO);
1446	}
1447	} else {
1448	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1449	return TRANSPORT_FAILED;
1450	}
1451
1452	return TRANSPORT_GOOD;
1453	}
1454
1455	static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1456	{
1457	unsigned int lun = SCSI_LUN(srb);
1458
1459	if (srb->cmnd[3] == 1) {
1460	struct xd_info *xd_card = &chip->xd_card;
1461	struct sd_info *sd_card = &chip->sd_card;
1462	struct ms_info *ms_card = &chip->ms_card;
1463	u8 tmp;
1464
1465	switch (srb->cmnd[4]) {
1466	case XD_CARD:
1467	tmp = (u8)(xd_card->xd_clock);
1468	break;
1469
1470	case SD_CARD:
1471	tmp = (u8)(sd_card->sd_clock);
1472	break;
1473
1474	case MS_CARD:
1475	tmp = (u8)(ms_card->ms_clock);
1476	break;
1477
1478	default:
1479	set_sense_type(chip, lun,
1480	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1481	return TRANSPORT_FAILED;
1482	}
1483
1484	rtsx_stor_set_xfer_buf(buffer: &tmp, buflen: 1, srb);
1485	} else if (srb->cmnd[3] == 2) {
1486	u8 tmp = chip->blink_led;
1487
1488	rtsx_stor_set_xfer_buf(buffer: &tmp, buflen: 1, srb);
1489	} else {
1490	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1491	return TRANSPORT_FAILED;
1492	}
1493
1494	return TRANSPORT_GOOD;
1495	}
1496
1497	static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1498	{
1499	int retval;
1500	unsigned int lun = SCSI_LUN(srb);
1501	u16 len;
1502
1503	rtsx_disable_aspm(chip);
1504
1505	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1506	rtsx_exit_ss(chip);
1507	wait_timeout(100);
1508	}
1509	rtsx_set_stat(chip, RTSX_STAT_RUN);
1510
1511	len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1512	len = min_t(u16, len, scsi_bufflen(srb));
1513
1514	if (srb->sc_data_direction == DMA_FROM_DEVICE)
1515	dev_dbg(rtsx_dev(chip), "Read from device\n");
1516	else
1517	dev_dbg(rtsx_dev(chip), "Write to device\n");
1518
1519	retval = rtsx_transfer_data(chip, card: 0, buf: scsi_sglist(cmd: srb), len,
1520	use_sg: scsi_sg_count(cmd: srb), dma_dir: srb->sc_data_direction,
1521	timeout: 1000);
1522	if (retval < 0) {
1523	if (srb->sc_data_direction == DMA_FROM_DEVICE)
1524	set_sense_type(chip, lun,
1525	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1526	else
1527	set_sense_type(chip, lun,
1528	SENSE_TYPE_MEDIA_WRITE_ERR);
1529
1530	return TRANSPORT_FAILED;
1531	}
1532	scsi_set_resid(cmd: srb, resid: 0);
1533
1534	return TRANSPORT_GOOD;
1535	}
1536
1537	static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1538	{
1539	struct sd_info *sd_card = &chip->sd_card;
1540	struct ms_info *ms_card = &chip->ms_card;
1541	int buf_len;
1542	unsigned int lun = SCSI_LUN(srb);
1543	u8 card = get_lun_card(chip, lun);
1544	u8 status[32];
1545	#ifdef SUPPORT_OCP
1546	u8 oc_now_mask = 0, oc_ever_mask = 0;
1547	#endif
1548
1549	memset(status, 0, 32);
1550
1551	status[0] = (u8)(chip->product_id);
1552	status[1] = chip->ic_version;
1553
1554	if (chip->auto_delink_en)
1555	status[2] = 0x10;
1556	else
1557	status[2] = 0x00;
1558
1559	status[3] = 20;
1560	status[4] = 10;
1561	status[5] = 05;
1562	status[6] = 21;
1563
1564	if (chip->card_wp)
1565	status[7] = 0x20;
1566	else
1567	status[7] = 0x00;
1568
1569	#ifdef SUPPORT_OCP
1570	status[8] = 0;
1571	if (CHECK_LUN_MODE(chip, SD_MS_2LUN) &&
1572	chip->lun2card[lun] == MS_CARD) {
1573	oc_now_mask = MS_OC_NOW;
1574	oc_ever_mask = MS_OC_EVER;
1575	} else {
1576	oc_now_mask = SD_OC_NOW;
1577	oc_ever_mask = SD_OC_EVER;
1578	}
1579
1580	if (chip->ocp_stat & oc_now_mask)
1581	status[8] |= 0x02;
1582
1583	if (chip->ocp_stat & oc_ever_mask)
1584	status[8] |= 0x01;
1585	#endif
1586
1587	if (card == SD_CARD) {
1588	if (CHK_SD(sd_card)) {
1589	if (CHK_SD_HCXC(sd_card)) {
1590	if (sd_card->capacity > 0x4000000)
1591	status[0x0E] = 0x02;
1592	else
1593	status[0x0E] = 0x01;
1594	} else {
1595	status[0x0E] = 0x00;
1596	}
1597
1598	if (CHK_SD_SDR104(sd_card))
1599	status[0x0F] = 0x03;
1600	else if (CHK_SD_DDR50(sd_card))
1601	status[0x0F] = 0x04;
1602	else if (CHK_SD_SDR50(sd_card))
1603	status[0x0F] = 0x02;
1604	else if (CHK_SD_HS(sd_card))
1605	status[0x0F] = 0x01;
1606	else
1607	status[0x0F] = 0x00;
1608	} else {
1609	if (CHK_MMC_SECTOR_MODE(sd_card))
1610	status[0x0E] = 0x01;
1611	else
1612	status[0x0E] = 0x00;
1613
1614	if (CHK_MMC_DDR52(sd_card))
1615	status[0x0F] = 0x03;
1616	else if (CHK_MMC_52M(sd_card))
1617	status[0x0F] = 0x02;
1618	else if (CHK_MMC_26M(sd_card))
1619	status[0x0F] = 0x01;
1620	else
1621	status[0x0F] = 0x00;
1622	}
1623	} else if (card == MS_CARD) {
1624	if (CHK_MSPRO(ms_card)) {
1625	if (CHK_MSXC(ms_card))
1626	status[0x0E] = 0x01;
1627	else
1628	status[0x0E] = 0x00;
1629
1630	if (CHK_HG8BIT(ms_card))
1631	status[0x0F] = 0x01;
1632	else
1633	status[0x0F] = 0x00;
1634	}
1635	}
1636
1637	#ifdef SUPPORT_SD_LOCK
1638	if (card == SD_CARD) {
1639	status[0x17] = 0x80;
1640	if (sd_card->sd_erase_status)
1641	status[0x17] |= 0x01;
1642	if (sd_card->sd_lock_status & SD_LOCKED) {
1643	status[0x17] |= 0x02;
1644	status[0x07] |= 0x40;
1645	}
1646	if (sd_card->sd_lock_status & SD_PWD_EXIST)
1647	status[0x17] |= 0x04;
1648	} else {
1649	status[0x17] = 0x00;
1650	}
1651
1652	dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1653	#endif
1654
1655	status[0x18] = 0x8A;
1656	status[0x1A] = 0x28;
1657	#ifdef SUPPORT_SD_LOCK
1658	status[0x1F] = 0x01;
1659	#endif
1660
1661	buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1662	rtsx_stor_set_xfer_buf(buffer: status, buflen: buf_len, srb);
1663	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - buf_len);
1664
1665	return TRANSPORT_GOOD;
1666	}
1667
1668	static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1669	{
1670	int phy_debug_mode;
1671	int retval;
1672	u16 reg;
1673
1674	if (!CHECK_PID(chip, 0x5208)) {
1675	set_sense_type(chip, SCSI_LUN(srb),
1676	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1677	return TRANSPORT_FAILED;
1678	}
1679
1680	phy_debug_mode = (int)(srb->cmnd[3]);
1681
1682	if (phy_debug_mode) {
1683	chip->phy_debug_mode = 1;
1684	retval = rtsx_write_register(chip, CDRESUMECTL, mask: 0x77, data: 0);
1685	if (retval != STATUS_SUCCESS)
1686	return TRANSPORT_FAILED;
1687
1688	rtsx_disable_bus_int(chip);
1689
1690	retval = rtsx_read_phy_register(chip, addr: 0x1C, val: &reg);
1691	if (retval != STATUS_SUCCESS)
1692	return TRANSPORT_FAILED;
1693
1694	reg |= 0x0001;
1695	retval = rtsx_write_phy_register(chip, addr: 0x1C, val: reg);
1696	if (retval != STATUS_SUCCESS)
1697	return TRANSPORT_FAILED;
1698	} else {
1699	chip->phy_debug_mode = 0;
1700	retval = rtsx_write_register(chip, CDRESUMECTL, mask: 0x77, data: 0x77);
1701	if (retval != STATUS_SUCCESS)
1702	return TRANSPORT_FAILED;
1703
1704	rtsx_enable_bus_int(chip);
1705
1706	retval = rtsx_read_phy_register(chip, addr: 0x1C, val: &reg);
1707	if (retval != STATUS_SUCCESS)
1708	return TRANSPORT_FAILED;
1709
1710	reg &= 0xFFFE;
1711	retval = rtsx_write_phy_register(chip, addr: 0x1C, val: reg);
1712	if (retval != STATUS_SUCCESS)
1713	return TRANSPORT_FAILED;
1714	}
1715
1716	return TRANSPORT_GOOD;
1717	}
1718
1719	static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1720	{
1721	int retval = STATUS_SUCCESS;
1722	unsigned int lun = SCSI_LUN(srb);
1723	u8 cmd_type, mask, value, idx;
1724	u16 addr;
1725
1726	rtsx_disable_aspm(chip);
1727
1728	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1729	rtsx_exit_ss(chip);
1730	wait_timeout(100);
1731	}
1732	rtsx_set_stat(chip, RTSX_STAT_RUN);
1733
1734	switch (srb->cmnd[3]) {
1735	case INIT_BATCHCMD:
1736	rtsx_init_cmd(chip);
1737	break;
1738
1739	case ADD_BATCHCMD:
1740	cmd_type = srb->cmnd[4];
1741	if (cmd_type > 2) {
1742	set_sense_type(chip, lun,
1743	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1744	return TRANSPORT_FAILED;
1745	}
1746	addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1747	mask = srb->cmnd[7];
1748	value = srb->cmnd[8];
1749	rtsx_add_cmd(chip, cmd_type, reg_addr: addr, mask, data: value);
1750	break;
1751
1752	case SEND_BATCHCMD:
1753	retval = rtsx_send_cmd(chip, card: 0, timeout: 1000);
1754	break;
1755
1756	case GET_BATCHRSP:
1757	idx = srb->cmnd[4];
1758	value = *(rtsx_get_cmd_data(chip) + idx);
1759	if (scsi_bufflen(cmd: srb) < 1) {
1760	set_sense_type(chip, lun,
1761	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1762	return TRANSPORT_FAILED;
1763	}
1764	rtsx_stor_set_xfer_buf(buffer: &value, buflen: 1, srb);
1765	scsi_set_resid(cmd: srb, resid: 0);
1766	break;
1767
1768	default:
1769	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1770	return TRANSPORT_FAILED;
1771	}
1772
1773	if (retval != STATUS_SUCCESS) {
1774	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1775	return TRANSPORT_FAILED;
1776	}
1777
1778	return TRANSPORT_GOOD;
1779	}
1780
1781	static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1782	{
1783	switch (srb->cmnd[3]) {
1784	case INIT_BATCHCMD:
1785	case ADD_BATCHCMD:
1786	case SEND_BATCHCMD:
1787	case GET_BATCHRSP:
1788	return rw_mem_cmd_buf(srb, chip);
1789	default:
1790	return TRANSPORT_ERROR;
1791	}
1792	}
1793
1794	static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1795	{
1796	unsigned short addr, len, i;
1797	int retval;
1798	u8 *buf;
1799	u16 val;
1800
1801	rtsx_disable_aspm(chip);
1802
1803	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1804	rtsx_exit_ss(chip);
1805	wait_timeout(100);
1806	}
1807	rtsx_set_stat(chip, RTSX_STAT_RUN);
1808
1809	addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1810	len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1811
1812	if (len % 2)
1813	len -= len % 2;
1814
1815	if (len) {
1816	buf = vmalloc(size: len);
1817	if (!buf)
1818	return TRANSPORT_ERROR;
1819
1820	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1821	if (retval != STATUS_SUCCESS) {
1822	vfree(addr: buf);
1823	set_sense_type(chip, SCSI_LUN(srb),
1824	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1825	return TRANSPORT_FAILED;
1826	}
1827
1828	for (i = 0; i < len / 2; i++) {
1829	retval = rtsx_read_phy_register(chip, addr: addr + i, val: &val);
1830	if (retval != STATUS_SUCCESS) {
1831	vfree(addr: buf);
1832	set_sense_type
1833	(chip, SCSI_LUN(srb),
1834	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1835	return TRANSPORT_FAILED;
1836	}
1837
1838	buf[2 * i] = (u8)(val >> 8);
1839	buf[2 * i + 1] = (u8)val;
1840	}
1841
1842	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1843	len);
1844	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
1845	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1846
1847	vfree(addr: buf);
1848	}
1849
1850	return TRANSPORT_GOOD;
1851	}
1852
1853	static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1854	{
1855	unsigned short addr, len, i;
1856	int retval;
1857	u8 *buf;
1858	u16 val;
1859
1860	rtsx_disable_aspm(chip);
1861
1862	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1863	rtsx_exit_ss(chip);
1864	wait_timeout(100);
1865	}
1866	rtsx_set_stat(chip, RTSX_STAT_RUN);
1867
1868	addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1869	len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1870
1871	if (len % 2)
1872	len -= len % 2;
1873
1874	if (len) {
1875	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1876	len);
1877
1878	buf = vmalloc(size: len);
1879	if (!buf)
1880	return TRANSPORT_ERROR;
1881
1882	rtsx_stor_get_xfer_buf(buffer: buf, buflen: len, srb);
1883	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1884
1885	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1886	if (retval != STATUS_SUCCESS) {
1887	vfree(addr: buf);
1888	set_sense_type(chip, SCSI_LUN(srb),
1889	SENSE_TYPE_MEDIA_WRITE_ERR);
1890	return TRANSPORT_FAILED;
1891	}
1892
1893	for (i = 0; i < len / 2; i++) {
1894	val = ((u16)buf[2 * i] << 8) | buf[2 * i + 1];
1895	retval = rtsx_write_phy_register(chip, addr: addr + i, val);
1896	if (retval != STATUS_SUCCESS) {
1897	vfree(addr: buf);
1898	set_sense_type(chip, SCSI_LUN(srb),
1899	SENSE_TYPE_MEDIA_WRITE_ERR);
1900	return TRANSPORT_FAILED;
1901	}
1902	}
1903
1904	vfree(addr: buf);
1905	}
1906
1907	return TRANSPORT_GOOD;
1908	}
1909
1910	static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1911	{
1912	unsigned short addr;
1913	int retval;
1914	u8 mode;
1915
1916	rtsx_disable_aspm(chip);
1917
1918	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1919	rtsx_exit_ss(chip);
1920	wait_timeout(100);
1921	}
1922	rtsx_set_stat(chip, RTSX_STAT_RUN);
1923
1924	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1925	if (retval != STATUS_SUCCESS) {
1926	set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1927	return TRANSPORT_FAILED;
1928	}
1929
1930	mode = srb->cmnd[3];
1931	addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1932
1933	if (mode == 0) {
1934	retval = spi_erase_eeprom_chip(chip);
1935	if (retval != STATUS_SUCCESS) {
1936	set_sense_type(chip, SCSI_LUN(srb),
1937	SENSE_TYPE_MEDIA_WRITE_ERR);
1938	return TRANSPORT_FAILED;
1939	}
1940	} else if (mode == 1) {
1941	retval = spi_erase_eeprom_byte(chip, addr);
1942	if (retval != STATUS_SUCCESS) {
1943	set_sense_type(chip, SCSI_LUN(srb),
1944	SENSE_TYPE_MEDIA_WRITE_ERR);
1945	return TRANSPORT_FAILED;
1946	}
1947	} else {
1948	set_sense_type(chip, SCSI_LUN(srb),
1949	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1950	return TRANSPORT_FAILED;
1951	}
1952
1953	return TRANSPORT_GOOD;
1954	}
1955
1956	static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1957	{
1958	unsigned short addr, len, i;
1959	int retval;
1960	u8 *buf;
1961
1962	rtsx_disable_aspm(chip);
1963
1964	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1965	rtsx_exit_ss(chip);
1966	wait_timeout(100);
1967	}
1968	rtsx_set_stat(chip, RTSX_STAT_RUN);
1969
1970	addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1971	len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1972
1973	buf = vmalloc(size: len);
1974	if (!buf)
1975	return TRANSPORT_ERROR;
1976
1977	retval = rtsx_force_power_on(chip, SSC_PDCTL);
1978	if (retval != STATUS_SUCCESS) {
1979	vfree(addr: buf);
1980	set_sense_type(chip, SCSI_LUN(srb),
1981	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1982	return TRANSPORT_FAILED;
1983	}
1984
1985	for (i = 0; i < len; i++) {
1986	retval = spi_read_eeprom(chip, addr: addr + i, val: buf + i);
1987	if (retval != STATUS_SUCCESS) {
1988	vfree(addr: buf);
1989	set_sense_type(chip, SCSI_LUN(srb),
1990	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1991	return TRANSPORT_FAILED;
1992	}
1993	}
1994
1995	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1996	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
1997	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
1998
1999	vfree(addr: buf);
2000
2001	return TRANSPORT_GOOD;
2002	}
2003
2004	static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2005	{
2006	unsigned short addr, len, i;
2007	int retval;
2008	u8 *buf;
2009
2010	rtsx_disable_aspm(chip);
2011
2012	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2013	rtsx_exit_ss(chip);
2014	wait_timeout(100);
2015	}
2016	rtsx_set_stat(chip, RTSX_STAT_RUN);
2017
2018	addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2019	len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2020
2021	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2022	buf = vmalloc(size: len);
2023	if (!buf)
2024	return TRANSPORT_ERROR;
2025
2026	rtsx_stor_get_xfer_buf(buffer: buf, buflen: len, srb);
2027	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
2028
2029	retval = rtsx_force_power_on(chip, SSC_PDCTL);
2030	if (retval != STATUS_SUCCESS) {
2031	vfree(addr: buf);
2032	set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2033	return TRANSPORT_FAILED;
2034	}
2035
2036	for (i = 0; i < len; i++) {
2037	retval = spi_write_eeprom(chip, addr: addr + i, val: buf[i]);
2038	if (retval != STATUS_SUCCESS) {
2039	vfree(addr: buf);
2040	set_sense_type(chip, SCSI_LUN(srb),
2041	SENSE_TYPE_MEDIA_WRITE_ERR);
2042	return TRANSPORT_FAILED;
2043	}
2044	}
2045
2046	vfree(addr: buf);
2047
2048	return TRANSPORT_GOOD;
2049	}
2050
2051	static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2052	{
2053	int retval;
2054	u8 addr, len, i;
2055	u8 *buf;
2056
2057	rtsx_disable_aspm(chip);
2058
2059	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2060	rtsx_exit_ss(chip);
2061	wait_timeout(100);
2062	}
2063	rtsx_set_stat(chip, RTSX_STAT_RUN);
2064
2065	addr = srb->cmnd[4];
2066	len = srb->cmnd[5];
2067
2068	buf = vmalloc(size: len);
2069	if (!buf)
2070	return TRANSPORT_ERROR;
2071
2072	retval = rtsx_force_power_on(chip, SSC_PDCTL);
2073	if (retval != STATUS_SUCCESS) {
2074	vfree(addr: buf);
2075	set_sense_type(chip, SCSI_LUN(srb),
2076	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2077	return TRANSPORT_FAILED;
2078	}
2079
2080	for (i = 0; i < len; i++) {
2081	retval = rtsx_read_efuse(chip, addr: addr + i, val: buf + i);
2082	if (retval != STATUS_SUCCESS) {
2083	vfree(addr: buf);
2084	set_sense_type(chip, SCSI_LUN(srb),
2085	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2086	return TRANSPORT_FAILED;
2087	}
2088	}
2089
2090	len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2091	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
2092	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
2093
2094	vfree(addr: buf);
2095
2096	return TRANSPORT_GOOD;
2097	}
2098
2099	static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2100	{
2101	int retval, result = TRANSPORT_GOOD;
2102	u16 val;
2103	u8 addr, len, i;
2104	u8 *buf;
2105
2106	rtsx_disable_aspm(chip);
2107
2108	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2109	rtsx_exit_ss(chip);
2110	wait_timeout(100);
2111	}
2112	rtsx_set_stat(chip, RTSX_STAT_RUN);
2113
2114	addr = srb->cmnd[4];
2115	len = srb->cmnd[5];
2116
2117	len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2118	buf = vmalloc(size: len);
2119	if (!buf)
2120	return TRANSPORT_ERROR;
2121
2122	rtsx_stor_get_xfer_buf(buffer: buf, buflen: len, srb);
2123	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
2124
2125	retval = rtsx_force_power_on(chip, SSC_PDCTL);
2126	if (retval != STATUS_SUCCESS) {
2127	vfree(addr: buf);
2128	return TRANSPORT_ERROR;
2129	}
2130
2131	if (chip->asic_code) {
2132	retval = rtsx_read_phy_register(chip, addr: 0x08, val: &val);
2133	if (retval != STATUS_SUCCESS) {
2134	vfree(addr: buf);
2135	return TRANSPORT_ERROR;
2136	}
2137
2138	retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2139	LDO3318_PWR_MASK, LDO_OFF);
2140	if (retval != STATUS_SUCCESS) {
2141	vfree(addr: buf);
2142	return TRANSPORT_ERROR;
2143	}
2144
2145	wait_timeout(600);
2146
2147	retval = rtsx_write_phy_register(chip, addr: 0x08,
2148	val: 0x4C00 | chip->phy_voltage);
2149	if (retval != STATUS_SUCCESS) {
2150	vfree(addr: buf);
2151	return TRANSPORT_ERROR;
2152	}
2153
2154	retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2155	LDO3318_PWR_MASK, LDO_ON);
2156	if (retval != STATUS_SUCCESS) {
2157	vfree(addr: buf);
2158	return TRANSPORT_ERROR;
2159	}
2160
2161	wait_timeout(600);
2162	}
2163
2164	retval = card_power_on(chip, SPI_CARD);
2165	if (retval != STATUS_SUCCESS) {
2166	vfree(addr: buf);
2167	return TRANSPORT_ERROR;
2168	}
2169
2170	wait_timeout(50);
2171
2172	for (i = 0; i < len; i++) {
2173	retval = rtsx_write_efuse(chip, addr: addr + i, val: buf[i]);
2174	if (retval != STATUS_SUCCESS) {
2175	set_sense_type(chip, SCSI_LUN(srb),
2176	SENSE_TYPE_MEDIA_WRITE_ERR);
2177	result = TRANSPORT_FAILED;
2178	goto exit;
2179	}
2180	}
2181
2182	exit:
2183	vfree(addr: buf);
2184
2185	retval = card_power_off(chip, SPI_CARD);
2186	if (retval != STATUS_SUCCESS)
2187	return TRANSPORT_ERROR;
2188
2189	if (chip->asic_code) {
2190	retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2191	LDO3318_PWR_MASK, LDO_OFF);
2192	if (retval != STATUS_SUCCESS)
2193	return TRANSPORT_ERROR;
2194
2195	wait_timeout(600);
2196
2197	retval = rtsx_write_phy_register(chip, addr: 0x08, val);
2198	if (retval != STATUS_SUCCESS)
2199	return TRANSPORT_ERROR;
2200
2201	retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2202	LDO3318_PWR_MASK, LDO_ON);
2203	if (retval != STATUS_SUCCESS)
2204	return TRANSPORT_ERROR;
2205	}
2206
2207	return result;
2208	}
2209
2210	static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2211	{
2212	int retval;
2213	bool func_max;
2214	u8 func;
2215	u16 addr, len;
2216	u8 *buf;
2217
2218	rtsx_disable_aspm(chip);
2219
2220	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2221	rtsx_exit_ss(chip);
2222	wait_timeout(100);
2223	}
2224	rtsx_set_stat(chip, RTSX_STAT_RUN);
2225
2226	func = srb->cmnd[3];
2227	addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2228	len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2229
2230	dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2231	__func__, func, addr, len);
2232
2233	if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2234	func_max = true;
2235	else
2236	func_max = false;
2237
2238	if (func > func_max) {
2239	set_sense_type(chip, SCSI_LUN(srb),
2240	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2241	return TRANSPORT_FAILED;
2242	}
2243
2244	buf = vmalloc(size: len);
2245	if (!buf)
2246	return TRANSPORT_ERROR;
2247
2248	retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2249	if (retval != STATUS_SUCCESS) {
2250	set_sense_type(chip, SCSI_LUN(srb),
2251	SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2252	vfree(addr: buf);
2253	return TRANSPORT_FAILED;
2254	}
2255
2256	len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2257	rtsx_stor_set_xfer_buf(buffer: buf, buflen: len, srb);
2258	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
2259
2260	vfree(addr: buf);
2261
2262	return TRANSPORT_GOOD;
2263	}
2264
2265	static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2266	{
2267	int retval;
2268	bool func_max;
2269	u8 func;
2270	u16 addr, len;
2271	u8 *buf;
2272
2273	rtsx_disable_aspm(chip);
2274
2275	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2276	rtsx_exit_ss(chip);
2277	wait_timeout(100);
2278	}
2279	rtsx_set_stat(chip, RTSX_STAT_RUN);
2280
2281	func = srb->cmnd[3];
2282	addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2283	len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2284
2285	dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2286	__func__, func, addr);
2287
2288	if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2289	func_max = true;
2290	else
2291	func_max = false;
2292
2293	if (func > func_max) {
2294	set_sense_type(chip, SCSI_LUN(srb),
2295	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2296	return TRANSPORT_FAILED;
2297	}
2298
2299	len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2300	buf = vmalloc(size: len);
2301	if (!buf)
2302	return TRANSPORT_ERROR;
2303
2304	rtsx_stor_get_xfer_buf(buffer: buf, buflen: len, srb);
2305	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - len);
2306
2307	retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2308	if (retval != STATUS_SUCCESS) {
2309	set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2310	vfree(addr: buf);
2311	return TRANSPORT_FAILED;
2312	}
2313
2314	vfree(addr: buf);
2315
2316	return TRANSPORT_GOOD;
2317	}
2318
2319	static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2320	{
2321	int result;
2322
2323	switch (srb->cmnd[2]) {
2324	case PP_READ10:
2325	case PP_WRITE10:
2326	result = read_write(srb, chip);
2327	break;
2328
2329	case READ_HOST_REG:
2330	result = read_host_reg(srb, chip);
2331	break;
2332
2333	case WRITE_HOST_REG:
2334	result = write_host_reg(srb, chip);
2335	break;
2336
2337	case GET_VAR:
2338	result = get_variable(srb, chip);
2339	break;
2340
2341	case SET_VAR:
2342	result = set_variable(srb, chip);
2343	break;
2344
2345	case DMA_READ:
2346	case DMA_WRITE:
2347	result = dma_access_ring_buffer(srb, chip);
2348	break;
2349
2350	case READ_PHY:
2351	result = read_phy_register(srb, chip);
2352	break;
2353
2354	case WRITE_PHY:
2355	result = write_phy_register(srb, chip);
2356	break;
2357
2358	case ERASE_EEPROM2:
2359	result = erase_eeprom2(srb, chip);
2360	break;
2361
2362	case READ_EEPROM2:
2363	result = read_eeprom2(srb, chip);
2364	break;
2365
2366	case WRITE_EEPROM2:
2367	result = write_eeprom2(srb, chip);
2368	break;
2369
2370	case READ_EFUSE:
2371	result = read_efuse(srb, chip);
2372	break;
2373
2374	case WRITE_EFUSE:
2375	result = write_efuse(srb, chip);
2376	break;
2377
2378	case READ_CFG:
2379	result = read_cfg_byte(srb, chip);
2380	break;
2381
2382	case WRITE_CFG:
2383	result = write_cfg_byte(srb, chip);
2384	break;
2385
2386	case SET_CHIP_MODE:
2387	result = set_chip_mode(srb, chip);
2388	break;
2389
2390	case SUIT_CMD:
2391	result = suit_cmd(srb, chip);
2392	break;
2393
2394	case GET_DEV_STATUS:
2395	result = get_dev_status(srb, chip);
2396	break;
2397
2398	default:
2399	set_sense_type(chip, SCSI_LUN(srb),
2400	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2401	return TRANSPORT_FAILED;
2402	}
2403
2404	return result;
2405	}
2406
2407	static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2408	{
2409	u8 rtsx_status[16];
2410	int buf_len;
2411	unsigned int lun = SCSI_LUN(srb);
2412
2413	rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2414	rtsx_status[1] = (u8)(chip->vendor_id);
2415
2416	rtsx_status[2] = (u8)(chip->product_id >> 8);
2417	rtsx_status[3] = (u8)(chip->product_id);
2418
2419	rtsx_status[4] = (u8)lun;
2420
2421	if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2422	if (chip->lun2card[lun] == SD_CARD)
2423	rtsx_status[5] = 2;
2424	else
2425	rtsx_status[5] = 3;
2426	} else {
2427	if (chip->card_exist) {
2428	if (chip->card_exist & XD_CARD)
2429	rtsx_status[5] = 4;
2430	else if (chip->card_exist & SD_CARD)
2431	rtsx_status[5] = 2;
2432	else if (chip->card_exist & MS_CARD)
2433	rtsx_status[5] = 3;
2434	else
2435	rtsx_status[5] = 7;
2436	} else {
2437	rtsx_status[5] = 7;
2438	}
2439	}
2440
2441	if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2442	rtsx_status[6] = 2;
2443	else
2444	rtsx_status[6] = 1;
2445
2446	rtsx_status[7] = (u8)(chip->product_id);
2447	rtsx_status[8] = chip->ic_version;
2448
2449	if (check_card_exist(chip, lun))
2450	rtsx_status[9] = 1;
2451	else
2452	rtsx_status[9] = 0;
2453
2454	if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2455	rtsx_status[10] = 0;
2456	else
2457	rtsx_status[10] = 1;
2458
2459	if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2460	if (chip->lun2card[lun] == SD_CARD)
2461	rtsx_status[11] = SD_CARD;
2462	else
2463	rtsx_status[11] = MS_CARD;
2464	} else {
2465	rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2466	}
2467
2468	if (check_card_ready(chip, lun))
2469	rtsx_status[12] = 1;
2470	else
2471	rtsx_status[12] = 0;
2472
2473	if (get_lun_card(chip, lun) == XD_CARD) {
2474	rtsx_status[13] = 0x40;
2475	} else if (get_lun_card(chip, lun) == SD_CARD) {
2476	struct sd_info *sd_card = &chip->sd_card;
2477
2478	rtsx_status[13] = 0x20;
2479	if (CHK_SD(sd_card)) {
2480	if (CHK_SD_HCXC(sd_card))
2481	rtsx_status[13] |= 0x04;
2482	if (CHK_SD_HS(sd_card))
2483	rtsx_status[13] |= 0x02;
2484	} else {
2485	rtsx_status[13] |= 0x08;
2486	if (CHK_MMC_52M(sd_card))
2487	rtsx_status[13] |= 0x02;
2488	if (CHK_MMC_SECTOR_MODE(sd_card))
2489	rtsx_status[13] |= 0x04;
2490	}
2491	} else if (get_lun_card(chip, lun) == MS_CARD) {
2492	struct ms_info *ms_card = &chip->ms_card;
2493
2494	if (CHK_MSPRO(ms_card)) {
2495	rtsx_status[13] = 0x38;
2496	if (CHK_HG8BIT(ms_card))
2497	rtsx_status[13] |= 0x04;
2498	#ifdef SUPPORT_MSXC
2499	if (CHK_MSXC(ms_card))
2500	rtsx_status[13] |= 0x01;
2501	#endif
2502	} else {
2503	rtsx_status[13] = 0x30;
2504	}
2505	} else {
2506	if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2507	#ifdef SUPPORT_SDIO
2508	if (chip->sd_io && chip->sd_int)
2509	rtsx_status[13] = 0x60;
2510	else
2511	rtsx_status[13] = 0x70;
2512	#else
2513	rtsx_status[13] = 0x70;
2514	#endif
2515	} else {
2516	if (chip->lun2card[lun] == SD_CARD)
2517	rtsx_status[13] = 0x20;
2518	else
2519	rtsx_status[13] = 0x30;
2520	}
2521	}
2522
2523	rtsx_status[14] = 0x78;
2524	if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2525	rtsx_status[15] = 0x83;
2526	else
2527	rtsx_status[15] = 0x82;
2528
2529	buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2530	rtsx_stor_set_xfer_buf(buffer: rtsx_status, buflen: buf_len, srb);
2531	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - buf_len);
2532
2533	return TRANSPORT_GOOD;
2534	}
2535
2536	static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2537	{
2538	unsigned int lun = SCSI_LUN(srb);
2539	u8 card, bus_width;
2540
2541	if (!check_card_ready(chip, lun)) {
2542	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2543	return TRANSPORT_FAILED;
2544	}
2545
2546	card = get_lun_card(chip, lun);
2547	if (card == SD_CARD || card == MS_CARD) {
2548	bus_width = chip->card_bus_width[lun];
2549	} else {
2550	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2551	return TRANSPORT_FAILED;
2552	}
2553
2554	scsi_set_resid(cmd: srb, resid: 0);
2555	rtsx_stor_set_xfer_buf(buffer: &bus_width, buflen: scsi_bufflen(cmd: srb), srb);
2556
2557	return TRANSPORT_GOOD;
2558	}
2559
2560	static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2561	{
2562	int result;
2563	unsigned int lun = SCSI_LUN(srb);
2564	u8 gpio_dir;
2565
2566	if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2567	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2568	return TRANSPORT_FAILED;
2569	}
2570
2571	rtsx_disable_aspm(chip);
2572
2573	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2574	rtsx_exit_ss(chip);
2575	wait_timeout(100);
2576	}
2577	rtsx_set_stat(chip, RTSX_STAT_RUN);
2578
2579	rtsx_force_power_on(chip, SSC_PDCTL);
2580
2581	rtsx_read_register(chip, CARD_GPIO_DIR, data: &gpio_dir);
2582	rtsx_write_register(chip, CARD_GPIO_DIR, mask: 0x07, data: gpio_dir & 0x06);
2583
2584	switch (srb->cmnd[2]) {
2585	case SCSI_SPI_GETSTATUS:
2586	result = spi_get_status(srb, chip);
2587	break;
2588
2589	case SCSI_SPI_SETPARAMETER:
2590	result = spi_set_parameter(srb, chip);
2591	break;
2592
2593	case SCSI_SPI_READFALSHID:
2594	result = spi_read_flash_id(srb, chip);
2595	break;
2596
2597	case SCSI_SPI_READFLASH:
2598	result = spi_read_flash(srb, chip);
2599	break;
2600
2601	case SCSI_SPI_WRITEFLASH:
2602	result = spi_write_flash(srb, chip);
2603	break;
2604
2605	case SCSI_SPI_WRITEFLASHSTATUS:
2606	result = spi_write_flash_status(srb, chip);
2607	break;
2608
2609	case SCSI_SPI_ERASEFLASH:
2610	result = spi_erase_flash(srb, chip);
2611	break;
2612
2613	default:
2614	rtsx_write_register(chip, CARD_GPIO_DIR, mask: 0x07, data: gpio_dir);
2615
2616	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2617	return TRANSPORT_FAILED;
2618	}
2619
2620	rtsx_write_register(chip, CARD_GPIO_DIR, mask: 0x07, data: gpio_dir);
2621
2622	if (result != STATUS_SUCCESS)
2623	return TRANSPORT_FAILED;
2624
2625	return TRANSPORT_GOOD;
2626	}
2627
2628	static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2629	{
2630	int result;
2631
2632	switch (srb->cmnd[1]) {
2633	case READ_STATUS:
2634	result = read_status(srb, chip);
2635	break;
2636
2637	case READ_MEM:
2638	result = read_mem(srb, chip);
2639	break;
2640
2641	case WRITE_MEM:
2642	result = write_mem(srb, chip);
2643	break;
2644
2645	case READ_EEPROM:
2646	result = read_eeprom(srb, chip);
2647	break;
2648
2649	case WRITE_EEPROM:
2650	result = write_eeprom(srb, chip);
2651	break;
2652
2653	case TOGGLE_GPIO:
2654	result = toggle_gpio_cmd(srb, chip);
2655	break;
2656
2657	case GET_SD_CSD:
2658	result = get_sd_csd(srb, chip);
2659	break;
2660
2661	case GET_BUS_WIDTH:
2662	result = get_card_bus_width(srb, chip);
2663	break;
2664
2665	case SCSI_APP_CMD:
2666	result = app_cmd(srb, chip);
2667	break;
2668
2669	case SPI_VENDOR_COMMAND:
2670	result = spi_vendor_cmd(srb, chip);
2671	break;
2672
2673	default:
2674	set_sense_type(chip, SCSI_LUN(srb),
2675	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2676	return TRANSPORT_FAILED;
2677	}
2678
2679	return result;
2680	}
2681
2682	#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2683	void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2684	{
2685	unsigned int lun = SCSI_LUN(srb);
2686	u16 sec_cnt;
2687
2688	if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10) {
2689	sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2690	} else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2691	sec_cnt = srb->cmnd[4];
2692	if (sec_cnt == 0)
2693	sec_cnt = 256;
2694	} else {
2695	return;
2696	}
2697
2698	if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2699	toggle_gpio(chip, LED_GPIO);
2700	chip->rw_cap[lun] = 0;
2701	} else {
2702	chip->rw_cap[lun] += sec_cnt;
2703	}
2704	}
2705	#endif
2706
2707	static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2708	{
2709	struct ms_info *ms_card = &chip->ms_card;
2710	unsigned int lun = SCSI_LUN(srb);
2711	bool quick_format;
2712	int retval;
2713
2714	if (get_lun_card(chip, lun) != MS_CARD) {
2715	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2716	return TRANSPORT_FAILED;
2717	}
2718
2719	if (srb->cmnd[3] != 0x4D || srb->cmnd[4] != 0x47 ||
2720	srb->cmnd[5] != 0x66 || srb->cmnd[6] != 0x6D ||
2721	srb->cmnd[7] != 0x74) {
2722	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2723	return TRANSPORT_FAILED;
2724	}
2725
2726	rtsx_disable_aspm(chip);
2727
2728	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2729	rtsx_exit_ss(chip);
2730	wait_timeout(100);
2731
2732	if (!check_card_ready(chip, lun) ||
2733	(get_card_size(chip, lun) == 0)) {
2734	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2735	return TRANSPORT_FAILED;
2736	}
2737	}
2738	rtsx_set_stat(chip, RTSX_STAT_RUN);
2739
2740	if (srb->cmnd[8] & 0x01)
2741	quick_format = false;
2742	else
2743	quick_format = true;
2744
2745	if (!(chip->card_ready & MS_CARD)) {
2746	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2747	return TRANSPORT_FAILED;
2748	}
2749
2750	if (chip->card_wp & MS_CARD) {
2751	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2752	return TRANSPORT_FAILED;
2753	}
2754
2755	if (!CHK_MSPRO(ms_card)) {
2756	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2757	return TRANSPORT_FAILED;
2758	}
2759
2760	retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2761	if (retval != STATUS_SUCCESS) {
2762	set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2763	return TRANSPORT_FAILED;
2764	}
2765
2766	scsi_set_resid(cmd: srb, resid: 0);
2767	return TRANSPORT_GOOD;
2768	}
2769
2770	#ifdef SUPPORT_PCGL_1P18
2771	static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2772	{
2773	struct ms_info *ms_card = &chip->ms_card;
2774	unsigned int lun = SCSI_LUN(srb);
2775	u8 dev_info_id, data_len;
2776	u8 *buf;
2777	unsigned int buf_len;
2778	int i;
2779
2780	if (!check_card_ready(chip, lun)) {
2781	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2782	return TRANSPORT_FAILED;
2783	}
2784	if (get_lun_card(chip, lun) != MS_CARD) {
2785	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2786	return TRANSPORT_FAILED;
2787	}
2788
2789	if (srb->cmnd[2] != 0xB0 || srb->cmnd[4] != 0x4D ||
2790	srb->cmnd[5] != 0x53 || srb->cmnd[6] != 0x49 ||
2791	srb->cmnd[7] != 0x44) {
2792	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2793	return TRANSPORT_FAILED;
2794	}
2795
2796	dev_info_id = srb->cmnd[3];
2797	if ((CHK_MSXC(ms_card) && dev_info_id == 0x10) ||
2798	(!CHK_MSXC(ms_card) && dev_info_id == 0x13) ||
2799	!CHK_MSPRO(ms_card)) {
2800	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2801	return TRANSPORT_FAILED;
2802	}
2803
2804	if (dev_info_id == 0x15) {
2805	buf_len = 0x3C;
2806	data_len = 0x3A;
2807	} else {
2808	buf_len = 0x6C;
2809	data_len = 0x6A;
2810	}
2811
2812	buf = kmalloc(size: buf_len, GFP_KERNEL);
2813	if (!buf)
2814	return TRANSPORT_ERROR;
2815
2816	i = 0;
2817	/* GET Memory Stick Media Information Response Header */
2818	buf[i++] = 0x00; /* Data length MSB */
2819	buf[i++] = data_len; /* Data length LSB */
2820	/* Device Information Type Code */
2821	if (CHK_MSXC(ms_card))
2822	buf[i++] = 0x03;
2823	else
2824	buf[i++] = 0x02;
2825
2826	/* SGM bit */
2827	buf[i++] = 0x01;
2828	/* Reserved */
2829	buf[i++] = 0x00;
2830	buf[i++] = 0x00;
2831	buf[i++] = 0x00;
2832	/* Number of Device Information */
2833	buf[i++] = 0x01;
2834
2835	/* Device Information Body */
2836
2837	/* Device Information ID Number */
2838	buf[i++] = dev_info_id;
2839	/* Device Information Length */
2840	if (dev_info_id == 0x15)
2841	data_len = 0x31;
2842	else
2843	data_len = 0x61;
2844
2845	buf[i++] = 0x00; /* Data length MSB */
2846	buf[i++] = data_len; /* Data length LSB */
2847	/* Valid Bit */
2848	buf[i++] = 0x80;
2849	if (dev_info_id == 0x10 || dev_info_id == 0x13) {
2850	/* System Information */
2851	memcpy(buf + i, ms_card->raw_sys_info, 96);
2852	} else {
2853	/* Model Name */
2854	memcpy(buf + i, ms_card->raw_model_name, 48);
2855	}
2856
2857	rtsx_stor_set_xfer_buf(buffer: buf, buflen: buf_len, srb);
2858	scsi_set_resid(cmd: srb, resid: scsi_bufflen(cmd: srb) - buf_len);
2859
2860	kfree(objp: buf);
2861	return STATUS_SUCCESS;
2862	}
2863	#endif
2864
2865	static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2866	{
2867	int retval = TRANSPORT_ERROR;
2868
2869	if (srb->cmnd[2] == MS_FORMAT)
2870	retval = ms_format_cmnd(srb, chip);
2871	#ifdef SUPPORT_PCGL_1P18
2872	else if (srb->cmnd[2] == GET_MS_INFORMATION)
2873	retval = get_ms_information(srb, chip);
2874	#endif
2875
2876	return retval;
2877	}
2878
2879	#ifdef SUPPORT_CPRM
2880	static int sd_extension_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2881	{
2882	unsigned int lun = SCSI_LUN(srb);
2883	int result;
2884
2885	rtsx_disable_aspm(chip);
2886
2887	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2888	rtsx_exit_ss(chip);
2889	wait_timeout(100);
2890	}
2891	rtsx_set_stat(chip, RTSX_STAT_RUN);
2892
2893	sd_cleanup_work(chip);
2894
2895	if (!check_card_ready(chip, lun)) {
2896	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2897	return TRANSPORT_FAILED;
2898	}
2899	if (get_lun_card(chip, lun) != SD_CARD) {
2900	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2901	return TRANSPORT_FAILED;
2902	}
2903
2904	switch (srb->cmnd[0]) {
2905	case SD_PASS_THRU_MODE:
2906	result = sd_pass_thru_mode(srb, chip);
2907	break;
2908
2909	case SD_EXECUTE_NO_DATA:
2910	result = sd_execute_no_data(srb, chip);
2911	break;
2912
2913	case SD_EXECUTE_READ:
2914	result = sd_execute_read_data(srb, chip);
2915	break;
2916
2917	case SD_EXECUTE_WRITE:
2918	result = sd_execute_write_data(srb, chip);
2919	break;
2920
2921	case SD_GET_RSP:
2922	result = sd_get_cmd_rsp(srb, chip);
2923	break;
2924
2925	case SD_HW_RST:
2926	result = sd_hw_rst(srb, chip);
2927	break;
2928
2929	default:
2930	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2931	return TRANSPORT_FAILED;
2932	}
2933
2934	return result;
2935	}
2936	#endif
2937
2938	#ifdef SUPPORT_MAGIC_GATE
2939	static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2940	{
2941	struct ms_info *ms_card = &chip->ms_card;
2942	unsigned int lun = SCSI_LUN(srb);
2943	int retval;
2944	u8 key_format;
2945
2946	rtsx_disable_aspm(chip);
2947
2948	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2949	rtsx_exit_ss(chip);
2950	wait_timeout(100);
2951	}
2952	rtsx_set_stat(chip, RTSX_STAT_RUN);
2953
2954	ms_cleanup_work(chip);
2955
2956	if (!check_card_ready(chip, lun)) {
2957	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2958	return TRANSPORT_FAILED;
2959	}
2960	if (get_lun_card(chip, lun) != MS_CARD) {
2961	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2962	return TRANSPORT_FAILED;
2963	}
2964
2965	if (srb->cmnd[7] != KC_MG_R_PRO) {
2966	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2967	return TRANSPORT_FAILED;
2968	}
2969
2970	if (!CHK_MSPRO(ms_card)) {
2971	set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
2972	return TRANSPORT_FAILED;
2973	}
2974
2975	key_format = srb->cmnd[10] & 0x3F;
2976	dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
2977
2978	switch (key_format) {
2979	case KF_GET_LOC_EKB:
2980	if ((scsi_bufflen(cmd: srb) == 0x41C) &&
2981	srb->cmnd[8] == 0x04 &&
2982	srb->cmnd[9] == 0x1C) {
2983	retval = mg_get_local_EKB(srb, chip);
2984	if (retval != STATUS_SUCCESS)
2985	return TRANSPORT_FAILED;
2986
2987	} else {
2988	set_sense_type(chip, lun,
2989	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2990	return TRANSPORT_FAILED;
2991	}
2992	break;
2993
2994	case KF_RSP_CHG:
2995	if ((scsi_bufflen(cmd: srb) == 0x24) &&
2996	srb->cmnd[8] == 0x00 &&
2997	srb->cmnd[9] == 0x24) {
2998	retval = mg_get_rsp_chg(srb, chip);
2999	if (retval != STATUS_SUCCESS)
3000	return TRANSPORT_FAILED;
3001
3002	} else {
3003	set_sense_type(chip, lun,
3004	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3005	return TRANSPORT_FAILED;
3006	}
3007	break;
3008
3009	case KF_GET_ICV:
3010	ms_card->mg_entry_num = srb->cmnd[5];
3011	if ((scsi_bufflen(cmd: srb) == 0x404) &&
3012	srb->cmnd[8] == 0x04 &&
3013	srb->cmnd[9] == 0x04 &&
3014	srb->cmnd[2] == 0x00 &&
3015	srb->cmnd[3] == 0x00 &&
3016	srb->cmnd[4] == 0x00 &&
3017	srb->cmnd[5] < 32) {
3018	retval = mg_get_ICV(srb, chip);
3019	if (retval != STATUS_SUCCESS)
3020	return TRANSPORT_FAILED;
3021
3022	} else {
3023	set_sense_type(chip, lun,
3024	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3025	return TRANSPORT_FAILED;
3026	}
3027	break;
3028
3029	default:
3030	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3031	return TRANSPORT_FAILED;
3032	}
3033
3034	scsi_set_resid(cmd: srb, resid: 0);
3035	return TRANSPORT_GOOD;
3036	}
3037
3038	static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3039	{
3040	struct ms_info *ms_card = &chip->ms_card;
3041	unsigned int lun = SCSI_LUN(srb);
3042	int retval;
3043	u8 key_format;
3044
3045	rtsx_disable_aspm(chip);
3046
3047	if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3048	rtsx_exit_ss(chip);
3049	wait_timeout(100);
3050	}
3051	rtsx_set_stat(chip, RTSX_STAT_RUN);
3052
3053	ms_cleanup_work(chip);
3054
3055	if (!check_card_ready(chip, lun)) {
3056	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3057	return TRANSPORT_FAILED;
3058	}
3059	if (check_card_wp(chip, lun)) {
3060	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3061	return TRANSPORT_FAILED;
3062	}
3063	if (get_lun_card(chip, lun) != MS_CARD) {
3064	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3065	return TRANSPORT_FAILED;
3066	}
3067
3068	if (srb->cmnd[7] != KC_MG_R_PRO) {
3069	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3070	return TRANSPORT_FAILED;
3071	}
3072
3073	if (!CHK_MSPRO(ms_card)) {
3074	set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3075	return TRANSPORT_FAILED;
3076	}
3077
3078	key_format = srb->cmnd[10] & 0x3F;
3079	dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3080
3081	switch (key_format) {
3082	case KF_SET_LEAF_ID:
3083	if ((scsi_bufflen(cmd: srb) == 0x0C) &&
3084	srb->cmnd[8] == 0x00 &&
3085	srb->cmnd[9] == 0x0C) {
3086	retval = mg_set_leaf_id(srb, chip);
3087	if (retval != STATUS_SUCCESS)
3088	return TRANSPORT_FAILED;
3089
3090	} else {
3091	set_sense_type(chip, lun,
3092	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3093	return TRANSPORT_FAILED;
3094	}
3095	break;
3096
3097	case KF_CHG_HOST:
3098	if ((scsi_bufflen(cmd: srb) == 0x0C) &&
3099	srb->cmnd[8] == 0x00 &&
3100	srb->cmnd[9] == 0x0C) {
3101	retval = mg_chg(srb, chip);
3102	if (retval != STATUS_SUCCESS)
3103	return TRANSPORT_FAILED;
3104
3105	} else {
3106	set_sense_type(chip, lun,
3107	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3108	return TRANSPORT_FAILED;
3109	}
3110	break;
3111
3112	case KF_RSP_HOST:
3113	if ((scsi_bufflen(cmd: srb) == 0x0C) &&
3114	srb->cmnd[8] == 0x00 &&
3115	srb->cmnd[9] == 0x0C) {
3116	retval = mg_rsp(srb, chip);
3117	if (retval != STATUS_SUCCESS)
3118	return TRANSPORT_FAILED;
3119
3120	} else {
3121	set_sense_type(chip, lun,
3122	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3123	return TRANSPORT_FAILED;
3124	}
3125	break;
3126
3127	case KF_SET_ICV:
3128	ms_card->mg_entry_num = srb->cmnd[5];
3129	if ((scsi_bufflen(cmd: srb) == 0x404) &&
3130	srb->cmnd[8] == 0x04 &&
3131	srb->cmnd[9] == 0x04 &&
3132	srb->cmnd[2] == 0x00 &&
3133	srb->cmnd[3] == 0x00 &&
3134	srb->cmnd[4] == 0x00 &&
3135	srb->cmnd[5] < 32) {
3136	retval = mg_set_ICV(srb, chip);
3137	if (retval != STATUS_SUCCESS)
3138	return TRANSPORT_FAILED;
3139
3140	} else {
3141	set_sense_type(chip, lun,
3142	SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3143	return TRANSPORT_FAILED;
3144	}
3145	break;
3146
3147	default:
3148	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3149	return TRANSPORT_FAILED;
3150	}
3151
3152	scsi_set_resid(cmd: srb, resid: 0);
3153	return TRANSPORT_GOOD;
3154	}
3155	#endif
3156
3157	int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3158	{
3159	#ifdef SUPPORT_SD_LOCK
3160	struct sd_info *sd_card = &chip->sd_card;
3161	#endif
3162	struct ms_info *ms_card = &chip->ms_card;
3163	unsigned int lun = SCSI_LUN(srb);
3164	int result;
3165
3166	#ifdef SUPPORT_SD_LOCK
3167	if (sd_card->sd_erase_status) {
3168	/* Block all SCSI command except for
3169	* REQUEST_SENSE and rs_ppstatus
3170	*/
3171	if (!(srb->cmnd[0] == VENDOR_CMND &&
3172	srb->cmnd[1] == SCSI_APP_CMD &&
3173	srb->cmnd[2] == GET_DEV_STATUS) &&
3174	srb->cmnd[0] != REQUEST_SENSE) {
3175	/* Logical Unit Not Ready Format in Progress */
3176	set_sense_data(chip, lun, CUR_ERR,
3177	sense_key: 0x02, info: 0, asc: 0x04, ascq: 0x04, sns_key_info0: 0, sns_key_info1: 0);
3178	return TRANSPORT_FAILED;
3179	}
3180	}
3181	#endif
3182
3183	if ((get_lun_card(chip, lun) == MS_CARD) &&
3184	ms_card->format_status == FORMAT_IN_PROGRESS) {
3185	if (srb->cmnd[0] != REQUEST_SENSE &&
3186	srb->cmnd[0] != INQUIRY) {
3187	/* Logical Unit Not Ready Format in Progress */
3188	set_sense_data(chip, lun, CUR_ERR, sense_key: 0x02, info: 0, asc: 0x04, ascq: 0x04,
3189	sns_key_info0: 0, sns_key_info1: (u16)(ms_card->progress));
3190	return TRANSPORT_FAILED;
3191	}
3192	}
3193
3194	switch (srb->cmnd[0]) {
3195	case READ_10:
3196	case WRITE_10:
3197	case READ_6:
3198	case WRITE_6:
3199	result = read_write(srb, chip);
3200	#if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3201	led_shine(srb, chip);
3202	#endif
3203	break;
3204
3205	case TEST_UNIT_READY:
3206	result = test_unit_ready(srb, chip);
3207	break;
3208
3209	case INQUIRY:
3210	result = inquiry(srb, chip);
3211	break;
3212
3213	case READ_CAPACITY:
3214	result = read_capacity(srb, chip);
3215	break;
3216
3217	case START_STOP:
3218	result = start_stop_unit(srb, chip);
3219	break;
3220
3221	case ALLOW_MEDIUM_REMOVAL:
3222	result = allow_medium_removal(srb, chip);
3223	break;
3224
3225	case REQUEST_SENSE:
3226	result = request_sense(srb, chip);
3227	break;
3228
3229	case MODE_SENSE:
3230	case MODE_SENSE_10:
3231	result = mode_sense(srb, chip);
3232	break;
3233
3234	case 0x23:
3235	result = read_format_capacity(srb, chip);
3236	break;
3237
3238	case VENDOR_CMND:
3239	result = vendor_cmnd(srb, chip);
3240	break;
3241
3242	case MS_SP_CMND:
3243	result = ms_sp_cmnd(srb, chip);
3244	break;
3245
3246	#ifdef SUPPORT_CPRM
3247	case SD_PASS_THRU_MODE:
3248	case SD_EXECUTE_NO_DATA:
3249	case SD_EXECUTE_READ:
3250	case SD_EXECUTE_WRITE:
3251	case SD_GET_RSP:
3252	case SD_HW_RST:
3253	result = sd_extension_cmnd(srb, chip);
3254	break;
3255	#endif
3256
3257	#ifdef SUPPORT_MAGIC_GATE
3258	case CMD_MSPRO_MG_RKEY:
3259	result = mg_report_key(srb, chip);
3260	break;
3261
3262	case CMD_MSPRO_MG_SKEY:
3263	result = mg_send_key(srb, chip);
3264	break;
3265	#endif
3266
3267	case FORMAT_UNIT:
3268	case MODE_SELECT:
3269	case VERIFY:
3270	result = TRANSPORT_GOOD;
3271	break;
3272
3273	default:
3274	set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3275	result = TRANSPORT_FAILED;
3276	}
3277
3278	return result;
3279	}
3280