tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

mmc: remove old card states

Remove card states that no longer make any sense.

Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>

Pierre Ossman bd766312 6abaa0c9

+34 -28
+14 -8
drivers/mmc/core/mmc.c
··· 56 56 /* 57 57 * Given the decoded CSD structure, decode the raw CID to our CID structure. 58 58 */ 59 - static void mmc_decode_cid(struct mmc_card *card) 59 + static int mmc_decode_cid(struct mmc_card *card) 60 60 { 61 61 u32 *resp = card->raw_cid; 62 62 ··· 101 101 default: 102 102 printk("%s: card has unknown MMCA version %d\n", 103 103 mmc_hostname(card->host), card->csd.mmca_vsn); 104 - mmc_card_set_bad(card); 105 - break; 104 + return -EINVAL; 106 105 } 106 + 107 + return 0; 107 108 } 108 109 109 110 /* 110 111 * Given a 128-bit response, decode to our card CSD structure. 111 112 */ 112 - static void mmc_decode_csd(struct mmc_card *card) 113 + static int mmc_decode_csd(struct mmc_card *card) 113 114 { 114 115 struct mmc_csd *csd = &card->csd; 115 116 unsigned int e, m, csd_struct; ··· 124 123 if (csd_struct != 1 && csd_struct != 2) { 125 124 printk("%s: unrecognised CSD structure version %d\n", 126 125 mmc_hostname(card->host), csd_struct); 127 - mmc_card_set_bad(card); 128 - return; 126 + return -EINVAL; 129 127 } 130 128 131 129 csd->mmca_vsn = UNSTUFF_BITS(resp, 122, 4); ··· 149 149 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3); 150 150 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4); 151 151 csd->write_partial = UNSTUFF_BITS(resp, 21, 1); 152 + 153 + return 0; 152 154 } 153 155 154 156 /* ··· 302 300 if (err != MMC_ERR_NONE) 303 301 goto free_card; 304 302 305 - mmc_decode_csd(card); 306 - mmc_decode_cid(card); 303 + err = mmc_decode_csd(card); 304 + if (err < 0) 305 + goto free_card; 306 + err = mmc_decode_cid(card); 307 + if (err < 0) 308 + goto free_card; 307 309 } 308 310 309 311 /*
+15 -8
drivers/mmc/core/sd.c
··· 88 88 /* 89 89 * Given a 128-bit response, decode to our card CSD structure. 90 90 */ 91 - static void mmc_decode_csd(struct mmc_card *card) 91 + static int mmc_decode_csd(struct mmc_card *card) 92 92 { 93 93 struct mmc_csd *csd = &card->csd; 94 94 unsigned int e, m, csd_struct; ··· 151 151 default: 152 152 printk("%s: unrecognised CSD structure version %d\n", 153 153 mmc_hostname(card->host), csd_struct); 154 - mmc_card_set_bad(card); 155 - return; 154 + return -EINVAL; 156 155 } 156 + 157 + return 0; 157 158 } 158 159 159 160 /* 160 161 * Given a 64-bit response, decode to our card SCR structure. 161 162 */ 162 - static void mmc_decode_scr(struct mmc_card *card) 163 + static int mmc_decode_scr(struct mmc_card *card) 163 164 { 164 165 struct sd_scr *scr = &card->scr; 165 166 unsigned int scr_struct; ··· 175 174 if (scr_struct != 0) { 176 175 printk("%s: unrecognised SCR structure version %d\n", 177 176 mmc_hostname(card->host), scr_struct); 178 - mmc_card_set_bad(card); 179 - return; 177 + return -EINVAL; 180 178 } 181 179 182 180 scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4); 183 181 scr->bus_widths = UNSTUFF_BITS(resp, 48, 4); 182 + 183 + return 0; 184 184 } 185 185 186 186 /* ··· 344 342 if (err != MMC_ERR_NONE) 345 343 goto free_card; 346 344 347 - mmc_decode_csd(card); 345 + err = mmc_decode_csd(card); 346 + if (err < 0) 347 + goto free_card; 348 + 348 349 mmc_decode_cid(card); 349 350 } 350 351 ··· 366 361 if (err != MMC_ERR_NONE) 367 362 goto free_card; 368 363 369 - mmc_decode_scr(card); 364 + err = mmc_decode_scr(card); 365 + if (err < 0) 366 + goto free_card; 370 367 371 368 /* 372 369 * Fetch switch information from card.
+2 -3
drivers/mmc/core/sysfs.c
··· 72 72 /* 73 73 * This currently matches any MMC driver to any MMC card - drivers 74 74 * themselves make the decision whether to drive this card in their 75 - * probe method. However, we force "bad" cards to fail. 75 + * probe method. 76 76 */ 77 77 static int mmc_bus_match(struct device *dev, struct device_driver *drv) 78 78 { 79 - struct mmc_card *card = dev_to_mmc_card(dev); 80 - return !mmc_card_bad(card); 79 + return 1; 81 80 } 82 81 83 82 static int
+3 -9
include/linux/mmc/card.h
··· 69 69 #define MMC_TYPE_SD 1 /* SD card */ 70 70 unsigned int state; /* (our) card state */ 71 71 #define MMC_STATE_PRESENT (1<<0) /* present in sysfs */ 72 - #define MMC_STATE_DEAD (1<<1) /* device no longer in stack */ 73 - #define MMC_STATE_BAD (1<<2) /* unrecognised device */ 74 - #define MMC_STATE_READONLY (1<<3) /* card is read-only */ 75 - #define MMC_STATE_HIGHSPEED (1<<4) /* card is in high speed mode */ 76 - #define MMC_STATE_BLOCKADDR (1<<5) /* card uses block-addressing */ 72 + #define MMC_STATE_READONLY (1<<1) /* card is read-only */ 73 + #define MMC_STATE_HIGHSPEED (1<<2) /* card is in high speed mode */ 74 + #define MMC_STATE_BLOCKADDR (1<<3) /* card uses block-addressing */ 77 75 u32 raw_cid[4]; /* raw card CID */ 78 76 u32 raw_csd[4]; /* raw card CSD */ 79 77 u32 raw_scr[2]; /* raw card SCR */ ··· 86 88 #define mmc_card_sd(c) ((c)->type == MMC_TYPE_SD) 87 89 88 90 #define mmc_card_present(c) ((c)->state & MMC_STATE_PRESENT) 89 - #define mmc_card_dead(c) ((c)->state & MMC_STATE_DEAD) 90 - #define mmc_card_bad(c) ((c)->state & MMC_STATE_BAD) 91 91 #define mmc_card_readonly(c) ((c)->state & MMC_STATE_READONLY) 92 92 #define mmc_card_highspeed(c) ((c)->state & MMC_STATE_HIGHSPEED) 93 93 #define mmc_card_blockaddr(c) ((c)->state & MMC_STATE_BLOCKADDR) 94 94 95 95 #define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT) 96 - #define mmc_card_set_dead(c) ((c)->state |= MMC_STATE_DEAD) 97 - #define mmc_card_set_bad(c) ((c)->state |= MMC_STATE_BAD) 98 96 #define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY) 99 97 #define mmc_card_set_highspeed(c) ((c)->state |= MMC_STATE_HIGHSPEED) 100 98 #define mmc_card_set_blockaddr(c) ((c)->state |= MMC_STATE_BLOCKADDR)