forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/drivers/staging/rts5208/sd.c
....@@ -1,19 +1,8 @@
1
-/* Driver for Realtek PCI-Express card reader
1
+// SPDX-License-Identifier: GPL-2.0+
2
+/*
3
+ * Driver for Realtek PCI-Express card reader
24  *
35  * Copyright(c) 2009-2013 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/>.
176  *
187  * Author:
198  *   Wei WANG (wei_wang@realsil.com.cn)
....@@ -109,9 +98,8 @@
10998 	u8 stat;
11099 
111100 	retval = rtsx_read_register(chip, REG_SD_STAT1, &stat);
112
-	if (retval) {
101
+	if (retval)
113102 		return retval;
114
-	}
115103 
116104 	if (!(stat & SD_DAT0_STATUS)) {
117105 		sd_set_err_code(chip, SD_BUSY);
....@@ -234,9 +222,8 @@
234222 		if ((cmd_idx != SEND_RELATIVE_ADDR) &&
235223 		    (cmd_idx != SEND_IF_COND)) {
236224 			if (cmd_idx != STOP_TRANSMISSION) {
237
-				if (ptr[1] & 0x80) {
225
+				if (ptr[1] & 0x80)
238226 					return STATUS_FAIL;
239
-				}
240227 			}
241228 #ifdef SUPPORT_SD_LOCK
242229 			if (ptr[1] & 0x7D) {
....@@ -284,9 +271,8 @@
284271 	if (!buf)
285272 		buf_len = 0;
286273 
287
-	if (buf_len > 512) {
274
+	if (buf_len > 512)
288275 		return STATUS_FAIL;
289
-	}
290276 
291277 	rtsx_init_cmd(chip);
292278 
....@@ -331,9 +317,8 @@
331317 
332318 	if (buf && buf_len) {
333319 		retval = rtsx_read_ppbuf(chip, buf, buf_len);
334
-		if (retval != STATUS_SUCCESS) {
320
+		if (retval != STATUS_SUCCESS)
335321 			return STATUS_FAIL;
336
-		}
337322 	}
338323 
339324 	return STATUS_SUCCESS;
....@@ -359,9 +344,8 @@
359344 
360345 	if (buf && buf_len) {
361346 		retval = rtsx_write_ppbuf(chip, buf, buf_len);
362
-		if (retval != STATUS_SUCCESS) {
347
+		if (retval != STATUS_SUCCESS)
363348 			return STATUS_FAIL;
364
-		}
365349 	}
366350 
367351 	rtsx_init_cmd(chip);
....@@ -426,9 +410,8 @@
426410 			break;
427411 	}
428412 
429
-	if (i == 6) {
413
+	if (i == 6)
430414 		return STATUS_FAIL;
431
-	}
432415 
433416 	memcpy(sd_card->raw_csd, rsp + 1, 15);
434417 
....@@ -543,9 +526,8 @@
543526 	}
544527 
545528 	retval = rtsx_write_register(chip, REG_SD_CFG1, 0x1C, val);
546
-	if (retval) {
529
+	if (retval)
547530 		return retval;
548
-	}
549531 
550532 	return STATUS_SUCCESS;
551533 }
....@@ -606,9 +588,8 @@
606588 		val = 0x20;
607589 
608590 	retval = rtsx_write_register(chip, REG_SD_CFG1, mask, val);
609
-	if (retval) {
591
+	if (retval)
610592 		return retval;
611
-	}
612593 
613594 	return STATUS_SUCCESS;
614595 }
....@@ -619,16 +600,14 @@
619600 	int retval;
620601 
621602 	retval = sd_set_sample_push_timing(chip);
622
-	if (retval != STATUS_SUCCESS) {
603
+	if (retval != STATUS_SUCCESS)
623604 		return STATUS_FAIL;
624
-	}
625605 
626606 	sd_choose_proper_clock(chip);
627607 
628608 	retval = switch_clock(chip, sd_card->sd_clock);
629
-	if (retval != STATUS_SUCCESS) {
609
+	if (retval != STATUS_SUCCESS)
630610 		return STATUS_FAIL;
631
-	}
632611 
633612 	return STATUS_SUCCESS;
634613 }
....@@ -651,9 +630,8 @@
651630 	}
652631 
653632 	retval = sd_send_cmd_get_rsp(chip, cmd_idx, addr, cmd_type, NULL, 0);
654
-	if (retval != STATUS_SUCCESS) {
633
+	if (retval != STATUS_SUCCESS)
655634 		return STATUS_FAIL;
656
-	}
657635 
658636 	return STATUS_SUCCESS;
659637 }
....@@ -667,9 +645,8 @@
667645 
668646 	retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
669647 				     SD_RSP_TYPE_R1, rsp, 5);
670
-	if (retval != STATUS_SUCCESS) {
648
+	if (retval != STATUS_SUCCESS)
671649 		return STATUS_FAIL;
672
-	}
673650 
674651 	if (rsp[1] & 0x02)
675652 		sd_card->sd_lock_status |= SD_LOCKED;
....@@ -679,9 +656,8 @@
679656 	dev_dbg(rtsx_dev(chip), "sd_card->sd_lock_status = 0x%x\n",
680657 		sd_card->sd_lock_status);
681658 
682
-	if (rsp[1] & 0x01) {
659
+	if (rsp[1] & 0x01)
683660 		return STATUS_FAIL;
684
-	}
685661 
686662 	return STATUS_SUCCESS;
687663 }
....@@ -698,9 +674,8 @@
698674 		retval = sd_send_cmd_get_rsp(chip, SEND_STATUS,
699675 					     sd_card->sd_addr, SD_RSP_TYPE_R1,
700676 					     rsp, 5);
701
-		if (retval != STATUS_SUCCESS) {
677
+		if (retval != STATUS_SUCCESS)
702678 			return STATUS_FAIL;
703
-		}
704679 
705680 		if (((rsp[3] & 0x1E) == state) &&
706681 		    ((rsp[3] & 0x01) == data_ready))
....@@ -719,31 +694,27 @@
719694 			retval = rtsx_write_phy_register(chip, 0x08,
720695 							 0x4FC0 |
721696 							 chip->phy_voltage);
722
-			if (retval != STATUS_SUCCESS) {
697
+			if (retval != STATUS_SUCCESS)
723698 				return STATUS_FAIL;
724
-			}
725699 		} else {
726700 			retval = rtsx_write_register(chip, SD_PAD_CTL,
727701 						     SD_IO_USING_1V8, 0);
728
-			if (retval) {
702
+			if (retval)
729703 				return retval;
730
-			}
731704 		}
732705 	} else if (voltage == SD_IO_1V8) {
733706 		if (chip->asic_code) {
734707 			retval = rtsx_write_phy_register(chip, 0x08,
735708 							 0x4C40 |
736709 							 chip->phy_voltage);
737
-			if (retval != STATUS_SUCCESS) {
710
+			if (retval != STATUS_SUCCESS)
738711 				return STATUS_FAIL;
739
-			}
740712 		} else {
741713 			retval = rtsx_write_register(chip, SD_PAD_CTL,
742714 						     SD_IO_USING_1V8,
743715 						     SD_IO_USING_1V8);
744
-			if (retval) {
716
+			if (retval)
745717 				return retval;
746
-			}
747718 		}
748719 	} else {
749720 		return STATUS_FAIL;
....@@ -760,22 +731,19 @@
760731 	retval = rtsx_write_register(chip, SD_BUS_STAT,
761732 				     SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP,
762733 				     SD_CLK_TOGGLE_EN);
763
-	if (retval) {
734
+	if (retval)
764735 		return retval;
765
-	}
766736 
767737 	retval = sd_send_cmd_get_rsp(chip, VOLTAGE_SWITCH, 0, SD_RSP_TYPE_R1,
768738 				     NULL, 0);
769
-	if (retval != STATUS_SUCCESS) {
739
+	if (retval != STATUS_SUCCESS)
770740 		return STATUS_FAIL;
771
-	}
772741 
773742 	udelay(chip->sd_voltage_switch_delay);
774743 
775744 	retval = rtsx_read_register(chip, SD_BUS_STAT, &stat);
776
-	if (retval) {
745
+	if (retval)
777746 		return retval;
778
-	}
779747 	if (stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
780748 				SD_DAT1_STATUS | SD_DAT0_STATUS)) {
781749 		return STATUS_FAIL;
....@@ -783,27 +751,23 @@
783751 
784752 	retval = rtsx_write_register(chip, SD_BUS_STAT, 0xFF,
785753 				     SD_CLK_FORCE_STOP);
786
-	if (retval) {
754
+	if (retval)
787755 		return retval;
788
-	}
789756 	retval = sd_change_bank_voltage(chip, SD_IO_1V8);
790
-	if (retval != STATUS_SUCCESS) {
757
+	if (retval != STATUS_SUCCESS)
791758 		return STATUS_FAIL;
792
-	}
793759 
794760 	wait_timeout(50);
795761 
796762 	retval = rtsx_write_register(chip, SD_BUS_STAT, 0xFF,
797763 				     SD_CLK_TOGGLE_EN);
798
-	if (retval) {
764
+	if (retval)
799765 		return retval;
800
-	}
801766 	wait_timeout(10);
802767 
803768 	retval = rtsx_read_register(chip, SD_BUS_STAT, &stat);
804
-	if (retval) {
769
+	if (retval)
805770 		return retval;
806
-	}
807771 	if ((stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
808772 				SD_DAT1_STATUS | SD_DAT0_STATUS)) !=
809773 			(SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS |
....@@ -817,9 +781,8 @@
817781 
818782 	retval = rtsx_write_register(chip, SD_BUS_STAT,
819783 				     SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0);
820
-	if (retval) {
784
+	if (retval)
821785 		return retval;
822
-	}
823786 
824787 	return STATUS_SUCCESS;
825788 }
....@@ -831,23 +794,19 @@
831794 	if (tune_dir == TUNE_RX) {
832795 		retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF,
833796 					     DCM_RESET | DCM_RX);
834
-		if (retval) {
797
+		if (retval)
835798 			return retval;
836
-		}
837799 		retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, DCM_RX);
838
-		if (retval) {
800
+		if (retval)
839801 			return retval;
840
-		}
841802 	} else {
842803 		retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF,
843804 					     DCM_RESET | DCM_TX);
844
-		if (retval) {
805
+		if (retval)
845806 			return retval;
846
-		}
847807 		retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, DCM_TX);
848
-		if (retval) {
808
+		if (retval)
849809 			return retval;
850
-		}
851810 	}
852811 
853812 	return STATUS_SUCCESS;
....@@ -877,28 +836,23 @@
877836 	if (chip->asic_code) {
878837 		retval = rtsx_write_register(chip, CLK_CTL, CHANGE_CLK,
879838 					     CHANGE_CLK);
880
-		if (retval) {
839
+		if (retval)
881840 			return retval;
882
-		}
883841 		retval = rtsx_write_register(chip, SD_VP_CTL, 0x1F,
884842 					     sample_point);
885
-		if (retval) {
843
+		if (retval)
886844 			return retval;
887
-		}
888845 		retval = rtsx_write_register(chip, SD_VPCLK0_CTL,
889846 					     PHASE_NOT_RESET, 0);
890
-		if (retval) {
847
+		if (retval)
891848 			return retval;
892
-		}
893849 		retval = rtsx_write_register(chip, SD_VPCLK0_CTL,
894850 					     PHASE_NOT_RESET, PHASE_NOT_RESET);
895
-		if (retval) {
851
+		if (retval)
896852 			return retval;
897
-		}
898853 		retval = rtsx_write_register(chip, CLK_CTL, CHANGE_CLK, 0);
899
-		if (retval) {
854
+		if (retval)
900855 			return retval;
901
-		}
902856 	} else {
903857 		rtsx_read_register(chip, SD_VP_CTL, &val);
904858 		dev_dbg(rtsx_dev(chip), "SD_VP_CTL: 0x%x\n", val);
....@@ -909,30 +863,26 @@
909863 			retval = rtsx_write_register(chip, SD_VP_CTL,
910864 						     PHASE_CHANGE,
911865 						     PHASE_CHANGE);
912
-			if (retval) {
866
+			if (retval)
913867 				return retval;
914
-			}
915868 			udelay(50);
916869 			retval = rtsx_write_register(chip, SD_VP_CTL, 0xFF,
917870 						     PHASE_CHANGE |
918871 						     PHASE_NOT_RESET |
919872 						     sample_point);
920
-			if (retval) {
873
+			if (retval)
921874 				return retval;
922
-			}
923875 		} else {
924876 			retval = rtsx_write_register(chip, CLK_CTL,
925877 						     CHANGE_CLK, CHANGE_CLK);
926
-			if (retval) {
878
+			if (retval)
927879 				return retval;
928
-			}
929880 			udelay(50);
930881 			retval = rtsx_write_register(chip, SD_VP_CTL, 0xFF,
931882 						     PHASE_NOT_RESET |
932883 						     sample_point);
933
-			if (retval) {
884
+			if (retval)
934885 				return retval;
935
-			}
936886 		}
937887 		udelay(100);
938888 
....@@ -942,45 +892,38 @@
942892 		rtsx_add_cmd(chip, CHECK_REG_CMD, SD_DCMPS_CTL,
943893 			     DCMPS_CHANGE_DONE, DCMPS_CHANGE_DONE);
944894 		retval = rtsx_send_cmd(chip, SD_CARD, 100);
945
-		if (retval != STATUS_SUCCESS) {
895
+		if (retval != STATUS_SUCCESS)
946896 			goto fail;
947
-		}
948897 
949898 		val = *rtsx_get_cmd_data(chip);
950
-		if (val & DCMPS_ERROR) {
899
+		if (val & DCMPS_ERROR)
951900 			goto fail;
952
-		}
953901 
954
-		if ((val & DCMPS_CURRENT_PHASE) != sample_point) {
902
+		if ((val & DCMPS_CURRENT_PHASE) != sample_point)
955903 			goto fail;
956
-		}
957904 
958905 		retval = rtsx_write_register(chip, SD_DCMPS_CTL,
959906 					     DCMPS_CHANGE, 0);
960
-		if (retval) {
907
+		if (retval)
961908 			return retval;
962
-		}
963909 		if (ddr_rx) {
964910 			retval = rtsx_write_register(chip, SD_VP_CTL,
965911 						     PHASE_CHANGE, 0);
966
-			if (retval) {
912
+			if (retval)
967913 				return retval;
968
-			}
969914 		} else {
970915 			retval = rtsx_write_register(chip, CLK_CTL,
971916 						     CHANGE_CLK, 0);
972
-			if (retval) {
917
+			if (retval)
973918 				return retval;
974
-			}
975919 		}
976920 
977921 		udelay(50);
978922 	}
979923 
980924 	retval = rtsx_write_register(chip, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0);
981
-	if (retval) {
925
+	if (retval)
982926 		return retval;
983
-	}
984927 
985928 	return STATUS_SUCCESS;
986929 
....@@ -1005,9 +948,8 @@
1005948 
1006949 	retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
1007950 				     SD_RSP_TYPE_R1, NULL, 0);
1008
-	if (retval != STATUS_SUCCESS) {
951
+	if (retval != STATUS_SUCCESS)
1009952 		return STATUS_FAIL;
1010
-	}
1011953 
1012954 	cmd[0] = 0x40 | SEND_SCR;
1013955 	cmd[1] = 0;
....@@ -1024,9 +966,8 @@
1024966 
1025967 	memcpy(sd_card->raw_scr, buf, 8);
1026968 
1027
-	if ((buf[0] & 0x0F) == 0) {
969
+	if ((buf[0] & 0x0F) == 0)
1028970 		return STATUS_FAIL;
1029
-	}
1030971 
1031972 	return STATUS_SUCCESS;
1032973 }
....@@ -1207,29 +1148,25 @@
12071148 
12081149 		dev_dbg(rtsx_dev(chip), "Maximum current consumption: %dmA\n",
12091150 			cc);
1210
-		if ((cc == 0) || (cc > 800)) {
1151
+		if ((cc == 0) || (cc > 800))
12111152 			return STATUS_FAIL;
1212
-		}
12131153 
12141154 		retval = sd_query_switch_result(chip, func_group,
12151155 						func_to_switch, buf, 64);
1216
-		if (retval != STATUS_SUCCESS) {
1156
+		if (retval != STATUS_SUCCESS)
12171157 			return STATUS_FAIL;
1218
-		}
12191158 
12201159 		if ((cc > 400) || (func_to_switch > CURRENT_LIMIT_400)) {
12211160 			retval = rtsx_write_register(chip, OCPPARA2,
12221161 						     SD_OCP_THD_MASK,
12231162 						     chip->sd_800mA_ocp_thd);
1224
-			if (retval) {
1163
+			if (retval)
12251164 				return retval;
1226
-			}
12271165 			retval = rtsx_write_register(chip, CARD_PWR_CTL,
12281166 						     PMOS_STRG_MASK,
12291167 						     PMOS_STRG_800mA);
1230
-			if (retval) {
1168
+			if (retval)
12311169 				return retval;
1232
-			}
12331170 		}
12341171 	}
12351172 
....@@ -1278,9 +1215,8 @@
12781215 			}
12791216 
12801217 			retval = rtsx_read_register(chip, SD_STAT1, &stat);
1281
-			if (retval) {
1218
+			if (retval)
12821219 				return retval;
1283
-			}
12841220 			if (stat & SD_CRC16_ERR) {
12851221 				dev_dbg(rtsx_dev(chip), "SD CRC16 error when switching mode\n");
12861222 				return STATUS_FAIL;
....@@ -1293,9 +1229,8 @@
12931229 		wait_timeout(20);
12941230 	}
12951231 
1296
-	if (!switch_good) {
1232
+	if (!switch_good)
12971233 		return STATUS_FAIL;
1298
-	}
12991234 
13001235 	return STATUS_SUCCESS;
13011236 }
....@@ -1310,9 +1245,8 @@
13101245 	/* Get supported functions */
13111246 	retval = sd_check_switch_mode(chip, SD_CHECK_MODE, NO_ARGUMENT,
13121247 				      NO_ARGUMENT, bus_width);
1313
-	if (retval != STATUS_SUCCESS) {
1248
+	if (retval != STATUS_SUCCESS)
13141249 		return STATUS_FAIL;
1315
-	}
13161250 
13171251 	sd_card->func_group1_mask &= ~(sd_card->sd_switch_fail);
13181252 
....@@ -1394,13 +1328,11 @@
13941328 	if (CHK_SD_DDR50(sd_card)) {
13951329 		retval = rtsx_write_register(chip, SD_PUSH_POINT_CTL, 0x06,
13961330 					     0x04);
1397
-		if (retval) {
1331
+		if (retval)
13981332 			return retval;
1399
-		}
14001333 		retval = sd_set_sample_push_timing(chip);
1401
-		if (retval != STATUS_SUCCESS) {
1334
+		if (retval != STATUS_SUCCESS)
14021335 			return STATUS_FAIL;
1403
-		}
14041336 	}
14051337 
14061338 	if (!func_to_switch || (func_to_switch == HS_SUPPORT)) {
....@@ -1454,9 +1386,8 @@
14541386 		retval = sd_check_switch(chip, SD_FUNC_GROUP_4, func_to_switch,
14551387 					 bus_width);
14561388 		if (retval != STATUS_SUCCESS) {
1457
-			if (sd_check_err_code(chip, SD_NO_CARD)) {
1389
+			if (sd_check_err_code(chip, SD_NO_CARD))
14581390 				return STATUS_FAIL;
1459
-			}
14601391 		}
14611392 		dev_dbg(rtsx_dev(chip), "Switch current limit finished! (%d)\n",
14621393 			retval);
....@@ -1464,9 +1395,8 @@
14641395 
14651396 	if (CHK_SD_DDR50(sd_card)) {
14661397 		retval = rtsx_write_register(chip, SD_PUSH_POINT_CTL, 0x06, 0);
1467
-		if (retval) {
1398
+		if (retval)
14681399 			return retval;
1469
-		}
14701400 	}
14711401 
14721402 	return STATUS_SUCCESS;
....@@ -1480,9 +1410,8 @@
14801410 
14811411 	for (i = 0; i < 100; i++) {
14821412 		retval = rtsx_read_register(chip, SD_DATA_STATE, &val);
1483
-		if (retval) {
1413
+		if (retval)
14841414 			return retval;
1485
-		}
14861415 		if (val & SD_DATA_IDLE) {
14871416 			retval = STATUS_SUCCESS;
14881417 			break;
....@@ -1500,9 +1429,8 @@
15001429 	u8 cmd[5];
15011430 
15021431 	retval = sd_change_phase(chip, sample_point, TUNE_RX);
1503
-	if (retval != STATUS_SUCCESS) {
1432
+	if (retval != STATUS_SUCCESS)
15041433 		return STATUS_FAIL;
1505
-	}
15061434 
15071435 	cmd[0] = 0x40 | SEND_TUNING_PATTERN;
15081436 	cmd[1] = 0;
....@@ -1529,17 +1457,15 @@
15291457 	u8 cmd[5];
15301458 
15311459 	retval = sd_change_phase(chip, sample_point, TUNE_RX);
1532
-	if (retval != STATUS_SUCCESS) {
1460
+	if (retval != STATUS_SUCCESS)
15331461 		return STATUS_FAIL;
1534
-	}
15351462 
15361463 	dev_dbg(rtsx_dev(chip), "sd ddr tuning rx\n");
15371464 
15381465 	retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
15391466 				     SD_RSP_TYPE_R1, NULL, 0);
1540
-	if (retval != STATUS_SUCCESS) {
1467
+	if (retval != STATUS_SUCCESS)
15411468 		return STATUS_FAIL;
1542
-	}
15431469 
15441470 	cmd[0] = 0x40 | SD_STATUS;
15451471 	cmd[1] = 0;
....@@ -1573,9 +1499,8 @@
15731499 		bus_width = SD_BUS_WIDTH_1;
15741500 
15751501 	retval = sd_change_phase(chip, sample_point, TUNE_RX);
1576
-	if (retval != STATUS_SUCCESS) {
1502
+	if (retval != STATUS_SUCCESS)
15771503 		return STATUS_FAIL;
1578
-	}
15791504 
15801505 	dev_dbg(rtsx_dev(chip), "mmc ddr tuning rx\n");
15811506 
....@@ -1603,15 +1528,13 @@
16031528 	int retval;
16041529 
16051530 	retval = sd_change_phase(chip, sample_point, TUNE_TX);
1606
-	if (retval != STATUS_SUCCESS) {
1531
+	if (retval != STATUS_SUCCESS)
16071532 		return STATUS_FAIL;
1608
-	}
16091533 
16101534 	retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
16111535 				     SD_RSP_80CLK_TIMEOUT_EN);
1612
-	if (retval) {
1536
+	if (retval)
16131537 		return retval;
1614
-	}
16151538 
16161539 	retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
16171540 				     SD_RSP_TYPE_R1, NULL, 0);
....@@ -1625,9 +1548,8 @@
16251548 
16261549 	retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
16271550 				     0);
1628
-	if (retval) {
1551
+	if (retval)
16291552 		return retval;
1630
-	}
16311553 
16321554 	return STATUS_SUCCESS;
16331555 }
....@@ -1639,9 +1561,8 @@
16391561 	u8 cmd[5], bus_width;
16401562 
16411563 	retval = sd_change_phase(chip, sample_point, TUNE_TX);
1642
-	if (retval != STATUS_SUCCESS) {
1564
+	if (retval != STATUS_SUCCESS)
16431565 		return STATUS_FAIL;
1644
-	}
16451566 
16461567 	if (CHK_SD(sd_card)) {
16471568 		bus_width = SD_BUS_WIDTH_4;
....@@ -1655,15 +1576,13 @@
16551576 	}
16561577 
16571578 	retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000);
1658
-	if (retval != STATUS_SUCCESS) {
1579
+	if (retval != STATUS_SUCCESS)
16591580 		return STATUS_FAIL;
1660
-	}
16611581 
16621582 	retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
16631583 				     SD_RSP_80CLK_TIMEOUT_EN);
1664
-	if (retval) {
1584
+	if (retval)
16651585 		return retval;
1666
-	}
16671586 
16681587 	cmd[0] = 0x40 | PROGRAM_CSD;
16691588 	cmd[1] = 0;
....@@ -1681,9 +1600,8 @@
16811600 
16821601 	retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
16831602 				     0);
1684
-	if (retval) {
1603
+	if (retval)
16851604 		return retval;
1686
-	}
16871605 
16881606 	sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1,
16891607 			    NULL, 0);
....@@ -1826,11 +1744,10 @@
18261744 			tuning_cmd = sd_sdr_tuning_rx_cmd;
18271745 
18281746 	} else {
1829
-		if (CHK_MMC_DDR52(sd_card)) {
1747
+		if (CHK_MMC_DDR52(sd_card))
18301748 			tuning_cmd = mmc_ddr_tuning_rx_cmd;
1831
-		} else {
1749
+		else
18321750 			return STATUS_FAIL;
1833
-		}
18341751 	}
18351752 
18361753 	for (i = 0; i < 3; i++) {
....@@ -1855,14 +1772,12 @@
18551772 	dev_dbg(rtsx_dev(chip), "RX phase_map = 0x%08x\n", phase_map);
18561773 
18571774 	final_phase = sd_search_final_phase(chip, phase_map, TUNE_RX);
1858
-	if (final_phase == 0xFF) {
1775
+	if (final_phase == 0xFF)
18591776 		return STATUS_FAIL;
1860
-	}
18611777 
18621778 	retval = sd_change_phase(chip, final_phase, TUNE_RX);
1863
-	if (retval != STATUS_SUCCESS) {
1779
+	if (retval != STATUS_SUCCESS)
18641780 		return STATUS_FAIL;
1865
-	}
18661781 
18671782 	return STATUS_SUCCESS;
18681783 }
....@@ -1877,9 +1792,8 @@
18771792 
18781793 	retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
18791794 				     SD_RSP_80CLK_TIMEOUT_EN);
1880
-	if (retval) {
1795
+	if (retval)
18811796 		return retval;
1882
-	}
18831797 
18841798 	phase_map = 0;
18851799 	for (i = MAX_PHASE; i >= 0; i--) {
....@@ -1904,22 +1818,19 @@
19041818 
19051819 	retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN,
19061820 				     0);
1907
-	if (retval) {
1821
+	if (retval)
19081822 		return retval;
1909
-	}
19101823 
19111824 	dev_dbg(rtsx_dev(chip), "DDR TX pre tune phase_map = 0x%08x\n",
19121825 		phase_map);
19131826 
19141827 	final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX);
1915
-	if (final_phase == 0xFF) {
1828
+	if (final_phase == 0xFF)
19161829 		return STATUS_FAIL;
1917
-	}
19181830 
19191831 	retval = sd_change_phase(chip, final_phase, TUNE_TX);
1920
-	if (retval != STATUS_SUCCESS) {
1832
+	if (retval != STATUS_SUCCESS)
19211833 		return STATUS_FAIL;
1922
-	}
19231834 
19241835 	dev_dbg(rtsx_dev(chip), "DDR TX pre tune phase: %d\n",
19251836 		(int)final_phase);
....@@ -1943,11 +1854,10 @@
19431854 			tuning_cmd = sd_sdr_tuning_tx_cmd;
19441855 
19451856 	} else {
1946
-		if (CHK_MMC_DDR52(sd_card)) {
1857
+		if (CHK_MMC_DDR52(sd_card))
19471858 			tuning_cmd = sd_ddr_tuning_tx_cmd;
1948
-		} else {
1859
+		else
19491860 			return STATUS_FAIL;
1950
-		}
19511861 	}
19521862 
19531863 	for (i = 0; i < 3; i++) {
....@@ -1974,14 +1884,12 @@
19741884 	dev_dbg(rtsx_dev(chip), "TX phase_map = 0x%08x\n", phase_map);
19751885 
19761886 	final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX);
1977
-	if (final_phase == 0xFF) {
1887
+	if (final_phase == 0xFF)
19781888 		return STATUS_FAIL;
1979
-	}
19801889 
19811890 	retval = sd_change_phase(chip, final_phase, TUNE_TX);
1982
-	if (retval != STATUS_SUCCESS) {
1891
+	if (retval != STATUS_SUCCESS)
19831892 		return STATUS_FAIL;
1984
-	}
19851893 
19861894 	return STATUS_SUCCESS;
19871895 }
....@@ -1991,14 +1899,12 @@
19911899 	int retval;
19921900 
19931901 	retval = sd_tuning_tx(chip);
1994
-	if (retval != STATUS_SUCCESS) {
1902
+	if (retval != STATUS_SUCCESS)
19951903 		return STATUS_FAIL;
1996
-	}
19971904 
19981905 	retval = sd_tuning_rx(chip);
1999
-	if (retval != STATUS_SUCCESS) {
1906
+	if (retval != STATUS_SUCCESS)
20001907 		return STATUS_FAIL;
2001
-	}
20021908 
20031909 	return STATUS_SUCCESS;
20041910 }
....@@ -2009,27 +1915,23 @@
20091915 
20101916 	if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) {
20111917 		retval = sd_ddr_pre_tuning_tx(chip);
2012
-		if (retval != STATUS_SUCCESS) {
1918
+		if (retval != STATUS_SUCCESS)
20131919 			return STATUS_FAIL;
2014
-		}
20151920 	} else {
20161921 		retval = sd_change_phase(chip, (u8)chip->sd_ddr_tx_phase,
20171922 					 TUNE_TX);
2018
-		if (retval != STATUS_SUCCESS) {
1923
+		if (retval != STATUS_SUCCESS)
20191924 			return STATUS_FAIL;
2020
-		}
20211925 	}
20221926 
20231927 	retval = sd_tuning_rx(chip);
2024
-	if (retval != STATUS_SUCCESS) {
1928
+	if (retval != STATUS_SUCCESS)
20251929 		return STATUS_FAIL;
2026
-	}
20271930 
20281931 	if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) {
20291932 		retval = sd_tuning_tx(chip);
2030
-		if (retval != STATUS_SUCCESS) {
1933
+		if (retval != STATUS_SUCCESS)
20311934 			return STATUS_FAIL;
2032
-		}
20331935 	}
20341936 
20351937 	return STATUS_SUCCESS;
....@@ -2041,27 +1943,23 @@
20411943 
20421944 	if (!(chip->sd_ctl & MMC_DDR_TX_PHASE_SET_BY_USER)) {
20431945 		retval = sd_ddr_pre_tuning_tx(chip);
2044
-		if (retval != STATUS_SUCCESS) {
1946
+		if (retval != STATUS_SUCCESS)
20451947 			return STATUS_FAIL;
2046
-		}
20471948 	} else {
20481949 		retval = sd_change_phase(chip, (u8)chip->mmc_ddr_tx_phase,
20491950 					 TUNE_TX);
2050
-		if (retval != STATUS_SUCCESS) {
1951
+		if (retval != STATUS_SUCCESS)
20511952 			return STATUS_FAIL;
2052
-		}
20531953 	}
20541954 
20551955 	retval = sd_tuning_rx(chip);
2056
-	if (retval != STATUS_SUCCESS) {
1956
+	if (retval != STATUS_SUCCESS)
20571957 		return STATUS_FAIL;
2058
-	}
20591958 
20601959 	if (!(chip->sd_ctl & MMC_DDR_TX_PHASE_SET_BY_USER)) {
20611960 		retval = sd_tuning_tx(chip);
2062
-		if (retval != STATUS_SUCCESS) {
1961
+		if (retval != STATUS_SUCCESS)
20631962 			return STATUS_FAIL;
2064
-		}
20651963 	}
20661964 
20671965 	return STATUS_SUCCESS;
....@@ -2074,14 +1972,12 @@
20741972 	int re_tuning = 0;
20751973 
20761974 	retval = select_card(chip, SD_CARD);
2077
-	if (retval != STATUS_SUCCESS) {
1975
+	if (retval != STATUS_SUCCESS)
20781976 		return STATUS_FAIL;
2079
-	}
20801977 
20811978 	retval = switch_clock(chip, sd_card->sd_clock);
2082
-	if (retval != STATUS_SUCCESS) {
1979
+	if (retval != STATUS_SUCCESS)
20831980 		return STATUS_FAIL;
2084
-	}
20851981 
20861982 	if (re_tuning) {
20871983 		if (CHK_SD(sd_card)) {
....@@ -2094,9 +1990,8 @@
20941990 				retval = mmc_ddr_tuning(chip);
20951991 		}
20961992 
2097
-		if (retval != STATUS_SUCCESS) {
1993
+		if (retval != STATUS_SUCCESS)
20981994 			return STATUS_FAIL;
2099
-		}
21001995 	}
21011996 
21021997 	return STATUS_SUCCESS;
....@@ -2126,25 +2021,21 @@
21262021 	chip->sd_io = 0;
21272022 
21282023 	retval = sd_set_init_para(chip);
2129
-	if (retval != STATUS_SUCCESS) {
2024
+	if (retval != STATUS_SUCCESS)
21302025 		return retval;
2131
-	}
21322026 
21332027 	retval = rtsx_write_register(chip, REG_SD_CFG1, 0xFF, 0x40);
2134
-	if (retval) {
2028
+	if (retval)
21352029 		return retval;
2136
-	}
21372030 
21382031 	retval = rtsx_write_register(chip, CARD_STOP, SD_STOP | SD_CLR_ERR,
21392032 				     SD_STOP | SD_CLR_ERR);
2140
-	if (retval) {
2033
+	if (retval)
21412034 		return retval;
2142
-	}
21432035 
21442036 	retval = select_card(chip, SD_CARD);
2145
-	if (retval != STATUS_SUCCESS) {
2037
+	if (retval != STATUS_SUCCESS)
21462038 		return STATUS_FAIL;
2147
-	}
21482039 
21492040 	return STATUS_SUCCESS;
21502041 }
....@@ -2157,60 +2048,50 @@
21572048 		retval = rtsx_write_register(chip, CARD_PULL_CTL1, 0xFF,
21582049 					     XD_D3_PD | SD_D7_PD | SD_CLK_PD |
21592050 					     SD_D5_PD);
2160
-		if (retval) {
2051
+		if (retval)
21612052 			return retval;
2162
-		}
21632053 		retval = rtsx_write_register(chip, CARD_PULL_CTL2, 0xFF,
21642054 					     SD_D6_PD | SD_D0_PD | SD_D1_PD |
21652055 					     XD_D5_PD);
2166
-		if (retval) {
2056
+		if (retval)
21672057 			return retval;
2168
-		}
21692058 		retval = rtsx_write_register(chip, CARD_PULL_CTL3, 0xFF,
21702059 					     SD_D4_PD | XD_CE_PD | XD_CLE_PD |
21712060 					     XD_CD_PU);
2172
-		if (retval) {
2061
+		if (retval)
21732062 			return retval;
2174
-		}
21752063 		retval = rtsx_write_register(chip, CARD_PULL_CTL4, 0xFF,
21762064 					     XD_RDY_PD | SD_D3_PD | SD_D2_PD |
21772065 					     XD_ALE_PD);
2178
-		if (retval) {
2066
+		if (retval)
21792067 			return retval;
2180
-		}
21812068 		retval = rtsx_write_register(chip, CARD_PULL_CTL5, 0xFF,
21822069 					     MS_INS_PU | SD_WP_PD | SD_CD_PU |
21832070 					     SD_CMD_PD);
2184
-		if (retval) {
2071
+		if (retval)
21852072 			return retval;
2186
-		}
21872073 		retval = rtsx_write_register(chip, CARD_PULL_CTL6, 0xFF,
21882074 					     MS_D5_PD | MS_D4_PD);
2189
-		if (retval) {
2075
+		if (retval)
21902076 			return retval;
2191
-		}
21922077 	} else if (CHECK_PID(chip, 0x5288)) {
21932078 		if (CHECK_BARO_PKG(chip, QFN)) {
21942079 			retval = rtsx_write_register(chip, CARD_PULL_CTL1,
21952080 						     0xFF, 0x55);
2196
-			if (retval) {
2081
+			if (retval)
21972082 				return retval;
2198
-			}
21992083 			retval = rtsx_write_register(chip, CARD_PULL_CTL2,
22002084 						     0xFF, 0x55);
2201
-			if (retval) {
2085
+			if (retval)
22022086 				return retval;
2203
-			}
22042087 			retval = rtsx_write_register(chip, CARD_PULL_CTL3,
22052088 						     0xFF, 0x4B);
2206
-			if (retval) {
2089
+			if (retval)
22072090 				return retval;
2208
-			}
22092091 			retval = rtsx_write_register(chip, CARD_PULL_CTL4,
22102092 						     0xFF, 0x69);
2211
-			if (retval) {
2093
+			if (retval)
22122094 				return retval;
2213
-			}
22142095 		}
22152096 	}
22162097 
....@@ -2250,9 +2131,8 @@
22502131 	}
22512132 
22522133 	retval = rtsx_send_cmd(chip, SD_CARD, 100);
2253
-	if (retval < 0) {
2134
+	if (retval < 0)
22542135 		return STATUS_FAIL;
2255
-	}
22562136 
22572137 	return STATUS_SUCCESS;
22582138 }
....@@ -2262,36 +2142,31 @@
22622142 	int retval;
22632143 
22642144 	retval = sd_power_off_card3v3(chip);
2265
-	if (retval != STATUS_SUCCESS) {
2145
+	if (retval != STATUS_SUCCESS)
22662146 		return STATUS_FAIL;
2267
-	}
22682147 
22692148 	if (!chip->ft2_fast_mode)
22702149 		wait_timeout(250);
22712150 
22722151 	retval = enable_card_clock(chip, SD_CARD);
2273
-	if (retval != STATUS_SUCCESS) {
2152
+	if (retval != STATUS_SUCCESS)
22742153 		return STATUS_FAIL;
2275
-	}
22762154 
22772155 	if (chip->asic_code) {
22782156 		retval = sd_pull_ctl_enable(chip);
2279
-		if (retval != STATUS_SUCCESS) {
2157
+		if (retval != STATUS_SUCCESS)
22802158 			return STATUS_FAIL;
2281
-		}
22822159 	} else {
22832160 		retval = rtsx_write_register(chip, FPGA_PULL_CTL,
22842161 					     FPGA_SD_PULL_CTL_BIT | 0x20, 0);
2285
-		if (retval) {
2162
+		if (retval)
22862163 			return retval;
2287
-		}
22882164 	}
22892165 
22902166 	if (!chip->ft2_fast_mode) {
22912167 		retval = card_power_on(chip, SD_CARD);
2292
-		if (retval != STATUS_SUCCESS) {
2168
+		if (retval != STATUS_SUCCESS)
22932169 			return STATUS_FAIL;
2294
-		}
22952170 
22962171 		wait_timeout(260);
22972172 
....@@ -2306,9 +2181,8 @@
23062181 
23072182 	retval = rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN,
23082183 				     SD_OUTPUT_EN);
2309
-	if (retval) {
2184
+	if (retval)
23102185 		return retval;
2311
-	}
23122186 
23132187 	return STATUS_SUCCESS;
23142188 }
....@@ -2318,14 +2192,12 @@
23182192 	int retval;
23192193 
23202194 	retval = rtsx_write_register(chip, REG_SD_CFG3, 0x01, 0x01);
2321
-	if (retval) {
2195
+	if (retval)
23222196 		return retval;
2323
-	}
23242197 	wait_timeout(5);
23252198 	retval = rtsx_write_register(chip, REG_SD_CFG3, 0x01, 0);
2326
-	if (retval) {
2199
+	if (retval)
23272200 		return retval;
2328
-	}
23292201 
23302202 	return STATUS_SUCCESS;
23312203 }
....@@ -2373,9 +2245,8 @@
23732245 
23742246 	retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
23752247 				     SD_RSP_TYPE_R1, NULL, 0);
2376
-	if (retval != STATUS_SUCCESS) {
2248
+	if (retval != STATUS_SUCCESS)
23772249 		return STATUS_FAIL;
2378
-	}
23792250 
23802251 	cmd[0] = 0x40 | SD_STATUS;
23812252 	cmd[1] = 0;
....@@ -2689,9 +2560,8 @@
26892560 
26902561 		retval = rtsx_write_register(chip, SD30_DRIVE_SEL, 0x07,
26912562 					     chip->sd30_drive_sel_1v8);
2692
-		if (retval) {
2563
+		if (retval)
26932564 			return retval;
2694
-		}
26952565 
26962566 		retval = sd_set_init_para(chip);
26972567 		if (retval != STATUS_SUCCESS)
....@@ -2703,17 +2573,13 @@
27032573 			retval = sd_sdr_tuning(chip);
27042574 
27052575 		if (retval != STATUS_SUCCESS) {
2706
-			if (sd20_mode) {
2576
+			retval = sd_init_power(chip);
2577
+			if (retval != STATUS_SUCCESS)
27072578 				goto status_fail;
2708
-			} else {
2709
-				retval = sd_init_power(chip);
2710
-				if (retval != STATUS_SUCCESS)
2711
-					goto status_fail;
27122579 
2713
-				try_sdio = false;
2714
-				sd20_mode = true;
2715
-				goto switch_fail;
2716
-			}
2580
+			try_sdio = false;
2581
+			sd20_mode = true;
2582
+			goto switch_fail;
27172583 		}
27182584 
27192585 		sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
....@@ -2728,17 +2594,13 @@
27282594 		if (read_lba0) {
27292595 			retval = sd_read_lba0(chip);
27302596 			if (retval != STATUS_SUCCESS) {
2731
-				if (sd20_mode) {
2597
+				retval = sd_init_power(chip);
2598
+				if (retval != STATUS_SUCCESS)
27322599 					goto status_fail;
2733
-				} else {
2734
-					retval = sd_init_power(chip);
2735
-					if (retval != STATUS_SUCCESS)
2736
-						goto status_fail;
27372600 
2738
-					try_sdio = false;
2739
-					sd20_mode = true;
2740
-					goto switch_fail;
2741
-				}
2601
+				try_sdio = false;
2602
+				sd20_mode = true;
2603
+				goto switch_fail;
27422604 			}
27432605 		}
27442606 	}
....@@ -2753,14 +2615,12 @@
27532615 	if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
27542616 		retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_H, 0xFF,
27552617 					     0x02);
2756
-		if (retval) {
2618
+		if (retval)
27572619 			return retval;
2758
-		}
27592620 		retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_L, 0xFF,
27602621 					     0x00);
2761
-		if (retval) {
2622
+		if (retval)
27622623 			return retval;
2763
-		}
27642624 	}
27652625 #endif
27662626 
....@@ -2780,9 +2640,8 @@
27802640 
27812641 	retval = sd_send_cmd_get_rsp(chip, BUSTEST_W, 0, SD_RSP_TYPE_R1, NULL,
27822642 				     0);
2783
-	if (retval != STATUS_SUCCESS) {
2643
+	if (retval != STATUS_SUCCESS)
27842644 		return SWITCH_FAIL;
2785
-	}
27862645 
27872646 	if (width == MMC_8BIT_BUS) {
27882647 		buf[0] = 0x55;
....@@ -2798,9 +2657,8 @@
27982657 	}
27992658 
28002659 	retval = rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0x02);
2801
-	if (retval != STATUS_SUCCESS) {
2660
+	if (retval != STATUS_SUCCESS)
28022661 		return SWITCH_ERR;
2803
-	}
28042662 
28052663 	retval = sd_write_data(chip, SD_TM_AUTO_WRITE_3, NULL, 0, byte_cnt, 1,
28062664 			       bus_width, buf, len, 100);
....@@ -2811,9 +2669,8 @@
28112669 	}
28122670 
28132671 	retval = rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0);
2814
-	if (retval != STATUS_SUCCESS) {
2672
+	if (retval != STATUS_SUCCESS)
28152673 		return SWITCH_ERR;
2816
-	}
28172674 
28182675 	dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d\n", BUSTEST_R);
28192676 
....@@ -2979,9 +2836,8 @@
29792836 
29802837 	sd_choose_proper_clock(chip);
29812838 	retval = switch_clock(chip, sd_card->sd_clock);
2982
-	if (retval != STATUS_SUCCESS) {
2839
+	if (retval != STATUS_SUCCESS)
29832840 		return STATUS_FAIL;
2984
-	}
29852841 
29862842 	/* Test Bus Procedure */
29872843 	retval = mmc_test_switch_bus(chip, MMC_8BIT_BUS);
....@@ -3028,18 +2884,16 @@
30282884 
30292885 switch_fail:
30302886 	retval = sd_prepare_reset(chip);
3031
-	if (retval != STATUS_SUCCESS) {
2887
+	if (retval != STATUS_SUCCESS)
30322888 		return retval;
3033
-	}
30342889 
30352890 	SET_MMC(sd_card);
30362891 
30372892 RTY_MMC_RST:
30382893 	retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0,
30392894 				     NULL, 0);
3040
-	if (retval != STATUS_SUCCESS) {
2895
+	if (retval != STATUS_SUCCESS)
30412896 		return STATUS_FAIL;
3042
-	}
30432897 
30442898 	do {
30452899 		if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) {
....@@ -3075,9 +2929,8 @@
30752929 		i++;
30762930 	} while (!(rsp[1] & 0x80) && (i < 255));
30772931 
3078
-	if (i == 255) {
2932
+	if (i == 255)
30792933 		return STATUS_FAIL;
3080
-	}
30812934 
30822935 	if ((rsp[1] & 0x60) == 0x40)
30832936 		SET_MMC_SECTOR_MODE(sd_card);
....@@ -3086,47 +2939,40 @@
30862939 
30872940 	retval = sd_send_cmd_get_rsp(chip, ALL_SEND_CID, 0, SD_RSP_TYPE_R2,
30882941 				     NULL, 0);
3089
-	if (retval != STATUS_SUCCESS) {
2942
+	if (retval != STATUS_SUCCESS)
30902943 		return STATUS_FAIL;
3091
-	}
30922944 
30932945 	sd_card->sd_addr = 0x00100000;
30942946 	retval = sd_send_cmd_get_rsp(chip, SET_RELATIVE_ADDR, sd_card->sd_addr,
30952947 				     SD_RSP_TYPE_R6, rsp, 5);
3096
-	if (retval != STATUS_SUCCESS) {
2948
+	if (retval != STATUS_SUCCESS)
30972949 		return STATUS_FAIL;
3098
-	}
30992950 
31002951 	retval = sd_check_csd(chip, 1);
3101
-	if (retval != STATUS_SUCCESS) {
2952
+	if (retval != STATUS_SUCCESS)
31022953 		return STATUS_FAIL;
3103
-	}
31042954 
31052955 	spec_ver = (sd_card->raw_csd[0] & 0x3C) >> 2;
31062956 
31072957 	retval = sd_select_card(chip, 1);
3108
-	if (retval != STATUS_SUCCESS) {
2958
+	if (retval != STATUS_SUCCESS)
31092959 		return STATUS_FAIL;
3110
-	}
31112960 
31122961 	retval = sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, SD_RSP_TYPE_R1,
31132962 				     NULL, 0);
3114
-	if (retval != STATUS_SUCCESS) {
2963
+	if (retval != STATUS_SUCCESS)
31152964 		return STATUS_FAIL;
3116
-	}
31172965 
31182966 #ifdef SUPPORT_SD_LOCK
31192967 MMC_UNLOCK_ENTRY:
31202968 	retval = sd_update_lock_status(chip);
3121
-	if (retval != STATUS_SUCCESS) {
2969
+	if (retval != STATUS_SUCCESS)
31222970 		return STATUS_FAIL;
3123
-	}
31242971 #endif
31252972 
31262973 	retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3127
-	if (retval != STATUS_SUCCESS) {
2974
+	if (retval != STATUS_SUCCESS)
31282975 		return STATUS_FAIL;
3129
-	}
31302976 
31312977 	chip->card_bus_width[chip->card2lun[SD_CARD]] = 1;
31322978 
....@@ -3136,30 +2982,26 @@
31362982 			retval = mmc_switch_timing_bus(chip, switch_ddr);
31372983 			if (retval != STATUS_SUCCESS) {
31382984 				retval = sd_init_power(chip);
3139
-				if (retval != STATUS_SUCCESS) {
2985
+				if (retval != STATUS_SUCCESS)
31402986 					return STATUS_FAIL;
3141
-				}
31422987 				sd_card->mmc_dont_switch_bus = 1;
31432988 				goto switch_fail;
31442989 			}
31452990 		}
31462991 
3147
-		if (CHK_MMC_SECTOR_MODE(sd_card) && (sd_card->capacity == 0)) {
2992
+		if (CHK_MMC_SECTOR_MODE(sd_card) && (sd_card->capacity == 0))
31482993 			return STATUS_FAIL;
3149
-		}
31502994 
31512995 		if (switch_ddr && CHK_MMC_DDR52(sd_card)) {
31522996 			retval = sd_set_init_para(chip);
3153
-			if (retval != STATUS_SUCCESS) {
2997
+			if (retval != STATUS_SUCCESS)
31542998 				return STATUS_FAIL;
3155
-			}
31562999 
31573000 			retval = mmc_ddr_tuning(chip);
31583001 			if (retval != STATUS_SUCCESS) {
31593002 				retval = sd_init_power(chip);
3160
-				if (retval != STATUS_SUCCESS) {
3003
+				if (retval != STATUS_SUCCESS)
31613004 					return STATUS_FAIL;
3162
-				}
31633005 
31643006 				switch_ddr = false;
31653007 				goto switch_fail;
....@@ -3170,9 +3012,8 @@
31703012 				retval = sd_read_lba0(chip);
31713013 				if (retval != STATUS_SUCCESS) {
31723014 					retval = sd_init_power(chip);
3173
-					if (retval != STATUS_SUCCESS) {
3015
+					if (retval != STATUS_SUCCESS)
31743016 						return STATUS_FAIL;
3175
-					}
31763017 
31773018 					switch_ddr = false;
31783019 					goto switch_fail;
....@@ -3185,14 +3026,12 @@
31853026 	if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
31863027 		retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_H, 0xFF,
31873028 					     0x02);
3188
-		if (retval) {
3029
+		if (retval)
31893030 			return retval;
3190
-		}
31913031 		retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_L, 0xFF,
31923032 					     0x00);
3193
-		if (retval) {
3033
+		if (retval)
31943034 			return retval;
3195
-		}
31963035 	}
31973036 #endif
31983037 
....@@ -3214,88 +3053,74 @@
32143053 	chip->capacity[chip->card2lun[SD_CARD]] = 0;
32153054 
32163055 	retval = enable_card_clock(chip, SD_CARD);
3217
-	if (retval != STATUS_SUCCESS) {
3056
+	if (retval != STATUS_SUCCESS)
32183057 		return STATUS_FAIL;
3219
-	}
32203058 
32213059 	if (chip->ignore_sd && CHK_SDIO_EXIST(chip) &&
32223060 	    !CHK_SDIO_IGNORED(chip)) {
32233061 		if (chip->asic_code) {
32243062 			retval = sd_pull_ctl_enable(chip);
3225
-			if (retval != STATUS_SUCCESS) {
3063
+			if (retval != STATUS_SUCCESS)
32263064 				return STATUS_FAIL;
3227
-			}
32283065 		} else {
32293066 			retval = rtsx_write_register(chip, FPGA_PULL_CTL,
32303067 						     FPGA_SD_PULL_CTL_BIT |
32313068 						     0x20, 0);
3232
-			if (retval != STATUS_SUCCESS) {
3069
+			if (retval != STATUS_SUCCESS)
32333070 				return STATUS_FAIL;
3234
-			}
32353071 		}
32363072 		retval = card_share_mode(chip, SD_CARD);
3237
-		if (retval != STATUS_SUCCESS) {
3073
+		if (retval != STATUS_SUCCESS)
32383074 			return STATUS_FAIL;
3239
-		}
32403075 
32413076 		chip->sd_io = 1;
32423077 		return STATUS_FAIL;
32433078 	}
32443079 
32453080 	retval = sd_init_power(chip);
3246
-	if (retval != STATUS_SUCCESS) {
3081
+	if (retval != STATUS_SUCCESS)
32473082 		return STATUS_FAIL;
3248
-	}
32493083 
32503084 	if (chip->sd_ctl & RESET_MMC_FIRST) {
32513085 		retval = reset_mmc(chip);
32523086 		if (retval != STATUS_SUCCESS) {
3253
-			if (sd_check_err_code(chip, SD_NO_CARD)) {
3087
+			if (sd_check_err_code(chip, SD_NO_CARD))
32543088 				return STATUS_FAIL;
3255
-			}
32563089 
32573090 			retval = reset_sd(chip);
3258
-			if (retval != STATUS_SUCCESS) {
3091
+			if (retval != STATUS_SUCCESS)
32593092 				return STATUS_FAIL;
3260
-			}
32613093 		}
32623094 	} else {
32633095 		retval = reset_sd(chip);
32643096 		if (retval != STATUS_SUCCESS) {
3265
-			if (sd_check_err_code(chip, SD_NO_CARD)) {
3097
+			if (sd_check_err_code(chip, SD_NO_CARD))
32663098 				return STATUS_FAIL;
3267
-			}
32683099 
3269
-			if (chip->sd_io) {
3100
+			if (chip->sd_io)
32703101 				return STATUS_FAIL;
3271
-			}
32723102 			retval = reset_mmc(chip);
3273
-			if (retval != STATUS_SUCCESS) {
3103
+			if (retval != STATUS_SUCCESS)
32743104 				return STATUS_FAIL;
3275
-			}
32763105 		}
32773106 	}
32783107 
32793108 	retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3280
-	if (retval != STATUS_SUCCESS) {
3109
+	if (retval != STATUS_SUCCESS)
32813110 		return STATUS_FAIL;
3282
-	}
32833111 
32843112 	retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_L, 0xFF, 0);
3285
-	if (retval) {
3113
+	if (retval)
32863114 		return retval;
3287
-	}
32883115 	retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_H, 0xFF, 2);
3289
-	if (retval) {
3116
+	if (retval)
32903117 		return retval;
3291
-	}
32923118 
32933119 	chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity;
32943120 
32953121 	retval = sd_set_init_para(chip);
3296
-	if (retval != STATUS_SUCCESS) {
3122
+	if (retval != STATUS_SUCCESS)
32973123 		return STATUS_FAIL;
3298
-	}
32993124 
33003125 	dev_dbg(rtsx_dev(chip), "sd_card->sd_type = 0x%x\n", sd_card->sd_type);
33013126 
....@@ -3321,40 +3146,33 @@
33213146 	chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity = 0;
33223147 
33233148 	retval = enable_card_clock(chip, SD_CARD);
3324
-	if (retval != STATUS_SUCCESS) {
3149
+	if (retval != STATUS_SUCCESS)
33253150 		return STATUS_FAIL;
3326
-	}
33273151 
33283152 	retval = sd_init_power(chip);
3329
-	if (retval != STATUS_SUCCESS) {
3153
+	if (retval != STATUS_SUCCESS)
33303154 		return STATUS_FAIL;
3331
-	}
33323155 
33333156 	retval = reset_mmc(chip);
3334
-	if (retval != STATUS_SUCCESS) {
3157
+	if (retval != STATUS_SUCCESS)
33353158 		return STATUS_FAIL;
3336
-	}
33373159 
33383160 	retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0);
3339
-	if (retval != STATUS_SUCCESS) {
3161
+	if (retval != STATUS_SUCCESS)
33403162 		return STATUS_FAIL;
3341
-	}
33423163 
33433164 	retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_L, 0xFF, 0);
3344
-	if (retval) {
3165
+	if (retval)
33453166 		return retval;
3346
-	}
33473167 	retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_H, 0xFF, 2);
3348
-	if (retval) {
3168
+	if (retval)
33493169 		return retval;
3350
-	}
33513170 
33523171 	chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity;
33533172 
33543173 	retval = sd_set_init_para(chip);
3355
-	if (retval != STATUS_SUCCESS) {
3174
+	if (retval != STATUS_SUCCESS)
33563175 		return STATUS_FAIL;
3357
-	}
33583176 
33593177 	dev_dbg(rtsx_dev(chip), "In %s, sd_card->sd_type = 0x%x\n",
33603178 		__func__, sd_card->sd_type);
....@@ -3380,9 +3198,8 @@
33803198 		retval = sd_send_cmd_get_rsp(chip, SEND_STATUS,
33813199 					     sd_card->sd_addr, SD_RSP_TYPE_R1,
33823200 					     NULL, 0);
3383
-		if (retval != STATUS_SUCCESS) {
3201
+		if (retval != STATUS_SUCCESS)
33843202 			return STATUS_FAIL;
3385
-		}
33863203 
33873204 		if (sd_card->sd_data_buf_ready) {
33883205 			return sd_send_cmd_get_rsp(chip, SEND_STATUS,
....@@ -3460,9 +3277,8 @@
34603277 	}
34613278 
34623279 	retval = sd_switch_clock(chip);
3463
-	if (retval != STATUS_SUCCESS) {
3280
+	if (retval != STATUS_SUCCESS)
34643281 		return STATUS_FAIL;
3465
-	}
34663282 
34673283 	return STATUS_SUCCESS;
34683284 }
....@@ -3756,11 +3572,6 @@
37563572 }
37573573 
37583574 #ifdef SUPPORT_CPRM
3759
-int soft_reset_sd_card(struct rtsx_chip *chip)
3760
-{
3761
-	return reset_sd(chip);
3762
-}
3763
-
37643575 int ext_sd_send_cmd_get_rsp(struct rtsx_chip *chip, u8 cmd_idx, u32 arg,
37653576 			    u8 rsp_type, u8 *rsp, int rsp_len,
37663577 			    bool special_check)
....@@ -3819,9 +3630,8 @@
38193630 
38203631 			if (rsp_type & SD_WAIT_BUSY_END) {
38213632 				retval = sd_check_data0_status(chip);
3822
-				if (retval != STATUS_SUCCESS) {
3633
+				if (retval != STATUS_SUCCESS)
38233634 					return retval;
3824
-				}
38253635 			} else {
38263636 				sd_set_err_code(chip, SD_TO_ERR);
38273637 			}
....@@ -3859,9 +3669,8 @@
38593669 	if ((cmd_idx == SELECT_CARD) || (cmd_idx == APP_CMD) ||
38603670 	    (cmd_idx == SEND_STATUS) || (cmd_idx == STOP_TRANSMISSION)) {
38613671 		if ((cmd_idx != STOP_TRANSMISSION) && !special_check) {
3862
-			if (ptr[1] & 0x80) {
3672
+			if (ptr[1] & 0x80)
38633673 				return STATUS_FAIL;
3864
-			}
38653674 		}
38663675 #ifdef SUPPORT_SD_LOCK
38673676 		if (ptr[1] & 0x7D) {
....@@ -3870,15 +3679,13 @@
38703679 #endif
38713680 			return STATUS_FAIL;
38723681 		}
3873
-		if (ptr[2] & 0xF8) {
3682
+		if (ptr[2] & 0xF8)
38743683 			return STATUS_FAIL;
3875
-		}
38763684 
38773685 		if (cmd_idx == SELECT_CARD) {
38783686 			if (rsp_type == SD_RSP_TYPE_R2) {
3879
-				if ((ptr[3] & 0x1E) != 0x04) {
3687
+				if ((ptr[3] & 0x1E) != 0x04)
38803688 					return STATUS_FAIL;
3881
-				}
38823689 			}
38833690 		}
38843691 	}
....@@ -3915,9 +3722,8 @@
39153722 	rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_CMD5, 0xFF, 0);
39163723 
39173724 	retval = rtsx_send_cmd(chip, SD_CARD, 100);
3918
-	if (retval != STATUS_SUCCESS) {
3725
+	if (retval != STATUS_SUCCESS)
39193726 		return STATUS_FAIL;
3920
-	}
39213727 
39223728 	if (rsp) {
39233729 		int min_len = (rsp_len < len) ? rsp_len : len;
....@@ -4057,9 +3863,8 @@
40573863 	}
40583864 
40593865 	retval = sd_switch_clock(chip);
4060
-	if (retval != STATUS_SUCCESS) {
3866
+	if (retval != STATUS_SUCCESS)
40613867 		return TRANSPORT_FAILED;
4062
-	}
40633868 
40643869 	if (sd_card->pre_cmd_err) {
40653870 		sd_card->pre_cmd_err = 0;
....@@ -4085,39 +3890,34 @@
40853890 	sd_card->last_rsp_type = rsp_type;
40863891 
40873892 	retval = sd_switch_clock(chip);
4088
-	if (retval != STATUS_SUCCESS) {
3893
+	if (retval != STATUS_SUCCESS)
40893894 		return TRANSPORT_FAILED;
4090
-	}
40913895 
40923896 #ifdef SUPPORT_SD_LOCK
40933897 	if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
40943898 		if (CHK_MMC_8BIT(sd_card)) {
40953899 			retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
40963900 						     SD_BUS_WIDTH_8);
4097
-			if (retval != STATUS_SUCCESS) {
3901
+			if (retval != STATUS_SUCCESS)
40983902 				return TRANSPORT_FAILED;
4099
-			}
41003903 
41013904 		} else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
41023905 			retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
41033906 						     SD_BUS_WIDTH_4);
4104
-			if (retval != STATUS_SUCCESS) {
3907
+			if (retval != STATUS_SUCCESS)
41053908 				return TRANSPORT_FAILED;
4106
-			}
41073909 		}
41083910 	}
41093911 #else
41103912 	retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
4111
-	if (retval != STATUS_SUCCESS) {
3913
+	if (retval != STATUS_SUCCESS)
41123914 		return TRANSPORT_FAILED;
4113
-	}
41143915 #endif
41153916 
41163917 	if (standby) {
41173918 		retval = sd_select_card(chip, 0);
4118
-		if (retval != STATUS_SUCCESS) {
3919
+		if (retval != STATUS_SUCCESS)
41193920 			goto sd_execute_cmd_failed;
4120
-		}
41213921 	}
41223922 
41233923 	if (acmd) {
....@@ -4125,29 +3925,25 @@
41253925 						 sd_card->sd_addr,
41263926 						 SD_RSP_TYPE_R1, NULL, 0,
41273927 						 false);
4128
-		if (retval != STATUS_SUCCESS) {
3928
+		if (retval != STATUS_SUCCESS)
41293929 			goto sd_execute_cmd_failed;
4130
-		}
41313930 	}
41323931 
41333932 	retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
41343933 					 sd_card->rsp, rsp_len, false);
4135
-	if (retval != STATUS_SUCCESS) {
3934
+	if (retval != STATUS_SUCCESS)
41363935 		goto sd_execute_cmd_failed;
4137
-	}
41383936 
41393937 	if (standby) {
41403938 		retval = sd_select_card(chip, 1);
4141
-		if (retval != STATUS_SUCCESS) {
3939
+		if (retval != STATUS_SUCCESS)
41423940 			goto sd_execute_cmd_failed;
4143
-		}
41443941 	}
41453942 
41463943 #ifdef SUPPORT_SD_LOCK
41473944 	retval = sd_update_lock_status(chip);
4148
-	if (retval != STATUS_SUCCESS) {
3945
+	if (retval != STATUS_SUCCESS)
41493946 		goto sd_execute_cmd_failed;
4150
-	}
41513947 #endif
41523948 
41533949 	scsi_set_resid(srb, 0);
....@@ -4186,9 +3982,8 @@
41863982 	}
41873983 
41883984 	retval = sd_switch_clock(chip);
4189
-	if (retval != STATUS_SUCCESS) {
3985
+	if (retval != STATUS_SUCCESS)
41903986 		return TRANSPORT_FAILED;
4191
-	}
41923987 
41933988 	cmd_idx = srb->cmnd[2] & 0x3F;
41943989 	if (srb->cmnd[1] & 0x04)
....@@ -4211,9 +4006,8 @@
42114006 	sd_card->last_rsp_type = rsp_type;
42124007 
42134008 	retval = sd_switch_clock(chip);
4214
-	if (retval != STATUS_SUCCESS) {
4009
+	if (retval != STATUS_SUCCESS)
42154010 		return TRANSPORT_FAILED;
4216
-	}
42174011 
42184012 #ifdef SUPPORT_SD_LOCK
42194013 	if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
....@@ -4235,16 +4029,14 @@
42354029 		retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
42364030 						 SD_RSP_TYPE_R1, NULL, 0,
42374031 						 false);
4238
-		if (retval != STATUS_SUCCESS) {
4032
+		if (retval != STATUS_SUCCESS)
42394033 			goto sd_execute_read_cmd_failed;
4240
-		}
42414034 	}
42424035 
42434036 	if (standby) {
42444037 		retval = sd_select_card(chip, 0);
4245
-		if (retval != STATUS_SUCCESS) {
4038
+		if (retval != STATUS_SUCCESS)
42464039 			goto sd_execute_read_cmd_failed;
4247
-		}
42484040 	}
42494041 
42504042 	if (acmd) {
....@@ -4252,9 +4044,8 @@
42524044 						 sd_card->sd_addr,
42534045 						 SD_RSP_TYPE_R1, NULL, 0,
42544046 						 false);
4255
-		if (retval != STATUS_SUCCESS) {
4047
+		if (retval != STATUS_SUCCESS)
42564048 			goto sd_execute_read_cmd_failed;
4257
-		}
42584049 	}
42594050 
42604051 	if (data_len <= 512) {
....@@ -4273,9 +4064,8 @@
42734064 		cmd[4] = srb->cmnd[6];
42744065 
42754066 		buf = kmalloc(data_len, GFP_KERNEL);
4276
-		if (!buf) {
4067
+		if (!buf)
42774068 			return TRANSPORT_ERROR;
4278
-		}
42794069 
42804070 		retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, byte_cnt,
42814071 				      blk_cnt, bus_width, buf, data_len, 2000);
....@@ -4340,43 +4130,37 @@
43404130 	}
43414131 
43424132 	retval = ext_sd_get_rsp(chip, rsp_len, sd_card->rsp, rsp_type);
4343
-	if (retval != STATUS_SUCCESS) {
4133
+	if (retval != STATUS_SUCCESS)
43444134 		goto sd_execute_read_cmd_failed;
4345
-	}
43464135 
43474136 	if (standby) {
43484137 		retval = sd_select_card(chip, 1);
4349
-		if (retval != STATUS_SUCCESS) {
4138
+		if (retval != STATUS_SUCCESS)
43504139 			goto sd_execute_read_cmd_failed;
4351
-		}
43524140 	}
43534141 
43544142 	if (send_cmd12) {
43554143 		retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
43564144 						 SD_RSP_TYPE_R1b, NULL, 0,
43574145 						 false);
4358
-		if (retval != STATUS_SUCCESS) {
4146
+		if (retval != STATUS_SUCCESS)
43594147 			goto sd_execute_read_cmd_failed;
4360
-		}
43614148 	}
43624149 
43634150 	if (data_len < 512) {
43644151 		retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
43654152 						 SD_RSP_TYPE_R1, NULL, 0,
43664153 						 false);
4367
-		if (retval != STATUS_SUCCESS) {
4154
+		if (retval != STATUS_SUCCESS)
43684155 			goto sd_execute_read_cmd_failed;
4369
-		}
43704156 
43714157 		retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
4372
-		if (retval != STATUS_SUCCESS) {
4158
+		if (retval != STATUS_SUCCESS)
43734159 			goto sd_execute_read_cmd_failed;
4374
-		}
43754160 
43764161 		retval = rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
4377
-		if (retval != STATUS_SUCCESS) {
4162
+		if (retval != STATUS_SUCCESS)
43784163 			goto sd_execute_read_cmd_failed;
4379
-		}
43804164 	}
43814165 
43824166 	if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04))
....@@ -4390,9 +4174,8 @@
43904174 		if (retval == STATUS_SUCCESS)
43914175 			break;
43924176 	}
4393
-	if (retval != STATUS_SUCCESS) {
4177
+	if (retval != STATUS_SUCCESS)
43944178 		goto sd_execute_read_cmd_failed;
4395
-	}
43964179 
43974180 	scsi_set_resid(srb, 0);
43984181 	return TRANSPORT_GOOD;
....@@ -4438,9 +4221,8 @@
44384221 	}
44394222 
44404223 	retval = sd_switch_clock(chip);
4441
-	if (retval != STATUS_SUCCESS) {
4224
+	if (retval != STATUS_SUCCESS)
44424225 		return TRANSPORT_FAILED;
4443
-	}
44444226 
44454227 	cmd_idx = srb->cmnd[2] & 0x3F;
44464228 	if (srb->cmnd[1] & 0x04)
....@@ -4472,48 +4254,42 @@
44724254 	sd_card->last_rsp_type = rsp_type;
44734255 
44744256 	retval = sd_switch_clock(chip);
4475
-	if (retval != STATUS_SUCCESS) {
4257
+	if (retval != STATUS_SUCCESS)
44764258 		return TRANSPORT_FAILED;
4477
-	}
44784259 
44794260 #ifdef SUPPORT_SD_LOCK
44804261 	if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
44814262 		if (CHK_MMC_8BIT(sd_card)) {
44824263 			retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
44834264 						     SD_BUS_WIDTH_8);
4484
-			if (retval != STATUS_SUCCESS) {
4265
+			if (retval != STATUS_SUCCESS)
44854266 				return TRANSPORT_FAILED;
4486
-			}
44874267 
44884268 		} else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
44894269 			retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03,
44904270 						     SD_BUS_WIDTH_4);
4491
-			if (retval != STATUS_SUCCESS) {
4271
+			if (retval != STATUS_SUCCESS)
44924272 				return TRANSPORT_FAILED;
4493
-			}
44944273 		}
44954274 	}
44964275 #else
44974276 	retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4);
4498
-	if (retval != STATUS_SUCCESS) {
4277
+	if (retval != STATUS_SUCCESS)
44994278 		return TRANSPORT_FAILED;
4500
-	}
45014279 #endif
45024280 
45034281 	if (data_len < 512) {
45044282 		retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
45054283 						 SD_RSP_TYPE_R1, NULL, 0,
45064284 						 false);
4507
-		if (retval != STATUS_SUCCESS) {
4285
+		if (retval != STATUS_SUCCESS)
45084286 			goto sd_execute_write_cmd_failed;
4509
-		}
45104287 	}
45114288 
45124289 	if (standby) {
45134290 		retval = sd_select_card(chip, 0);
4514
-		if (retval != STATUS_SUCCESS) {
4291
+		if (retval != STATUS_SUCCESS)
45154292 			goto sd_execute_write_cmd_failed;
4516
-		}
45174293 	}
45184294 
45194295 	if (acmd) {
....@@ -4521,25 +4297,22 @@
45214297 						 sd_card->sd_addr,
45224298 						 SD_RSP_TYPE_R1, NULL, 0,
45234299 						 false);
4524
-		if (retval != STATUS_SUCCESS) {
4300
+		if (retval != STATUS_SUCCESS)
45254301 			goto sd_execute_write_cmd_failed;
4526
-		}
45274302 	}
45284303 
45294304 	retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
45304305 					 sd_card->rsp, rsp_len, false);
4531
-	if (retval != STATUS_SUCCESS) {
4306
+	if (retval != STATUS_SUCCESS)
45324307 		goto sd_execute_write_cmd_failed;
4533
-	}
45344308 
45354309 	if (data_len <= 512) {
45364310 		u16 i;
45374311 		u8 *buf;
45384312 
45394313 		buf = kmalloc(data_len, GFP_KERNEL);
4540
-		if (!buf) {
4314
+		if (!buf)
45414315 			return TRANSPORT_ERROR;
4542
-		}
45434316 
45444317 		rtsx_stor_get_xfer_buf(buf, data_len, srb);
45454318 
....@@ -4651,7 +4424,12 @@
46514424 		rtsx_init_cmd(chip);
46524425 		rtsx_add_cmd(chip, CHECK_REG_CMD, 0xFD30, 0x02, 0x02);
46534426 
4654
-		rtsx_send_cmd(chip, SD_CARD, 250);
4427
+		retval = rtsx_send_cmd(chip, SD_CARD, 250);
4428
+		if (retval < 0) {
4429
+			write_err = true;
4430
+			rtsx_clear_sd_error(chip);
4431
+			goto sd_execute_write_cmd_failed;
4432
+		}
46554433 
46564434 		retval = sd_update_lock_status(chip);
46574435 		if (retval != STATUS_SUCCESS) {
....@@ -4663,37 +4441,32 @@
46634441 
46644442 	if (standby) {
46654443 		retval = sd_select_card(chip, 1);
4666
-		if (retval != STATUS_SUCCESS) {
4444
+		if (retval != STATUS_SUCCESS)
46674445 			goto sd_execute_write_cmd_failed;
4668
-		}
46694446 	}
46704447 
46714448 	if (send_cmd12) {
46724449 		retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, 0,
46734450 						 SD_RSP_TYPE_R1b, NULL, 0,
46744451 						 false);
4675
-		if (retval != STATUS_SUCCESS) {
4452
+		if (retval != STATUS_SUCCESS)
46764453 			goto sd_execute_write_cmd_failed;
4677
-		}
46784454 	}
46794455 
46804456 	if (data_len < 512) {
46814457 		retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
46824458 						 SD_RSP_TYPE_R1, NULL, 0,
46834459 						 false);
4684
-		if (retval != STATUS_SUCCESS) {
4460
+		if (retval != STATUS_SUCCESS)
46854461 			goto sd_execute_write_cmd_failed;
4686
-		}
46874462 
46884463 		retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
4689
-		if (retval != STATUS_SUCCESS) {
4464
+		if (retval != STATUS_SUCCESS)
46904465 			goto sd_execute_write_cmd_failed;
4691
-		}
46924466 
46934467 		retval = rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
4694
-		if (retval != STATUS_SUCCESS) {
4468
+		if (retval != STATUS_SUCCESS)
46954469 			goto sd_execute_write_cmd_failed;
4696
-		}
46974470 	}
46984471 
46994472 	if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04))
....@@ -4707,9 +4480,8 @@
47074480 		if (retval == STATUS_SUCCESS)
47084481 			break;
47094482 	}
4710
-	if (retval != STATUS_SUCCESS) {
4483
+	if (retval != STATUS_SUCCESS)
47114484 		goto sd_execute_write_cmd_failed;
4712
-	}
47134485 
47144486 #ifdef SUPPORT_SD_LOCK
47154487 	if (cmd_idx == LOCK_UNLOCK) {
....@@ -4727,20 +4499,19 @@
47274499 			sd_lock_state, sd_card->sd_lock_status);
47284500 		if (sd_lock_state ^ (sd_card->sd_lock_status & SD_LOCKED)) {
47294501 			sd_card->sd_lock_notify = 1;
4730
-			if (sd_lock_state) {
4731
-				if (sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) {
4732
-					sd_card->sd_lock_status |= (
4733
-						SD_UNLOCK_POW_ON | SD_SDR_RST);
4734
-					if (CHK_SD(sd_card)) {
4735
-						retval = reset_sd(chip);
4736
-						if (retval != STATUS_SUCCESS) {
4737
-							sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
4738
-							goto sd_execute_write_cmd_failed;
4739
-						}
4502
+			if (sd_lock_state &&
4503
+			    (sd_card->sd_lock_status & SD_LOCK_1BIT_MODE)) {
4504
+				sd_card->sd_lock_status |= (
4505
+					SD_UNLOCK_POW_ON | SD_SDR_RST);
4506
+				if (CHK_SD(sd_card)) {
4507
+					retval = reset_sd(chip);
4508
+					if (retval != STATUS_SUCCESS) {
4509
+						sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
4510
+						goto sd_execute_write_cmd_failed;
47404511 					}
4741
-
4742
-					sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
47434512 				}
4513
+
4514
+				sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST);
47444515 			}
47454516 		}
47464517 	}
....@@ -4854,7 +4625,7 @@
48544625 		break;
48554626 
48564627 	case 1:
4857
-		retval = soft_reset_sd_card(chip);
4628
+		retval = reset_sd(chip);
48584629 		if (retval != STATUS_SUCCESS) {
48594630 			set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
48604631 			sd_card->pre_cmd_err = 1;
....@@ -4888,36 +4659,31 @@
48884659 	int retval;
48894660 
48904661 	retval = disable_card_clock(chip, SD_CARD);
4891
-	if (retval != STATUS_SUCCESS) {
4662
+	if (retval != STATUS_SUCCESS)
48924663 		return STATUS_FAIL;
4893
-	}
48944664 
48954665 	retval = rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN, 0);
4896
-	if (retval) {
4666
+	if (retval)
48974667 		return retval;
4898
-	}
48994668 
49004669 	if (!chip->ft2_fast_mode) {
49014670 		retval = card_power_off(chip, SD_CARD);
4902
-		if (retval != STATUS_SUCCESS) {
4671
+		if (retval != STATUS_SUCCESS)
49034672 			return STATUS_FAIL;
4904
-		}
49054673 
49064674 		mdelay(50);
49074675 	}
49084676 
49094677 	if (chip->asic_code) {
49104678 		retval = sd_pull_ctl_disable(chip);
4911
-		if (retval != STATUS_SUCCESS) {
4679
+		if (retval != STATUS_SUCCESS)
49124680 			return STATUS_FAIL;
4913
-		}
49144681 	} else {
49154682 		retval = rtsx_write_register(chip, FPGA_PULL_CTL,
49164683 					     FPGA_SD_PULL_CTL_BIT | 0x20,
49174684 					     FPGA_SD_PULL_CTL_BIT);
4918
-		if (retval) {
4685
+		if (retval)
49194686 			return retval;
4920
-		}
49214687 	}
49224688 
49234689 	return STATUS_SUCCESS;
....@@ -4944,9 +4710,8 @@
49444710 	memset(sd_card->raw_scr, 0, 8);
49454711 
49464712 	retval = sd_power_off_card3v3(chip);
4947
-	if (retval != STATUS_SUCCESS) {
4713
+	if (retval != STATUS_SUCCESS)
49484714 		return STATUS_FAIL;
4949
-	}
49504715 
49514716 	return STATUS_SUCCESS;
49524717 }