add dts config

hc

2023-12-06 08f87f769b595151be1afeff53e144f543faa614

 kernel/drivers/staging/rts5208/xd.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
2
4
  *
3
5
  * 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/>.
17
6
  *
18
7
  * Author:
19
8
  *   Wei WANG (wei_wang@realsil.com.cn)
..
..
@@ -60,9 +49,8 @@
60
49
 		xd_card->xd_clock = CLK_50;
61
50
 
62
51
 	retval = switch_clock(chip, xd_card->xd_clock);
63
-	if (retval != STATUS_SUCCESS) {
52
+	if (retval != STATUS_SUCCESS)
64
53
 		return STATUS_FAIL;
65
-	}
66
54
 
67
55
 	return STATUS_SUCCESS;
68
56
 }
..
..
@@ -73,14 +61,12 @@
73
61
 	int retval;
74
62
 
75
63
 	retval = select_card(chip, XD_CARD);
76
-	if (retval != STATUS_SUCCESS) {
64
+	if (retval != STATUS_SUCCESS)
77
65
 		return STATUS_FAIL;
78
-	}
79
66
 
80
67
 	retval = switch_clock(chip, xd_card->xd_clock);
81
-	if (retval != STATUS_SUCCESS) {
68
+	if (retval != STATUS_SUCCESS)
82
69
 		return STATUS_FAIL;
83
-	}
84
70
 
85
71
 	return STATUS_SUCCESS;
86
72
 }
..
..
@@ -102,9 +88,8 @@
102
88
 		rtsx_add_cmd(chip, READ_REG_CMD, (u16)(XD_ADDRESS1 + i), 0, 0);
103
89
 
104
90
 	retval = rtsx_send_cmd(chip, XD_CARD, 20);
105
-	if (retval < 0) {
91
+	if (retval < 0)
106
92
 		return STATUS_FAIL;
107
-	}
108
93
 
109
94
 	ptr = rtsx_get_cmd_data(chip) + 1;
