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