drivers/mmc/wbsd.c

   1 /*
   2  *  linux/drivers/mmc/wbsd.c - Winbond W83L51xD SD/MMC driver
   3  *
   4  *  Copyright (C) 2004-2005 Pierre Ossman, All Rights Reserved.
   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 version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  *
  11  * Warning!
  12  *
  13  * Changes to the FIFO system should be done with extreme care since
  14  * the hardware is full of bugs related to the FIFO. Known issues are:
  15  *
  16  * - FIFO size field in FSR is always zero.
  17  *
  18  * - FIFO interrupts tend not to work as they should. Interrupts are
  19  *   triggered only for full/empty events, not for threshold values.
  20  *
  21  * - On APIC systems the FIFO empty interrupt is sometimes lost.
  22  */
  23
  24 #include <linux/config.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/init.h>
  28 #include <linux/ioport.h>
  29 #include <linux/device.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/delay.h>
  32 #include <linux/highmem.h>
  33 #include <linux/mmc/host.h>
  34 #include <linux/mmc/protocol.h>
  35
  36 #include <asm/io.h>
  37 #include <asm/dma.h>
  38 #include <asm/scatterlist.h>
  39
  40 #include "wbsd.h"
  41
  42 #define DRIVER_NAME "wbsd"
  43 #define DRIVER_VERSION "1.1"
  44
  45 #ifdef CONFIG_MMC_DEBUG
  46 #define DBG(x...) \
  47         printk(KERN_DEBUG DRIVER_NAME ": " x)
  48 #define DBGF(f, x...) \
  49         printk(KERN_DEBUG DRIVER_NAME " [%s()]: " f, __func__ , ##x)
  50 #else
  51 #define DBG(x...)       do { } while (0)
  52 #define DBGF(x...)      do { } while (0)
  53 #endif
  54
  55 static unsigned int io = 0x248;
  56 static unsigned int irq = 6;
  57 static int dma = 2;
  58
  59 #ifdef CONFIG_MMC_DEBUG
  60 void DBG_REG(int reg, u8 value)
  61 {
  62         int i;
  63
  64         printk(KERN_DEBUG "wbsd: Register %d: 0x%02X %3d '%c' ",
  65                 reg, (int)value, (int)value, (value < 0x20)?'.':value);
  66
  67         for (i = 7;i >= 0;i--)
  68         {
  69                 if (value & (1 << i))
  70                         printk("x");
  71                 else
  72                         printk(".");
  73         }
  74
  75         printk("\n");
  76 }
  77 #else
  78 #define DBG_REG(r, v) do {}  while (0)
  79 #endif
  80
  81 /*
  82  * Basic functions
  83  */
  84
  85 static inline void wbsd_unlock_config(struct wbsd_host* host)
  86 {
  87         outb(host->unlock_code, host->config);
  88         outb(host->unlock_code, host->config);
  89 }
  90
  91 static inline void wbsd_lock_config(struct wbsd_host* host)
  92 {
  93         outb(LOCK_CODE, host->config);
  94 }
  95
  96 static inline void wbsd_write_config(struct wbsd_host* host, u8 reg, u8 value)
  97 {
  98         outb(reg, host->config);
  99         outb(value, host->config + 1);
 100 }
 101
 102 static inline u8 wbsd_read_config(struct wbsd_host* host, u8 reg)
 103 {
 104         outb(reg, host->config);
 105         return inb(host->config + 1);
 106 }
 107
 108 static inline void wbsd_write_index(struct wbsd_host* host, u8 index, u8 value)
 109 {
 110         outb(index, host->base + WBSD_IDXR);
 111         outb(value, host->base + WBSD_DATAR);
 112 }
 113
 114 static inline u8 wbsd_read_index(struct wbsd_host* host, u8 index)
 115 {
 116         outb(index, host->base + WBSD_IDXR);
 117         return inb(host->base + WBSD_DATAR);
 118 }
 119
 120 /*
 121  * Common routines
 122  */
 123
 124 static void wbsd_init_device(struct wbsd_host* host)
 125 {
 126         u8 setup, ier;
 127
 128         /*
 129          * Reset chip (SD/MMC part) and fifo.
 130          */
 131         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 132         setup |= WBSD_FIFO_RESET | WBSD_SOFT_RESET;
 133         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 134
 135         /*
 136          * Read back default clock.
 137          */
 138         host->clk = wbsd_read_index(host, WBSD_IDX_CLK);
 139
 140         /*
 141          * Power down port.
 142          */
 143         outb(WBSD_POWER_N, host->base + WBSD_CSR);
 144
 145         /*
 146          * Set maximum timeout.
 147          */
 148         wbsd_write_index(host, WBSD_IDX_TAAC, 0x7F);
 149
 150         /*
 151          * Enable interesting interrupts.
 152          */
 153         ier = 0;
 154         ier |= WBSD_EINT_CARD;
 155         ier |= WBSD_EINT_FIFO_THRE;
 156         ier |= WBSD_EINT_CCRC;
 157         ier |= WBSD_EINT_TIMEOUT;
 158         ier |= WBSD_EINT_CRC;
 159         ier |= WBSD_EINT_TC;
 160
 161         outb(ier, host->base + WBSD_EIR);
 162
 163         /*
 164          * Clear interrupts.
 165          */
 166         inb(host->base + WBSD_ISR);
 167 }
 168
 169 static void wbsd_reset(struct wbsd_host* host)
 170 {
 171         u8 setup;
 172
 173         printk(KERN_ERR DRIVER_NAME ": Resetting chip\n");
 174
 175         /*
 176          * Soft reset of chip (SD/MMC part).
 177          */
 178         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 179         setup |= WBSD_SOFT_RESET;
 180         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 181 }
 182
 183 static void wbsd_request_end(struct wbsd_host* host, struct mmc_request* mrq)
 184 {
 185         unsigned long dmaflags;
 186
 187         DBGF("Ending request, cmd (%x)\n", mrq->cmd->opcode);
 188
 189         if (host->dma >= 0)
 190         {
 191                 /*
 192                  * Release ISA DMA controller.
 193                  */
 194                 dmaflags = claim_dma_lock();
 195                 disable_dma(host->dma);
 196                 clear_dma_ff(host->dma);
 197                 release_dma_lock(dmaflags);
 198
 199                 /*
 200                  * Disable DMA on host.
 201                  */
 202                 wbsd_write_index(host, WBSD_IDX_DMA, 0);
 203         }
 204
 205         host->mrq = NULL;
 206
 207         /*
 208          * MMC layer might call back into the driver so first unlock.
 209          */
 210         spin_unlock(&host->lock);
 211         mmc_request_done(host->mmc, mrq);
 212         spin_lock(&host->lock);
 213 }
 214
 215 /*
 216  * Scatter/gather functions
 217  */
 218
 219 static inline void wbsd_init_sg(struct wbsd_host* host, struct mmc_data* data)
 220 {
 221         /*
 222          * Get info. about SG list from data structure.
 223          */
 224         host->cur_sg = data->sg;
 225         host->num_sg = data->sg_len;
 226
 227         host->offset = 0;
 228         host->remain = host->cur_sg->length;
 229 }
 230
 231 static inline int wbsd_next_sg(struct wbsd_host* host)
 232 {
 233         /*
 234          * Skip to next SG entry.
 235          */
 236         host->cur_sg++;
 237         host->num_sg--;
 238
 239         /*
 240          * Any entries left?
 241          */
 242         if (host->num_sg > 0)
 243           {
 244             host->offset = 0;
 245             host->remain = host->cur_sg->length;
 246           }
 247
 248         return host->num_sg;
 249 }
 250
 251 static inline char* wbsd_kmap_sg(struct wbsd_host* host)
 252 {
 253         host->mapped_sg = kmap_atomic(host->cur_sg->page, KM_BIO_SRC_IRQ) +
 254                 host->cur_sg->offset;
 255         return host->mapped_sg;
 256 }
 257
 258 static inline void wbsd_kunmap_sg(struct wbsd_host* host)
 259 {
 260         kunmap_atomic(host->mapped_sg, KM_BIO_SRC_IRQ);
 261 }
 262
 263 static inline void wbsd_sg_to_dma(struct wbsd_host* host, struct mmc_data* data)
 264 {
 265         unsigned int len, i, size;
 266         struct scatterlist* sg;
 267         char* dmabuf = host->dma_buffer;
 268         char* sgbuf;
 269
 270         size = host->size;
 271
 272         sg = data->sg;
 273         len = data->sg_len;
 274
 275         /*
 276          * Just loop through all entries. Size might not
 277          * be the entire list though so make sure that
 278          * we do not transfer too much.
 279          */
 280         for (i = 0;i < len;i++)
 281         {
 282                 sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
 283                 if (size < sg[i].length)
 284                         memcpy(dmabuf, sgbuf, size);
 285                 else
 286                         memcpy(dmabuf, sgbuf, sg[i].length);
 287                 kunmap_atomic(sgbuf, KM_BIO_SRC_IRQ);
 288                 dmabuf += sg[i].length;
 289
 290                 if (size < sg[i].length)
 291                         size = 0;
 292                 else
 293                         size -= sg[i].length;
 294
 295                 if (size == 0)
 296                         break;
 297         }
 298
 299         /*
 300          * Check that we didn't get a request to transfer
 301          * more data than can fit into the SG list.
 302          */
 303
 304         BUG_ON(size != 0);
 305
 306         host->size -= size;
 307 }
 308
 309 static inline void wbsd_dma_to_sg(struct wbsd_host* host, struct mmc_data* data)
 310 {
 311         unsigned int len, i, size;
 312         struct scatterlist* sg;
 313         char* dmabuf = host->dma_buffer;
 314         char* sgbuf;
 315
 316         size = host->size;
 317
 318         sg = data->sg;
 319         len = data->sg_len;
 320
 321         /*
 322          * Just loop through all entries. Size might not
 323          * be the entire list though so make sure that
 324          * we do not transfer too much.
 325          */
 326         for (i = 0;i < len;i++)
 327         {
 328                 sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
 329                 if (size < sg[i].length)
 330                         memcpy(sgbuf, dmabuf, size);
 331                 else
 332                         memcpy(sgbuf, dmabuf, sg[i].length);
 333                 kunmap_atomic(sgbuf, KM_BIO_SRC_IRQ);
 334                 dmabuf += sg[i].length;
 335
 336                 if (size < sg[i].length)
 337                         size = 0;
 338                 else
 339                         size -= sg[i].length;
 340
 341                 if (size == 0)
 342                         break;
 343         }
 344
 345         /*
 346          * Check that we didn't get a request to transfer
 347          * more data than can fit into the SG list.
 348          */
 349
 350         BUG_ON(size != 0);
 351
 352         host->size -= size;
 353 }
 354
 355 /*
 356  * Command handling
 357  */
 358
 359 static inline void wbsd_get_short_reply(struct wbsd_host* host,
 360         struct mmc_command* cmd)
 361 {
 362         /*
 363          * Correct response type?
 364          */
 365         if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT)
 366         {
 367                 cmd->error = MMC_ERR_INVALID;
 368                 return;
 369         }
 370
 371         cmd->resp[0] =
 372                 wbsd_read_index(host, WBSD_IDX_RESP12) << 24;
 373         cmd->resp[0] |=
 374                 wbsd_read_index(host, WBSD_IDX_RESP13) << 16;
 375         cmd->resp[0] |=
 376                 wbsd_read_index(host, WBSD_IDX_RESP14) << 8;
 377         cmd->resp[0] |=
 378                 wbsd_read_index(host, WBSD_IDX_RESP15) << 0;
 379         cmd->resp[1] =
 380                 wbsd_read_index(host, WBSD_IDX_RESP16) << 24;
 381 }
 382
 383 static inline void wbsd_get_long_reply(struct wbsd_host* host,
 384         struct mmc_command* cmd)
 385 {
 386         int i;
 387
 388         /*
 389          * Correct response type?
 390          */
 391         if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG)
 392         {
 393                 cmd->error = MMC_ERR_INVALID;
 394                 return;
 395         }
 396
 397         for (i = 0;i < 4;i++)
 398         {
 399                 cmd->resp[i] =
 400                         wbsd_read_index(host, WBSD_IDX_RESP1 + i * 4) << 24;
 401                 cmd->resp[i] |=
 402                         wbsd_read_index(host, WBSD_IDX_RESP2 + i * 4) << 16;
 403                 cmd->resp[i] |=
 404                         wbsd_read_index(host, WBSD_IDX_RESP3 + i * 4) << 8;
 405                 cmd->resp[i] |=
 406                         wbsd_read_index(host, WBSD_IDX_RESP4 + i * 4) << 0;
 407         }
 408 }
 409
 410 static irqreturn_t wbsd_irq(int irq, void *dev_id, struct pt_regs *regs);
 411
 412 static void wbsd_send_command(struct wbsd_host* host, struct mmc_command* cmd)
 413 {
 414         int i;
 415         u8 status, isr;
 416
 417         DBGF("Sending cmd (%x)\n", cmd->opcode);
 418
 419         /*
 420          * Clear accumulated ISR. The interrupt routine
 421          * will fill this one with events that occur during
 422          * transfer.
 423          */
 424         host->isr = 0;
 425
 426         /*
 427          * Send the command (CRC calculated by host).
 428          */
 429         outb(cmd->opcode, host->base + WBSD_CMDR);
 430         for (i = 3;i >= 0;i--)
 431                 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR);
 432
 433         cmd->error = MMC_ERR_NONE;
 434
 435         /*
 436          * Wait for the request to complete.
 437          */
 438         do {
 439                 status = wbsd_read_index(host, WBSD_IDX_STATUS);
 440         } while (status & WBSD_CARDTRAFFIC);
 441
 442         /*
 443          * Do we expect a reply?
 444          */
 445         if ((cmd->flags & MMC_RSP_MASK) != MMC_RSP_NONE)
 446         {
 447                 /*
 448                  * Read back status.
 449                  */
 450                 isr = host->isr;
 451
 452                 /* Card removed? */
 453                 if (isr & WBSD_INT_CARD)
 454                         cmd->error = MMC_ERR_TIMEOUT;
 455                 /* Timeout? */
 456                 else if (isr & WBSD_INT_TIMEOUT)
 457                         cmd->error = MMC_ERR_TIMEOUT;
 458                 /* CRC? */
 459                 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
 460                         cmd->error = MMC_ERR_BADCRC;
 461                 /* All ok */
 462                 else
 463                 {
 464                         if ((cmd->flags & MMC_RSP_MASK) == MMC_RSP_SHORT)
 465                                 wbsd_get_short_reply(host, cmd);
 466                         else
 467                                 wbsd_get_long_reply(host, cmd);
 468                 }
 469         }
 470
 471         DBGF("Sent cmd (%x), res %d\n", cmd->opcode, cmd->error);
 472 }
 473
 474 /*
 475  * Data functions
 476  */
 477
 478 static void wbsd_empty_fifo(struct wbsd_host* host)
 479 {
 480         struct mmc_data* data = host->mrq->cmd->data;
 481         char* buffer;
 482         int i, fsr, fifo;
 483
 484         /*
 485          * Handle excessive data.
 486          */
 487         if (data->bytes_xfered == host->size)
 488                 return;
 489
 490         buffer = wbsd_kmap_sg(host) + host->offset;
 491
 492         /*
 493          * Drain the fifo. This has a tendency to loop longer
 494          * than the FIFO length (usually one block).
 495          */
 496         while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_EMPTY))
 497         {
 498                 /*
 499                  * The size field in the FSR is broken so we have to
 500                  * do some guessing.
 501                  */
 502                 if (fsr & WBSD_FIFO_FULL)
 503                         fifo = 16;
 504                 else if (fsr & WBSD_FIFO_FUTHRE)
 505                         fifo = 8;
 506                 else
 507                         fifo = 1;
 508
 509                 for (i = 0;i < fifo;i++)
 510                 {
 511                         *buffer = inb(host->base + WBSD_DFR);
 512                         buffer++;
 513                         host->offset++;
 514                         host->remain--;
 515
 516                         data->bytes_xfered++;
 517
 518                         /*
 519                          * Transfer done?
 520                          */
 521                         if (data->bytes_xfered == host->size)
 522                         {
 523                                 wbsd_kunmap_sg(host);
 524                                 return;
 525                         }
 526
 527                         /*
 528                          * End of scatter list entry?
 529                          */
 530                         if (host->remain == 0)
 531                         {
 532                                 wbsd_kunmap_sg(host);
 533
 534                                 /*
 535                                  * Get next entry. Check if last.
 536                                  */
 537                                 if (!wbsd_next_sg(host))
 538                                 {
 539                                         /*
 540                                          * We should never reach this point.
 541                                          * It means that we're trying to
 542                                          * transfer more blocks than can fit
 543                                          * into the scatter list.
 544                                          */
 545                                         BUG_ON(1);
 546
 547                                         host->size = data->bytes_xfered;
 548
 549                                         return;
 550                                 }
 551
 552                                 buffer = wbsd_kmap_sg(host);
 553                         }
 554                 }
 555         }
 556
 557         wbsd_kunmap_sg(host);
 558
 559         /*
 560          * This is a very dirty hack to solve a
 561          * hardware problem. The chip doesn't trigger
 562          * FIFO threshold interrupts properly.
 563          */
 564         if ((host->size - data->bytes_xfered) < 16)
 565                 tasklet_schedule(&host->fifo_tasklet);
 566 }
 567
 568 static void wbsd_fill_fifo(struct wbsd_host* host)
 569 {
 570         struct mmc_data* data = host->mrq->cmd->data;
 571         char* buffer;
 572         int i, fsr, fifo;
 573
 574         /*
 575          * Check that we aren't being called after the
 576          * entire buffer has been transfered.
 577          */
 578         if (data->bytes_xfered == host->size)
 579                 return;
 580
 581         buffer = wbsd_kmap_sg(host) + host->offset;
 582
 583         /*
 584          * Fill the fifo. This has a tendency to loop longer
 585          * than the FIFO length (usually one block).
 586          */
 587         while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_FULL))
 588         {
 589                 /*
 590                  * The size field in the FSR is broken so we have to
 591                  * do some guessing.
 592                  */
 593                 if (fsr & WBSD_FIFO_EMPTY)
 594                         fifo = 0;
 595                 else if (fsr & WBSD_FIFO_EMTHRE)
 596                         fifo = 8;
 597                 else
 598                         fifo = 15;
 599
 600                 for (i = 16;i > fifo;i--)
 601                 {
 602                         outb(*buffer, host->base + WBSD_DFR);
 603                         buffer++;
 604                         host->offset++;
 605                         host->remain--;
 606
 607                         data->bytes_xfered++;
 608
 609                         /*
 610                          * Transfer done?
 611                          */
 612                         if (data->bytes_xfered == host->size)
 613                         {
 614                                 wbsd_kunmap_sg(host);
 615                                 return;
 616                         }
 617
 618                         /*
 619                          * End of scatter list entry?
 620                          */
 621                         if (host->remain == 0)
 622                         {
 623                                 wbsd_kunmap_sg(host);
 624
 625                                 /*
 626                                  * Get next entry. Check if last.
 627                                  */
 628                                 if (!wbsd_next_sg(host))
 629                                 {
 630                                         /*
 631                                          * We should never reach this point.
 632                                          * It means that we're trying to
 633                                          * transfer more blocks than can fit
 634                                          * into the scatter list.
 635                                          */
 636                                         BUG_ON(1);
 637
 638                                         host->size = data->bytes_xfered;
 639
 640                                         return;
 641                                 }
 642
 643                                 buffer = wbsd_kmap_sg(host);
 644                         }
 645                 }
 646         }
 647
 648         wbsd_kunmap_sg(host);
 649 }
 650
 651 static void wbsd_prepare_data(struct wbsd_host* host, struct mmc_data* data)
 652 {
 653         u16 blksize;
 654         u8 setup;
 655         unsigned long dmaflags;
 656
 657         DBGF("blksz %04x blks %04x flags %08x\n",
 658                 1 << data->blksz_bits, data->blocks, data->flags);
 659         DBGF("tsac %d ms nsac %d clk\n",
 660                 data->timeout_ns / 1000000, data->timeout_clks);
 661
 662         /*
 663          * Calculate size.
 664          */
 665         host->size = data->blocks << data->blksz_bits;
 666
 667         /*
 668          * Check timeout values for overflow.
 669          * (Yes, some cards cause this value to overflow).
 670          */
 671         if (data->timeout_ns > 127000000)
 672                 wbsd_write_index(host, WBSD_IDX_TAAC, 127);
 673         else
 674                 wbsd_write_index(host, WBSD_IDX_TAAC, data->timeout_ns/1000000);
 675
 676         if (data->timeout_clks > 255)
 677                 wbsd_write_index(host, WBSD_IDX_NSAC, 255);
 678         else
 679                 wbsd_write_index(host, WBSD_IDX_NSAC, data->timeout_clks);
 680
 681         /*
 682          * Inform the chip of how large blocks will be
 683          * sent. It needs this to determine when to
 684          * calculate CRC.
 685          *
 686          * Space for CRC must be included in the size.
 687          */
 688         blksize = (1 << data->blksz_bits) + 2;
 689
 690         wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
 691         wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
 692
 693         /*
 694          * Clear the FIFO. This is needed even for DMA
 695          * transfers since the chip still uses the FIFO
 696          * internally.
 697          */
 698         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 699         setup |= WBSD_FIFO_RESET;
 700         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 701
 702         /*
 703          * DMA transfer?
 704          */
 705         if (host->dma >= 0)
 706         {
 707                 /*
 708                  * The buffer for DMA is only 64 kB.
 709                  */
 710                 BUG_ON(host->size > 0x10000);
 711                 if (host->size > 0x10000)
 712                 {
 713                         data->error = MMC_ERR_INVALID;
 714                         return;
 715                 }
 716
 717                 /*
 718                  * Transfer data from the SG list to
 719                  * the DMA buffer.
 720                  */
 721                 if (data->flags & MMC_DATA_WRITE)
 722                         wbsd_sg_to_dma(host, data);
 723
 724                 /*
 725                  * Initialise the ISA DMA controller.
 726                  */
 727                 dmaflags = claim_dma_lock();
 728                 disable_dma(host->dma);
 729                 clear_dma_ff(host->dma);
 730                 if (data->flags & MMC_DATA_READ)
 731                         set_dma_mode(host->dma, DMA_MODE_READ & ~0x40);
 732                 else
 733                         set_dma_mode(host->dma, DMA_MODE_WRITE & ~0x40);
 734                 set_dma_addr(host->dma, host->dma_addr);
 735                 set_dma_count(host->dma, host->size);
 736
 737                 enable_dma(host->dma);
 738                 release_dma_lock(dmaflags);
 739
 740                 /*
 741                  * Enable DMA on the host.
 742                  */
 743                 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE);
 744         }
 745         else
 746         {
 747                 /*
 748                  * This flag is used to keep printk
 749                  * output to a minimum.
 750                  */
 751                 host->firsterr = 1;
 752
 753                 /*
 754                  * Initialise the SG list.
 755                  */
 756                 wbsd_init_sg(host, data);
 757
 758                 /*
 759                  * Turn off DMA.
 760                  */
 761                 wbsd_write_index(host, WBSD_IDX_DMA, 0);
 762
 763                 /*
 764                  * Set up FIFO threshold levels (and fill
 765                  * buffer if doing a write).
 766                  */
 767                 if (data->flags & MMC_DATA_READ)
 768                 {
 769                         wbsd_write_index(host, WBSD_IDX_FIFOEN,
 770                                 WBSD_FIFOEN_FULL | 8);
 771                 }
 772                 else
 773                 {
 774                         wbsd_write_index(host, WBSD_IDX_FIFOEN,
 775                                 WBSD_FIFOEN_EMPTY | 8);
 776                         wbsd_fill_fifo(host);
 777                 }
 778         }
 779
 780         data->error = MMC_ERR_NONE;
 781 }
 782
 783 static void wbsd_finish_data(struct wbsd_host* host, struct mmc_data* data)
 784 {
 785         unsigned long dmaflags;
 786         int count;
 787         u8 status;
 788
 789         WARN_ON(host->mrq == NULL);
 790
 791         /*
 792          * Send a stop command if needed.
 793          */
 794         if (data->stop)
 795                 wbsd_send_command(host, data->stop);
 796
 797         /*
 798          * Wait for the controller to leave data
 799          * transfer state.
 800          */
 801         do
 802         {
 803                 status = wbsd_read_index(host, WBSD_IDX_STATUS);
 804         } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE));
 805
 806         /*
 807          * DMA transfer?
 808          */
 809         if (host->dma >= 0)
 810         {
 811                 /*
 812                  * Disable DMA on the host.
 813                  */
 814                 wbsd_write_index(host, WBSD_IDX_DMA, 0);
 815
 816                 /*
 817                  * Turn of ISA DMA controller.
 818                  */
 819                 dmaflags = claim_dma_lock();
 820                 disable_dma(host->dma);
 821                 clear_dma_ff(host->dma);
 822                 count = get_dma_residue(host->dma);
 823                 release_dma_lock(dmaflags);
 824
 825                 /*
 826                  * Any leftover data?
 827                  */
 828                 if (count)
 829                 {
 830                         printk(KERN_ERR DRIVER_NAME ": Incomplete DMA "
 831                                 "transfer. %d bytes left.\n", count);
 832
 833                         data->error = MMC_ERR_FAILED;
 834                 }
 835                 else
 836                 {
 837                         /*
 838                          * Transfer data from DMA buffer to
 839                          * SG list.
 840                          */
 841                         if (data->flags & MMC_DATA_READ)
 842                                 wbsd_dma_to_sg(host, data);
 843
 844                         data->bytes_xfered = host->size;
 845                 }
 846         }
 847
 848         DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered);
 849
 850         wbsd_request_end(host, host->mrq);
 851 }
 852
 853 /*
 854  * MMC Callbacks
 855  */
 856
 857 static void wbsd_request(struct mmc_host* mmc, struct mmc_request* mrq)
 858 {
 859         struct wbsd_host* host = mmc_priv(mmc);
 860         struct mmc_command* cmd;
 861
 862         /*
 863          * Disable tasklets to avoid a deadlock.
 864          */
 865         spin_lock_bh(&host->lock);
 866
 867         BUG_ON(host->mrq != NULL);
 868
 869         cmd = mrq->cmd;
 870
 871         host->mrq = mrq;
 872
 873         /*
 874          * If there is no card in the slot then
 875          * timeout immediatly.
 876          */
 877         if (!(inb(host->base + WBSD_CSR) & WBSD_CARDPRESENT))
 878         {
 879                 cmd->error = MMC_ERR_TIMEOUT;
 880                 goto done;
 881         }
 882
 883         /*
 884          * Does the request include data?
 885          */
 886         if (cmd->data)
 887         {
 888                 wbsd_prepare_data(host, cmd->data);
 889
 890                 if (cmd->data->error != MMC_ERR_NONE)
 891                         goto done;
 892         }
 893
 894         wbsd_send_command(host, cmd);
 895
 896         /*
 897          * If this is a data transfer the request
 898          * will be finished after the data has
 899          * transfered.
 900          */
 901         if (cmd->data && (cmd->error == MMC_ERR_NONE))
 902         {
 903                 /*
 904                  * Dirty fix for hardware bug.
 905                  */
 906                 if (host->dma == -1)
 907                         tasklet_schedule(&host->fifo_tasklet);
 908
 909                 spin_unlock_bh(&host->lock);
 910
 911                 return;
 912         }
 913
 914 done:
 915         wbsd_request_end(host, mrq);
 916
 917         spin_unlock_bh(&host->lock);
 918 }
 919
 920 static void wbsd_set_ios(struct mmc_host* mmc, struct mmc_ios* ios)
 921 {
 922         struct wbsd_host* host = mmc_priv(mmc);
 923         u8 clk, setup, pwr;
 924
 925         DBGF("clock %uHz busmode %u powermode %u Vdd %u\n",
 926                 ios->clock, ios->bus_mode, ios->power_mode, ios->vdd);
 927
 928         spin_lock_bh(&host->lock);
 929
 930         /*
 931          * Reset the chip on each power off.
 932          * Should clear out any weird states.
 933          */
 934         if (ios->power_mode == MMC_POWER_OFF)
 935                 wbsd_init_device(host);
 936
 937         if (ios->clock >= 24000000)
 938                 clk = WBSD_CLK_24M;
 939         else if (ios->clock >= 16000000)
 940                 clk = WBSD_CLK_16M;
 941         else if (ios->clock >= 12000000)
 942                 clk = WBSD_CLK_12M;
 943         else
 944                 clk = WBSD_CLK_375K;
 945
 946         /*
 947          * Only write to the clock register when
 948          * there is an actual change.
 949          */
 950         if (clk != host->clk)
 951         {
 952                 wbsd_write_index(host, WBSD_IDX_CLK, clk);
 953                 host->clk = clk;
 954         }
 955
 956         if (ios->power_mode != MMC_POWER_OFF)
 957         {
 958                 /*
 959                  * Power up card.
 960                  */
 961                 pwr = inb(host->base + WBSD_CSR);
 962                 pwr &= ~WBSD_POWER_N;
 963                 outb(pwr, host->base + WBSD_CSR);
 964
 965                 /*
 966                  * This behaviour is stolen from the
 967                  * Windows driver. Don't know why, but
 968                  * it is needed.
 969                  */
 970                 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 971                 if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
 972                         setup |= WBSD_DAT3_H;
 973                 else
 974                         setup &= ~WBSD_DAT3_H;
 975                 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 976
 977                 mdelay(1);
 978         }
 979
 980         spin_unlock_bh(&host->lock);
 981 }
 982
 983 /*
 984  * Tasklets
 985  */
 986
 987 inline static struct mmc_data* wbsd_get_data(struct wbsd_host* host)
 988 {
 989         WARN_ON(!host->mrq);
 990         if (!host->mrq)
 991                 return NULL;
 992
 993         WARN_ON(!host->mrq->cmd);
 994         if (!host->mrq->cmd)
 995                 return NULL;
 996
 997         WARN_ON(!host->mrq->cmd->data);
 998         if (!host->mrq->cmd->data)
 999                 return NULL;
1000
1001         return host->mrq->cmd->data;
1002 }
1003
1004 static void wbsd_tasklet_card(unsigned long param)
1005 {
1006         struct wbsd_host* host = (struct wbsd_host*)param;
1007         u8 csr;
1008
1009         spin_lock(&host->lock);
1010
1011         csr = inb(host->base + WBSD_CSR);
1012         WARN_ON(csr == 0xff);
1013
1014         if (csr & WBSD_CARDPRESENT)
1015                 DBG("Card inserted\n");
1016         else
1017         {
1018                 DBG("Card removed\n");
1019
1020                 if (host->mrq)
1021                 {
1022                         printk(KERN_ERR DRIVER_NAME
1023                                 ": Card removed during transfer!\n");
1024                         wbsd_reset(host);
1025
1026                         host->mrq->cmd->error = MMC_ERR_FAILED;
1027                         tasklet_schedule(&host->finish_tasklet);
1028                 }
1029         }
1030
1031         /*
1032          * Unlock first since we might get a call back.
1033          */
1034         spin_unlock(&host->lock);
1035
1036         mmc_detect_change(host->mmc);
1037 }
1038
1039 static void wbsd_tasklet_fifo(unsigned long param)
1040 {
1041         struct wbsd_host* host = (struct wbsd_host*)param;
1042         struct mmc_data* data;
1043
1044         spin_lock(&host->lock);
1045
1046         if (!host->mrq)
1047                 goto end;
1048
1049         data = wbsd_get_data(host);
1050         if (!data)
1051                 goto end;
1052
1053         if (data->flags & MMC_DATA_WRITE)
1054                 wbsd_fill_fifo(host);
1055         else
1056                 wbsd_empty_fifo(host);
1057
1058         /*
1059          * Done?
1060          */
1061         if (host->size == data->bytes_xfered)
1062         {
1063                 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1064                 tasklet_schedule(&host->finish_tasklet);
1065         }
1066
1067 end:
1068         spin_unlock(&host->lock);
1069 }
1070
1071 static void wbsd_tasklet_crc(unsigned long param)
1072 {
1073         struct wbsd_host* host = (struct wbsd_host*)param;
1074         struct mmc_data* data;
1075
1076         spin_lock(&host->lock);
1077
1078         if (!host->mrq)
1079                 goto end;
1080
1081         data = wbsd_get_data(host);
1082         if (!data)
1083                 goto end;
1084
1085         DBGF("CRC error\n");
1086
1087         data->error = MMC_ERR_BADCRC;
1088
1089         tasklet_schedule(&host->finish_tasklet);
1090
1091 end:
1092         spin_unlock(&host->lock);
1093 }
1094
1095 static void wbsd_tasklet_timeout(unsigned long param)
1096 {
1097         struct wbsd_host* host = (struct wbsd_host*)param;
1098         struct mmc_data* data;
1099
1100         spin_lock(&host->lock);
1101
1102         if (!host->mrq)
1103                 goto end;
1104
1105         data = wbsd_get_data(host);
1106         if (!data)
1107                 goto end;
1108
1109         DBGF("Timeout\n");
1110
1111         data->error = MMC_ERR_TIMEOUT;
1112
1113         tasklet_schedule(&host->finish_tasklet);
1114
1115 end:
1116         spin_unlock(&host->lock);
1117 }
1118
1119 static void wbsd_tasklet_finish(unsigned long param)
1120 {
1121         struct wbsd_host* host = (struct wbsd_host*)param;
1122         struct mmc_data* data;
1123
1124         spin_lock(&host->lock);
1125
1126         WARN_ON(!host->mrq);
1127         if (!host->mrq)
1128                 goto end;
1129
1130         data = wbsd_get_data(host);
1131         if (!data)
1132                 goto end;
1133
1134         wbsd_finish_data(host, data);
1135
1136 end:
1137         spin_unlock(&host->lock);
1138 }
1139
1140 static void wbsd_tasklet_block(unsigned long param)
1141 {
1142         struct wbsd_host* host = (struct wbsd_host*)param;
1143         struct mmc_data* data;
1144
1145         spin_lock(&host->lock);
1146
1147         if ((wbsd_read_index(host, WBSD_IDX_CRCSTATUS) & WBSD_CRC_MASK) !=
1148                 WBSD_CRC_OK)
1149         {
1150                 data = wbsd_get_data(host);
1151                 if (!data)
1152                         goto end;
1153
1154                 DBGF("CRC error\n");
1155
1156                 data->error = MMC_ERR_BADCRC;
1157
1158                 tasklet_schedule(&host->finish_tasklet);
1159         }
1160
1161 end:
1162         spin_unlock(&host->lock);
1163 }
1164
1165 /*
1166  * Interrupt handling
1167  */
1168
1169 static irqreturn_t wbsd_irq(int irq, void *dev_id, struct pt_regs *regs)
1170 {
1171         struct wbsd_host* host = dev_id;
1172         int isr;
1173
1174         isr = inb(host->base + WBSD_ISR);
1175
1176         /*
1177          * Was it actually our hardware that caused the interrupt?
1178          */
1179         if (isr == 0xff || isr == 0x00)
1180                 return IRQ_NONE;
1181
1182         host->isr |= isr;
1183
1184         /*
1185          * Schedule tasklets as needed.
1186          */
1187         if (isr & WBSD_INT_CARD)
1188                 tasklet_schedule(&host->card_tasklet);
1189         if (isr & WBSD_INT_FIFO_THRE)
1190                 tasklet_schedule(&host->fifo_tasklet);
1191         if (isr & WBSD_INT_CRC)
1192                 tasklet_hi_schedule(&host->crc_tasklet);
1193         if (isr & WBSD_INT_TIMEOUT)
1194                 tasklet_hi_schedule(&host->timeout_tasklet);
1195         if (isr & WBSD_INT_BUSYEND)
1196                 tasklet_hi_schedule(&host->block_tasklet);
1197         if (isr & WBSD_INT_TC)
1198                 tasklet_schedule(&host->finish_tasklet);
1199
1200         return IRQ_HANDLED;
1201 }
1202
1203 /*
1204  * Support functions for probe
1205  */
1206
1207 static int wbsd_scan(struct wbsd_host* host)
1208 {
1209         int i, j, k;
1210         int id;
1211
1212         /*
1213          * Iterate through all ports, all codes to
1214          * find hardware that is in our known list.
1215          */
1216         for (i = 0;i < sizeof(config_ports)/sizeof(int);i++)
1217         {
1218                 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1219                         continue;
1220
1221                 for (j = 0;j < sizeof(unlock_codes)/sizeof(int);j++)
1222                 {
1223                         id = 0xFFFF;
1224
1225                         outb(unlock_codes[j], config_ports[i]);
1226                         outb(unlock_codes[j], config_ports[i]);
1227
1228                         outb(WBSD_CONF_ID_HI, config_ports[i]);
1229                         id = inb(config_ports[i] + 1) << 8;
1230
1231                         outb(WBSD_CONF_ID_LO, config_ports[i]);
1232                         id |= inb(config_ports[i] + 1);
1233
1234                         for (k = 0;k < sizeof(valid_ids)/sizeof(int);k++)
1235                         {
1236                                 if (id == valid_ids[k])
1237                                 {
1238                                         host->chip_id = id;
1239                                         host->config = config_ports[i];
1240                                         host->unlock_code = unlock_codes[i];
1241
1242                                         return 0;
1243                                 }
1244                         }
1245
1246                         if (id != 0xFFFF)
1247                         {
1248                                 DBG("Unknown hardware (id %x) found at %x\n",
1249                                         id, config_ports[i]);
1250                         }
1251
1252                         outb(LOCK_CODE, config_ports[i]);
1253                 }
1254
1255                 release_region(config_ports[i], 2);
1256         }
1257
1258         return -ENODEV;
1259 }
1260
1261 static int wbsd_request_regions(struct wbsd_host* host)
1262 {
1263         if (io & 0x7)
1264                 return -EINVAL;
1265
1266         if (!request_region(io, 8, DRIVER_NAME))
1267                 return -EIO;
1268
1269         host->base = io;
1270
1271         return 0;
1272 }
1273
1274 static void wbsd_release_regions(struct wbsd_host* host)
1275 {
1276         if (host->base)
1277                 release_region(host->base, 8);
1278
1279         if (host->config)
1280                 release_region(host->config, 2);
1281 }
1282
1283 static void wbsd_init_dma(struct wbsd_host* host)
1284 {
1285         host->dma = -1;
1286
1287         if (dma < 0)
1288                 return;
1289
1290         if (request_dma(dma, DRIVER_NAME))
1291                 goto err;
1292
1293         /*
1294          * We need to allocate a special buffer in
1295          * order for ISA to be able to DMA to it.
1296          */
1297         host->dma_buffer = kmalloc(65536,
1298                 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1299         if (!host->dma_buffer)
1300                 goto free;
1301
1302         /*
1303          * Translate the address to a physical address.
1304          */
1305         host->dma_addr = isa_virt_to_bus(host->dma_buffer);
1306
1307         /*
1308          * ISA DMA must be aligned on a 64k basis.
1309          */
1310         if ((host->dma_addr & 0xffff) != 0)
1311                 goto kfree;
1312         /*
1313          * ISA cannot access memory above 16 MB.
1314          */
1315         else if (host->dma_addr >= 0x1000000)
1316                 goto kfree;
1317
1318         host->dma = dma;
1319
1320         return;
1321
1322 kfree:
1323         /*
1324          * If we've gotten here then there is some kind of alignment bug
1325          */
1326         BUG_ON(1);
1327
1328         kfree(host->dma_buffer);
1329         host->dma_buffer = NULL;
1330
1331 free:
1332         free_dma(dma);
1333
1334 err:
1335         printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1336                 "Falling back on FIFO.\n", dma);
1337 }
1338
1339 static struct mmc_host_ops wbsd_ops = {
1340         .request        = wbsd_request,
1341         .set_ios        = wbsd_set_ios,
1342 };
1343
1344 /*
1345  * Device probe
1346  */
1347
1348 static int wbsd_probe(struct device* dev)
1349 {
1350         struct wbsd_host* host = NULL;
1351         struct mmc_host* mmc = NULL;
1352         int ret;
1353
1354         /*
1355          * Allocate MMC structure.
1356          */
1357         mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1358         if (!mmc)
1359                 return -ENOMEM;
1360
1361         host = mmc_priv(mmc);
1362         host->mmc = mmc;
1363
1364         /*
1365          * Scan for hardware.
1366          */
1367         ret = wbsd_scan(host);
1368         if (ret)
1369                 goto freemmc;
1370
1371         /*
1372          * Reset the chip.
1373          */
1374         wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1375         wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1376
1377         /*
1378          * Allocate I/O ports.
1379          */
1380         ret = wbsd_request_regions(host);
1381         if (ret)
1382                 goto release;
1383
1384         /*
1385          * Set host parameters.
1386          */
1387         mmc->ops = &wbsd_ops;
1388         mmc->f_min = 375000;
1389         mmc->f_max = 24000000;
1390         mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
1391
1392         spin_lock_init(&host->lock);
1393
1394         /*
1395          * Select SD/MMC function.
1396          */
1397         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1398
1399         /*
1400          * Set up card detection.
1401          */
1402         wbsd_write_config(host, WBSD_CONF_PINS, 0x02);
1403
1404         /*
1405          * Configure I/O port.
1406          */
1407         wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1408         wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1409
1410         /*
1411          * Allocate interrupt.
1412          */
1413         ret = request_irq(irq, wbsd_irq, SA_SHIRQ, DRIVER_NAME, host);
1414         if (ret)
1415                 goto release;
1416
1417         host->irq = irq;
1418
1419         /*
1420          * Set up tasklets.
1421          */
1422         tasklet_init(&host->card_tasklet, wbsd_tasklet_card, (unsigned long)host);
1423         tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo, (unsigned long)host);
1424         tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc, (unsigned long)host);
1425         tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout, (unsigned long)host);
1426         tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish, (unsigned long)host);
1427         tasklet_init(&host->block_tasklet, wbsd_tasklet_block, (unsigned long)host);
1428
1429         /*
1430          * Configure interrupt.
1431          */
1432         wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1433
1434         /*
1435          * Allocate DMA.
1436          */
1437         wbsd_init_dma(host);
1438
1439         /*
1440          * If all went well, then configure DMA.
1441          */
1442         if (host->dma >= 0)
1443                 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1444
1445         /*
1446          * Maximum number of segments. Worst case is one sector per segment
1447          * so this will be 64kB/512.
1448          */
1449         mmc->max_hw_segs = 128;
1450         mmc->max_phys_segs = 128;
1451
1452         /*
1453          * Maximum number of sectors in one transfer. Also limited by 64kB
1454          * buffer.
1455          */
1456         mmc->max_sectors = 128;
1457
1458         /*
1459          * Maximum segment size. Could be one segment with the maximum number
1460          * of segments.
1461          */
1462         mmc->max_seg_size = mmc->max_sectors * 512;
1463
1464         /*
1465          * Enable chip.
1466          */
1467         wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1468
1469         /*
1470          * Power up chip.
1471          */
1472         wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1473
1474         /*
1475          * Power Management stuff. No idea how this works.
1476          * Not tested.
1477          */
1478 #ifdef CONFIG_PM
1479         wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1480 #endif
1481
1482         /*
1483          * Reset the chip into a known state.
1484          */
1485         wbsd_init_device(host);
1486
1487         dev_set_drvdata(dev, mmc);
1488
1489         /*
1490          * Add host to MMC layer.
1491          */
1492         mmc_add_host(mmc);
1493
1494         printk(KERN_INFO "%s: W83L51xD id %x at 0x%x irq %d dma %d\n",
1495                 mmc->host_name, (int)host->chip_id, (int)host->base,
1496                 (int)host->irq, (int)host->dma);
1497
1498         return 0;
1499
1500 release:
1501         wbsd_release_regions(host);
1502
1503 freemmc:
1504         mmc_free_host(mmc);
1505
1506         return ret;
1507 }
1508
1509 /*
1510  * Device remove
1511  */
1512
1513 static int wbsd_remove(struct device* dev)
1514 {
1515         struct mmc_host* mmc = dev_get_drvdata(dev);
1516         struct wbsd_host* host;
1517
1518         if (!mmc)
1519                 return 0;
1520
1521         host = mmc_priv(mmc);
1522
1523         /*
1524          * Unregister host with MMC layer.
1525          */
1526         mmc_remove_host(mmc);
1527
1528         /*
1529          * Power down the SD/MMC function.
1530          */
1531         wbsd_unlock_config(host);
1532         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1533         wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1534         wbsd_lock_config(host);
1535
1536         /*
1537          * Free resources.
1538          */
1539         if (host->dma_buffer)
1540                 kfree(host->dma_buffer);
1541
1542         if (host->dma >= 0)
1543                 free_dma(host->dma);
1544
1545         free_irq(host->irq, host);
1546
1547         tasklet_kill(&host->card_tasklet);
1548         tasklet_kill(&host->fifo_tasklet);
1549         tasklet_kill(&host->crc_tasklet);
1550         tasklet_kill(&host->timeout_tasklet);
1551         tasklet_kill(&host->finish_tasklet);
1552         tasklet_kill(&host->block_tasklet);
1553
1554         wbsd_release_regions(host);
1555
1556         mmc_free_host(mmc);
1557
1558         return 0;
1559 }
1560
1561 /*
1562  * Power management
1563  */
1564
1565 #ifdef CONFIG_PM
1566 static int wbsd_suspend(struct device *dev, u32 state, u32 level)
1567 {
1568         DBGF("Not yet supported\n");
1569
1570         return 0;
1571 }
1572
1573 static int wbsd_resume(struct device *dev, u32 level)
1574 {
1575         DBGF("Not yet supported\n");
1576
1577         return 0;
1578 }
1579 #else
1580 #define wbsd_suspend NULL
1581 #define wbsd_resume NULL
1582 #endif
1583
1584 static void wbsd_release(struct device *dev)
1585 {
1586 }
1587
1588 static struct platform_device wbsd_device = {
1589         .name           = DRIVER_NAME,
1590         .id                     = -1,
1591         .dev            = {
1592                 .release = wbsd_release,
1593         },
1594 };
1595
1596 static struct device_driver wbsd_driver = {
1597         .name           = DRIVER_NAME,
1598         .bus            = &platform_bus_type,
1599         .probe          = wbsd_probe,
1600         .remove         = wbsd_remove,
1601
1602         .suspend        = wbsd_suspend,
1603         .resume         = wbsd_resume,
1604 };
1605
1606 /*
1607  * Module loading/unloading
1608  */
1609
1610 static int __init wbsd_drv_init(void)
1611 {
1612         int result;
1613
1614         printk(KERN_INFO DRIVER_NAME
1615                 ": Winbond W83L51xD SD/MMC card interface driver, "
1616                 DRIVER_VERSION "\n");
1617         printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
1618
1619         result = driver_register(&wbsd_driver);
1620         if (result < 0)
1621                 return result;
1622
1623         result = platform_device_register(&wbsd_device);
1624         if (result < 0)
1625                 return result;
1626
1627         return 0;
1628 }
1629
1630 static void __exit wbsd_drv_exit(void)
1631 {
1632         platform_device_unregister(&wbsd_device);
1633
1634         driver_unregister(&wbsd_driver);
1635
1636         DBG("unloaded\n");
1637 }
1638
1639 module_init(wbsd_drv_init);
1640 module_exit(wbsd_drv_exit);
1641 module_param(io, uint, 0444);
1642 module_param(irq, uint, 0444);
1643 module_param(dma, int, 0444);
1644
1645 MODULE_LICENSE("GPL");
1646 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
1647 MODULE_VERSION(DRIVER_VERSION);
1648
1649 MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
1650 MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
1651 MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");