drivers/mmc/card/mmc_test.c

   1 /*
   2  *  linux/drivers/mmc/card/mmc_test.c
   3  *
   4  *  Copyright 2007 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              *buffer;
  30 };
  31
  32 /*******************************************************************/
  33 /*  Helper functions                                               */
  34 /*******************************************************************/
  35
  36 static int mmc_test_set_blksize(struct mmc_test_card *test, unsigned size)
  37 {
  38         struct mmc_command cmd;
  39         int ret;
  40
  41         cmd.opcode = MMC_SET_BLOCKLEN;
  42         cmd.arg = size;
  43         cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
  44         ret = mmc_wait_for_cmd(test->card->host, &cmd, 0);
  45         if (ret)
  46                 return ret;
  47
  48         return 0;
  49 }
  50
  51 static int __mmc_test_transfer(struct mmc_test_card *test, int write,
  52         unsigned broken_xfer, u8 *buffer, unsigned addr,
  53         unsigned blocks, unsigned blksz)
  54 {
  55         int ret, busy;
  56
  57         struct mmc_request mrq;
  58         struct mmc_command cmd;
  59         struct mmc_command stop;
  60         struct mmc_data data;
  61
  62         struct scatterlist sg;
  63
  64         memset(&mrq, 0, sizeof(struct mmc_request));
  65
  66         mrq.cmd = &cmd;
  67         mrq.data = &data;
  68
  69         memset(&cmd, 0, sizeof(struct mmc_command));
  70
  71         if (broken_xfer) {
  72                 if (blocks > 1) {
  73                         cmd.opcode = write ?
  74                                 MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
  75                 } else {
  76                         cmd.opcode = MMC_SEND_STATUS;
  77                 }
  78         } else {
  79                 if (blocks > 1) {
  80                         cmd.opcode = write ?
  81                                 MMC_WRITE_MULTIPLE_BLOCK : MMC_READ_MULTIPLE_BLOCK;
  82                 } else {
  83                         cmd.opcode = write ?
  84                                 MMC_WRITE_BLOCK : MMC_READ_SINGLE_BLOCK;
  85                 }
  86         }
  87
  88         if (broken_xfer && blocks == 1)
  89                 cmd.arg = test->card->rca << 16;
  90         else
  91                 cmd.arg = addr;
  92         cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
  93
  94         memset(&stop, 0, sizeof(struct mmc_command));
  95
  96         if (!broken_xfer && (blocks > 1)) {
  97                 stop.opcode = MMC_STOP_TRANSMISSION;
  98                 stop.arg = 0;
  99                 stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
 100
 101                 mrq.stop = &stop;
 102         }
 103
 104         memset(&data, 0, sizeof(struct mmc_data));
 105
 106         data.blksz = blksz;
 107         data.blocks = blocks;
 108         data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
 109         data.sg = &sg;
 110         data.sg_len = 1;
 111
 112         sg_init_one(&sg, buffer, blocks * blksz);
 113
 114         mmc_set_data_timeout(&data, test->card);
 115
 116         mmc_wait_for_req(test->card->host, &mrq);
 117
 118         ret = 0;
 119
 120         if (broken_xfer) {
 121                 if (!ret && cmd.error)
 122                         ret = cmd.error;
 123                 if (!ret && data.error == 0)
 124                         ret = RESULT_FAIL;
 125                 if (!ret && data.error != -ETIMEDOUT)
 126                         ret = data.error;
 127                 if (!ret && stop.error)
 128                         ret = stop.error;
 129                 if (blocks > 1) {
 130                         if (!ret && data.bytes_xfered > blksz)
 131                                 ret = RESULT_FAIL;
 132                 } else {
 133                         if (!ret && data.bytes_xfered > 0)
 134                                 ret = RESULT_FAIL;
 135                 }
 136         } else {
 137                 if (!ret && cmd.error)
 138                         ret = cmd.error;
 139                 if (!ret && data.error)
 140                         ret = data.error;
 141                 if (!ret && stop.error)
 142                         ret = stop.error;
 143                 if (!ret && data.bytes_xfered != blocks * blksz)
 144                         ret = RESULT_FAIL;
 145         }
 146
 147         if (ret == -EINVAL)
 148                 ret = RESULT_UNSUP_HOST;
 149
 150         busy = 0;
 151         do {
 152                 int ret2;
 153
 154                 memset(&cmd, 0, sizeof(struct mmc_command));
 155
 156                 cmd.opcode = MMC_SEND_STATUS;
 157                 cmd.arg = test->card->rca << 16;
 158                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 159
 160                 ret2 = mmc_wait_for_cmd(test->card->host, &cmd, 0);
 161                 if (ret2)
 162                         break;
 163
 164                 if (!busy && !(cmd.resp[0] & R1_READY_FOR_DATA)) {
 165                         busy = 1;
 166                         printk(KERN_INFO "%s: Warning: Host did not "
 167                                 "wait for busy state to end.\n",
 168                                 mmc_hostname(test->card->host));
 169                 }
 170         } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
 171
 172         return ret;
 173 }
 174
 175 static int mmc_test_transfer(struct mmc_test_card *test, int write,
 176         u8 *buffer, unsigned addr, unsigned blocks, unsigned blksz)
 177 {
 178         return __mmc_test_transfer(test, write, 0, buffer,
 179                         addr, blocks, blksz);
 180 }
 181
 182 static int mmc_test_prepare_verify(struct mmc_test_card *test, int write)
 183 {
 184         int ret, i;
 185
 186         ret = mmc_test_set_blksize(test, 512);
 187         if (ret)
 188                 return ret;
 189
 190         if (write)
 191                 memset(test->buffer, 0xDF, BUFFER_SIZE);
 192         else {
 193                 for (i = 0;i < BUFFER_SIZE;i++)
 194                         test->buffer[i] = i;
 195         }
 196
 197         for (i = 0;i < BUFFER_SIZE / 512;i++) {
 198                 ret = mmc_test_transfer(test, 1, test->buffer + i * 512,
 199                         i * 512, 1, 512);
 200                 if (ret)
 201                         return ret;
 202         }
 203
 204         return 0;
 205 }
 206
 207 static int mmc_test_prepare_verify_write(struct mmc_test_card *test)
 208 {
 209         return mmc_test_prepare_verify(test, 1);
 210 }
 211
 212 static int mmc_test_prepare_verify_read(struct mmc_test_card *test)
 213 {
 214         return mmc_test_prepare_verify(test, 0);
 215 }
 216
 217 static int mmc_test_verified_transfer(struct mmc_test_card *test, int write,
 218         u8 *buffer, unsigned addr, unsigned blocks, unsigned blksz)
 219 {
 220         int ret, i, sectors;
 221
 222         /*
 223          * It is assumed that the above preparation has been done.
 224          */
 225
 226         memset(test->buffer, 0, BUFFER_SIZE);
 227
 228         if (write) {
 229                 for (i = 0;i < blocks * blksz;i++)
 230                         buffer[i] = i;
 231         }
 232
 233         ret = mmc_test_set_blksize(test, blksz);
 234         if (ret)
 235                 return ret;
 236
 237         ret = mmc_test_transfer(test, write, buffer, addr, blocks, blksz);
 238         if (ret)
 239                 return ret;
 240
 241         if (write) {
 242                 ret = mmc_test_set_blksize(test, 512);
 243                 if (ret)
 244                         return ret;
 245
 246                 sectors = (blocks * blksz + 511) / 512;
 247                 if ((sectors * 512) == (blocks * blksz))
 248                         sectors++;
 249
 250                 if ((sectors * 512) > BUFFER_SIZE)
 251                         return -EINVAL;
 252
 253                 memset(test->buffer, 0, sectors * 512);
 254
 255                 for (i = 0;i < sectors;i++) {
 256                         ret = mmc_test_transfer(test, 0,
 257                                 test->buffer + i * 512,
 258                                 addr + i * 512, 1, 512);
 259                         if (ret)
 260                                 return ret;
 261                 }
 262
 263                 for (i = 0;i < blocks * blksz;i++) {
 264                         if (test->buffer[i] != (u8)i)
 265                                 return RESULT_FAIL;
 266                 }
 267
 268                 for (;i < sectors * 512;i++) {
 269                         if (test->buffer[i] != 0xDF)
 270                                 return RESULT_FAIL;
 271                 }
 272         } else {
 273                 for (i = 0;i < blocks * blksz;i++) {
 274                         if (buffer[i] != (u8)i)
 275                                 return RESULT_FAIL;
 276                 }
 277         }
 278
 279         return 0;
 280 }
 281
 282 static int mmc_test_cleanup_verify(struct mmc_test_card *test)
 283 {
 284         int ret, i;
 285
 286         ret = mmc_test_set_blksize(test, 512);
 287         if (ret)
 288                 return ret;
 289
 290         memset(test->buffer, 0, BUFFER_SIZE);
 291
 292         for (i = 0;i < BUFFER_SIZE / 512;i++) {
 293                 ret = mmc_test_transfer(test, 1, test->buffer + i * 512,
 294                         i * 512, 1, 512);
 295                 if (ret)
 296                         return ret;
 297         }
 298
 299         return 0;
 300 }
 301
 302 /*******************************************************************/
 303 /*  Tests                                                          */
 304 /*******************************************************************/
 305
 306 struct mmc_test_case {
 307         const char *name;
 308
 309         int (*prepare)(struct mmc_test_card *);
 310         int (*run)(struct mmc_test_card *);
 311         int (*cleanup)(struct mmc_test_card *);
 312 };
 313
 314 static int mmc_test_basic_write(struct mmc_test_card *test)
 315 {
 316         int ret;
 317
 318         ret = mmc_test_set_blksize(test, 512);
 319         if (ret)
 320                 return ret;
 321
 322         ret = mmc_test_transfer(test, 1, test->buffer, 0, 1, 512);
 323         if (ret)
 324                 return ret;
 325
 326         return 0;
 327 }
 328
 329 static int mmc_test_basic_read(struct mmc_test_card *test)
 330 {
 331         int ret;
 332
 333         ret = mmc_test_set_blksize(test, 512);
 334         if (ret)
 335                 return ret;
 336
 337         ret = mmc_test_transfer(test, 0, test->buffer, 0, 1, 512);
 338         if (ret)
 339                 return ret;
 340
 341         return 0;
 342 }
 343
 344 static int mmc_test_verify_write(struct mmc_test_card *test)
 345 {
 346         int ret;
 347
 348         ret = mmc_test_verified_transfer(test, 1, test->buffer, 0, 1, 512);
 349         if (ret)
 350                 return ret;
 351
 352         return 0;
 353 }
 354
 355 static int mmc_test_verify_read(struct mmc_test_card *test)
 356 {
 357         int ret;
 358
 359         ret = mmc_test_verified_transfer(test, 0, test->buffer, 0, 1, 512);
 360         if (ret)
 361                 return ret;
 362
 363         return 0;
 364 }
 365
 366 static int mmc_test_multi_write(struct mmc_test_card *test)
 367 {
 368         int ret;
 369         unsigned int size;
 370
 371         if (test->card->host->max_blk_count == 1)
 372                 return RESULT_UNSUP_HOST;
 373
 374         size = PAGE_SIZE * 2;
 375         size = min(size, test->card->host->max_req_size);
 376         size = min(size, test->card->host->max_seg_size);
 377         size = min(size, test->card->host->max_blk_count * 512);
 378
 379         if (size < 1024)
 380                 return RESULT_UNSUP_HOST;
 381
 382         ret = mmc_test_verified_transfer(test, 1, test->buffer, 0,
 383                 size / 512, 512);
 384         if (ret)
 385                 return ret;
 386
 387         return 0;
 388 }
 389
 390 static int mmc_test_multi_read(struct mmc_test_card *test)
 391 {
 392         int ret;
 393         unsigned int size;
 394
 395         if (test->card->host->max_blk_count == 1)
 396                 return RESULT_UNSUP_HOST;
 397
 398         size = PAGE_SIZE * 2;
 399         size = min(size, test->card->host->max_req_size);
 400         size = min(size, test->card->host->max_seg_size);
 401         size = min(size, test->card->host->max_blk_count * 512);
 402
 403         if (size < 1024)
 404                 return RESULT_UNSUP_HOST;
 405
 406         ret = mmc_test_verified_transfer(test, 0, test->buffer, 0,
 407                 size / 512, 512);
 408         if (ret)
 409                 return ret;
 410
 411         return 0;
 412 }
 413
 414 static int mmc_test_pow2_write(struct mmc_test_card *test)
 415 {
 416         int ret, i;
 417
 418         if (!test->card->csd.write_partial)
 419                 return RESULT_UNSUP_CARD;
 420
 421         for (i = 1; i < 512;i <<= 1) {
 422                 ret = mmc_test_verified_transfer(test, 1,
 423                         test->buffer, 0, 1, i);
 424                 if (ret)
 425                         return ret;
 426         }
 427
 428         return 0;
 429 }
 430
 431 static int mmc_test_pow2_read(struct mmc_test_card *test)
 432 {
 433         int ret, i;
 434
 435         if (!test->card->csd.read_partial)
 436                 return RESULT_UNSUP_CARD;
 437
 438         for (i = 1; i < 512;i <<= 1) {
 439                 ret = mmc_test_verified_transfer(test, 0,
 440                         test->buffer, 0, 1, i);
 441                 if (ret)
 442                         return ret;
 443         }
 444
 445         return 0;
 446 }
 447
 448 static int mmc_test_weird_write(struct mmc_test_card *test)
 449 {
 450         int ret, i;
 451
 452         if (!test->card->csd.write_partial)
 453                 return RESULT_UNSUP_CARD;
 454
 455         for (i = 3; i < 512;i += 7) {
 456                 ret = mmc_test_verified_transfer(test, 1,
 457                         test->buffer, 0, 1, i);
 458                 if (ret)
 459                         return ret;
 460         }
 461
 462         return 0;
 463 }
 464
 465 static int mmc_test_weird_read(struct mmc_test_card *test)
 466 {
 467         int ret, i;
 468
 469         if (!test->card->csd.read_partial)
 470                 return RESULT_UNSUP_CARD;
 471
 472         for (i = 3; i < 512;i += 7) {
 473                 ret = mmc_test_verified_transfer(test, 0,
 474                         test->buffer, 0, 1, i);
 475                 if (ret)
 476                         return ret;
 477         }
 478
 479         return 0;
 480 }
 481
 482 static int mmc_test_align_write(struct mmc_test_card *test)
 483 {
 484         int ret, i;
 485
 486         for (i = 1;i < 4;i++) {
 487                 ret = mmc_test_verified_transfer(test, 1, test->buffer + i,
 488                         0, 1, 512);
 489                 if (ret)
 490                         return ret;
 491         }
 492
 493         return 0;
 494 }
 495
 496 static int mmc_test_align_read(struct mmc_test_card *test)
 497 {
 498         int ret, i;
 499
 500         for (i = 1;i < 4;i++) {
 501                 ret = mmc_test_verified_transfer(test, 0, test->buffer + i,
 502                         0, 1, 512);
 503                 if (ret)
 504                         return ret;
 505         }
 506
 507         return 0;
 508 }
 509
 510 static int mmc_test_align_multi_write(struct mmc_test_card *test)
 511 {
 512         int ret, i;
 513         unsigned int size;
 514
 515         if (test->card->host->max_blk_count == 1)
 516                 return RESULT_UNSUP_HOST;
 517
 518         size = PAGE_SIZE * 2;
 519         size = min(size, test->card->host->max_req_size);
 520         size = min(size, test->card->host->max_seg_size);
 521         size = min(size, test->card->host->max_blk_count * 512);
 522
 523         if (size < 1024)
 524                 return RESULT_UNSUP_HOST;
 525
 526         for (i = 1;i < 4;i++) {
 527                 ret = mmc_test_verified_transfer(test, 1, test->buffer + i,
 528                         0, size / 512, 512);
 529                 if (ret)
 530                         return ret;
 531         }
 532
 533         return 0;
 534 }
 535
 536 static int mmc_test_align_multi_read(struct mmc_test_card *test)
 537 {
 538         int ret, i;
 539         unsigned int size;
 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         for (i = 1;i < 4;i++) {
 553                 ret = mmc_test_verified_transfer(test, 0, test->buffer + i,
 554                         0, size / 512, 512);
 555                 if (ret)
 556                         return ret;
 557         }
 558
 559         return 0;
 560 }
 561
 562 static int mmc_test_xfersize_write(struct mmc_test_card *test)
 563 {
 564         int ret;
 565
 566         ret = mmc_test_set_blksize(test, 512);
 567         if (ret)
 568                 return ret;
 569
 570         ret = __mmc_test_transfer(test, 1, 1, test->buffer, 0, 1, 512);
 571         if (ret)
 572                 return ret;
 573
 574         return 0;
 575 }
 576
 577 static int mmc_test_xfersize_read(struct mmc_test_card *test)
 578 {
 579         int ret;
 580
 581         ret = mmc_test_set_blksize(test, 512);
 582         if (ret)
 583                 return ret;
 584
 585         ret = __mmc_test_transfer(test, 0, 1, test->buffer, 0, 1, 512);
 586         if (ret)
 587                 return ret;
 588
 589         return 0;
 590 }
 591
 592 static int mmc_test_multi_xfersize_write(struct mmc_test_card *test)
 593 {
 594         int ret;
 595
 596         if (test->card->host->max_blk_count == 1)
 597                 return RESULT_UNSUP_HOST;
 598
 599         ret = mmc_test_set_blksize(test, 512);
 600         if (ret)
 601                 return ret;
 602
 603         ret = __mmc_test_transfer(test, 1, 1, test->buffer, 0, 2, 512);
 604         if (ret)
 605                 return ret;
 606
 607         return 0;
 608 }
 609
 610 static int mmc_test_multi_xfersize_read(struct mmc_test_card *test)
 611 {
 612         int ret;
 613
 614         if (test->card->host->max_blk_count == 1)
 615                 return RESULT_UNSUP_HOST;
 616
 617         ret = mmc_test_set_blksize(test, 512);
 618         if (ret)
 619                 return ret;
 620
 621         ret = __mmc_test_transfer(test, 0, 1, test->buffer, 0, 2, 512);
 622         if (ret)
 623                 return ret;
 624
 625         return 0;
 626 }
 627
 628 static const struct mmc_test_case mmc_test_cases[] = {
 629         {
 630                 .name = "Basic write (no data verification)",
 631                 .run = mmc_test_basic_write,
 632         },
 633
 634         {
 635                 .name = "Basic read (no data verification)",
 636                 .run = mmc_test_basic_read,
 637         },
 638
 639         {
 640                 .name = "Basic write (with data verification)",
 641                 .prepare = mmc_test_prepare_verify_write,
 642                 .run = mmc_test_verify_write,
 643                 .cleanup = mmc_test_cleanup_verify,
 644         },
 645
 646         {
 647                 .name = "Basic read (with data verification)",
 648                 .prepare = mmc_test_prepare_verify_read,
 649                 .run = mmc_test_verify_read,
 650                 .cleanup = mmc_test_cleanup_verify,
 651         },
 652
 653         {
 654                 .name = "Multi-block write",
 655                 .prepare = mmc_test_prepare_verify_write,
 656                 .run = mmc_test_multi_write,
 657                 .cleanup = mmc_test_cleanup_verify,
 658         },
 659
 660         {
 661                 .name = "Multi-block read",
 662                 .prepare = mmc_test_prepare_verify_read,
 663                 .run = mmc_test_multi_read,
 664                 .cleanup = mmc_test_cleanup_verify,
 665         },
 666
 667         {
 668                 .name = "Power of two block writes",
 669                 .prepare = mmc_test_prepare_verify_write,
 670                 .run = mmc_test_pow2_write,
 671                 .cleanup = mmc_test_cleanup_verify,
 672         },
 673
 674         {
 675                 .name = "Power of two block reads",
 676                 .prepare = mmc_test_prepare_verify_read,
 677                 .run = mmc_test_pow2_read,
 678                 .cleanup = mmc_test_cleanup_verify,
 679         },
 680
 681         {
 682                 .name = "Weird sized block writes",
 683                 .prepare = mmc_test_prepare_verify_write,
 684                 .run = mmc_test_weird_write,
 685                 .cleanup = mmc_test_cleanup_verify,
 686         },
 687
 688         {
 689                 .name = "Weird sized block reads",
 690                 .prepare = mmc_test_prepare_verify_read,
 691                 .run = mmc_test_weird_read,
 692                 .cleanup = mmc_test_cleanup_verify,
 693         },
 694
 695         {
 696                 .name = "Badly aligned write",
 697                 .prepare = mmc_test_prepare_verify_write,
 698                 .run = mmc_test_align_write,
 699                 .cleanup = mmc_test_cleanup_verify,
 700         },
 701
 702         {
 703                 .name = "Badly aligned read",
 704                 .prepare = mmc_test_prepare_verify_read,
 705                 .run = mmc_test_align_read,
 706                 .cleanup = mmc_test_cleanup_verify,
 707         },
 708
 709         {
 710                 .name = "Badly aligned multi-block write",
 711                 .prepare = mmc_test_prepare_verify_write,
 712                 .run = mmc_test_align_multi_write,
 713                 .cleanup = mmc_test_cleanup_verify,
 714         },
 715
 716         {
 717                 .name = "Badly aligned multi-block read",
 718                 .prepare = mmc_test_prepare_verify_read,
 719                 .run = mmc_test_align_multi_read,
 720                 .cleanup = mmc_test_cleanup_verify,
 721         },
 722
 723         {
 724                 .name = "Correct xfer_size at write (start failure)",
 725                 .run = mmc_test_xfersize_write,
 726         },
 727
 728         {
 729                 .name = "Correct xfer_size at read (start failure)",
 730                 .run = mmc_test_xfersize_read,
 731         },
 732
 733         {
 734                 .name = "Correct xfer_size at write (midway failure)",
 735                 .run = mmc_test_multi_xfersize_write,
 736         },
 737
 738         {
 739                 .name = "Correct xfer_size at read (midway failure)",
 740                 .run = mmc_test_multi_xfersize_read,
 741         },
 742 };
 743
 744 static struct mutex mmc_test_lock;
 745
 746 static void mmc_test_run(struct mmc_test_card *test)
 747 {
 748         int i, ret;
 749
 750         printk(KERN_INFO "%s: Starting tests of card %s...\n",
 751                 mmc_hostname(test->card->host), mmc_card_id(test->card));
 752
 753         mmc_claim_host(test->card->host);
 754
 755         for (i = 0;i < ARRAY_SIZE(mmc_test_cases);i++) {
 756                 printk(KERN_INFO "%s: Test case %d. %s...\n",
 757                         mmc_hostname(test->card->host), i + 1,
 758                         mmc_test_cases[i].name);
 759
 760                 if (mmc_test_cases[i].prepare) {
 761                         ret = mmc_test_cases[i].prepare(test);
 762                         if (ret) {
 763                                 printk(KERN_INFO "%s: Result: Prepare "
 764                                         "stage failed! (%d)\n",
 765                                         mmc_hostname(test->card->host),
 766                                         ret);
 767                                 continue;
 768                         }
 769                 }
 770
 771                 ret = mmc_test_cases[i].run(test);
 772                 switch (ret) {
 773                 case RESULT_OK:
 774                         printk(KERN_INFO "%s: Result: OK\n",
 775                                 mmc_hostname(test->card->host));
 776                         break;
 777                 case RESULT_FAIL:
 778                         printk(KERN_INFO "%s: Result: FAILED\n",
 779                                 mmc_hostname(test->card->host));
 780                         break;
 781                 case RESULT_UNSUP_HOST:
 782                         printk(KERN_INFO "%s: Result: UNSUPPORTED "
 783                                 "(by host)\n",
 784                                 mmc_hostname(test->card->host));
 785                         break;
 786                 case RESULT_UNSUP_CARD:
 787                         printk(KERN_INFO "%s: Result: UNSUPPORTED "
 788                                 "(by card)\n",
 789                                 mmc_hostname(test->card->host));
 790                         break;
 791                 default:
 792                         printk(KERN_INFO "%s: Result: ERROR (%d)\n",
 793                                 mmc_hostname(test->card->host), ret);
 794                 }
 795
 796                 if (mmc_test_cases[i].cleanup) {
 797                         ret = mmc_test_cases[i].cleanup(test);
 798                         if (ret) {
 799                                 printk(KERN_INFO "%s: Warning: Cleanup "
 800                                         "stage failed! (%d)\n",
 801                                         mmc_hostname(test->card->host),
 802                                         ret);
 803                         }
 804                 }
 805         }
 806
 807         mmc_release_host(test->card->host);
 808
 809         printk(KERN_INFO "%s: Tests completed.\n",
 810                 mmc_hostname(test->card->host));
 811 }
 812
 813 static ssize_t mmc_test_show(struct device *dev,
 814         struct device_attribute *attr, char *buf)
 815 {
 816         mutex_lock(&mmc_test_lock);
 817         mutex_unlock(&mmc_test_lock);
 818
 819         return 0;
 820 }
 821
 822 static ssize_t mmc_test_store(struct device *dev,
 823         struct device_attribute *attr, const char *buf, size_t count)
 824 {
 825         struct mmc_card *card;
 826         struct mmc_test_card *test;
 827
 828         card = container_of(dev, struct mmc_card, dev);
 829
 830         test = kzalloc(sizeof(struct mmc_test_card), GFP_KERNEL);
 831         if (!test)
 832                 return -ENOMEM;
 833
 834         test->card = card;
 835
 836         test->buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
 837         if (test->buffer) {
 838                 mutex_lock(&mmc_test_lock);
 839                 mmc_test_run(test);
 840                 mutex_unlock(&mmc_test_lock);
 841         }
 842
 843         kfree(test->buffer);
 844         kfree(test);
 845
 846         return count;
 847 }
 848
 849 static DEVICE_ATTR(test, S_IWUSR | S_IRUGO, mmc_test_show, mmc_test_store);
 850
 851 static int mmc_test_probe(struct mmc_card *card)
 852 {
 853         int ret;
 854
 855         mutex_init(&mmc_test_lock);
 856
 857         ret = device_create_file(&card->dev, &dev_attr_test);
 858         if (ret)
 859                 return ret;
 860
 861         return 0;
 862 }
 863
 864 static void mmc_test_remove(struct mmc_card *card)
 865 {
 866         device_remove_file(&card->dev, &dev_attr_test);
 867 }
 868
 869 static struct mmc_driver mmc_driver = {
 870         .drv            = {
 871                 .name   = "mmc_test",
 872         },
 873         .probe          = mmc_test_probe,
 874         .remove         = mmc_test_remove,
 875 };
 876
 877 static int __init mmc_test_init(void)
 878 {
 879         return mmc_register_driver(&mmc_driver);
 880 }
 881
 882 static void __exit mmc_test_exit(void)
 883 {
 884         mmc_unregister_driver(&mmc_driver);
 885 }
 886
 887 module_init(mmc_test_init);
 888 module_exit(mmc_test_exit);
 889
 890 MODULE_LICENSE("GPL");
 891 MODULE_DESCRIPTION("Multimedia Card (MMC) host test driver");
 892 MODULE_AUTHOR("Pierre Ossman");