Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/drzeus/mmc
[linux-2.6.git] / drivers / mmc / card / mmc_test.c
1 /*
2  *  linux/drivers/mmc/card/mmc_test.c
3  *
4  *  Copyright 2007-2008 Pierre Ossman
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or (at
9  * your option) any later version.
10  */
11
12 #include <linux/mmc/core.h>
13 #include <linux/mmc/card.h>
14 #include <linux/mmc/host.h>
15 #include <linux/mmc/mmc.h>
16
17 #include <linux/scatterlist.h>
18
19 #define RESULT_OK               0
20 #define RESULT_FAIL             1
21 #define RESULT_UNSUP_HOST       2
22 #define RESULT_UNSUP_CARD       3
23
24 #define BUFFER_SIZE     (PAGE_SIZE * 4)
25
26 struct mmc_test_card {
27         struct mmc_card *card;
28
29         u8              scratch[BUFFER_SIZE];
30         u8              *buffer;
31 };
32
33 /*******************************************************************/
34 /*  General helper functions                                       */
35 /*******************************************************************/
36
37 /*
38  * Configure correct block size in card
39  */
40 static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)
41 {
42         struct mmc_command cmd;
43         int ret;
44
45         cmd.opcode = MMC_SET_BLOCKLEN;
46         cmd.arg = size;
47         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
48         ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
49         if (ret)
50                 return ret;
51
52         return 0;
53 }
54
55 /*
56  * Fill in the mmc_request structure given a set of transfer parameters.
57  */
58 static void mmc_test_prepare_mrq(struct mmc_test_card *test,
59         struct mmc_request *mrq, struct scatterlist *sg, unsigned sg_len,
60         unsigned dev_addr, unsigned blocks, unsigned blksz, int write)
61 {
62         BUG_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop);
63
64         if (blocks > 1) {
65                 mrq->cmd->opcode = write ?
66                         MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
67         } else {
68                 mrq->cmd->opcode = write ?
69                         MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
70         }
71
72         mrq->cmd->arg = dev_addr;
73         mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
74
75         if (blocks == 1)
76                 mrq->stop = NULL;
77         else {
78                 mrq->stop->opcode = MMC_STOP_TRANSMISSION;
79                 mrq->stop->arg = 0;
80                 mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
81         }
82
83         mrq->data->blksz = blksz;
84         mrq->data->blocks = blocks;
85         mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
86         mrq->data->sg = sg;
87         mrq->data->sg_len = sg_len;
88
89         mmc_set_data_timeout(mrq->data, test->card);
90 }
91
92 /*
93  * Wait for the card to finish the busy state
94  */
95 static int mmc_test_wait_busy(struct mmc_test_card *test)
96 {
97         int ret, busy;
98         struct mmc_command cmd;
99
100         busy = 0;
101         do {
102                 memset(&cmd, 0, sizeof(struct mmc_command));
103
104                 cmd.opcode = MMC_SEND_STATUS;
105                 cmd.arg = test->card->rca << 16;
106                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
107
108                 ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
109                 if (ret)
110                         break;
111
112                 if (!busy && !(cmd.resp[0] & R1_READY_FOR_DATA)) {
113                         busy = 1;
114                         printk(KERN_INFO "%s: Warning: Host did not "
115                                 "wait for busy state to end.\n",
116                                 mmc_hostname(test->card->host));
117                 }
118         } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
119
120         return ret;
121 }
122
123 /*
124  * Transfer a single sector of kernel addressable data
125  */
126 static int mmc_test_buffer_transfer(struct mmc_test_card *test,
127         u8 *buffer, unsigned addr, unsigned blksz, int write)
128 {
129         int ret;
130
131         struct mmc_request mrq;
132         struct mmc_command cmd;
133         struct mmc_command stop;
134         struct mmc_data data;
135
136         struct scatterlist sg;
137
138         memset(&mrq, 0, sizeof(struct mmc_request));
139         memset(&cmd, 0, sizeof(struct mmc_command));
140         memset(&data, 0, sizeof(struct mmc_data));
141         memset(&stop, 0, sizeof(struct mmc_command));
142
143         mrq.cmd = &cmd;
144         mrq.data = &data;
145         mrq.stop = &stop;
146
147         sg_init_one(&sg, buffer, blksz);
148
149         mmc_test_prepare_mrq(test, &mrq, &sg, 1, addr, 1, blksz, write);
150
151         mmc_wait_for_req(test->card->host, &mrq);
152
153         if (cmd.error)
154                 return cmd.error;
155         if (data.error)
156                 return data.error;
157
158         ret = mmc_test_wait_busy(test);
159         if (ret)
160                 return ret;
161
162         return 0;
163 }
164
165 /*******************************************************************/
166 /*  Test preparation and cleanup                                   */
167 /*******************************************************************/
168
169 /*
170  * Fill the first couple of sectors of the card with known data
171  * so that bad reads/writes can be detected
172  */
173 static int __mmc_test_prepare(struct mmc_test_card *test, int write)
174 {
175         int ret, i;
176
177         ret = mmc_test_set_blksize(test, 512);
178         if (ret)
179                 return ret;
180
181         if (write)
182                 memset(test->buffer, 0xDF, 512);
183         else {
184                 for (i = 0;i < 512;i++)
185                         test->buffer[i] = i;
186         }
187
188         for (i = 0;i < BUFFER_SIZE / 512;i++) {
189                 ret = mmc_test_buffer_transfer(test, test->buffer, i * 512, 512, 1);
190                 if (ret)
191                         return ret;
192         }
193
194         return 0;
195 }
196
197 static int mmc_test_prepare_write(struct mmc_test_card *test)
198 {
199         return __mmc_test_prepare(test, 1);
200 }
201
202 static int mmc_test_prepare_read(struct mmc_test_card *test)
203 {
204         return __mmc_test_prepare(test, 0);
205 }
206
207 static int mmc_test_cleanup(struct mmc_test_card *test)
208 {
209         int ret, i;
210
211         ret = mmc_test_set_blksize(test, 512);
212         if (ret)
213                 return ret;
214
215         memset(test->buffer, 0, 512);
216
217         for (i = 0;i < BUFFER_SIZE / 512;i++) {
218                 ret = mmc_test_buffer_transfer(test, test->buffer, i * 512, 512, 1);
219                 if (ret)
220                         return ret;
221         }
222
223         return 0;
224 }
225
226 /*******************************************************************/
227 /*  Test execution helpers                                         */
228 /*******************************************************************/
229
230 /*
231  * Modifies the mmc_request to perform the "short transfer" tests
232  */
233 static void mmc_test_prepare_broken_mrq(struct mmc_test_card *test,
234         struct mmc_request *mrq, int write)
235 {
236         BUG_ON(!mrq || !mrq->cmd || !mrq->data);
237
238         if (mrq->data->blocks > 1) {
239                 mrq->cmd->opcode = write ?
240                         MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
241                 mrq->stop = NULL;
242         } else {
243                 mrq->cmd->opcode = MMC_SEND_STATUS;
244                 mrq->cmd->arg = test->card->rca << 16;
245         }
246 }
247
248 /*
249  * Checks that a normal transfer didn't have any errors
250  */
251 static int mmc_test_check_result(struct mmc_test_card *test,
252         struct mmc_request *mrq)
253 {
254         int ret;
255
256         BUG_ON(!mrq || !mrq->cmd || !mrq->data);
257
258         ret = 0;
259
260         if (!ret && mrq->cmd->error)
261                 ret = mrq->cmd->error;
262         if (!ret && mrq->data->error)
263                 ret = mrq->data->error;
264         if (!ret && mrq->stop && mrq->stop->error)
265                 ret = mrq->stop->error;
266         if (!ret && mrq->data->bytes_xfered !=
267                 mrq->data->blocks * mrq->data->blksz)
268                 ret = RESULT_FAIL;
269
270         if (ret == -EINVAL)
271                 ret = RESULT_UNSUP_HOST;
272
273         return ret;
274 }
275
276 /*
277  * Checks that a "short transfer" behaved as expected
278  */
279 static int mmc_test_check_broken_result(struct mmc_test_card *test,
280         struct mmc_request *mrq)
281 {
282         int ret;
283
284         BUG_ON(!mrq || !mrq->cmd || !mrq->data);
285
286         ret = 0;
287
288         if (!ret && mrq->cmd->error)
289                 ret = mrq->cmd->error;
290         if (!ret && mrq->data->error == 0)
291                 ret = RESULT_FAIL;
292         if (!ret && mrq->data->error != -ETIMEDOUT)
293                 ret = mrq->data->error;
294         if (!ret && mrq->stop && mrq->stop->error)
295                 ret = mrq->stop->error;
296         if (mrq->data->blocks > 1) {
297                 if (!ret && mrq->data->bytes_xfered > mrq->data->blksz)
298                         ret = RESULT_FAIL;
299         } else {
300                 if (!ret && mrq->data->bytes_xfered > 0)
301                         ret = RESULT_FAIL;
302         }
303
304         if (ret == -EINVAL)
305                 ret = RESULT_UNSUP_HOST;
306
307         return ret;
308 }
309
310 /*
311  * Tests a basic transfer with certain parameters
312  */
313 static int mmc_test_simple_transfer(struct mmc_test_card *test,
314         struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
315         unsigned blocks, unsigned blksz, int write)
316 {
317         struct mmc_request mrq;
318         struct mmc_command cmd;
319         struct mmc_command stop;
320         struct mmc_data data;
321
322         memset(&mrq, 0, sizeof(struct mmc_request));
323         memset(&cmd, 0, sizeof(struct mmc_command));
324         memset(&data, 0, sizeof(struct mmc_data));
325         memset(&stop, 0, sizeof(struct mmc_command));
326
327         mrq.cmd = &cmd;
328         mrq.data = &data;
329         mrq.stop = &stop;
330
331         mmc_test_prepare_mrq(test, &mrq, sg, sg_len, dev_addr,
332                 blocks, blksz, write);
333
334         mmc_wait_for_req(test->card->host, &mrq);
335
336         mmc_test_wait_busy(test);
337
338         return mmc_test_check_result(test, &mrq);
339 }
340
341 /*
342  * Tests a transfer where the card will fail completely or partly
343  */
344 static int mmc_test_broken_transfer(struct mmc_test_card *test,
345         unsigned blocks, unsigned blksz, int write)
346 {
347         struct mmc_request mrq;
348         struct mmc_command cmd;
349         struct mmc_command stop;
350         struct mmc_data data;
351
352         struct scatterlist sg;
353
354         memset(&mrq, 0, sizeof(struct mmc_request));
355         memset(&cmd, 0, sizeof(struct mmc_command));
356         memset(&data, 0, sizeof(struct mmc_data));
357         memset(&stop, 0, sizeof(struct mmc_command));
358
359         mrq.cmd = &cmd;
360         mrq.data = &data;
361         mrq.stop = &stop;
362
363         sg_init_one(&sg, test->buffer, blocks * blksz);
364
365         mmc_test_prepare_mrq(test, &mrq, &sg, 1, 0, blocks, blksz, write);
366         mmc_test_prepare_broken_mrq(test, &mrq, write);
367
368         mmc_wait_for_req(test->card->host, &mrq);
369
370         mmc_test_wait_busy(test);
371
372         return mmc_test_check_broken_result(test, &mrq);
373 }
374
375 /*
376  * Does a complete transfer test where data is also validated
377  *
378  * Note: mmc_test_prepare() must have been done before this call
379  */
380 static int mmc_test_transfer(struct mmc_test_card *test,
381         struct scatterlist *sg, unsigned sg_len, unsigned dev_addr,
382         unsigned blocks, unsigned blksz, int write)
383 {
384         int ret, i;
385         unsigned long flags;
386
387         if (write) {
388                 for (i = 0;i < blocks * blksz;i++)
389                         test->scratch[i] = i;
390         } else {
391                 memset(test->scratch, 0, BUFFER_SIZE);
392         }
393         local_irq_save(flags);
394         sg_copy_from_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
395         local_irq_restore(flags);
396
397         ret = mmc_test_set_blksize(test, blksz);
398         if (ret)
399                 return ret;
400
401         ret = mmc_test_simple_transfer(test, sg, sg_len, dev_addr,
402                 blocks, blksz, write);
403         if (ret)
404                 return ret;
405
406         if (write) {
407                 int sectors;
408
409                 ret = mmc_test_set_blksize(test, 512);
410                 if (ret)
411                         return ret;
412
413                 sectors = (blocks * blksz + 511) / 512;
414                 if ((sectors * 512) == (blocks * blksz))
415                         sectors++;
416
417                 if ((sectors * 512) > BUFFER_SIZE)
418                         return -EINVAL;
419
420                 memset(test->buffer, 0, sectors * 512);
421
422                 for (i = 0;i < sectors;i++) {
423                         ret = mmc_test_buffer_transfer(test,
424                                 test->buffer + i * 512,
425                                 dev_addr + i * 512, 512, 0);
426                         if (ret)
427                                 return ret;
428                 }
429
430                 for (i = 0;i < blocks * blksz;i++) {
431                         if (test->buffer[i] != (u8)i)
432                                 return RESULT_FAIL;
433                 }
434
435                 for (;i < sectors * 512;i++) {
436                         if (test->buffer[i] != 0xDF)
437                                 return RESULT_FAIL;
438                 }
439         } else {
440                 local_irq_save(flags);
441                 sg_copy_to_buffer(sg, sg_len, test->scratch, BUFFER_SIZE);
442                 local_irq_restore(flags);
443                 for (i = 0;i < blocks * blksz;i++) {
444                         if (test->scratch[i] != (u8)i)
445                                 return RESULT_FAIL;
446                 }
447         }
448
449         return 0;
450 }
451
452 /*******************************************************************/
453 /*  Tests                                                          */
454 /*******************************************************************/
455
456 struct mmc_test_case {
457         const char *name;
458
459         int (*prepare)(struct mmc_test_card *);
460         int (*run)(struct mmc_test_card *);
461         int (*cleanup)(struct mmc_test_card *);
462 };
463
464 static int mmc_test_basic_write(struct mmc_test_card *test)
465 {
466         int ret;
467         struct scatterlist sg;
468
469         ret = mmc_test_set_blksize(test, 512);
470         if (ret)
471                 return ret;
472
473         sg_init_one(&sg, test->buffer, 512);
474
475         ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 1);
476         if (ret)
477                 return ret;
478
479         return 0;
480 }
481
482 static int mmc_test_basic_read(struct mmc_test_card *test)
483 {
484         int ret;
485         struct scatterlist sg;
486
487         ret = mmc_test_set_blksize(test, 512);
488         if (ret)
489                 return ret;
490
491         sg_init_one(&sg, test->buffer, 512);
492
493         ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 1);
494         if (ret)
495                 return ret;
496
497         return 0;
498 }
499
500 static int mmc_test_verify_write(struct mmc_test_card *test)
501 {
502         int ret;
503         struct scatterlist sg;
504
505         sg_init_one(&sg, test->buffer, 512);
506
507         ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
508         if (ret)
509                 return ret;
510
511         return 0;
512 }
513
514 static int mmc_test_verify_read(struct mmc_test_card *test)
515 {
516         int ret;
517         struct scatterlist sg;
518
519         sg_init_one(&sg, test->buffer, 512);
520
521         ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
522         if (ret)
523                 return ret;
524
525         return 0;
526 }
527
528 static int mmc_test_multi_write(struct mmc_test_card *test)
529 {
530         int ret;
531         unsigned int size;
532         struct scatterlist sg;
533
534         if (test->card->host->max_blk_count == 1)
535                 return RESULT_UNSUP_HOST;
536
537         size = PAGE_SIZE * 2;
538         size = min(size, test->card->host->max_req_size);
539         size = min(size, test->card->host->max_seg_size);
540         size = min(size, test->card->host->max_blk_count * 512);
541
542         if (size < 1024)
543                 return RESULT_UNSUP_HOST;
544
545         sg_init_one(&sg, test->buffer, size);
546
547         ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
548         if (ret)
549                 return ret;
550
551         return 0;
552 }
553
554 static int mmc_test_multi_read(struct mmc_test_card *test)
555 {
556         int ret;
557         unsigned int size;
558         struct scatterlist sg;
559
560         if (test->card->host->max_blk_count == 1)
561                 return RESULT_UNSUP_HOST;
562
563         size = PAGE_SIZE * 2;
564         size = min(size, test->card->host->max_req_size);
565         size = min(size, test->card->host->max_seg_size);
566         size = min(size, test->card->host->max_blk_count * 512);
567
568         if (size < 1024)
569                 return RESULT_UNSUP_HOST;
570
571         sg_init_one(&sg, test->buffer, size);
572
573         ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
574         if (ret)
575                 return ret;
576
577         return 0;
578 }
579
580 static int mmc_test_pow2_write(struct mmc_test_card *test)
581 {
582         int ret, i;
583         struct scatterlist sg;
584
585         if (!test->card->csd.write_partial)
586                 return RESULT_UNSUP_CARD;
587
588         for (i = 1; i < 512;i <<= 1) {
589                 sg_init_one(&sg, test->buffer, i);
590                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
591                 if (ret)
592                         return ret;
593         }
594
595         return 0;
596 }
597
598 static int mmc_test_pow2_read(struct mmc_test_card *test)
599 {
600         int ret, i;
601         struct scatterlist sg;
602
603         if (!test->card->csd.read_partial)
604                 return RESULT_UNSUP_CARD;
605
606         for (i = 1; i < 512;i <<= 1) {
607                 sg_init_one(&sg, test->buffer, i);
608                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
609                 if (ret)
610                         return ret;
611         }
612
613         return 0;
614 }
615
616 static int mmc_test_weird_write(struct mmc_test_card *test)
617 {
618         int ret, i;
619         struct scatterlist sg;
620
621         if (!test->card->csd.write_partial)
622                 return RESULT_UNSUP_CARD;
623
624         for (i = 3; i < 512;i += 7) {
625                 sg_init_one(&sg, test->buffer, i);
626                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 1);
627                 if (ret)
628                         return ret;
629         }
630
631         return 0;
632 }
633
634 static int mmc_test_weird_read(struct mmc_test_card *test)
635 {
636         int ret, i;
637         struct scatterlist sg;
638
639         if (!test->card->csd.read_partial)
640                 return RESULT_UNSUP_CARD;
641
642         for (i = 3; i < 512;i += 7) {
643                 sg_init_one(&sg, test->buffer, i);
644                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, i, 0);
645                 if (ret)
646                         return ret;
647         }
648
649         return 0;
650 }
651
652 static int mmc_test_align_write(struct mmc_test_card *test)
653 {
654         int ret, i;
655         struct scatterlist sg;
656
657         for (i = 1;i < 4;i++) {
658                 sg_init_one(&sg, test->buffer + i, 512);
659                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 1);
660                 if (ret)
661                         return ret;
662         }
663
664         return 0;
665 }
666
667 static int mmc_test_align_read(struct mmc_test_card *test)
668 {
669         int ret, i;
670         struct scatterlist sg;
671
672         for (i = 1;i < 4;i++) {
673                 sg_init_one(&sg, test->buffer + i, 512);
674                 ret = mmc_test_transfer(test, &sg, 1, 0, 1, 512, 0);
675                 if (ret)
676                         return ret;
677         }
678
679         return 0;
680 }
681
682 static int mmc_test_align_multi_write(struct mmc_test_card *test)
683 {
684         int ret, i;
685         unsigned int size;
686         struct scatterlist sg;
687
688         if (test->card->host->max_blk_count == 1)
689                 return RESULT_UNSUP_HOST;
690
691         size = PAGE_SIZE * 2;
692         size = min(size, test->card->host->max_req_size);
693         size = min(size, test->card->host->max_seg_size);
694         size = min(size, test->card->host->max_blk_count * 512);
695
696         if (size < 1024)
697                 return RESULT_UNSUP_HOST;
698
699         for (i = 1;i < 4;i++) {
700                 sg_init_one(&sg, test->buffer + i, size);
701                 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 1);
702                 if (ret)
703                         return ret;
704         }
705
706         return 0;
707 }
708
709 static int mmc_test_align_multi_read(struct mmc_test_card *test)
710 {
711         int ret, i;
712         unsigned int size;
713         struct scatterlist sg;
714
715         if (test->card->host->max_blk_count == 1)
716                 return RESULT_UNSUP_HOST;
717
718         size = PAGE_SIZE * 2;
719         size = min(size, test->card->host->max_req_size);
720         size = min(size, test->card->host->max_seg_size);
721         size = min(size, test->card->host->max_blk_count * 512);
722
723         if (size < 1024)
724                 return RESULT_UNSUP_HOST;
725
726         for (i = 1;i < 4;i++) {
727                 sg_init_one(&sg, test->buffer + i, size);
728                 ret = mmc_test_transfer(test, &sg, 1, 0, size/512, 512, 0);
729                 if (ret)
730                         return ret;
731         }
732
733         return 0;
734 }
735
736 static int mmc_test_xfersize_write(struct mmc_test_card *test)
737 {
738         int ret;
739
740         ret = mmc_test_set_blksize(test, 512);
741         if (ret)
742                 return ret;
743
744         ret = mmc_test_broken_transfer(test, 1, 512, 1);
745         if (ret)
746                 return ret;
747
748         return 0;
749 }
750
751 static int mmc_test_xfersize_read(struct mmc_test_card *test)
752 {
753         int ret;
754
755         ret = mmc_test_set_blksize(test, 512);
756         if (ret)
757                 return ret;
758
759         ret = mmc_test_broken_transfer(test, 1, 512, 0);
760         if (ret)
761                 return ret;
762
763         return 0;
764 }
765
766 static int mmc_test_multi_xfersize_write(struct mmc_test_card *test)
767 {
768         int ret;
769
770         if (test->card->host->max_blk_count == 1)
771                 return RESULT_UNSUP_HOST;
772
773         ret = mmc_test_set_blksize(test, 512);
774         if (ret)
775                 return ret;
776
777         ret = mmc_test_broken_transfer(test, 2, 512, 1);
778         if (ret)
779                 return ret;
780
781         return 0;
782 }
783
784 static int mmc_test_multi_xfersize_read(struct mmc_test_card *test)
785 {
786         int ret;
787
788         if (test->card->host->max_blk_count == 1)
789                 return RESULT_UNSUP_HOST;
790
791         ret = mmc_test_set_blksize(test, 512);
792         if (ret)
793                 return ret;
794
795         ret = mmc_test_broken_transfer(test, 2, 512, 0);
796         if (ret)
797                 return ret;
798
799         return 0;
800 }
801
802 static const struct mmc_test_case mmc_test_cases[] = {
803         {
804                 .name = "Basic write (no data verification)",
805                 .run = mmc_test_basic_write,
806         },
807
808         {
809                 .name = "Basic read (no data verification)",
810                 .run = mmc_test_basic_read,
811         },
812
813         {
814                 .name = "Basic write (with data verification)",
815                 .prepare = mmc_test_prepare_write,
816                 .run = mmc_test_verify_write,
817                 .cleanup = mmc_test_cleanup,
818         },
819
820         {
821                 .name = "Basic read (with data verification)",
822                 .prepare = mmc_test_prepare_read,
823                 .run = mmc_test_verify_read,
824                 .cleanup = mmc_test_cleanup,
825         },
826
827         {
828                 .name = "Multi-block write",
829                 .prepare = mmc_test_prepare_write,
830                 .run = mmc_test_multi_write,
831                 .cleanup = mmc_test_cleanup,
832         },
833
834         {
835                 .name = "Multi-block read",
836                 .prepare = mmc_test_prepare_read,
837                 .run = mmc_test_multi_read,
838                 .cleanup = mmc_test_cleanup,
839         },
840
841         {
842                 .name = "Power of two block writes",
843                 .prepare = mmc_test_prepare_write,
844                 .run = mmc_test_pow2_write,
845                 .cleanup = mmc_test_cleanup,
846         },
847
848         {
849                 .name = "Power of two block reads",
850                 .prepare = mmc_test_prepare_read,
851                 .run = mmc_test_pow2_read,
852                 .cleanup = mmc_test_cleanup,
853         },
854
855         {
856                 .name = "Weird sized block writes",
857                 .prepare = mmc_test_prepare_write,
858                 .run = mmc_test_weird_write,
859                 .cleanup = mmc_test_cleanup,
860         },
861
862         {
863                 .name = "Weird sized block reads",
864                 .prepare = mmc_test_prepare_read,
865                 .run = mmc_test_weird_read,
866                 .cleanup = mmc_test_cleanup,
867         },
868
869         {
870                 .name = "Badly aligned write",
871                 .prepare = mmc_test_prepare_write,
872                 .run = mmc_test_align_write,
873                 .cleanup = mmc_test_cleanup,
874         },
875
876         {
877                 .name = "Badly aligned read",
878                 .prepare = mmc_test_prepare_read,
879                 .run = mmc_test_align_read,
880                 .cleanup = mmc_test_cleanup,
881         },
882
883         {
884                 .name = "Badly aligned multi-block write",
885                 .prepare = mmc_test_prepare_write,
886                 .run = mmc_test_align_multi_write,
887                 .cleanup = mmc_test_cleanup,
888         },
889
890         {
891                 .name = "Badly aligned multi-block read",
892                 .prepare = mmc_test_prepare_read,
893                 .run = mmc_test_align_multi_read,
894                 .cleanup = mmc_test_cleanup,
895         },
896
897         {
898                 .name = "Correct xfer_size at write (start failure)",
899                 .run = mmc_test_xfersize_write,
900         },
901
902         {
903                 .name = "Correct xfer_size at read (start failure)",
904                 .run = mmc_test_xfersize_read,
905         },
906
907         {
908                 .name = "Correct xfer_size at write (midway failure)",
909                 .run = mmc_test_multi_xfersize_write,
910         },
911
912         {
913                 .name = "Correct xfer_size at read (midway failure)",
914                 .run = mmc_test_multi_xfersize_read,
915         },
916 };
917
918 static struct mutex mmc_test_lock;
919
920 static void mmc_test_run(struct mmc_test_card *test, int testcase)
921 {
922         int i, ret;
923
924         printk(KERN_INFO "%s: Starting tests of card %s...\n",
925                 mmc_hostname(test->card->host), mmc_card_id(test->card));
926
927         mmc_claim_host(test->card->host);
928
929         for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {
930                 if (testcase && ((i + 1) != testcase))
931                         continue;
932
933                 printk(KERN_INFO "%s: Test case %d. %s...\n",
934                         mmc_hostname(test->card->host), i + 1,
935                         mmc_test_cases[i].name);
936
937                 if (mmc_test_cases[i].prepare) {
938                         ret = mmc_test_cases[i].prepare(test);
939                         if (ret) {
940                                 printk(KERN_INFO "%s: Result: Prepare "
941                                         "stage failed! (%d)\n",
942                                         mmc_hostname(test->card->host),
943                                         ret);
944                                 continue;
945                         }
946                 }
947
948                 ret = mmc_test_cases[i].run(test);
949                 switch (ret) {
950                 case RESULT_OK:
951                         printk(KERN_INFO "%s: Result: OK\n",
952                                 mmc_hostname(test->card->host));
953                         break;
954                 case RESULT_FAIL:
955                         printk(KERN_INFO "%s: Result: FAILED\n",
956                                 mmc_hostname(test->card->host));
957                         break;
958                 case RESULT_UNSUP_HOST:
959                         printk(KERN_INFO "%s: Result: UNSUPPORTED "
960                                 "(by host)\n",
961                                 mmc_hostname(test->card->host));
962                         break;
963                 case RESULT_UNSUP_CARD:
964                         printk(KERN_INFO "%s: Result: UNSUPPORTED "
965                                 "(by card)\n",
966                                 mmc_hostname(test->card->host));
967                         break;
968                 default:
969                         printk(KERN_INFO "%s: Result: ERROR (%d)\n",
970                                 mmc_hostname(test->card->host), ret);
971                 }
972
973                 if (mmc_test_cases[i].cleanup) {
974                         ret = mmc_test_cases[i].cleanup(test);
975                         if (ret) {
976                                 printk(KERN_INFO "%s: Warning: Cleanup "
977                                         "stage failed! (%d)\n",
978                                         mmc_hostname(test->card->host),
979                                         ret);
980                         }
981                 }
982         }
983
984         mmc_release_host(test->card->host);
985
986         printk(KERN_INFO "%s: Tests completed.\n",
987                 mmc_hostname(test->card->host));
988 }
989
990 static ssize_t mmc_test_show(struct device *dev,
991         struct device_attribute *attr, char *buf)
992 {
993         mutex_lock(&mmc_test_lock);
994         mutex_unlock(&mmc_test_lock);
995
996         return 0;
997 }
998
999 static ssize_t mmc_test_store(struct device *dev,
1000         struct device_attribute *attr, const char *buf, size_t count)
1001 {
1002         struct mmc_card *card;
1003         struct mmc_test_card *test;
1004         int testcase;
1005
1006         card = container_of(dev, struct mmc_card, dev);
1007
1008         testcase = simple_strtol(buf, NULL, 10);
1009
1010         test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);
1011         if (!test)
1012                 return -ENOMEM;
1013
1014         test->card = card;
1015
1016         test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
1017         if (test->buffer) {
1018                 mutex_lock(&mmc_test_lock);
1019                 mmc_test_run(test, testcase);
1020                 mutex_unlock(&mmc_test_lock);
1021         }
1022
1023         kfree(test->buffer);
1024         kfree(test);
1025
1026         return count;
1027 }
1028
1029 static DEVICE_ATTR(test, S_IWUSR | S_IRUGO, mmc_test_show, mmc_test_store);
1030
1031 static int mmc_test_probe(struct mmc_card *card)
1032 {
1033         int ret;
1034
1035         if ((card->type != MMC_TYPE_MMC) && (card->type != MMC_TYPE_SD))
1036                 return -ENODEV;
1037
1038         mutex_init(&mmc_test_lock);
1039
1040         ret = device_create_file(&card->dev, &dev_attr_test);
1041         if (ret)
1042                 return ret;
1043
1044         return 0;
1045 }
1046
1047 static void mmc_test_remove(struct mmc_card *card)
1048 {
1049         device_remove_file(&card->dev, &dev_attr_test);
1050 }
1051
1052 static struct mmc_driver mmc_driver = {
1053         .drv            = {
1054                 .name   = "mmc_test",
1055         },
1056         .probe          = mmc_test_probe,
1057         .remove         = mmc_test_remove,
1058 };
1059
1060 static int __init mmc_test_init(void)
1061 {
1062         return mmc_register_driver(&mmc_driver);
1063 }
1064
1065 static void __exit mmc_test_exit(void)
1066 {
1067         mmc_unregister_driver(&mmc_driver);
1068 }
1069
1070 module_init(mmc_test_init);
1071 module_exit(mmc_test_exit);
1072
1073 MODULE_LICENSE("GPL");
1074 MODULE_DESCRIPTION("Multimedia Card (MMC) host test driver");
1075 MODULE_AUTHOR("Pierre Ossman");