aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mmc
diff options
context:
space:
mode:
authorPierre Ossman <drzeus@drzeus.cx>2007-07-22 16:18:46 -0400
committerPierre Ossman <drzeus@drzeus.cx>2007-09-23 02:46:48 -0400
commit17b0429dde9ab60f9cee8e07ab28c7dc6cfe6efd (patch)
tree9f87df1ffbeca4c6f828b7979f2e45ef898a3ef0 /drivers/mmc
parentb7e113dc9d52c4a37d2da6fafe77959f3a28eccf (diff)
mmc: remove custom error codes
Convert the MMC layer to use standard error codes and not its own, incompatible values. Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>
Diffstat (limited to 'drivers/mmc')
-rw-r--r--drivers/mmc/card/block.c4
-rw-r--r--drivers/mmc/core/core.c4
-rw-r--r--drivers/mmc/core/mmc.c36
-rw-r--r--drivers/mmc/core/mmc_ops.c34
-rw-r--r--drivers/mmc/core/sd.c56
-rw-r--r--drivers/mmc/core/sd_ops.c46
-rw-r--r--drivers/mmc/host/at91_mci.c12
-rw-r--r--drivers/mmc/host/au1xmmc.c32
-rw-r--r--drivers/mmc/host/imxmmc.c14
-rw-r--r--drivers/mmc/host/mmci.c12
-rw-r--r--drivers/mmc/host/omap.c12
-rw-r--r--drivers/mmc/host/pxamci.c12
-rw-r--r--drivers/mmc/host/sdhci.c51
-rw-r--r--drivers/mmc/host/tifm_sd.c20
-rw-r--r--drivers/mmc/host/wbsd.c41
15 files changed, 190 insertions, 196 deletions
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 93fe2e5dd616..0da341acf32b 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -154,7 +154,7 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
154 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 154 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
155 155
156 err = mmc_wait_for_cmd(card->host, &cmd, 0); 156 err = mmc_wait_for_cmd(card->host, &cmd, 0);
157 if ((err != MMC_ERR_NONE) || !(cmd.resp[0] & R1_APP_CMD)) 157 if (err || !(cmd.resp[0] & R1_APP_CMD))
158 return (u32)-1; 158 return (u32)-1;
159 159
160 memset(&cmd, 0, sizeof(struct mmc_command)); 160 memset(&cmd, 0, sizeof(struct mmc_command));
@@ -192,7 +192,7 @@ static u32 mmc_sd_num_wr_blocks(struct mmc_card *card)
192 192
193 mmc_wait_for_req(card->host, &mrq); 193 mmc_wait_for_req(card->host, &mrq);
194 194
195 if (cmd.error != MMC_ERR_NONE || data.error != MMC_ERR_NONE) 195 if (cmd.error || data.error)
196 return (u32)-1; 196 return (u32)-1;
197 197
198 blocks = ntohl(blocks); 198 blocks = ntohl(blocks);
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index bfd2ae5bd669..63b67296e92d 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -598,7 +598,7 @@ void mmc_rescan(struct work_struct *work)
598 mmc_send_if_cond(host, host->ocr_avail); 598 mmc_send_if_cond(host, host->ocr_avail);
599 599
600 err = mmc_send_app_op_cond(host, 0, &ocr); 600 err = mmc_send_app_op_cond(host, 0, &ocr);
601 if (err == MMC_ERR_NONE) { 601 if (!err) {
602 if (mmc_attach_sd(host, ocr)) 602 if (mmc_attach_sd(host, ocr))
603 mmc_power_off(host); 603 mmc_power_off(host);
604 } else { 604 } else {
@@ -607,7 +607,7 @@ void mmc_rescan(struct work_struct *work)
607 * searching for MMC cards. 607 * searching for MMC cards.
608 */ 608 */
609 err = mmc_send_op_cond(host, 0, &ocr); 609 err = mmc_send_op_cond(host, 0, &ocr);
610 if (err == MMC_ERR_NONE) { 610 if (!err) {
611 if (mmc_attach_mmc(host, ocr)) 611 if (mmc_attach_mmc(host, ocr))
612 mmc_power_off(host); 612 mmc_power_off(host);
613 } else { 613 } else {
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 21d7f48e1d4e..fe483d5af744 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -164,10 +164,10 @@ static int mmc_read_ext_csd(struct mmc_card *card)
164 164
165 BUG_ON(!card); 165 BUG_ON(!card);
166 166
167 err = MMC_ERR_FAILED; 167 err = -EIO;
168 168
169 if (card->csd.mmca_vsn < CSD_SPEC_VER_4) 169 if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
170 return MMC_ERR_NONE; 170 return 0;
171 171
172 /* 172 /*
173 * As the ext_csd is so large and mostly unused, we don't store the 173 * As the ext_csd is so large and mostly unused, we don't store the
@@ -178,11 +178,11 @@ static int mmc_read_ext_csd(struct mmc_card *card)
178 printk(KERN_ERR "%s: could not allocate a buffer to " 178 printk(KERN_ERR "%s: could not allocate a buffer to "
179 "receive the ext_csd. mmc v4 cards will be " 179 "receive the ext_csd. mmc v4 cards will be "
180 "treated as v3.\n", mmc_hostname(card->host)); 180 "treated as v3.\n", mmc_hostname(card->host));
181 return MMC_ERR_FAILED; 181 return -ENOMEM;
182 } 182 }
183 183
184 err = mmc_send_ext_csd(card, ext_csd); 184 err = mmc_send_ext_csd(card, ext_csd);
185 if (err != MMC_ERR_NONE) { 185 if (err) {
186 /* 186 /*
187 * High capacity cards should have this "magic" size 187 * High capacity cards should have this "magic" size
188 * stored in their CSD. 188 * stored in their CSD.
@@ -197,7 +197,7 @@ static int mmc_read_ext_csd(struct mmc_card *card)
197 "EXT_CSD, performance might " 197 "EXT_CSD, performance might "
198 "suffer.\n", 198 "suffer.\n",
199 mmc_hostname(card->host)); 199 mmc_hostname(card->host));
200 err = MMC_ERR_NONE; 200 err = 0;
201 } 201 }
202 goto out; 202 goto out;
203 } 203 }
@@ -258,14 +258,14 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
258 258
259 /* The extra bit indicates that we support high capacity */ 259 /* The extra bit indicates that we support high capacity */
260 err = mmc_send_op_cond(host, ocr | (1 << 30), NULL); 260 err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
261 if (err != MMC_ERR_NONE) 261 if (err)
262 goto err; 262 goto err;
263 263
264 /* 264 /*
265 * Fetch CID from card. 265 * Fetch CID from card.
266 */ 266 */
267 err = mmc_all_send_cid(host, cid); 267 err = mmc_all_send_cid(host, cid);
268 if (err != MMC_ERR_NONE) 268 if (err)
269 goto err; 269 goto err;
270 270
271 if (oldcard) { 271 if (oldcard) {
@@ -290,7 +290,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
290 * Set card RCA. 290 * Set card RCA.
291 */ 291 */
292 err = mmc_set_relative_addr(card); 292 err = mmc_set_relative_addr(card);
293 if (err != MMC_ERR_NONE) 293 if (err)
294 goto free_card; 294 goto free_card;
295 295
296 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 296 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
@@ -300,7 +300,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
300 * Fetch CSD from card. 300 * Fetch CSD from card.
301 */ 301 */
302 err = mmc_send_csd(card, card->raw_csd); 302 err = mmc_send_csd(card, card->raw_csd);
303 if (err != MMC_ERR_NONE) 303 if (err)
304 goto free_card; 304 goto free_card;
305 305
306 err = mmc_decode_csd(card); 306 err = mmc_decode_csd(card);
@@ -315,7 +315,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
315 * Select card, as all following commands rely on that. 315 * Select card, as all following commands rely on that.
316 */ 316 */
317 err = mmc_select_card(card); 317 err = mmc_select_card(card);
318 if (err != MMC_ERR_NONE) 318 if (err)
319 goto free_card; 319 goto free_card;
320 320
321 if (!oldcard) { 321 if (!oldcard) {
@@ -323,7 +323,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
323 * Fetch and process extened CSD. 323 * Fetch and process extened CSD.
324 */ 324 */
325 err = mmc_read_ext_csd(card); 325 err = mmc_read_ext_csd(card);
326 if (err != MMC_ERR_NONE) 326 if (err)
327 goto free_card; 327 goto free_card;
328 } 328 }
329 329
@@ -334,7 +334,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
334 (host->caps & MMC_CAP_MMC_HIGHSPEED)) { 334 (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
335 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 335 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
336 EXT_CSD_HS_TIMING, 1); 336 EXT_CSD_HS_TIMING, 1);
337 if (err != MMC_ERR_NONE) 337 if (err)
338 goto free_card; 338 goto free_card;
339 339
340 mmc_card_set_highspeed(card); 340 mmc_card_set_highspeed(card);
@@ -363,7 +363,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
363 (host->caps & MMC_CAP_4_BIT_DATA)) { 363 (host->caps & MMC_CAP_4_BIT_DATA)) {
364 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 364 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
365 EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_4); 365 EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_4);
366 if (err != MMC_ERR_NONE) 366 if (err)
367 goto free_card; 367 goto free_card;
368 368
369 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4); 369 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
@@ -372,14 +372,14 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
372 if (!oldcard) 372 if (!oldcard)
373 host->card = card; 373 host->card = card;
374 374
375 return MMC_ERR_NONE; 375 return 0;
376 376
377free_card: 377free_card:
378 if (!oldcard) 378 if (!oldcard)
379 mmc_remove_card(card); 379 mmc_remove_card(card);
380err: 380err:
381 381
382 return MMC_ERR_FAILED; 382 return -EIO;
383} 383}
384 384
385/* 385/*
@@ -413,7 +413,7 @@ static void mmc_detect(struct mmc_host *host)
413 413
414 mmc_release_host(host); 414 mmc_release_host(host);
415 415
416 if (err != MMC_ERR_NONE) { 416 if (err) {
417 mmc_remove(host); 417 mmc_remove(host);
418 418
419 mmc_claim_host(host); 419 mmc_claim_host(host);
@@ -502,7 +502,7 @@ static void mmc_resume(struct mmc_host *host)
502 err = mmc_init_card(host, host->ocr, host->card); 502 err = mmc_init_card(host, host->ocr, host->card);
503 mmc_release_host(host); 503 mmc_release_host(host);
504 504
505 if (err != MMC_ERR_NONE) { 505 if (err) {
506 mmc_remove(host); 506 mmc_remove(host);
507 507
508 mmc_claim_host(host); 508 mmc_claim_host(host);
@@ -565,7 +565,7 @@ int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
565 * Detect and init the card. 565 * Detect and init the card.
566 */ 566 */
567 err = mmc_init_card(host, host->ocr, NULL); 567 err = mmc_init_card(host, host->ocr, NULL);
568 if (err != MMC_ERR_NONE) 568 if (err)
569 goto err; 569 goto err;
570 570
571 mmc_release_host(host); 571 mmc_release_host(host);
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 913e75f00843..15cd575effaa 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -40,10 +40,10 @@ static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
40 } 40 }
41 41
42 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 42 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
43 if (err != MMC_ERR_NONE) 43 if (err)
44 return err; 44 return err;
45 45
46 return MMC_ERR_NONE; 46 return 0;
47} 47}
48 48
49int mmc_select_card(struct mmc_card *card) 49int mmc_select_card(struct mmc_card *card)
@@ -99,13 +99,13 @@ int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
99 99
100 for (i = 100; i; i--) { 100 for (i = 100; i; i--) {
101 err = mmc_wait_for_cmd(host, &cmd, 0); 101 err = mmc_wait_for_cmd(host, &cmd, 0);
102 if (err != MMC_ERR_NONE) 102 if (err)
103 break; 103 break;
104 104
105 if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0) 105 if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
106 break; 106 break;
107 107
108 err = MMC_ERR_TIMEOUT; 108 err = -ETIMEDOUT;
109 109
110 mmc_delay(10); 110 mmc_delay(10);
111 } 111 }
@@ -131,12 +131,12 @@ int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
131 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 131 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
132 132
133 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 133 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
134 if (err != MMC_ERR_NONE) 134 if (err)
135 return err; 135 return err;
136 136
137 memcpy(cid, cmd.resp, sizeof(u32) * 4); 137 memcpy(cid, cmd.resp, sizeof(u32) * 4);
138 138
139 return MMC_ERR_NONE; 139 return 0;
140} 140}
141 141
142int mmc_set_relative_addr(struct mmc_card *card) 142int mmc_set_relative_addr(struct mmc_card *card)
@@ -154,10 +154,10 @@ int mmc_set_relative_addr(struct mmc_card *card)
154 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 154 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
155 155
156 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 156 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
157 if (err != MMC_ERR_NONE) 157 if (err)
158 return err; 158 return err;
159 159
160 return MMC_ERR_NONE; 160 return 0;
161} 161}
162 162
163int mmc_send_csd(struct mmc_card *card, u32 *csd) 163int mmc_send_csd(struct mmc_card *card, u32 *csd)
@@ -176,12 +176,12 @@ int mmc_send_csd(struct mmc_card *card, u32 *csd)
176 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC; 176 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
177 177
178 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 178 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
179 if (err != MMC_ERR_NONE) 179 if (err)
180 return err; 180 return err;
181 181
182 memcpy(csd, cmd.resp, sizeof(u32) * 4); 182 memcpy(csd, cmd.resp, sizeof(u32) * 4);
183 183
184 return MMC_ERR_NONE; 184 return 0;
185} 185}
186 186
187int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd) 187int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
@@ -218,12 +218,12 @@ int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
218 218
219 mmc_wait_for_req(card->host, &mrq); 219 mmc_wait_for_req(card->host, &mrq);
220 220
221 if (cmd.error != MMC_ERR_NONE) 221 if (cmd.error)
222 return cmd.error; 222 return cmd.error;
223 if (data.error != MMC_ERR_NONE) 223 if (data.error)
224 return data.error; 224 return data.error;
225 225
226 return MMC_ERR_NONE; 226 return 0;
227} 227}
228 228
229int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value) 229int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
@@ -244,10 +244,10 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
244 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 244 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
245 245
246 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 246 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
247 if (err != MMC_ERR_NONE) 247 if (err)
248 return err; 248 return err;
249 249
250 return MMC_ERR_NONE; 250 return 0;
251} 251}
252 252
253int mmc_send_status(struct mmc_card *card, u32 *status) 253int mmc_send_status(struct mmc_card *card, u32 *status)
@@ -265,12 +265,12 @@ int mmc_send_status(struct mmc_card *card, u32 *status)
265 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 265 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
266 266
267 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 267 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
268 if (err != MMC_ERR_NONE) 268 if (err)
269 return err; 269 return err;
270 270
271 if (status) 271 if (status)
272 *status = cmd.resp[0]; 272 *status = cmd.resp[0];
273 273
274 return MMC_ERR_NONE; 274 return 0;
275} 275}
276 276
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 1edc62b1e5c6..00895c99d9bb 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -193,30 +193,30 @@ static int mmc_read_switch(struct mmc_card *card)
193 u8 *status; 193 u8 *status;
194 194
195 if (card->scr.sda_vsn < SCR_SPEC_VER_1) 195 if (card->scr.sda_vsn < SCR_SPEC_VER_1)
196 return MMC_ERR_NONE; 196 return 0;
197 197
198 if (!(card->csd.cmdclass & CCC_SWITCH)) { 198 if (!(card->csd.cmdclass & CCC_SWITCH)) {
199 printk(KERN_WARNING "%s: card lacks mandatory switch " 199 printk(KERN_WARNING "%s: card lacks mandatory switch "
200 "function, performance might suffer.\n", 200 "function, performance might suffer.\n",
201 mmc_hostname(card->host)); 201 mmc_hostname(card->host));
202 return MMC_ERR_NONE; 202 return 0;
203 } 203 }
204 204
205 err = MMC_ERR_FAILED; 205 err = -EIO;
206 206
207 status = kmalloc(64, GFP_KERNEL); 207 status = kmalloc(64, GFP_KERNEL);
208 if (!status) { 208 if (!status) {
209 printk(KERN_ERR "%s: could not allocate a buffer for " 209 printk(KERN_ERR "%s: could not allocate a buffer for "
210 "switch capabilities.\n", mmc_hostname(card->host)); 210 "switch capabilities.\n", mmc_hostname(card->host));
211 return err; 211 return -ENOMEM;
212 } 212 }
213 213
214 err = mmc_sd_switch(card, 0, 0, 1, status); 214 err = mmc_sd_switch(card, 0, 0, 1, status);
215 if (err != MMC_ERR_NONE) { 215 if (err) {
216 printk(KERN_WARNING "%s: problem reading switch " 216 printk(KERN_WARNING "%s: problem reading switch "
217 "capabilities, performance might suffer.\n", 217 "capabilities, performance might suffer.\n",
218 mmc_hostname(card->host)); 218 mmc_hostname(card->host));
219 err = MMC_ERR_NONE; 219 err = 0;
220 goto out; 220 goto out;
221 } 221 }
222 222
@@ -238,28 +238,28 @@ static int mmc_switch_hs(struct mmc_card *card)
238 u8 *status; 238 u8 *status;
239 239
240 if (card->scr.sda_vsn < SCR_SPEC_VER_1) 240 if (card->scr.sda_vsn < SCR_SPEC_VER_1)
241 return MMC_ERR_NONE; 241 return 0;
242 242
243 if (!(card->csd.cmdclass & CCC_SWITCH)) 243 if (!(card->csd.cmdclass & CCC_SWITCH))
244 return MMC_ERR_NONE; 244 return 0;
245 245
246 if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED)) 246 if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
247 return MMC_ERR_NONE; 247 return 0;
248 248
249 if (card->sw_caps.hs_max_dtr == 0) 249 if (card->sw_caps.hs_max_dtr == 0)
250 return MMC_ERR_NONE; 250 return 0;
251 251
252 err = MMC_ERR_FAILED; 252 err = -EIO;
253 253
254 status = kmalloc(64, GFP_KERNEL); 254 status = kmalloc(64, GFP_KERNEL);
255 if (!status) { 255 if (!status) {
256 printk(KERN_ERR "%s: could not allocate a buffer for " 256 printk(KERN_ERR "%s: could not allocate a buffer for "
257 "switch capabilities.\n", mmc_hostname(card->host)); 257 "switch capabilities.\n", mmc_hostname(card->host));
258 return err; 258 return -ENOMEM;
259 } 259 }
260 260
261 err = mmc_sd_switch(card, 1, 0, 1, status); 261 err = mmc_sd_switch(card, 1, 0, 1, status);
262 if (err != MMC_ERR_NONE) 262 if (err)
263 goto out; 263 goto out;
264 264
265 if ((status[16] & 0xF) != 1) { 265 if ((status[16] & 0xF) != 1) {
@@ -309,18 +309,18 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
309 * block-addressed SDHC cards. 309 * block-addressed SDHC cards.
310 */ 310 */
311 err = mmc_send_if_cond(host, ocr); 311 err = mmc_send_if_cond(host, ocr);
312 if (err == MMC_ERR_NONE) 312 if (!err)
313 ocr |= 1 << 30; 313 ocr |= 1 << 30;
314 314
315 err = mmc_send_app_op_cond(host, ocr, NULL); 315 err = mmc_send_app_op_cond(host, ocr, NULL);
316 if (err != MMC_ERR_NONE) 316 if (err)
317 goto err; 317 goto err;
318 318
319 /* 319 /*
320 * Fetch CID from card. 320 * Fetch CID from card.
321 */ 321 */
322 err = mmc_all_send_cid(host, cid); 322 err = mmc_all_send_cid(host, cid);
323 if (err != MMC_ERR_NONE) 323 if (err)
324 goto err; 324 goto err;
325 325
326 if (oldcard) { 326 if (oldcard) {
@@ -344,7 +344,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
344 * Set card RCA. 344 * Set card RCA.
345 */ 345 */
346 err = mmc_send_relative_addr(host, &card->rca); 346 err = mmc_send_relative_addr(host, &card->rca);
347 if (err != MMC_ERR_NONE) 347 if (err)
348 goto free_card; 348 goto free_card;
349 349
350 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 350 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
@@ -354,7 +354,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
354 * Fetch CSD from card. 354 * Fetch CSD from card.
355 */ 355 */
356 err = mmc_send_csd(card, card->raw_csd); 356 err = mmc_send_csd(card, card->raw_csd);
357 if (err != MMC_ERR_NONE) 357 if (err)
358 goto free_card; 358 goto free_card;
359 359
360 err = mmc_decode_csd(card); 360 err = mmc_decode_csd(card);
@@ -368,7 +368,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
368 * Select card, as all following commands rely on that. 368 * Select card, as all following commands rely on that.
369 */ 369 */
370 err = mmc_select_card(card); 370 err = mmc_select_card(card);
371 if (err != MMC_ERR_NONE) 371 if (err)
372 goto free_card; 372 goto free_card;
373 373
374 if (!oldcard) { 374 if (!oldcard) {
@@ -376,7 +376,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
376 * Fetch SCR from card. 376 * Fetch SCR from card.
377 */ 377 */
378 err = mmc_app_send_scr(card, card->raw_scr); 378 err = mmc_app_send_scr(card, card->raw_scr);
379 if (err != MMC_ERR_NONE) 379 if (err)
380 goto free_card; 380 goto free_card;
381 381
382 err = mmc_decode_scr(card); 382 err = mmc_decode_scr(card);
@@ -387,7 +387,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
387 * Fetch switch information from card. 387 * Fetch switch information from card.
388 */ 388 */
389 err = mmc_read_switch(card); 389 err = mmc_read_switch(card);
390 if (err != MMC_ERR_NONE) 390 if (err)
391 goto free_card; 391 goto free_card;
392 } 392 }
393 393
@@ -395,7 +395,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
395 * Attempt to change to high-speed (if supported) 395 * Attempt to change to high-speed (if supported)
396 */ 396 */
397 err = mmc_switch_hs(card); 397 err = mmc_switch_hs(card);
398 if (err != MMC_ERR_NONE) 398 if (err)
399 goto free_card; 399 goto free_card;
400 400
401 /* 401 /*
@@ -418,7 +418,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
418 if ((host->caps & MMC_CAP_4_BIT_DATA) && 418 if ((host->caps & MMC_CAP_4_BIT_DATA) &&
419 (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) { 419 (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
420 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); 420 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
421 if (err != MMC_ERR_NONE) 421 if (err)
422 goto free_card; 422 goto free_card;
423 423
424 mmc_set_bus_width(host, MMC_BUS_WIDTH_4); 424 mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
@@ -442,14 +442,14 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
442 if (!oldcard) 442 if (!oldcard)
443 host->card = card; 443 host->card = card;
444 444
445 return MMC_ERR_NONE; 445 return 0;
446 446
447free_card: 447free_card:
448 if (!oldcard) 448 if (!oldcard)
449 mmc_remove_card(card); 449 mmc_remove_card(card);
450err: 450err:
451 451
452 return MMC_ERR_FAILED; 452 return -EIO;
453} 453}
454 454
455/* 455/*
@@ -483,7 +483,7 @@ static void mmc_sd_detect(struct mmc_host *host)
483 483
484 mmc_release_host(host); 484 mmc_release_host(host);
485 485
486 if (err != MMC_ERR_NONE) { 486 if (err) {
487 mmc_sd_remove(host); 487 mmc_sd_remove(host);
488 488
489 mmc_claim_host(host); 489 mmc_claim_host(host);
@@ -574,7 +574,7 @@ static void mmc_sd_resume(struct mmc_host *host)
574 err = mmc_sd_init_card(host, host->ocr, host->card); 574 err = mmc_sd_init_card(host, host->ocr, host->card);
575 mmc_release_host(host); 575 mmc_release_host(host);
576 576
577 if (err != MMC_ERR_NONE) { 577 if (err) {
578 mmc_sd_remove(host); 578 mmc_sd_remove(host);
579 579
580 mmc_claim_host(host); 580 mmc_claim_host(host);
@@ -644,7 +644,7 @@ int mmc_attach_sd(struct mmc_host *host, u32 ocr)
644 * Detect and init the card. 644 * Detect and init the card.
645 */ 645 */
646 err = mmc_sd_init_card(host, host->ocr, NULL); 646 err = mmc_sd_init_card(host, host->ocr, NULL);
647 if (err != MMC_ERR_NONE) 647 if (err)
648 goto err; 648 goto err;
649 649
650 mmc_release_host(host); 650 mmc_release_host(host);
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 342f340ebc25..b4d43bd0fedd 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -40,14 +40,14 @@ static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card)
40 } 40 }
41 41
42 err = mmc_wait_for_cmd(host, &cmd, 0); 42 err = mmc_wait_for_cmd(host, &cmd, 0);
43 if (err != MMC_ERR_NONE) 43 if (err)
44 return err; 44 return err;
45 45
46 /* Check that card supported application commands */ 46 /* Check that card supported application commands */
47 if (!(cmd.resp[0] & R1_APP_CMD)) 47 if (!(cmd.resp[0] & R1_APP_CMD))
48 return MMC_ERR_FAILED; 48 return -EOPNOTSUPP;
49 49
50 return MMC_ERR_NONE; 50 return 0;
51} 51}
52 52
53/** 53/**
@@ -73,7 +73,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
73 BUG_ON(!cmd); 73 BUG_ON(!cmd);
74 BUG_ON(retries < 0); 74 BUG_ON(retries < 0);
75 75
76 err = MMC_ERR_INVALID; 76 err = -EIO;
77 77
78 /* 78 /*
79 * We have to resend MMC_APP_CMD for each attempt so 79 * We have to resend MMC_APP_CMD for each attempt so
@@ -83,7 +83,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
83 memset(&mrq, 0, sizeof(struct mmc_request)); 83 memset(&mrq, 0, sizeof(struct mmc_request));
84 84
85 err = mmc_app_cmd(host, card); 85 err = mmc_app_cmd(host, card);
86 if (err != MMC_ERR_NONE) 86 if (err)
87 continue; 87 continue;
88 88
89 memset(&mrq, 0, sizeof(struct mmc_request)); 89 memset(&mrq, 0, sizeof(struct mmc_request));
@@ -97,7 +97,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
97 mmc_wait_for_req(host, &mrq); 97 mmc_wait_for_req(host, &mrq);
98 98
99 err = cmd->error; 99 err = cmd->error;
100 if (cmd->error == MMC_ERR_NONE) 100 if (!cmd->error)
101 break; 101 break;
102 } 102 }
103 103
@@ -127,14 +127,14 @@ int mmc_app_set_bus_width(struct mmc_card *card, int width)
127 cmd.arg = SD_BUS_WIDTH_4; 127 cmd.arg = SD_BUS_WIDTH_4;
128 break; 128 break;
129 default: 129 default:
130 return MMC_ERR_INVALID; 130 return -EINVAL;
131 } 131 }
132 132
133 err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES); 133 err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
134 if (err != MMC_ERR_NONE) 134 if (err)
135 return err; 135 return err;
136 136
137 return MMC_ERR_NONE; 137 return 0;
138} 138}
139 139
140int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) 140int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
@@ -152,13 +152,13 @@ int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
152 152
153 for (i = 100; i; i--) { 153 for (i = 100; i; i--) {
154 err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES); 154 err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
155 if (err != MMC_ERR_NONE) 155 if (err)
156 break; 156 break;
157 157
158 if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0) 158 if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
159 break; 159 break;
160 160
161 err = MMC_ERR_TIMEOUT; 161 err = -ETIMEDOUT;
162 162
163 mmc_delay(10); 163 mmc_delay(10);
164 } 164 }
@@ -185,13 +185,13 @@ int mmc_send_if_cond(struct mmc_host *host, u32 ocr)
185 cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR; 185 cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR;
186 186
187 err = mmc_wait_for_cmd(host, &cmd, 0); 187 err = mmc_wait_for_cmd(host, &cmd, 0);
188 if (err != MMC_ERR_NONE) 188 if (err)
189 return err; 189 return err;
190 190
191 if ((cmd.resp[0] & 0xFF) != test_pattern) 191 if ((cmd.resp[0] & 0xFF) != test_pattern)
192 return MMC_ERR_FAILED; 192 return -EIO;
193 193
194 return MMC_ERR_NONE; 194 return 0;
195} 195}
196 196
197int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca) 197int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
@@ -209,12 +209,12 @@ int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
209 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR; 209 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
210 210
211 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 211 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
212 if (err != MMC_ERR_NONE) 212 if (err)
213 return err; 213 return err;
214 214
215 *rca = cmd.resp[0] >> 16; 215 *rca = cmd.resp[0] >> 16;
216 216
217 return MMC_ERR_NONE; 217 return 0;
218} 218}
219 219
220int mmc_app_send_scr(struct mmc_card *card, u32 *scr) 220int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
@@ -230,7 +230,7 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
230 BUG_ON(!scr); 230 BUG_ON(!scr);
231 231
232 err = mmc_app_cmd(card->host, card); 232 err = mmc_app_cmd(card->host, card);
233 if (err != MMC_ERR_NONE) 233 if (err)
234 return err; 234 return err;
235 235
236 memset(&mrq, 0, sizeof(struct mmc_request)); 236 memset(&mrq, 0, sizeof(struct mmc_request));
@@ -256,15 +256,15 @@ int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
256 256
257 mmc_wait_for_req(card->host, &mrq); 257 mmc_wait_for_req(card->host, &mrq);
258 258
259 if (cmd.error != MMC_ERR_NONE) 259 if (cmd.error)
260 return cmd.error; 260 return cmd.error;
261 if (data.error != MMC_ERR_NONE) 261 if (data.error)
262 return data.error; 262 return data.error;
263 263
264 scr[0] = ntohl(scr[0]); 264 scr[0] = ntohl(scr[0]);
265 scr[1] = ntohl(scr[1]); 265 scr[1] = ntohl(scr[1]);
266 266
267 return MMC_ERR_NONE; 267 return 0;
268} 268}
269 269
270int mmc_sd_switch(struct mmc_card *card, int mode, int group, 270int mmc_sd_switch(struct mmc_card *card, int mode, int group,
@@ -306,11 +306,11 @@ int mmc_sd_switch(struct mmc_card *card, int mode, int group,
306 306
307 mmc_wait_for_req(card->host, &mrq); 307 mmc_wait_for_req(card->host, &mrq);
308 308
309 if (cmd.error != MMC_ERR_NONE) 309 if (cmd.error)
310 return cmd.error; 310 return cmd.error;
311 if (data.error != MMC_ERR_NONE) 311 if (data.error)
312 return data.error; 312 return data.error;
313 313
314 return MMC_ERR_NONE; 314 return 0;
315} 315}
316 316
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 955ea60583b5..810a433ce532 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -577,24 +577,22 @@ static void at91_mci_completed_command(struct at91mci_host *host)
577 AT91_MCI_RENDE | AT91_MCI_RTOE | AT91_MCI_DCRCE | 577 AT91_MCI_RENDE | AT91_MCI_RTOE | AT91_MCI_DCRCE |
578 AT91_MCI_DTOE | AT91_MCI_OVRE | AT91_MCI_UNRE)) { 578 AT91_MCI_DTOE | AT91_MCI_OVRE | AT91_MCI_UNRE)) {
579 if ((status & AT91_MCI_RCRCE) && !(mmc_resp_type(cmd) & MMC_RSP_CRC)) { 579 if ((status & AT91_MCI_RCRCE) && !(mmc_resp_type(cmd) & MMC_RSP_CRC)) {
580 cmd->error = MMC_ERR_NONE; 580 cmd->error = 0;
581 } 581 }
582 else { 582 else {
583 if (status & (AT91_MCI_RTOE | AT91_MCI_DTOE)) 583 if (status & (AT91_MCI_RTOE | AT91_MCI_DTOE))
584 cmd->error = MMC_ERR_TIMEOUT; 584 cmd->error = -ETIMEDOUT;
585 else if (status & (AT91_MCI_RCRCE | AT91_MCI_DCRCE)) 585 else if (status & (AT91_MCI_RCRCE | AT91_MCI_DCRCE))
586 cmd->error = MMC_ERR_BADCRC; 586 cmd->error = -EILSEQ;
587 else if (status & (AT91_MCI_OVRE | AT91_MCI_UNRE))
588 cmd->error = MMC_ERR_FIFO;
589 else 587 else
590 cmd->error = MMC_ERR_FAILED; 588 cmd->error = -EIO;
591 589
592 pr_debug("Error detected and set to %d (cmd = %d, retries = %d)\n", 590 pr_debug("Error detected and set to %d (cmd = %d, retries = %d)\n",
593 cmd->error, cmd->opcode, cmd->retries); 591 cmd->error, cmd->opcode, cmd->retries);
594 } 592 }
595 } 593 }
596 else 594 else
597 cmd->error = MMC_ERR_NONE; 595 cmd->error = 0;
598 596
599 at91_mci_process_next(host); 597 at91_mci_process_next(host);
600} 598}
diff --git a/drivers/mmc/host/au1xmmc.c b/drivers/mmc/host/au1xmmc.c
index 34c99d4ea041..49b0367e57c8 100644
--- a/drivers/mmc/host/au1xmmc.c
+++ b/drivers/mmc/host/au1xmmc.c
@@ -208,7 +208,7 @@ static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
208 default: 208 default:
209 printk(KERN_INFO "au1xmmc: unhandled response type %02x\n", 209 printk(KERN_INFO "au1xmmc: unhandled response type %02x\n",
210 mmc_resp_type(cmd)); 210 mmc_resp_type(cmd));
211 return MMC_ERR_INVALID; 211 return -EINVAL;
212 } 212 }
213 213
214 if (flags & MMC_DATA_READ) { 214 if (flags & MMC_DATA_READ) {
@@ -253,7 +253,7 @@ static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
253 IRQ_ON(host, SD_CONFIG_CR); 253 IRQ_ON(host, SD_CONFIG_CR);
254 } 254 }
255 255
256 return MMC_ERR_NONE; 256 return 0;
257} 257}
258 258
259static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status) 259static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status)
@@ -278,7 +278,7 @@ static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status)
278 while((host->flags & HOST_F_XMIT) && (status & SD_STATUS_DB)) 278 while((host->flags & HOST_F_XMIT) && (status & SD_STATUS_DB))
279 status = au_readl(HOST_STATUS(host)); 279 status = au_readl(HOST_STATUS(host));
280 280
281 data->error = MMC_ERR_NONE; 281 data->error = 0;
282 dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, host->dma.dir); 282 dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len, host->dma.dir);
283 283
284 /* Process any errors */ 284 /* Process any errors */
@@ -288,14 +288,14 @@ static void au1xmmc_data_complete(struct au1xmmc_host *host, u32 status)
288 crc |= ((status & 0x07) == 0x02) ? 0 : 1; 288 crc |= ((status & 0x07) == 0x02) ? 0 : 1;
289 289
290 if (crc) 290 if (crc)
291 data->error = MMC_ERR_BADCRC; 291 data->error = -EILSEQ;
292 292
293 /* Clear the CRC bits */ 293 /* Clear the CRC bits */
294 au_writel(SD_STATUS_WC | SD_STATUS_RC, HOST_STATUS(host)); 294 au_writel(SD_STATUS_WC | SD_STATUS_RC, HOST_STATUS(host));
295 295
296 data->bytes_xfered = 0; 296 data->bytes_xfered = 0;
297 297
298 if (data->error == MMC_ERR_NONE) { 298 if (!data->error) {
299 if (host->flags & HOST_F_DMA) { 299 if (host->flags & HOST_F_DMA) {
300 u32 chan = DMA_CHANNEL(host); 300 u32 chan = DMA_CHANNEL(host);
301 301
@@ -475,7 +475,7 @@ static void au1xmmc_cmd_complete(struct au1xmmc_host *host, u32 status)
475 return; 475 return;
476 476
477 cmd = mrq->cmd; 477 cmd = mrq->cmd;
478 cmd->error = MMC_ERR_NONE; 478 cmd->error = 0;
479 479
480 if (cmd->flags & MMC_RSP_PRESENT) { 480 if (cmd->flags & MMC_RSP_PRESENT) {
481 if (cmd->flags & MMC_RSP_136) { 481 if (cmd->flags & MMC_RSP_136) {
@@ -512,11 +512,11 @@ static void au1xmmc_cmd_complete(struct au1xmmc_host *host, u32 status)
512 /* Figure out errors */ 512 /* Figure out errors */
513 513
514 if (status & (SD_STATUS_SC | SD_STATUS_WC | SD_STATUS_RC)) 514 if (status & (SD_STATUS_SC | SD_STATUS_WC | SD_STATUS_RC))
515 cmd->error = MMC_ERR_BADCRC; 515 cmd->error = -EILSEQ;
516 516
517 trans = host->flags & (HOST_F_XMIT | HOST_F_RECV); 517 trans = host->flags & (HOST_F_XMIT | HOST_F_RECV);
518 518
519 if (!trans || cmd->error != MMC_ERR_NONE) { 519 if (!trans || cmd->error) {
520 520
521 IRQ_OFF(host, SD_CONFIG_TH | SD_CONFIG_RA|SD_CONFIG_RF); 521 IRQ_OFF(host, SD_CONFIG_TH | SD_CONFIG_RA|SD_CONFIG_RF);
522 tasklet_schedule(&host->finish_task); 522 tasklet_schedule(&host->finish_task);
@@ -589,7 +589,7 @@ au1xmmc_prepare_data(struct au1xmmc_host *host, struct mmc_data *data)
589 data->sg_len, host->dma.dir); 589 data->sg_len, host->dma.dir);
590 590
591 if (host->dma.len == 0) 591 if (host->dma.len == 0)
592 return MMC_ERR_TIMEOUT; 592 return -ETIMEDOUT;
593 593
594 au_writel(data->blksz - 1, HOST_BLKSIZE(host)); 594 au_writel(data->blksz - 1, HOST_BLKSIZE(host));
595 595
@@ -640,11 +640,11 @@ au1xmmc_prepare_data(struct au1xmmc_host *host, struct mmc_data *data)
640 //IRQ_ON(host, SD_CONFIG_RA|SD_CONFIG_RF); 640 //IRQ_ON(host, SD_CONFIG_RA|SD_CONFIG_RF);
641 } 641 }
642 642
643 return MMC_ERR_NONE; 643 return 0;
644 644
645 dataerr: 645 dataerr:
646 dma_unmap_sg(mmc_dev(host->mmc),data->sg,data->sg_len,host->dma.dir); 646 dma_unmap_sg(mmc_dev(host->mmc),data->sg,data->sg_len,host->dma.dir);
647 return MMC_ERR_TIMEOUT; 647 return -ETIMEDOUT;
648} 648}
649 649
650/* static void au1xmmc_request 650/* static void au1xmmc_request
@@ -656,7 +656,7 @@ static void au1xmmc_request(struct mmc_host* mmc, struct mmc_request* mrq)
656 656
657 struct au1xmmc_host *host = mmc_priv(mmc); 657 struct au1xmmc_host *host = mmc_priv(mmc);
658 unsigned int flags = 0; 658 unsigned int flags = 0;
659 int ret = MMC_ERR_NONE; 659 int ret = 0;
660 660
661 WARN_ON(irqs_disabled()); 661 WARN_ON(irqs_disabled());
662 WARN_ON(host->status != HOST_S_IDLE); 662 WARN_ON(host->status != HOST_S_IDLE);
@@ -672,10 +672,10 @@ static void au1xmmc_request(struct mmc_host* mmc, struct mmc_request* mrq)
672 ret = au1xmmc_prepare_data(host, mrq->data); 672 ret = au1xmmc_prepare_data(host, mrq->data);
673 } 673 }
674 674
675 if (ret == MMC_ERR_NONE) 675 if (!ret)
676 ret = au1xmmc_send_command(host, 0, mrq->cmd, flags); 676 ret = au1xmmc_send_command(host, 0, mrq->cmd, flags);
677 677
678 if (ret != MMC_ERR_NONE) { 678 if (ret) {
679 mrq->cmd->error = ret; 679 mrq->cmd->error = ret;
680 au1xmmc_finish_request(host); 680 au1xmmc_finish_request(host);
681 } 681 }
@@ -764,10 +764,10 @@ static irqreturn_t au1xmmc_irq(int irq, void *dev_id)
764 764
765 if (host->mrq && (status & STATUS_TIMEOUT)) { 765 if (host->mrq && (status & STATUS_TIMEOUT)) {
766 if (status & SD_STATUS_RAT) 766 if (status & SD_STATUS_RAT)
767 host->mrq->cmd->error = MMC_ERR_TIMEOUT; 767 host->mrq->cmd->error = -ETIMEDOUT;
768 768
769 else if (status & SD_STATUS_DT) 769 else if (status & SD_STATUS_DT)
770 host->mrq->data->error = MMC_ERR_TIMEOUT; 770 host->mrq->data->error = -ETIMEDOUT;
771 771
772 /* In PIO mode, interrupts might still be enabled */ 772 /* In PIO mode, interrupts might still be enabled */
773 IRQ_OFF(host, SD_CONFIG_NE | SD_CONFIG_TH); 773 IRQ_OFF(host, SD_CONFIG_NE | SD_CONFIG_TH);
diff --git a/drivers/mmc/host/imxmmc.c b/drivers/mmc/host/imxmmc.c
index 54bfc9f25596..04458c342812 100644
--- a/drivers/mmc/host/imxmmc.c
+++ b/drivers/mmc/host/imxmmc.c
@@ -428,11 +428,11 @@ static int imxmci_finish_data(struct imxmci_host *host, unsigned int stat)
428 if ( stat & STATUS_ERR_MASK ) { 428 if ( stat & STATUS_ERR_MASK ) {
429 dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n",stat); 429 dev_dbg(mmc_dev(host->mmc), "request failed. status: 0x%08x\n",stat);
430 if(stat & (STATUS_CRC_READ_ERR | STATUS_CRC_WRITE_ERR)) 430 if(stat & (STATUS_CRC_READ_ERR | STATUS_CRC_WRITE_ERR))
431 data->error = MMC_ERR_BADCRC; 431 data->error = -EILSEQ;
432 else if(stat & STATUS_TIME_OUT_READ) 432 else if(stat & STATUS_TIME_OUT_READ)
433 data->error = MMC_ERR_TIMEOUT; 433 data->error = -ETIMEDOUT;
434 else 434 else
435 data->error = MMC_ERR_FAILED; 435 data->error = -EIO;
436 } else { 436 } else {
437 data->bytes_xfered = host->dma_size; 437 data->bytes_xfered = host->dma_size;
438 } 438 }
@@ -458,10 +458,10 @@ static int imxmci_cmd_done(struct imxmci_host *host, unsigned int stat)
458 458
459 if (stat & STATUS_TIME_OUT_RESP) { 459 if (stat & STATUS_TIME_OUT_RESP) {
460 dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n"); 460 dev_dbg(mmc_dev(host->mmc), "CMD TIMEOUT\n");
461 cmd->error = MMC_ERR_TIMEOUT; 461 cmd->error = -ETIMEDOUT;
462 } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) { 462 } else if (stat & STATUS_RESP_CRC_ERR && cmd->flags & MMC_RSP_CRC) {
463 dev_dbg(mmc_dev(host->mmc), "cmd crc error\n"); 463 dev_dbg(mmc_dev(host->mmc), "cmd crc error\n");
464 cmd->error = MMC_ERR_BADCRC; 464 cmd->error = -EILSEQ;
465 } 465 }
466 466
467 if(cmd->flags & MMC_RSP_PRESENT) { 467 if(cmd->flags & MMC_RSP_PRESENT) {
@@ -482,7 +482,7 @@ static int imxmci_cmd_done(struct imxmci_host *host, unsigned int stat)
482 dev_dbg(mmc_dev(host->mmc), "RESP 0x%08x, 0x%08x, 0x%08x, 0x%08x, error %d\n", 482 dev_dbg(mmc_dev(host->mmc), "RESP 0x%08x, 0x%08x, 0x%08x, 0x%08x, error %d\n",
483 cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3], cmd->error); 483 cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3], cmd->error);
484 484
485 if (data && (cmd->error == MMC_ERR_NONE) && !(stat & STATUS_ERR_MASK)) { 485 if (data && !cmd->error && !(stat & STATUS_ERR_MASK)) {
486 if (host->req->data->flags & MMC_DATA_WRITE) { 486 if (host->req->data->flags & MMC_DATA_WRITE) {
487 487
488 /* Wait for FIFO to be empty before starting DMA write */ 488 /* Wait for FIFO to be empty before starting DMA write */
@@ -491,7 +491,7 @@ static int imxmci_cmd_done(struct imxmci_host *host, unsigned int stat)
491 if(imxmci_busy_wait_for_status(host, &stat, 491 if(imxmci_busy_wait_for_status(host, &stat,
492 STATUS_APPL_BUFF_FE, 492 STATUS_APPL_BUFF_FE,
493 40, "imxmci_cmd_done DMA WR") < 0) { 493 40, "imxmci_cmd_done DMA WR") < 0) {
494 cmd->error = MMC_ERR_FIFO; 494 cmd->error = -EIO;
495 imxmci_finish_data(host, stat); 495 imxmci_finish_data(host, stat);
496 if(host->req) 496 if(host->req)
497 imxmci_finish_request(host, host->req); 497 imxmci_finish_request(host, host->req);
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index be730c0a0352..d53e9a8bdaa2 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -154,11 +154,11 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
154 } 154 }
155 if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) { 155 if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
156 if (status & MCI_DATACRCFAIL) 156 if (status & MCI_DATACRCFAIL)
157 data->error = MMC_ERR_BADCRC; 157 data->error = -EILSEQ;
158 else if (status & MCI_DATATIMEOUT) 158 else if (status & MCI_DATATIMEOUT)
159 data->error = MMC_ERR_TIMEOUT; 159 data->error = -ETIMEDOUT;
160 else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN)) 160 else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN))
161 data->error = MMC_ERR_FIFO; 161 data->error = -EIO;
162 status |= MCI_DATAEND; 162 status |= MCI_DATAEND;
163 163
164 /* 164 /*
@@ -193,12 +193,12 @@ mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd,
193 cmd->resp[3] = readl(base + MMCIRESPONSE3); 193 cmd->resp[3] = readl(base + MMCIRESPONSE3);
194 194
195 if (status & MCI_CMDTIMEOUT) { 195 if (status & MCI_CMDTIMEOUT) {
196 cmd->error = MMC_ERR_TIMEOUT; 196 cmd->error = -ETIMEDOUT;
197 } else if (status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) { 197 } else if (status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) {
198 cmd->error = MMC_ERR_BADCRC; 198 cmd->error = -EILSEQ;
199 } 199 }
200 200
201 if (!cmd->data || cmd->error != MMC_ERR_NONE) { 201 if (!cmd->data || cmd->error) {
202 if (host->data) 202 if (host->data)
203 mmci_stop_data(host); 203 mmci_stop_data(host);
204 mmci_request_end(host, cmd->mrq); 204 mmci_request_end(host, cmd->mrq);
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index 0cf97edc5f58..60a67dfcda6a 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -263,7 +263,7 @@ mmc_omap_xfer_done(struct mmc_omap_host *host, struct mmc_data *data)
263 enum dma_data_direction dma_data_dir; 263 enum dma_data_direction dma_data_dir;
264 264
265 BUG_ON(host->dma_ch < 0); 265 BUG_ON(host->dma_ch < 0);
266 if (data->error != MMC_ERR_NONE) 266 if (data->error)
267 omap_stop_dma(host->dma_ch); 267 omap_stop_dma(host->dma_ch);
268 /* Release DMA channel lazily */ 268 /* Release DMA channel lazily */
269 mod_timer(&host->dma_timer, jiffies + HZ); 269 mod_timer(&host->dma_timer, jiffies + HZ);
@@ -368,7 +368,7 @@ mmc_omap_cmd_done(struct mmc_omap_host *host, struct mmc_command *cmd)
368 } 368 }
369 } 369 }
370 370
371 if (host->data == NULL || cmd->error != MMC_ERR_NONE) { 371 if (host->data == NULL || cmd->error) {
372 host->mrq = NULL; 372 host->mrq = NULL;
373 clk_disable(host->fclk); 373 clk_disable(host->fclk);
374 mmc_request_done(host->mmc, cmd->mrq); 374 mmc_request_done(host->mmc, cmd->mrq);
@@ -475,14 +475,14 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
475 if (status & OMAP_MMC_STAT_DATA_TOUT) { 475 if (status & OMAP_MMC_STAT_DATA_TOUT) {
476 dev_dbg(mmc_dev(host->mmc), "data timeout\n"); 476 dev_dbg(mmc_dev(host->mmc), "data timeout\n");
477 if (host->data) { 477 if (host->data) {
478 host->data->error |= MMC_ERR_TIMEOUT; 478 host->data->error = -ETIMEDOUT;
479 transfer_error = 1; 479 transfer_error = 1;
480 } 480 }
481 } 481 }
482 482
483 if (status & OMAP_MMC_STAT_DATA_CRC) { 483 if (status & OMAP_MMC_STAT_DATA_CRC) {
484 if (host->data) { 484 if (host->data) {
485 host->data->error |= MMC_ERR_BADCRC; 485 host->data->error = -EILSEQ;
486 dev_dbg(mmc_dev(host->mmc), 486 dev_dbg(mmc_dev(host->mmc),
487 "data CRC error, bytes left %d\n", 487 "data CRC error, bytes left %d\n",
488 host->total_bytes_left); 488 host->total_bytes_left);
@@ -504,7 +504,7 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
504 dev_err(mmc_dev(host->mmc), 504 dev_err(mmc_dev(host->mmc),
505 "command timeout, CMD %d\n", 505 "command timeout, CMD %d\n",
506 host->cmd->opcode); 506 host->cmd->opcode);
507 host->cmd->error = MMC_ERR_TIMEOUT; 507 host->cmd->error = -ETIMEDOUT;
508 end_command = 1; 508 end_command = 1;
509 } 509 }
510 } 510 }
@@ -514,7 +514,7 @@ static irqreturn_t mmc_omap_irq(int irq, void *dev_id)
514 dev_err(mmc_dev(host->mmc), 514 dev_err(mmc_dev(host->mmc),
515 "command CRC error (CMD%d, arg 0x%08x)\n", 515 "command CRC error (CMD%d, arg 0x%08x)\n",
516 host->cmd->opcode, host->cmd->arg); 516 host->cmd->opcode, host->cmd->arg);
517 host->cmd->error = MMC_ERR_BADCRC; 517 host->cmd->error = -EILSEQ;
518 end_command = 1; 518 end_command = 1;
519 } else 519 } else
520 dev_err(mmc_dev(host->mmc), 520 dev_err(mmc_dev(host->mmc),
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index ff960334b337..b89e32d1e9b5 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -226,7 +226,7 @@ static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat)
226 } 226 }
227 227
228 if (stat & STAT_TIME_OUT_RESPONSE) { 228 if (stat & STAT_TIME_OUT_RESPONSE) {
229 cmd->error = MMC_ERR_TIMEOUT; 229 cmd->error = -ETIMEDOUT;
230 } else if (stat & STAT_RES_CRC_ERR && cmd->flags & MMC_RSP_CRC) { 230 } else if (stat & STAT_RES_CRC_ERR && cmd->flags & MMC_RSP_CRC) {
231#ifdef CONFIG_PXA27x 231#ifdef CONFIG_PXA27x
232 /* 232 /*
@@ -239,11 +239,11 @@ static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat)
239 pr_debug("ignoring CRC from command %d - *risky*\n", cmd->opcode); 239 pr_debug("ignoring CRC from command %d - *risky*\n", cmd->opcode);
240 } else 240 } else
241#endif 241#endif
242 cmd->error = MMC_ERR_BADCRC; 242 cmd->error = -EILSEQ;
243 } 243 }
244 244
245 pxamci_disable_irq(host, END_CMD_RES); 245 pxamci_disable_irq(host, END_CMD_RES);
246 if (host->data && cmd->error == MMC_ERR_NONE) { 246 if (host->data && !cmd->error) {
247 pxamci_enable_irq(host, DATA_TRAN_DONE); 247 pxamci_enable_irq(host, DATA_TRAN_DONE);
248 } else { 248 } else {
249 pxamci_finish_request(host, host->mrq); 249 pxamci_finish_request(host, host->mrq);
@@ -264,9 +264,9 @@ static int pxamci_data_done(struct pxamci_host *host, unsigned int stat)
264 host->dma_dir); 264 host->dma_dir);
265 265
266 if (stat & STAT_READ_TIME_OUT) 266 if (stat & STAT_READ_TIME_OUT)
267 data->error = MMC_ERR_TIMEOUT; 267 data->error = -ETIMEDOUT;
268 else if (stat & (STAT_CRC_READ_ERROR|STAT_CRC_WRITE_ERROR)) 268 else if (stat & (STAT_CRC_READ_ERROR|STAT_CRC_WRITE_ERROR))
269 data->error = MMC_ERR_BADCRC; 269 data->error = -EILSEQ;
270 270
271 /* 271 /*
272 * There appears to be a hardware design bug here. There seems to 272 * There appears to be a hardware design bug here. There seems to
@@ -274,7 +274,7 @@ static int pxamci_data_done(struct pxamci_host *host, unsigned int stat)
274 * This means that if there was an error on any block, we mark all 274 * This means that if there was an error on any block, we mark all
275 * data blocks as being in error. 275 * data blocks as being in error.
276 */ 276 */
277 if (data->error == MMC_ERR_NONE) 277 if (!data->error)
278 data->bytes_xfered = data->blocks * data->blksz; 278 data->bytes_xfered = data->blocks * data->blksz;
279 else 279 else
280 data->bytes_xfered = 0; 280 data->bytes_xfered = 0;
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 20a7d89e01ba..479d6a265dd1 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -481,16 +481,16 @@ static void sdhci_finish_data(struct sdhci_host *host)
481 * Controller doesn't count down when in single block mode. 481 * Controller doesn't count down when in single block mode.
482 */ 482 */
483 if (data->blocks == 1) 483 if (data->blocks == 1)
484 blocks = (data->error == MMC_ERR_NONE) ? 0 : 1; 484 blocks = (data->error == 0) ? 0 : 1;
485 else 485 else
486 blocks = readw(host->ioaddr + SDHCI_BLOCK_COUNT); 486 blocks = readw(host->ioaddr + SDHCI_BLOCK_COUNT);
487 data->bytes_xfered = data->blksz * (data->blocks - blocks); 487 data->bytes_xfered = data->blksz * (data->blocks - blocks);
488 488
489 if ((data->error == MMC_ERR_NONE) && blocks) { 489 if (!data->error && blocks) {
490 printk(KERN_ERR "%s: Controller signalled completion even " 490 printk(KERN_ERR "%s: Controller signalled completion even "
491 "though there were blocks left.\n", 491 "though there were blocks left.\n",
492 mmc_hostname(host->mmc)); 492 mmc_hostname(host->mmc));
493 data->error = MMC_ERR_FAILED; 493 data->error = -EIO;
494 } 494 }
495 495
496 if (data->stop) { 496 if (data->stop) {
@@ -498,7 +498,7 @@ static void sdhci_finish_data(struct sdhci_host *host)
498 * The controller needs a reset of internal state machines 498 * The controller needs a reset of internal state machines
499 * upon error conditions. 499 * upon error conditions.
500 */ 500 */
501 if (data->error != MMC_ERR_NONE) { 501 if (data->error) {
502 sdhci_reset(host, SDHCI_RESET_CMD); 502 sdhci_reset(host, SDHCI_RESET_CMD);
503 sdhci_reset(host, SDHCI_RESET_DATA); 503 sdhci_reset(host, SDHCI_RESET_DATA);
504 } 504 }
@@ -533,7 +533,7 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
533 printk(KERN_ERR "%s: Controller never released " 533 printk(KERN_ERR "%s: Controller never released "
534 "inhibit bit(s).\n", mmc_hostname(host->mmc)); 534 "inhibit bit(s).\n", mmc_hostname(host->mmc));
535 sdhci_dumpregs(host); 535 sdhci_dumpregs(host);
536 cmd->error = MMC_ERR_FAILED; 536 cmd->error = -EIO;
537 tasklet_schedule(&host->finish_tasklet); 537 tasklet_schedule(&host->finish_tasklet);
538 return; 538 return;
539 } 539 }
@@ -554,7 +554,7 @@ static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
554 if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) { 554 if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
555 printk(KERN_ERR "%s: Unsupported response type!\n", 555 printk(KERN_ERR "%s: Unsupported response type!\n",
556 mmc_hostname(host->mmc)); 556 mmc_hostname(host->mmc));
557 cmd->error = MMC_ERR_INVALID; 557 cmd->error = -EINVAL;
558 tasklet_schedule(&host->finish_tasklet); 558 tasklet_schedule(&host->finish_tasklet);
559 return; 559 return;
560 } 560 }
@@ -601,7 +601,7 @@ static void sdhci_finish_command(struct sdhci_host *host)
601 } 601 }
602 } 602 }
603 603
604 host->cmd->error = MMC_ERR_NONE; 604 host->cmd->error = 0;
605 605
606 if (host->data && host->data_early) 606 if (host->data && host->data_early)
607 sdhci_finish_data(host); 607 sdhci_finish_data(host);
@@ -722,7 +722,7 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
722 host->mrq = mrq; 722 host->mrq = mrq;
723 723
724 if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) { 724 if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
725 host->mrq->cmd->error = MMC_ERR_TIMEOUT; 725 host->mrq->cmd->error = -ENOMEDIUM;
726 tasklet_schedule(&host->finish_tasklet); 726 tasklet_schedule(&host->finish_tasklet);
727 } else 727 } else
728 sdhci_send_command(host, mrq->cmd); 728 sdhci_send_command(host, mrq->cmd);
@@ -831,7 +831,7 @@ static void sdhci_tasklet_card(unsigned long param)
831 sdhci_reset(host, SDHCI_RESET_CMD); 831 sdhci_reset(host, SDHCI_RESET_CMD);
832 sdhci_reset(host, SDHCI_RESET_DATA); 832 sdhci_reset(host, SDHCI_RESET_DATA);
833 833
834 host->mrq->cmd->error = MMC_ERR_FAILED; 834 host->mrq->cmd->error = -ENOMEDIUM;
835 tasklet_schedule(&host->finish_tasklet); 835 tasklet_schedule(&host->finish_tasklet);
836 } 836 }
837 } 837 }
@@ -859,9 +859,9 @@ static void sdhci_tasklet_finish(unsigned long param)
859 * The controller needs a reset of internal state machines 859 * The controller needs a reset of internal state machines
860 * upon error conditions. 860 * upon error conditions.
861 */ 861 */
862 if ((mrq->cmd->error != MMC_ERR_NONE) || 862 if (mrq->cmd->error ||
863 (mrq->data && ((mrq->data->error != MMC_ERR_NONE) || 863 (mrq->data && (mrq->data->error ||
864 (mrq->data->stop && (mrq->data->stop->error != MMC_ERR_NONE))))) { 864 (mrq->data->stop && mrq->data->stop->error)))) {
865 865
866 /* Some controllers need this kick or reset won't work here */ 866 /* Some controllers need this kick or reset won't work here */
867 if (host->chip->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) { 867 if (host->chip->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) {
@@ -906,13 +906,13 @@ static void sdhci_timeout_timer(unsigned long data)
906 sdhci_dumpregs(host); 906 sdhci_dumpregs(host);
907 907
908 if (host->data) { 908 if (host->data) {
909 host->data->error = MMC_ERR_TIMEOUT; 909 host->data->error = -ETIMEDOUT;
910 sdhci_finish_data(host); 910 sdhci_finish_data(host);
911 } else { 911 } else {
912 if (host->cmd) 912 if (host->cmd)
913 host->cmd->error = MMC_ERR_TIMEOUT; 913 host->cmd->error = -ETIMEDOUT;
914 else 914 else
915 host->mrq->cmd->error = MMC_ERR_TIMEOUT; 915 host->mrq->cmd->error = -ETIMEDOUT;
916 916
917 tasklet_schedule(&host->finish_tasklet); 917 tasklet_schedule(&host->finish_tasklet);
918 } 918 }
@@ -941,13 +941,12 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
941 } 941 }
942 942
943 if (intmask & SDHCI_INT_TIMEOUT) 943 if (intmask & SDHCI_INT_TIMEOUT)
944 host->cmd->error = MMC_ERR_TIMEOUT; 944 host->cmd->error = -ETIMEDOUT;
945 else if (intmask & SDHCI_INT_CRC) 945 else if (intmask & (SDHCI_INT_CRC | SDHCI_INT_END_BIT |
946 host->cmd->error = MMC_ERR_BADCRC; 946 SDHCI_INT_INDEX))
947 else if (intmask & (SDHCI_INT_END_BIT | SDHCI_INT_INDEX)) 947 host->cmd->error = -EILSEQ;
948 host->cmd->error = MMC_ERR_FAILED;
949 948
950 if (host->cmd->error != MMC_ERR_NONE) 949 if (host->cmd->error)
951 tasklet_schedule(&host->finish_tasklet); 950 tasklet_schedule(&host->finish_tasklet);
952 else if (intmask & SDHCI_INT_RESPONSE) 951 else if (intmask & SDHCI_INT_RESPONSE)
953 sdhci_finish_command(host); 952 sdhci_finish_command(host);
@@ -974,13 +973,11 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
974 } 973 }
975 974
976 if (intmask & SDHCI_INT_DATA_TIMEOUT) 975 if (intmask & SDHCI_INT_DATA_TIMEOUT)
977 host->data->error = MMC_ERR_TIMEOUT; 976 host->data->error = -ETIMEDOUT;
978 else if (intmask & SDHCI_INT_DATA_CRC) 977 else if (intmask & (SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_END_BIT))
979 host->data->error = MMC_ERR_BADCRC; 978 host->data->error = -EILSEQ;
980 else if (intmask & SDHCI_INT_DATA_END_BIT)
981 host->data->error = MMC_ERR_FAILED;
982 979
983 if (host->data->error != MMC_ERR_NONE) 980 if (host->data->error)
984 sdhci_finish_data(host); 981 sdhci_finish_data(host);
985 else { 982 else {
986 if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL)) 983 if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
diff --git a/drivers/mmc/host/tifm_sd.c b/drivers/mmc/host/tifm_sd.c
index 8b736e968447..b4a56e5e5132 100644
--- a/drivers/mmc/host/tifm_sd.c
+++ b/drivers/mmc/host/tifm_sd.c
@@ -404,14 +404,14 @@ static void tifm_sd_check_status(struct tifm_sd *host)
404 struct tifm_dev *sock = host->dev; 404 struct tifm_dev *sock = host->dev;
405 struct mmc_command *cmd = host->req->cmd; 405 struct mmc_command *cmd = host->req->cmd;
406 406
407 if (cmd->error != MMC_ERR_NONE) 407 if (cmd->error)
408 goto finish_request; 408 goto finish_request;
409 409
410 if (!(host->cmd_flags & CMD_READY)) 410 if (!(host->cmd_flags & CMD_READY))
411 return; 411 return;
412 412
413 if (cmd->data) { 413 if (cmd->data) {
414 if (cmd->data->error != MMC_ERR_NONE) { 414 if (cmd->data->error) {
415 if ((host->cmd_flags & SCMD_ACTIVE) 415 if ((host->cmd_flags & SCMD_ACTIVE)
416 && !(host->cmd_flags & SCMD_READY)) 416 && !(host->cmd_flags & SCMD_READY))
417 return; 417 return;
@@ -504,7 +504,7 @@ static void tifm_sd_card_event(struct tifm_dev *sock)
504{ 504{
505 struct tifm_sd *host; 505 struct tifm_sd *host;
506 unsigned int host_status = 0; 506 unsigned int host_status = 0;
507 int cmd_error = MMC_ERR_NONE; 507 int cmd_error = 0;
508 struct mmc_command *cmd = NULL; 508 struct mmc_command *cmd = NULL;
509 unsigned long flags; 509 unsigned long flags;
510 510
@@ -521,15 +521,15 @@ static void tifm_sd_card_event(struct tifm_dev *sock)
521 writel(host_status & TIFM_MMCSD_ERRMASK, 521 writel(host_status & TIFM_MMCSD_ERRMASK,
522 sock->addr + SOCK_MMCSD_STATUS); 522 sock->addr + SOCK_MMCSD_STATUS);
523 if (host_status & TIFM_MMCSD_CTO) 523 if (host_status & TIFM_MMCSD_CTO)
524 cmd_error = MMC_ERR_TIMEOUT; 524 cmd_error = -ETIMEDOUT;
525 else if (host_status & TIFM_MMCSD_CCRC) 525 else if (host_status & TIFM_MMCSD_CCRC)
526 cmd_error = MMC_ERR_BADCRC; 526 cmd_error = -EILSEQ;
527 527
528 if (cmd->data) { 528 if (cmd->data) {
529 if (host_status & TIFM_MMCSD_DTO) 529 if (host_status & TIFM_MMCSD_DTO)
530 cmd->data->error = MMC_ERR_TIMEOUT; 530 cmd->data->error = -ETIMEDOUT;
531 else if (host_status & TIFM_MMCSD_DCRC) 531 else if (host_status & TIFM_MMCSD_DCRC)
532 cmd->data->error = MMC_ERR_BADCRC; 532 cmd->data->error = -EILSEQ;
533 } 533 }
534 534
535 writel(TIFM_FIFO_INT_SETALL, 535 writel(TIFM_FIFO_INT_SETALL,
@@ -722,7 +722,7 @@ static void tifm_sd_request(struct mmc_host *mmc, struct mmc_request *mrq)
722 return; 722 return;
723 723
724err_out: 724err_out:
725 mrq->cmd->error = MMC_ERR_TIMEOUT; 725 mrq->cmd->error = -ETIMEDOUT;
726 mmc_request_done(mmc, mrq); 726 mmc_request_done(mmc, mrq);
727} 727}
728 728
@@ -1012,9 +1012,9 @@ static void tifm_sd_remove(struct tifm_dev *sock)
1012 writel(TIFM_FIFO_INT_SETALL, 1012 writel(TIFM_FIFO_INT_SETALL,
1013 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR); 1013 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
1014 writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET); 1014 writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
1015 host->req->cmd->error = MMC_ERR_TIMEOUT; 1015 host->req->cmd->error = -ENOMEDIUM;
1016 if (host->req->stop) 1016 if (host->req->stop)
1017 host->req->stop->error = MMC_ERR_TIMEOUT; 1017 host->req->stop->error = -ENOMEDIUM;
1018 tasklet_schedule(&host->finish_tasklet); 1018 tasklet_schedule(&host->finish_tasklet);
1019 } 1019 }
1020 spin_unlock_irqrestore(&sock->lock, flags); 1020 spin_unlock_irqrestore(&sock->lock, flags);
diff --git a/drivers/mmc/host/wbsd.c b/drivers/mmc/host/wbsd.c
index 9bf2a877113b..44968c2279e1 100644
--- a/drivers/mmc/host/wbsd.c
+++ b/drivers/mmc/host/wbsd.c
@@ -317,7 +317,7 @@ static inline void wbsd_get_short_reply(struct wbsd_host *host,
317 * Correct response type? 317 * Correct response type?
318 */ 318 */
319 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) { 319 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) {
320 cmd->error = MMC_ERR_INVALID; 320 cmd->error = -EILSEQ;
321 return; 321 return;
322 } 322 }
323 323
@@ -337,7 +337,7 @@ static inline void wbsd_get_long_reply(struct wbsd_host *host,
337 * Correct response type? 337 * Correct response type?
338 */ 338 */
339 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) { 339 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) {
340 cmd->error = MMC_ERR_INVALID; 340 cmd->error = -EILSEQ;
341 return; 341 return;
342 } 342 }
343 343
@@ -372,7 +372,7 @@ static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
372 for (i = 3; i >= 0; i--) 372 for (i = 3; i >= 0; i--)
373 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR); 373 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR);
374 374
375 cmd->error = MMC_ERR_NONE; 375 cmd->error = 0;
376 376
377 /* 377 /*
378 * Wait for the request to complete. 378 * Wait for the request to complete.
@@ -392,13 +392,13 @@ static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
392 392
393 /* Card removed? */ 393 /* Card removed? */
394 if (isr & WBSD_INT_CARD) 394 if (isr & WBSD_INT_CARD)
395 cmd->error = MMC_ERR_TIMEOUT; 395 cmd->error = -ENOMEDIUM;
396 /* Timeout? */ 396 /* Timeout? */
397 else if (isr & WBSD_INT_TIMEOUT) 397 else if (isr & WBSD_INT_TIMEOUT)
398 cmd->error = MMC_ERR_TIMEOUT; 398 cmd->error = -ETIMEDOUT;
399 /* CRC? */ 399 /* CRC? */
400 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC)) 400 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
401 cmd->error = MMC_ERR_BADCRC; 401 cmd->error = -EILSEQ;
402 /* All ok */ 402 /* All ok */
403 else { 403 else {
404 if (cmd->flags & MMC_RSP_136) 404 if (cmd->flags & MMC_RSP_136)
@@ -585,7 +585,7 @@ static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
585 ((blksize >> 4) & 0xF0) | WBSD_DATA_WIDTH); 585 ((blksize >> 4) & 0xF0) | WBSD_DATA_WIDTH);
586 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF); 586 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
587 } else { 587 } else {
588 data->error = MMC_ERR_INVALID; 588 data->error = -EINVAL;
589 return; 589 return;
590 } 590 }
591 591
@@ -607,7 +607,7 @@ static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
607 */ 607 */
608 BUG_ON(size > 0x10000); 608 BUG_ON(size > 0x10000);
609 if (size > 0x10000) { 609 if (size > 0x10000) {
610 data->error = MMC_ERR_INVALID; 610 data->error = -EINVAL;
611 return; 611 return;
612 } 612 }
613 613
@@ -669,7 +669,7 @@ static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
669 } 669 }
670 } 670 }
671 671
672 data->error = MMC_ERR_NONE; 672 data->error = 0;
673} 673}
674 674
675static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data) 675static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
@@ -724,8 +724,8 @@ static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
724 "%d bytes left.\n", 724 "%d bytes left.\n",
725 mmc_hostname(host->mmc), count); 725 mmc_hostname(host->mmc), count);
726 726
727 if (data->error == MMC_ERR_NONE) 727 if (!data->error)
728 data->error = MMC_ERR_FAILED; 728 data->error = -EIO;
729 } else { 729 } else {
730 /* 730 /*
731 * Transfer data from DMA buffer to 731 * Transfer data from DMA buffer to
@@ -735,7 +735,7 @@ static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
735 wbsd_dma_to_sg(host, data); 735 wbsd_dma_to_sg(host, data);
736 } 736 }
737 737
738 if (data->error != MMC_ERR_NONE) { 738 if (data->error) {
739 if (data->bytes_xfered) 739 if (data->bytes_xfered)
740 data->bytes_xfered -= data->blksz; 740 data->bytes_xfered -= data->blksz;
741 } 741 }
@@ -767,11 +767,10 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
767 host->mrq = mrq; 767 host->mrq = mrq;
768 768
769 /* 769 /*
770 * If there is no card in the slot then 770 * Check that there is actually a card in the slot.
771 * timeout immediatly.
772 */ 771 */
773 if (!(host->flags & WBSD_FCARD_PRESENT)) { 772 if (!(host->flags & WBSD_FCARD_PRESENT)) {
774 cmd->error = MMC_ERR_TIMEOUT; 773 cmd->error = -ENOMEDIUM;
775 goto done; 774 goto done;
776 } 775 }
777 776
@@ -807,7 +806,7 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
807 "supported by this controller.\n", 806 "supported by this controller.\n",
808 mmc_hostname(host->mmc), cmd->opcode); 807 mmc_hostname(host->mmc), cmd->opcode);
809#endif 808#endif
810 cmd->error = MMC_ERR_INVALID; 809 cmd->error = -EINVAL;
811 810
812 goto done; 811 goto done;
813 }; 812 };
@@ -819,7 +818,7 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
819 if (cmd->data) { 818 if (cmd->data) {
820 wbsd_prepare_data(host, cmd->data); 819 wbsd_prepare_data(host, cmd->data);
821 820
822 if (cmd->data->error != MMC_ERR_NONE) 821 if (cmd->data->error)
823 goto done; 822 goto done;
824 } 823 }
825 824
@@ -830,7 +829,7 @@ static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
830 * will be finished after the data has 829 * will be finished after the data has
831 * transfered. 830 * transfered.
832 */ 831 */
833 if (cmd->data && (cmd->error == MMC_ERR_NONE)) { 832 if (cmd->data && !cmd->error) {
834 /* 833 /*
835 * Dirty fix for hardware bug. 834 * Dirty fix for hardware bug.
836 */ 835 */
@@ -1033,7 +1032,7 @@ static void wbsd_tasklet_card(unsigned long param)
1033 mmc_hostname(host->mmc)); 1032 mmc_hostname(host->mmc));
1034 wbsd_reset(host); 1033 wbsd_reset(host);
1035 1034
1036 host->mrq->cmd->error = MMC_ERR_FAILED; 1035 host->mrq->cmd->error = -ENOMEDIUM;
1037 tasklet_schedule(&host->finish_tasklet); 1036 tasklet_schedule(&host->finish_tasklet);
1038 } 1037 }
1039 1038
@@ -1097,7 +1096,7 @@ static void wbsd_tasklet_crc(unsigned long param)
1097 1096
1098 DBGF("CRC error\n"); 1097 DBGF("CRC error\n");
1099 1098
1100 data->error = MMC_ERR_BADCRC; 1099 data->error = -EILSEQ;
1101 1100
1102 tasklet_schedule(&host->finish_tasklet); 1101 tasklet_schedule(&host->finish_tasklet);
1103 1102
@@ -1121,7 +1120,7 @@ static void wbsd_tasklet_timeout(unsigned long param)
1121 1120
1122 DBGF("Timeout\n"); 1121 DBGF("Timeout\n");
1123 1122
1124 data->error = MMC_ERR_TIMEOUT; 1123 data->error = -ETIMEDOUT;
1125 1124
1126 tasklet_schedule(&host->finish_tasklet); 1125 tasklet_schedule(&host->finish_tasklet);
1127 1126