110
95
 	if (id_buf && buf_len) {
..
..
@@ -173,9 +158,8 @@
173
158
 	rtsx_add_cmd(chip, READ_REG_CMD, XD_PARITY, 0, 0);
174
159
 
175
160
 	retval = rtsx_send_cmd(chip, XD_CARD, 500);
176
-	if (retval < 0) {
161
+	if (retval < 0)
177
162
 		return STATUS_FAIL;
178
-	}
179
163
 
180
164
 	if (buf && buf_len) {
181
165
 		u8 *ptr = rtsx_get_cmd_data(chip) + 1;
..
..
@@ -193,9 +177,8 @@
193
177
 {
194
178
 	int retval, i;
195
179
 
196
-	if (!buf || (buf_len < 0)) {
180
+	if (!buf || (buf_len < 0))
197
181
 		return STATUS_FAIL;
198
-	}
199
182
 
200
183
 	rtsx_init_cmd(chip);
201
184
 
..
..
@@ -220,9 +203,8 @@
220
203
 	int retval;
221
204
 	u8 reg;
222
205
 
223
-	if (!buf || (buf_len < 10)) {
206
+	if (!buf || (buf_len < 10))
224
207
 		return STATUS_FAIL;
225
-	}
226
208
 
227
209
 	rtsx_init_cmd(chip);
228
210
 
..
..
@@ -246,36 +228,31 @@
246
228
 	}
247
229
 
248
230
 	retval = rtsx_read_register(chip, XD_PAGE_STATUS, &reg);
249
-	if (retval) {
231
+	if (retval)
250
232
 		return retval;
251
-	}
252
233
 	if (reg != XD_GPG) {
253
234
 		rtsx_clear_xd_error(chip);
254
235
 		return STATUS_FAIL;
255
236
 	}
256
237
 
257
238
 	retval = rtsx_read_register(chip, XD_CTL, &reg);
258
-	if (retval) {
239
+	if (retval)
259
240
 		return retval;
260
-	}
261
241
 	if (!(reg & XD_ECC1_ERROR) || !(reg & XD_ECC1_UNCORRECTABLE)) {
262
242
 		retval = xd_read_data_from_ppb(chip, 0, buf, buf_len);
263
-		if (retval != STATUS_SUCCESS) {
243
+		if (retval != STATUS_SUCCESS)
264
244
 			return STATUS_FAIL;
265
-		}
266
245
 		if (reg & XD_ECC1_ERROR) {
267
246
 			u8 ecc_bit, ecc_byte;
268
247
 
269
248
 			retval = rtsx_read_register(chip, XD_ECC_BIT1,
270
249
 						    &ecc_bit);
271
-			if (retval) {
250
+			if (retval)
272
251
 				return retval;
273
-			}
274
252
 			retval = rtsx_read_register(chip, XD_ECC_BYTE1,
275
253
 						    &ecc_byte);
276
-			if (retval) {
254
+			if (retval)
277
255
 				return retval;
278
-			}
279
256
 
280
257
 			dev_dbg(rtsx_dev(chip), "ECC_BIT1 = 0x%x, ECC_BYTE1 = 0x%x\n",
281
258
 				ecc_bit, ecc_byte);
..
..
@@ -291,22 +268,19 @@
291
268
 		rtsx_clear_xd_error(chip);
292
269
 
293
270
 		retval = xd_read_data_from_ppb(chip, 256, buf, buf_len);
294
-		if (retval != STATUS_SUCCESS) {
271
+		if (retval != STATUS_SUCCESS)
295
272
 			return STATUS_FAIL;
296
-		}
297
273
 		if (reg & XD_ECC2_ERROR) {
298
274
 			u8 ecc_bit, ecc_byte;
299
275
 
300
276
 			retval = rtsx_read_register(chip, XD_ECC_BIT2,
301
277
 						    &ecc_bit);
302
-			if (retval) {
278
+			if (retval)
303
279
 				return retval;
304
-			}
305
280
 			retval = rtsx_read_register(chip, XD_ECC_BYTE2,
306
281
 						    &ecc_byte);
307
-			if (retval) {
282
+			if (retval)
308
283
 				return retval;
309
-			}
310
284
 
311
285
 			dev_dbg(rtsx_dev(chip), "ECC_BIT2 = 0x%x, ECC_BYTE2 = 0x%x\n",
312
286
 				ecc_bit, ecc_byte);
..
..
@@ -404,68 +378,58 @@
404
378
 					     XD_D2_PD |
405
379
 					     XD_D1_PD |
406
380
 					     XD_D0_PD);
407
-		if (retval) {
381
+		if (retval)
408
382
 			return retval;
409
-		}
410
383
 		retval = rtsx_write_register(chip, CARD_PULL_CTL2, 0xFF,
411
384
 					     XD_D7_PD |
412
385
 					     XD_D6_PD |
413
386
 					     XD_D5_PD |
414
387
 					     XD_D4_PD);
415
-		if (retval) {
388
+		if (retval)
416
389
 			return retval;
417
-		}
418
390
 		retval = rtsx_write_register(chip, CARD_PULL_CTL3, 0xFF,
419
391
 					     XD_WP_PD |
420
392
 					     XD_CE_PD |
421
393
 					     XD_CLE_PD |
422
394
 					     XD_CD_PU);
423
-		if (retval) {
395
+		if (retval)
424
396
 			return retval;
425
-		}
426
397
 		retval = rtsx_write_register(chip, CARD_PULL_CTL4, 0xFF,
427
398
 					     XD_RDY_PD |
428
399
 					     XD_WE_PD |
429
400
 					     XD_RE_PD |
430
401
 					     XD_ALE_PD);
431
-		if (retval) {
402
+		if (retval)
432
403
 			return retval;
433
-		}
434
404
 		retval = rtsx_write_register(chip, CARD_PULL_CTL5, 0xFF,
435
405
 					     MS_INS_PU |
436
406
 					     SD_WP_PD |
437
407
 					     SD_CD_PU |
438
408
 					     SD_CMD_PD);
439
-		if (retval) {
409
+		if (retval)
440
410
 			return retval;
441
-		}
442
411
 		retval = rtsx_write_register(chip, CARD_PULL_CTL6, 0xFF,
443
412
 					     MS_D5_PD | MS_D4_PD);
444
-		if (retval) {
413
+		if (retval)
445
414
 			return retval;
446
-		}
447
415
 	} else if (CHECK_PID(chip, 0x5288)) {
448
416
 		if (CHECK_BARO_PKG(chip, QFN)) {
449
417
 			retval = rtsx_write_register(chip, CARD_PULL_CTL1,
450
418
 						     0xFF, 0x55);
451
-			if (retval) {
419
+			if (retval)
452
420
 				return retval;
453
-			}
454
421
 			retval = rtsx_write_register(chip, CARD_PULL_CTL2,
455
422
 						     0xFF, 0x55);
456
-			if (retval) {
423
+			if (retval)
457
424
 				return retval;
458
-			}
459
425
 			retval = rtsx_write_register(chip, CARD_PULL_CTL3,
460
426
 						     0xFF, 0x4B);
461
-			if (retval) {
427
+			if (retval)
462
428
 				return retval;
463
-			}
464
429
 			retval = rtsx_write_register(chip, CARD_PULL_CTL4,
465
430
 						     0xFF, 0x69);
466
-			if (retval) {
431
+			if (retval)
467
432
 				return retval;
468
-			}
469
433
 		}
470
434
 	}
471
435
 
..
..
@@ -479,9 +443,8 @@
479
443
 	u8 *ptr, id_buf[4], redunt[11];
480
444
 
481
445
 	retval = select_card(chip, XD_CARD);
482
-	if (retval != STATUS_SUCCESS) {
446
+	if (retval != STATUS_SUCCESS)
483
447
 		return STATUS_FAIL;
484
-	}
485
448
 
486
449
 	rtsx_init_cmd(chip);
487
450
 
..
..
@@ -505,15 +468,13 @@
505
468
 	rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_OE, XD_OUTPUT_EN, 0);
506
469
 
507
470
 	retval = rtsx_send_cmd(chip, XD_CARD, 100);
508
-	if (retval < 0) {
471
+	if (retval < 0)
509
472
 		return STATUS_FAIL;
510
-	}
511
473
 
512
474
 	if (!chip->ft2_fast_mode) {
513
475
 		retval = card_power_off(chip, XD_CARD);
514
-		if (retval != STATUS_SUCCESS) {
476
+		if (retval != STATUS_SUCCESS)
515
477
 			return STATUS_FAIL;
516
-		}
517
478
 
518
479
 		wait_timeout(250);
519
480
 
..
..
@@ -529,14 +490,12 @@
529
490
 		}
530
491
 
531
492
 		retval = rtsx_send_cmd(chip, XD_CARD, 100);
532
-		if (retval < 0) {
493
+		if (retval < 0)
533
494
 			return STATUS_FAIL;
534
-		}
535
495
 
536
496
 		retval = card_power_on(chip, XD_CARD);
537
-		if (retval != STATUS_SUCCESS) {
497
+		if (retval != STATUS_SUCCESS)
538
498
 			return STATUS_FAIL;
539
-		}
540
499
 
541
500
 #ifdef SUPPORT_OCP
542
501
 		wait_timeout(50);
..
..
@@ -565,17 +524,15 @@
565
524
 	rtsx_add_cmd(chip, WRITE_REG_CMD, XD_CTL, XD_CE_DISEN, XD_CE_DISEN);
566
525
 
567
526
 	retval = rtsx_send_cmd(chip, XD_CARD, 100);
568
-	if (retval < 0) {
527
+	if (retval < 0)
569
528
 		return STATUS_FAIL;
570
-	}
571
529
 
572
530
 	if (!chip->ft2_fast_mode)
573
531
 		wait_timeout(200);
574
532
 
575
533
 	retval = xd_set_init_para(chip);
576
-	if (retval != STATUS_SUCCESS) {
534
+	if (retval != STATUS_SUCCESS)
577
535
 		return STATUS_FAIL;
578
-	}
579
536
 
580
537
 	/* Read ID to check if the timing setting is right */
581
538
 	for (i = 0; i < 4; i++) {
..
..
@@ -598,9 +555,8 @@
598
555
 		rtsx_add_cmd(chip, READ_REG_CMD, XD_CTL, 0, 0);
599
556
 
600
557
 		retval = rtsx_send_cmd(chip, XD_CARD, 100);
601
-		if (retval < 0) {
558
+		if (retval < 0)
602
559
 			return STATUS_FAIL;
603
-		}
604
560
 
605
561
 		ptr = rtsx_get_cmd_data(chip) + 1;
606
562
 
..
..
@@ -612,9 +568,8 @@
612
568
 			continue;
613
569
 
614
570
 		retval = xd_read_id(chip, READ_ID, id_buf, 4);
615
-		if (retval != STATUS_SUCCESS) {
571
+		if (retval != STATUS_SUCCESS)
616
572
 			return STATUS_FAIL;
617
-		}
618
573
 
619
574
 		dev_dbg(rtsx_dev(chip), "READ_ID: 0x%x 0x%x 0x%x 0x%x\n",
620
575
 			id_buf[0], id_buf[1], id_buf[2], id_buf[3]);
..
..
@@ -675,13 +630,13 @@
675
630
 			xd_card->zone_cnt = 32;
676
631
 			xd_card->capacity = 1024000;
677
632
 			break;
678
-		case xD_1G_X8_512:
633
+		case XD_1G_X8_512:
679
634
 			XD_PAGE_512(xd_card);
680
635
 			xd_card->addr_cycle = 4;
681
636
 			xd_card->zone_cnt = 64;
682
637
 			xd_card->capacity = 2048000;
683
638
 			break;
684
-		case xD_2G_X8_512:
639
+		case XD_2G_X8_512:
685
640
 			XD_PAGE_512(xd_card);
686
641
 			xd_card->addr_cycle = 4;
687
642
 			xd_card->zone_cnt = 128;
..
..
@@ -694,9 +649,8 @@
694
649
 		/* Confirm timing setting */
695
650
 		for (j = 0; j < 10; j++) {
696
651
 			retval = xd_read_id(chip, READ_ID, id_buf, 4);
697
-			if (retval != STATUS_SUCCESS) {
652
+			if (retval != STATUS_SUCCESS)
698
653
 				return STATUS_FAIL;
699
-			}
700
654
 
701
655
 			if (id_buf[1] != xd_card->device_code)
702
656
 				break;
..
..
@@ -715,23 +669,20 @@
715
669
 		return STATUS_FAIL;
716
670
 	}
717
671
 
718
-	retval = xd_read_id(chip, READ_xD_ID, id_buf, 4);
719
-	if (retval != STATUS_SUCCESS) {
672
+	retval = xd_read_id(chip, READ_XD_ID, id_buf, 4);
673
+	if (retval != STATUS_SUCCESS)
720
674
 		return STATUS_FAIL;
721
-	}
722
-	dev_dbg(rtsx_dev(chip), "READ_xD_ID: 0x%x 0x%x 0x%x 0x%x\n",
675
+	dev_dbg(rtsx_dev(chip), "READ_XD_ID: 0x%x 0x%x 0x%x 0x%x\n",
723
676
 		id_buf[0], id_buf[1], id_buf[2], id_buf[3]);
724
-	if (id_buf[2] != XD_ID_CODE) {
677
+	if (id_buf[2] != XD_ID_CODE)
725
678
 		return STATUS_FAIL;
726
-	}
727
679
 
728
680
 	/* Search CIS block */
729
681
 	for (i = 0; i < 24; i++) {
730
682
 		u32 page_addr;
731
683
 
732
-		if (detect_card_cd(chip, XD_CARD) != STATUS_SUCCESS) {
684
+		if (detect_card_cd(chip, XD_CARD) != STATUS_SUCCESS)
733
685
 			return STATUS_FAIL;
734
-		}
735
686
 
736
687
 		page_addr = (u32)i << xd_card->block_shift;
737
688
 
..
..
@@ -769,9 +720,8 @@
769
720
 			page_addr += j;
770
721
 
771
722
 			retval = xd_read_cis(chip, page_addr, buf, 10);
772
-			if (retval != STATUS_SUCCESS) {
723
+			if (retval != STATUS_SUCCESS)
773
724
 				return STATUS_FAIL;
774
-			}
775
725
 
776
726
 			if ((buf[0] == 0x01) && (buf[1] == 0x03) &&
777
727
 			    (buf[2] == 0xD9) &&
..
..
@@ -841,17 +791,15 @@
841
791
 	dev_dbg(rtsx_dev(chip), "%s: zone_cnt = %d\n", __func__,
842
792
 		xd_card->zone_cnt);
843
793
 
844
-	if (xd_card->zone_cnt < 1) {
794
+	if (xd_card->zone_cnt < 1)
845
795
 		return STATUS_FAIL;
846
-	}
847
796
 
848
797
 	size = xd_card->zone_cnt * sizeof(struct zone_entry);
849
798
 	dev_dbg(rtsx_dev(chip), "Buffer size for l2p table is %d\n", size);
850
799
 
851
800
 	xd_card->zone = vmalloc(size);
852
-	if (!xd_card->zone) {
801
+	if (!xd_card->zone)
853
802
 		return STATUS_ERROR;
854
-	}
855
803
 
856
804
 	for (i = 0; i < xd_card->zone_cnt; i++) {
857
805
 		xd_card->zone[i].build_flag = 0;
..
..
@@ -1028,19 +976,16 @@
1028
976
 	xd_card->delay_write.delay_write_flag = 0;
1029
977
 
1030
978
 	retval = enable_card_clock(chip, XD_CARD);
1031
-	if (retval != STATUS_SUCCESS) {
979
+	if (retval != STATUS_SUCCESS)
1032
980
 		return STATUS_FAIL;
1033
-	}
1034
981
 
1035
982
 	retval = reset_xd(chip);
1036
-	if (retval != STATUS_SUCCESS) {
983
+	if (retval != STATUS_SUCCESS)
1037
984
 		return STATUS_FAIL;
1038
-	}
1039
985
 
1040
986
 	retval = xd_init_l2p_tbl(chip);
1041
-	if (retval != STATUS_SUCCESS) {
987
+	if (retval != STATUS_SUCCESS)
1042
988
 		return STATUS_FAIL;
1043
-	}
1044
989
 
1045
990
 	return STATUS_SUCCESS;
1046
991
 }
..
..
@@ -1054,9 +999,8 @@
1054
999
 
1055
1000
 	dev_dbg(rtsx_dev(chip), "mark block 0x%x as bad block\n", phy_blk);
1056
1001
 
1057
-	if (phy_blk == BLK_NOT_FOUND) {
1002
+	if (phy_blk == BLK_NOT_FOUND)
1058
1003
 		return STATUS_FAIL;
1059
-	}
1060
1004
 
1061
1005
 	rtsx_init_cmd(chip);
1062
1006
 
..
..
@@ -1107,12 +1051,10 @@
1107
1051
 
1108
1052
 	dev_dbg(rtsx_dev(chip), "Init block 0x%x\n", phy_blk);
1109
1053
 
1110
-	if (start_page > end_page) {
1054
+	if (start_page > end_page)
1111
1055
 		return STATUS_FAIL;
1112
-	}
1113
-	if (phy_blk == BLK_NOT_FOUND) {
1056
+	if (phy_blk == BLK_NOT_FOUND)
1114
1057
 		return STATUS_FAIL;
1115
-	}
1116
1058
 
1117
1059
 	rtsx_init_cmd(chip);
1118
1060
 
..
..
@@ -1164,13 +1106,11 @@
1164
1106
 	dev_dbg(rtsx_dev(chip), "Copy page from block 0x%x to block 0x%x\n",
1165
1107
 		old_blk, new_blk);
1166
1108
 
1167
-	if (start_page > end_page) {
1109
+	if (start_page > end_page)
1168
1110
 		return STATUS_FAIL;
1169
-	}
1170
1111
 
1171
-	if ((old_blk == BLK_NOT_FOUND) || (new_blk == BLK_NOT_FOUND)) {
1112
+	if ((old_blk == BLK_NOT_FOUND) || (new_blk == BLK_NOT_FOUND))
1172
1113
 		return STATUS_FAIL;
1173
-	}
1174
1114
 
1175
1115
 	old_page = (old_blk << xd_card->block_shift) + start_page;
1176
1116
 	new_page = (new_blk << xd_card->block_shift) + start_page;
..
..
@@ -1179,9 +1119,8 @@
1179
1119
 
1180
1120
 	retval = rtsx_write_register(chip, CARD_DATA_SOURCE, 0x01,
1181
1121
 				     PINGPONG_BUFFER);
1182
-	if (retval) {
1122
+	if (retval)
1183
1123
 		return retval;
1184
-	}
1185
1124
 
1186
1125
 	for (i = start_page; i < end_page; i++) {
1187
1126
 		if (detect_card_cd(chip, XD_CARD) != STATUS_SUCCESS) {
..
..
@@ -1216,10 +1155,10 @@
1216
1155
 					return STATUS_FAIL;
1217
1156
 				}
1218
1157
 
1219
-				if (((reg & (XD_ECC1_ERROR | XD_ECC1_UNCORRECTABLE)) ==
1220
-						(XD_ECC1_ERROR | XD_ECC1_UNCORRECTABLE)) ||
1221
-					((reg & (XD_ECC2_ERROR | XD_ECC2_UNCORRECTABLE)) ==
1222
-						(XD_ECC2_ERROR | XD_ECC2_UNCORRECTABLE))) {
1158
+				if (((reg & XD_ECC1_ERROR) &&
1159
+				     (reg & XD_ECC1_UNCORRECTABLE)) ||
1160
+				    ((reg & XD_ECC2_ERROR) &&
1161
+				     (reg & XD_ECC2_UNCORRECTABLE))) {
1223
1162
 					rtsx_write_register(chip,
1224
1163
 							    XD_PAGE_STATUS,
1225
1164
 							    0xFF,
..
..
@@ -1287,9 +1226,8 @@
1287
1226
 	rtsx_add_cmd(chip, READ_REG_CMD, XD_CTL, 0, 0);
1288
1227
 
1289
1228
 	retval = rtsx_send_cmd(chip, XD_CARD, 100);
1290
-	if (retval < 0) {
1229
+	if (retval < 0)
1291
1230
 		return STATUS_FAIL;
1292
-	}
1293
1231
 
1294
1232
 	ptr = rtsx_get_cmd_data(chip) + 1;
1295
1233
 	if (((ptr[0] & READY_FLAG) == READY_STATE) && (ptr[1] & XD_RDY))
..
..
@@ -1305,9 +1243,8 @@
1305
1243
 	u8 reg = 0, *ptr;
1306
1244
 	int i, retval;
1307
1245
 
1308
-	if (phy_blk == BLK_NOT_FOUND) {
1246
+	if (phy_blk == BLK_NOT_FOUND)
1309
1247
 		return STATUS_FAIL;
1310
-	}
1311
1248
 
1312
1249
 	page_addr = phy_blk << xd_card->block_shift;
1313
1250
 
..
..
@@ -1333,9 +1270,8 @@
1333
1270
 			}
1334
1271
 			xd_set_err_code(chip, XD_ERASE_FAIL);
1335
1272
 			retval = xd_reset_cmd(chip);
1336
-			if (retval != STATUS_SUCCESS) {
1273
+			if (retval != STATUS_SUCCESS)
1337
1274
 				return STATUS_FAIL;
1338
-			}
1339
1275
 			continue;
1340
1276
 		}
1341
1277
 
..
..
@@ -1382,17 +1318,15 @@
1382
1318
 
1383
1319
 	if (!zone->l2p_table) {
1384
1320
 		zone->l2p_table = vmalloc(2000);
1385
-		if (!zone->l2p_table) {
1321
+		if (!zone->l2p_table)
1386
1322
 			goto build_fail;
1387
-		}
1388
1323
 	}
1389
1324
 	memset((u8 *)(zone->l2p_table), 0xff, 2000);
1390
1325
 
1391
1326
 	if (!zone->free_table) {
1392
1327
 		zone->free_table = vmalloc(XD_FREE_TABLE_CNT * 2);
1393
-		if (!zone->free_table) {
1328
+		if (!zone->free_table)
1394
1329
 			goto build_fail;
1395
-		}
1396
1330
 	}
1397
1331
 	memset((u8 *)(zone->free_table), 0xff, XD_FREE_TABLE_CNT * 2);
1398
1332
 
..
..
@@ -1555,9 +1489,8 @@
1555
1489
 		     XD_TRANSFER_END, XD_TRANSFER_END);
1556
1490
 
1557
1491
 	retval = rtsx_send_cmd(chip, XD_CARD, 200);
1558
-	if (retval < 0) {
1492
+	if (retval < 0)
1559
1493
 		return STATUS_FAIL;
1560
-	}
1561
1494
 
1562
1495
 	return STATUS_SUCCESS;
1563
1496
 }
..
..
@@ -1636,17 +1569,15 @@
1636
1569
 
1637
1570
 fail:
1638
1571
 	retval = rtsx_read_register(chip, XD_PAGE_STATUS, &reg_val);
1639
-	if (retval) {
1572
+	if (retval)
1640
1573
 		return retval;
1641
-	}
1642
1574
 
1643
1575
 	if (reg_val !=  XD_GPG)
1644
1576
 		xd_set_err_code(chip, XD_PRG_ERROR);
1645
1577
 
1646
1578
 	retval = rtsx_read_register(chip, XD_CTL, &reg_val);
1647
-	if (retval) {
1579
+	if (retval)
1648
1580
 		return retval;
1649
-	}
1650
1581
 
1651
1582
 	if (((reg_val & (XD_ECC1_ERROR | XD_ECC1_UNCORRECTABLE)) ==
1652
1583
 				(XD_ECC1_ERROR | XD_ECC1_UNCORRECTABLE)) ||
..
..
@@ -1702,9 +1633,8 @@
1702
1633
 	dev_dbg(rtsx_dev(chip),	"new_blk = 0x%x, ", new_blk);
1703
1634
 	dev_dbg(rtsx_dev(chip), "log_blk = 0x%x\n", log_blk);
1704
1635
 
1705
-	if (page_off > xd_card->page_off) {
1636
+	if (page_off > xd_card->page_off)
1706
1637
 		return STATUS_FAIL;
1707
-	}
1708
1638
 
1709
1639
 	zone_no = (int)(log_blk / 1000);
1710
1640
 	log_off = (u16)(log_blk % 1000);
..
..
@@ -1760,9 +1690,8 @@
1760
1690
 
1761
1691
 	if (page_off) {
1762
1692
 		retval = xd_copy_page(chip, old_blk, new_blk, 0, page_off);
1763
-		if (retval != STATUS_SUCCESS) {
1693
+		if (retval != STATUS_SUCCESS)
1764
1694
 			return STATUS_FAIL;
1765
-		}
1766
1695
 	}
1767
1696
 
1768
1697
 	return STATUS_SUCCESS;
..
..
@@ -1858,9 +1787,8 @@
1858
1787
 
1859
1788
 fail:
1860
1789
 	retval = rtsx_read_register(chip, XD_DAT, &reg_val);
1861
-	if (retval) {
1790
+	if (retval)
1862
1791
 		return retval;
1863
-	}
1864
1792
 	if (reg_val & PROGRAM_ERROR) {
1865
1793
 		xd_set_err_code(chip, XD_PRG_ERROR);
1866
1794
 		xd_mark_bad_block(chip, new_blk);
..
..
@@ -1880,9 +1808,8 @@
1880
1808
 	if (delay_write->delay_write_flag) {
1881
1809
 		dev_dbg(rtsx_dev(chip), "%s\n", __func__);
1882
1810
 		retval = xd_switch_clock(chip);
1883
-		if (retval != STATUS_SUCCESS) {
1811
+		if (retval != STATUS_SUCCESS)
1884
1812
 			return STATUS_FAIL;
1885
-		}
1886
1813
 
1887
1814
 		delay_write->delay_write_flag = 0;
1888
1815
 		retval = xd_finish_write(chip,
..
..
@@ -1890,9 +1817,8 @@
1890
1817
 					 delay_write->new_phyblock,
1891
1818
 					 delay_write->logblock,
1892
1819
 					 delay_write->pageoff);
1893
-		if (retval != STATUS_SUCCESS) {
1820
+		if (retval != STATUS_SUCCESS)
1894
1821
 			return STATUS_FAIL;
1895
-		}
1896
1822
 	}
1897
1823
 
1898
1824
 	return STATUS_SUCCESS;
..
..
@@ -1924,9 +1850,8 @@
1924
1850
 	ptr = (u8 *)scsi_sglist(srb);
1925
1851
 
1926
1852
 	retval = xd_switch_clock(chip);
1927
-	if (retval != STATUS_SUCCESS) {
1853
+	if (retval != STATUS_SUCCESS)
1928
1854
 		return STATUS_FAIL;
1929
-	}
1930
1855
 
1931
1856
 	if (detect_card_cd(chip, XD_CARD) != STATUS_SUCCESS) {
1932
1857
 		chip->card_fail |= XD_CARD;
..
..
@@ -2180,34 +2105,29 @@
2180
2105
 	int retval;
2181
2106
 
2182
2107
 	retval = disable_card_clock(chip, XD_CARD);
2183
-	if (retval != STATUS_SUCCESS) {
2108
+	if (retval != STATUS_SUCCESS)
2184
2109
 		return STATUS_FAIL;
2185
-	}
2186
2110
 
2187
2111
 	retval = rtsx_write_register(chip, CARD_OE, XD_OUTPUT_EN, 0);
2188
-	if (retval) {
2112
+	if (retval)
2189
2113
 		return retval;
2190
-	}
2191
2114
 
2192
2115
 	if (!chip->ft2_fast_mode) {
2193
2116
 		retval = card_power_off(chip, XD_CARD);
2194
-		if (retval != STATUS_SUCCESS) {
2117
+		if (retval != STATUS_SUCCESS)
2195
2118
 			return STATUS_FAIL;
2196
-		}
2197
2119
 
2198
2120
 		wait_timeout(50);
2199
2121
 	}
2200
2122
 
2201
2123
 	if (chip->asic_code) {
2202
2124
 		retval = xd_pull_ctl_disable(chip);
2203
-		if (retval != STATUS_SUCCESS) {
2125
+		if (retval != STATUS_SUCCESS)
2204
2126
 			return STATUS_FAIL;
2205
-		}
2206
2127
 	} else {
2207
2128
 		retval = rtsx_write_register(chip, FPGA_PULL_CTL, 0xFF, 0xDF);
2208
-		if (retval) {
2129
+		if (retval)
2209
2130
 			return retval;
2210
-		}
2211
2131
 	}
2212
2132
 
2213
2133
 	return STATUS_SUCCESS;
..
..
@@ -2227,9 +2147,8 @@
2227
2147
 	xd_free_l2p_tbl(chip);
2228
2148
 
2229
2149
 	retval = xd_power_off_card3v3(chip);
2230
-	if (retval != STATUS_SUCCESS) {
2150
+	if (retval != STATUS_SUCCESS)
2231
2151
 		return STATUS_FAIL;
2232
-	}
2233
2152
 
2234
2153
 	return STATUS_SUCCESS;
2235
2154
 }