git.oblomov.eu Git - linux-2.6/blob - drivers/mmc/host/wbsd.c

   1 /*
   2  *  linux/drivers/mmc/wbsd.c - Winbond W83L51xD SD/MMC driver
   3  *
   4  *  Copyright (C) 2004-2007 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 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  * Warning!
  13  *
  14  * Changes to the FIFO system should be done with extreme care since
  15  * the hardware is full of bugs related to the FIFO. Known issues are:
  16  *
  17  * - FIFO size field in FSR is always zero.
  18  *
  19  * - FIFO interrupts tend not to work as they should. Interrupts are
  20  *   triggered only for full/empty events, not for threshold values.
  21  *
  22  * - On APIC systems the FIFO empty interrupt is sometimes lost.
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/init.h>
  28 #include <linux/ioport.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/dma-mapping.h>
  32 #include <linux/delay.h>
  33 #include <linux/pnp.h>
  34 #include <linux/highmem.h>
  35 #include <linux/mmc/host.h>
  36
  37 #include <asm/io.h>
  38 #include <asm/dma.h>
  39 #include <asm/scatterlist.h>
  40
  41 #include "wbsd.h"
  42
  43 #define DRIVER_NAME "wbsd"
  44
  45 #define DBG(x...) \
  46         pr_debug(DRIVER_NAME ": " x)
  47 #define DBGF(f, x...) \
  48         pr_debug(DRIVER_NAME " [%s()]: " f, __func__ , ##x)
  49
  50 /*
  51  * Device resources
  52  */
  53
  54 #ifdef CONFIG_PNP
  55
  56 static const struct pnp_device_id pnp_dev_table[] = {
  57         { "WEC0517", 0 },
  58         { "WEC0518", 0 },
  59         { "", 0 },
  60 };
  61
  62 MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
  63
  64 #endif /* CONFIG_PNP */
  65
  66 static const int config_ports[] = { 0x2E, 0x4E };
  67 static const int unlock_codes[] = { 0x83, 0x87 };
  68
  69 static const int valid_ids[] = {
  70         0x7112,
  71         };
  72
  73 #ifdef CONFIG_PNP
  74 static unsigned int nopnp = 0;
  75 #else
  76 static const unsigned int nopnp = 1;
  77 #endif
  78 static unsigned int io = 0x248;
  79 static unsigned int irq = 6;
  80 static int dma = 2;
  81
  82 /*
  83  * Basic functions
  84  */
  85
  86 static inline void wbsd_unlock_config(struct wbsd_host *host)
  87 {
  88         BUG_ON(host->config == 0);
  89
  90         outb(host->unlock_code, host->config);
  91         outb(host->unlock_code, host->config);
  92 }
  93
  94 static inline void wbsd_lock_config(struct wbsd_host *host)
  95 {
  96         BUG_ON(host->config == 0);
  97
  98         outb(LOCK_CODE, host->config);
  99 }
 100
 101 static inline void wbsd_write_config(struct wbsd_host *host, u8 reg, u8 value)
 102 {
 103         BUG_ON(host->config == 0);
 104
 105         outb(reg, host->config);
 106         outb(value, host->config + 1);
 107 }
 108
 109 static inline u8 wbsd_read_config(struct wbsd_host *host, u8 reg)
 110 {
 111         BUG_ON(host->config == 0);
 112
 113         outb(reg, host->config);
 114         return inb(host->config + 1);
 115 }
 116
 117 static inline void wbsd_write_index(struct wbsd_host *host, u8 index, u8 value)
 118 {
 119         outb(index, host->base + WBSD_IDXR);
 120         outb(value, host->base + WBSD_DATAR);
 121 }
 122
 123 static inline u8 wbsd_read_index(struct wbsd_host *host, u8 index)
 124 {
 125         outb(index, host->base + WBSD_IDXR);
 126         return inb(host->base + WBSD_DATAR);
 127 }
 128
 129 /*
 130  * Common routines
 131  */
 132
 133 static void wbsd_init_device(struct wbsd_host *host)
 134 {
 135         u8 setup, ier;
 136
 137         /*
 138          * Reset chip (SD/MMC part) and fifo.
 139          */
 140         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 141         setup |= WBSD_FIFO_RESET | WBSD_SOFT_RESET;
 142         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 143
 144         /*
 145          * Set DAT3 to input
 146          */
 147         setup &= ~WBSD_DAT3_H;
 148         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 149         host->flags &= ~WBSD_FIGNORE_DETECT;
 150
 151         /*
 152          * Read back default clock.
 153          */
 154         host->clk = wbsd_read_index(host, WBSD_IDX_CLK);
 155
 156         /*
 157          * Power down port.
 158          */
 159         outb(WBSD_POWER_N, host->base + WBSD_CSR);
 160
 161         /*
 162          * Set maximum timeout.
 163          */
 164         wbsd_write_index(host, WBSD_IDX_TAAC, 0x7F);
 165
 166         /*
 167          * Test for card presence
 168          */
 169         if (inb(host->base + WBSD_CSR) & WBSD_CARDPRESENT)
 170                 host->flags |= WBSD_FCARD_PRESENT;
 171         else
 172                 host->flags &= ~WBSD_FCARD_PRESENT;
 173
 174         /*
 175          * Enable interesting interrupts.
 176          */
 177         ier = 0;
 178         ier |= WBSD_EINT_CARD;
 179         ier |= WBSD_EINT_FIFO_THRE;
 180         ier |= WBSD_EINT_CRC;
 181         ier |= WBSD_EINT_TIMEOUT;
 182         ier |= WBSD_EINT_TC;
 183
 184         outb(ier, host->base + WBSD_EIR);
 185
 186         /*
 187          * Clear interrupts.
 188          */
 189         inb(host->base + WBSD_ISR);
 190 }
 191
 192 static void wbsd_reset(struct wbsd_host *host)
 193 {
 194         u8 setup;
 195
 196         printk(KERN_ERR "%s: Resetting chip\n", mmc_hostname(host->mmc));
 197
 198         /*
 199          * Soft reset of chip (SD/MMC part).
 200          */
 201         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 202         setup |= WBSD_SOFT_RESET;
 203         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 204 }
 205
 206 static void wbsd_request_end(struct wbsd_host *host, struct mmc_request *mrq)
 207 {
 208         unsigned long dmaflags;
 209
 210         DBGF("Ending request, cmd (%x)\n", mrq->cmd->opcode);
 211
 212         if (host->dma >= 0) {
 213                 /*
 214                  * Release ISA DMA controller.
 215                  */
 216                 dmaflags = claim_dma_lock();
 217                 disable_dma(host->dma);
 218                 clear_dma_ff(host->dma);
 219                 release_dma_lock(dmaflags);
 220
 221                 /*
 222                  * Disable DMA on host.
 223                  */
 224                 wbsd_write_index(host, WBSD_IDX_DMA, 0);
 225         }
 226
 227         host->mrq = NULL;
 228
 229         /*
 230          * MMC layer might call back into the driver so first unlock.
 231          */
 232         spin_unlock(&host->lock);
 233         mmc_request_done(host->mmc, mrq);
 234         spin_lock(&host->lock);
 235 }
 236
 237 /*
 238  * Scatter/gather functions
 239  */
 240
 241 static inline void wbsd_init_sg(struct wbsd_host *host, struct mmc_data *data)
 242 {
 243         /*
 244          * Get info. about SG list from data structure.
 245          */
 246         host->cur_sg = data->sg;
 247         host->num_sg = data->sg_len;
 248
 249         host->offset = 0;
 250         host->remain = host->cur_sg->length;
 251 }
 252
 253 static inline int wbsd_next_sg(struct wbsd_host *host)
 254 {
 255         /*
 256          * Skip to next SG entry.
 257          */
 258         host->cur_sg++;
 259         host->num_sg--;
 260
 261         /*
 262          * Any entries left?
 263          */
 264         if (host->num_sg > 0) {
 265                 host->offset = 0;
 266                 host->remain = host->cur_sg->length;
 267         }
 268
 269         return host->num_sg;
 270 }
 271
 272 static inline char *wbsd_sg_to_buffer(struct wbsd_host *host)
 273 {
 274         return page_address(host->cur_sg->page) + host->cur_sg->offset;
 275 }
 276
 277 static inline void wbsd_sg_to_dma(struct wbsd_host *host, struct mmc_data *data)
 278 {
 279         unsigned int len, i;
 280         struct scatterlist *sg;
 281         char *dmabuf = host->dma_buffer;
 282         char *sgbuf;
 283
 284         sg = data->sg;
 285         len = data->sg_len;
 286
 287         for (i = 0; i < len; i++) {
 288                 sgbuf = page_address(sg[i].page) + sg[i].offset;
 289                 memcpy(dmabuf, sgbuf, sg[i].length);
 290                 dmabuf += sg[i].length;
 291         }
 292 }
 293
 294 static inline void wbsd_dma_to_sg(struct wbsd_host *host, struct mmc_data *data)
 295 {
 296         unsigned int len, i;
 297         struct scatterlist *sg;
 298         char *dmabuf = host->dma_buffer;
 299         char *sgbuf;
 300
 301         sg = data->sg;
 302         len = data->sg_len;
 303
 304         for (i = 0; i < len; i++) {
 305                 sgbuf = page_address(sg[i].page) + sg[i].offset;
 306                 memcpy(sgbuf, dmabuf, sg[i].length);
 307                 dmabuf += sg[i].length;
 308         }
 309 }
 310
 311 /*
 312  * Command handling
 313  */
 314
 315 static inline void wbsd_get_short_reply(struct wbsd_host *host,
 316                                         struct mmc_command *cmd)
 317 {
 318         /*
 319          * Correct response type?
 320          */
 321         if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) {
 322                 cmd->error = MMC_ERR_INVALID;
 323                 return;
 324         }
 325
 326         cmd->resp[0]  = wbsd_read_index(host, WBSD_IDX_RESP12) << 24;
 327         cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP13) << 16;
 328         cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP14) << 8;
 329         cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP15) << 0;
 330         cmd->resp[1]  = wbsd_read_index(host, WBSD_IDX_RESP16) << 24;
 331 }
 332
 333 static inline void wbsd_get_long_reply(struct wbsd_host *host,
 334         struct mmc_command *cmd)
 335 {
 336         int i;
 337
 338         /*
 339          * Correct response type?
 340          */
 341         if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) {
 342                 cmd->error = MMC_ERR_INVALID;
 343                 return;
 344         }
 345
 346         for (i = 0; i < 4; i++) {
 347                 cmd->resp[i] =
 348                         wbsd_read_index(host, WBSD_IDX_RESP1 + i * 4) << 24;
 349                 cmd->resp[i] |=
 350                         wbsd_read_index(host, WBSD_IDX_RESP2 + i * 4) << 16;
 351                 cmd->resp[i] |=
 352                         wbsd_read_index(host, WBSD_IDX_RESP3 + i * 4) << 8;
 353                 cmd->resp[i] |=
 354                         wbsd_read_index(host, WBSD_IDX_RESP4 + i * 4) << 0;
 355         }
 356 }
 357
 358 static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
 359 {
 360         int i;
 361         u8 status, isr;
 362
 363         DBGF("Sending cmd (%x)\n", cmd->opcode);
 364
 365         /*
 366          * Clear accumulated ISR. The interrupt routine
 367          * will fill this one with events that occur during
 368          * transfer.
 369          */
 370         host->isr = 0;
 371
 372         /*
 373          * Send the command (CRC calculated by host).
 374          */
 375         outb(cmd->opcode, host->base + WBSD_CMDR);
 376         for (i = 3; i >= 0; i--)
 377                 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR);
 378
 379         cmd->error = MMC_ERR_NONE;
 380
 381         /*
 382          * Wait for the request to complete.
 383          */
 384         do {
 385                 status = wbsd_read_index(host, WBSD_IDX_STATUS);
 386         } while (status & WBSD_CARDTRAFFIC);
 387
 388         /*
 389          * Do we expect a reply?
 390          */
 391         if (cmd->flags & MMC_RSP_PRESENT) {
 392                 /*
 393                  * Read back status.
 394                  */
 395                 isr = host->isr;
 396
 397                 /* Card removed? */
 398                 if (isr & WBSD_INT_CARD)
 399                         cmd->error = MMC_ERR_TIMEOUT;
 400                 /* Timeout? */
 401                 else if (isr & WBSD_INT_TIMEOUT)
 402                         cmd->error = MMC_ERR_TIMEOUT;
 403                 /* CRC? */
 404                 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
 405                         cmd->error = MMC_ERR_BADCRC;
 406                 /* All ok */
 407                 else {
 408                         if (cmd->flags & MMC_RSP_136)
 409                                 wbsd_get_long_reply(host, cmd);
 410                         else
 411                                 wbsd_get_short_reply(host, cmd);
 412                 }
 413         }
 414
 415         DBGF("Sent cmd (%x), res %d\n", cmd->opcode, cmd->error);
 416 }
 417
 418 /*
 419  * Data functions
 420  */
 421
 422 static void wbsd_empty_fifo(struct wbsd_host *host)
 423 {
 424         struct mmc_data *data = host->mrq->cmd->data;
 425         char *buffer;
 426         int i, fsr, fifo;
 427
 428         /*
 429          * Handle excessive data.
 430          */
 431         if (host->num_sg == 0)
 432                 return;
 433
 434         buffer = wbsd_sg_to_buffer(host) + host->offset;
 435
 436         /*
 437          * Drain the fifo. This has a tendency to loop longer
 438          * than the FIFO length (usually one block).
 439          */
 440         while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_EMPTY)) {
 441                 /*
 442                  * The size field in the FSR is broken so we have to
 443                  * do some guessing.
 444                  */
 445                 if (fsr & WBSD_FIFO_FULL)
 446                         fifo = 16;
 447                 else if (fsr & WBSD_FIFO_FUTHRE)
 448                         fifo = 8;
 449                 else
 450                         fifo = 1;
 451
 452                 for (i = 0; i < fifo; i++) {
 453                         *buffer = inb(host->base + WBSD_DFR);
 454                         buffer++;
 455                         host->offset++;
 456                         host->remain--;
 457
 458                         data->bytes_xfered++;
 459
 460                         /*
 461                          * End of scatter list entry?
 462                          */
 463                         if (host->remain == 0) {
 464                                 /*
 465                                  * Get next entry. Check if last.
 466                                  */
 467                                 if (!wbsd_next_sg(host))
 468                                         return;
 469
 470                                 buffer = wbsd_sg_to_buffer(host);
 471                         }
 472                 }
 473         }
 474
 475         /*
 476          * This is a very dirty hack to solve a
 477          * hardware problem. The chip doesn't trigger
 478          * FIFO threshold interrupts properly.
 479          */
 480         if ((data->blocks * data->blksz - data->bytes_xfered) < 16)
 481                 tasklet_schedule(&host->fifo_tasklet);
 482 }
 483
 484 static void wbsd_fill_fifo(struct wbsd_host *host)
 485 {
 486         struct mmc_data *data = host->mrq->cmd->data;
 487         char *buffer;
 488         int i, fsr, fifo;
 489
 490         /*
 491          * Check that we aren't being called after the
 492          * entire buffer has been transfered.
 493          */
 494         if (host->num_sg == 0)
 495                 return;
 496
 497         buffer = wbsd_sg_to_buffer(host) + host->offset;
 498
 499         /*
 500          * Fill the fifo. This has a tendency to loop longer
 501          * than the FIFO length (usually one block).
 502          */
 503         while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_FULL)) {
 504                 /*
 505                  * The size field in the FSR is broken so we have to
 506                  * do some guessing.
 507                  */
 508                 if (fsr & WBSD_FIFO_EMPTY)
 509                         fifo = 0;
 510                 else if (fsr & WBSD_FIFO_EMTHRE)
 511                         fifo = 8;
 512                 else
 513                         fifo = 15;
 514
 515                 for (i = 16; i > fifo; i--) {
 516                         outb(*buffer, host->base + WBSD_DFR);
 517                         buffer++;
 518                         host->offset++;
 519                         host->remain--;
 520
 521                         data->bytes_xfered++;
 522
 523                         /*
 524                          * End of scatter list entry?
 525                          */
 526                         if (host->remain == 0) {
 527                                 /*
 528                                  * Get next entry. Check if last.
 529                                  */
 530                                 if (!wbsd_next_sg(host))
 531                                         return;
 532
 533                                 buffer = wbsd_sg_to_buffer(host);
 534                         }
 535                 }
 536         }
 537
 538         /*
 539          * The controller stops sending interrupts for
 540          * 'FIFO empty' under certain conditions. So we
 541          * need to be a bit more pro-active.
 542          */
 543         tasklet_schedule(&host->fifo_tasklet);
 544 }
 545
 546 static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
 547 {
 548         u16 blksize;
 549         u8 setup;
 550         unsigned long dmaflags;
 551         unsigned int size;
 552
 553         DBGF("blksz %04x blks %04x flags %08x\n",
 554                 data->blksz, data->blocks, data->flags);
 555         DBGF("tsac %d ms nsac %d clk\n",
 556                 data->timeout_ns / 1000000, data->timeout_clks);
 557
 558         /*
 559          * Calculate size.
 560          */
 561         size = data->blocks * data->blksz;
 562
 563         /*
 564          * Check timeout values for overflow.
 565          * (Yes, some cards cause this value to overflow).
 566          */
 567         if (data->timeout_ns > 127000000)
 568                 wbsd_write_index(host, WBSD_IDX_TAAC, 127);
 569         else {
 570                 wbsd_write_index(host, WBSD_IDX_TAAC,
 571                         data->timeout_ns / 1000000);
 572         }
 573
 574         if (data->timeout_clks > 255)
 575                 wbsd_write_index(host, WBSD_IDX_NSAC, 255);
 576         else
 577                 wbsd_write_index(host, WBSD_IDX_NSAC, data->timeout_clks);
 578
 579         /*
 580          * Inform the chip of how large blocks will be
 581          * sent. It needs this to determine when to
 582          * calculate CRC.
 583          *
 584          * Space for CRC must be included in the size.
 585          * Two bytes are needed for each data line.
 586          */
 587         if (host->bus_width == MMC_BUS_WIDTH_1) {
 588                 blksize = data->blksz + 2;
 589
 590                 wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
 591                 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
 592         } else if (host->bus_width == MMC_BUS_WIDTH_4) {
 593                 blksize = data->blksz + 2 * 4;
 594
 595                 wbsd_write_index(host, WBSD_IDX_PBSMSB,
 596                         ((blksize >> 4) & 0xF0) | WBSD_DATA_WIDTH);
 597                 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
 598         } else {
 599                 data->error = MMC_ERR_INVALID;
 600                 return;
 601         }
 602
 603         /*
 604          * Clear the FIFO. This is needed even for DMA
 605          * transfers since the chip still uses the FIFO
 606          * internally.
 607          */
 608         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 609         setup |= WBSD_FIFO_RESET;
 610         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 611
 612         /*
 613          * DMA transfer?
 614          */
 615         if (host->dma >= 0) {
 616                 /*
 617                  * The buffer for DMA is only 64 kB.
 618                  */
 619                 BUG_ON(size > 0x10000);
 620                 if (size > 0x10000) {
 621                         data->error = MMC_ERR_INVALID;
 622                         return;
 623                 }
 624
 625                 /*
 626                  * Transfer data from the SG list to
 627                  * the DMA buffer.
 628                  */
 629                 if (data->flags & MMC_DATA_WRITE)
 630                         wbsd_sg_to_dma(host, data);
 631
 632                 /*
 633                  * Initialise the ISA DMA controller.
 634                  */
 635                 dmaflags = claim_dma_lock();
 636                 disable_dma(host->dma);
 637                 clear_dma_ff(host->dma);
 638                 if (data->flags & MMC_DATA_READ)
 639                         set_dma_mode(host->dma, DMA_MODE_READ & ~0x40);
 640                 else
 641                         set_dma_mode(host->dma, DMA_MODE_WRITE & ~0x40);
 642                 set_dma_addr(host->dma, host->dma_addr);
 643                 set_dma_count(host->dma, size);
 644
 645                 enable_dma(host->dma);
 646                 release_dma_lock(dmaflags);
 647
 648                 /*
 649                  * Enable DMA on the host.
 650                  */
 651                 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE);
 652         } else {
 653                 /*
 654                  * This flag is used to keep printk
 655                  * output to a minimum.
 656                  */
 657                 host->firsterr = 1;
 658
 659                 /*
 660                  * Initialise the SG list.
 661                  */
 662                 wbsd_init_sg(host, data);
 663
 664                 /*
 665                  * Turn off DMA.
 666                  */
 667                 wbsd_write_index(host, WBSD_IDX_DMA, 0);
 668
 669                 /*
 670                  * Set up FIFO threshold levels (and fill
 671                  * buffer if doing a write).
 672                  */
 673                 if (data->flags & MMC_DATA_READ) {
 674                         wbsd_write_index(host, WBSD_IDX_FIFOEN,
 675                                 WBSD_FIFOEN_FULL | 8);
 676                 } else {
 677                         wbsd_write_index(host, WBSD_IDX_FIFOEN,
 678                                 WBSD_FIFOEN_EMPTY | 8);
 679                         wbsd_fill_fifo(host);
 680                 }
 681         }
 682
 683         data->error = MMC_ERR_NONE;
 684 }
 685
 686 static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
 687 {
 688         unsigned long dmaflags;
 689         int count;
 690         u8 status;
 691
 692         WARN_ON(host->mrq == NULL);
 693
 694         /*
 695          * Send a stop command if needed.
 696          */
 697         if (data->stop)
 698                 wbsd_send_command(host, data->stop);
 699
 700         /*
 701          * Wait for the controller to leave data
 702          * transfer state.
 703          */
 704         do {
 705                 status = wbsd_read_index(host, WBSD_IDX_STATUS);
 706         } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE));
 707
 708         /*
 709          * DMA transfer?
 710          */
 711         if (host->dma >= 0) {
 712                 /*
 713                  * Disable DMA on the host.
 714                  */
 715                 wbsd_write_index(host, WBSD_IDX_DMA, 0);
 716
 717                 /*
 718                  * Turn of ISA DMA controller.
 719                  */
 720                 dmaflags = claim_dma_lock();
 721                 disable_dma(host->dma);
 722                 clear_dma_ff(host->dma);
 723                 count = get_dma_residue(host->dma);
 724                 release_dma_lock(dmaflags);
 725
 726                 data->bytes_xfered = host->mrq->data->blocks *
 727                         host->mrq->data->blksz - count;
 728                 data->bytes_xfered -= data->bytes_xfered % data->blksz;
 729
 730                 /*
 731                  * Any leftover data?
 732                  */
 733                 if (count) {
 734                         printk(KERN_ERR "%s: Incomplete DMA transfer. "
 735                                 "%d bytes left.\n",
 736                                 mmc_hostname(host->mmc), count);
 737
 738                         if (data->error == MMC_ERR_NONE)
 739                                 data->error = MMC_ERR_FAILED;
 740                 } else {
 741                         /*
 742                          * Transfer data from DMA buffer to
 743                          * SG list.
 744                          */
 745                         if (data->flags & MMC_DATA_READ)
 746                                 wbsd_dma_to_sg(host, data);
 747                 }
 748
 749                 if (data->error != MMC_ERR_NONE) {
 750                         if (data->bytes_xfered)
 751                                 data->bytes_xfered -= data->blksz;
 752                 }
 753         }
 754
 755         DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered);
 756
 757         wbsd_request_end(host, host->mrq);
 758 }
 759
 760 /*****************************************************************************\
 761  *                                                                           *
 762  * MMC layer callbacks                                                       *
 763  *                                                                           *
 764 \*****************************************************************************/
 765
 766 static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
 767 {
 768         struct wbsd_host *host = mmc_priv(mmc);
 769         struct mmc_command *cmd;
 770
 771         /*
 772          * Disable tasklets to avoid a deadlock.
 773          */
 774         spin_lock_bh(&host->lock);
 775
 776         BUG_ON(host->mrq != NULL);
 777
 778         cmd = mrq->cmd;
 779
 780         host->mrq = mrq;
 781
 782         /*
 783          * If there is no card in the slot then
 784          * timeout immediatly.
 785          */
 786         if (!(host->flags & WBSD_FCARD_PRESENT)) {
 787                 cmd->error = MMC_ERR_TIMEOUT;
 788                 goto done;
 789         }
 790
 791         if (cmd->data) {
 792                 /*
 793                  * The hardware is so delightfully stupid that it has a list
 794                  * of "data" commands. If a command isn't on this list, it'll
 795                  * just go back to the idle state and won't send any data
 796                  * interrupts.
 797                  */
 798                 switch (cmd->opcode) {
 799                 case 11:
 800                 case 17:
 801                 case 18:
 802                 case 20:
 803                 case 24:
 804                 case 25:
 805                 case 26:
 806                 case 27:
 807                 case 30:
 808                 case 42:
 809                 case 56:
 810                         break;
 811
 812                 /* ACMDs. We don't keep track of state, so we just treat them
 813                  * like any other command. */
 814                 case 51:
 815                         break;
 816
 817                 default:
 818 #ifdef CONFIG_MMC_DEBUG
 819                         printk(KERN_WARNING "%s: Data command %d is not "
 820                                 "supported by this controller.\n",
 821                                 mmc_hostname(host->mmc), cmd->opcode);
 822 #endif
 823                         cmd->error = MMC_ERR_INVALID;
 824
 825                         goto done;
 826                 };
 827         }
 828
 829         /*
 830          * Does the request include data?
 831          */
 832         if (cmd->data) {
 833                 wbsd_prepare_data(host, cmd->data);
 834
 835                 if (cmd->data->error != MMC_ERR_NONE)
 836                         goto done;
 837         }
 838
 839         wbsd_send_command(host, cmd);
 840
 841         /*
 842          * If this is a data transfer the request
 843          * will be finished after the data has
 844          * transfered.
 845          */
 846         if (cmd->data && (cmd->error == MMC_ERR_NONE)) {
 847                 /*
 848                  * Dirty fix for hardware bug.
 849                  */
 850                 if (host->dma == -1)
 851                         tasklet_schedule(&host->fifo_tasklet);
 852
 853                 spin_unlock_bh(&host->lock);
 854
 855                 return;
 856         }
 857
 858 done:
 859         wbsd_request_end(host, mrq);
 860
 861         spin_unlock_bh(&host->lock);
 862 }
 863
 864 static void wbsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 865 {
 866         struct wbsd_host *host = mmc_priv(mmc);
 867         u8 clk, setup, pwr;
 868
 869         spin_lock_bh(&host->lock);
 870
 871         /*
 872          * Reset the chip on each power off.
 873          * Should clear out any weird states.
 874          */
 875         if (ios->power_mode == MMC_POWER_OFF)
 876                 wbsd_init_device(host);
 877
 878         if (ios->clock >= 24000000)
 879                 clk = WBSD_CLK_24M;
 880         else if (ios->clock >= 16000000)
 881                 clk = WBSD_CLK_16M;
 882         else if (ios->clock >= 12000000)
 883                 clk = WBSD_CLK_12M;
 884         else
 885                 clk = WBSD_CLK_375K;
 886
 887         /*
 888          * Only write to the clock register when
 889          * there is an actual change.
 890          */
 891         if (clk != host->clk) {
 892                 wbsd_write_index(host, WBSD_IDX_CLK, clk);
 893                 host->clk = clk;
 894         }
 895
 896         /*
 897          * Power up card.
 898          */
 899         if (ios->power_mode != MMC_POWER_OFF) {
 900                 pwr = inb(host->base + WBSD_CSR);
 901                 pwr &= ~WBSD_POWER_N;
 902                 outb(pwr, host->base + WBSD_CSR);
 903         }
 904
 905         /*
 906          * MMC cards need to have pin 1 high during init.
 907          * It wreaks havoc with the card detection though so
 908          * that needs to be disabled.
 909          */
 910         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 911         if (ios->chip_select == MMC_CS_HIGH) {
 912                 BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
 913                 setup |= WBSD_DAT3_H;
 914                 host->flags |= WBSD_FIGNORE_DETECT;
 915         } else {
 916                 if (setup & WBSD_DAT3_H) {
 917                         setup &= ~WBSD_DAT3_H;
 918
 919                         /*
 920                          * We cannot resume card detection immediatly
 921                          * because of capacitance and delays in the chip.
 922                          */
 923                         mod_timer(&host->ignore_timer, jiffies + HZ / 100);
 924                 }
 925         }
 926         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 927
 928         /*
 929          * Store bus width for later. Will be used when
 930          * setting up the data transfer.
 931          */
 932         host->bus_width = ios->bus_width;
 933
 934         spin_unlock_bh(&host->lock);
 935 }
 936
 937 static int wbsd_get_ro(struct mmc_host *mmc)
 938 {
 939         struct wbsd_host *host = mmc_priv(mmc);
 940         u8 csr;
 941
 942         spin_lock_bh(&host->lock);
 943
 944         csr = inb(host->base + WBSD_CSR);
 945         csr |= WBSD_MSLED;
 946         outb(csr, host->base + WBSD_CSR);
 947
 948         mdelay(1);
 949
 950         csr = inb(host->base + WBSD_CSR);
 951         csr &= ~WBSD_MSLED;
 952         outb(csr, host->base + WBSD_CSR);
 953
 954         spin_unlock_bh(&host->lock);
 955
 956         return csr & WBSD_WRPT;
 957 }
 958
 959 static const struct mmc_host_ops wbsd_ops = {
 960         .request        = wbsd_request,
 961         .set_ios        = wbsd_set_ios,
 962         .get_ro         = wbsd_get_ro,
 963 };
 964
 965 /*****************************************************************************\
 966  *                                                                           *
 967  * Interrupt handling                                                        *
 968  *                                                                           *
 969 \*****************************************************************************/
 970
 971 /*
 972  * Helper function to reset detection ignore
 973  */
 974
 975 static void wbsd_reset_ignore(unsigned long data)
 976 {
 977         struct wbsd_host *host = (struct wbsd_host *)data;
 978
 979         BUG_ON(host == NULL);
 980
 981         DBG("Resetting card detection ignore\n");
 982
 983         spin_lock_bh(&host->lock);
 984
 985         host->flags &= ~WBSD_FIGNORE_DETECT;
 986
 987         /*
 988          * Card status might have changed during the
 989          * blackout.
 990          */
 991         tasklet_schedule(&host->card_tasklet);
 992
 993         spin_unlock_bh(&host->lock);
 994 }
 995
 996 /*
 997  * Tasklets
 998  */
 999
1000 static inline struct mmc_data *wbsd_get_data(struct wbsd_host *host)
1001 {
1002         WARN_ON(!host->mrq);
1003         if (!host->mrq)
1004                 return NULL;
1005
1006         WARN_ON(!host->mrq->cmd);
1007         if (!host->mrq->cmd)
1008                 return NULL;
1009
1010         WARN_ON(!host->mrq->cmd->data);
1011         if (!host->mrq->cmd->data)
1012                 return NULL;
1013
1014         return host->mrq->cmd->data;
1015 }
1016
1017 static void wbsd_tasklet_card(unsigned long param)
1018 {
1019         struct wbsd_host *host = (struct wbsd_host *)param;
1020         u8 csr;
1021         int delay = -1;
1022
1023         spin_lock(&host->lock);
1024
1025         if (host->flags & WBSD_FIGNORE_DETECT) {
1026                 spin_unlock(&host->lock);
1027                 return;
1028         }
1029
1030         csr = inb(host->base + WBSD_CSR);
1031         WARN_ON(csr == 0xff);
1032
1033         if (csr & WBSD_CARDPRESENT) {
1034                 if (!(host->flags & WBSD_FCARD_PRESENT)) {
1035                         DBG("Card inserted\n");
1036                         host->flags |= WBSD_FCARD_PRESENT;
1037
1038                         delay = 500;
1039                 }
1040         } else if (host->flags & WBSD_FCARD_PRESENT) {
1041                 DBG("Card removed\n");
1042                 host->flags &= ~WBSD_FCARD_PRESENT;
1043
1044                 if (host->mrq) {
1045                         printk(KERN_ERR "%s: Card removed during transfer!\n",
1046                                 mmc_hostname(host->mmc));
1047                         wbsd_reset(host);
1048
1049                         host->mrq->cmd->error = MMC_ERR_FAILED;
1050                         tasklet_schedule(&host->finish_tasklet);
1051                 }
1052
1053                 delay = 0;
1054         }
1055
1056         /*
1057          * Unlock first since we might get a call back.
1058          */
1059
1060         spin_unlock(&host->lock);
1061
1062         if (delay != -1)
1063                 mmc_detect_change(host->mmc, msecs_to_jiffies(delay));
1064 }
1065
1066 static void wbsd_tasklet_fifo(unsigned long param)
1067 {
1068         struct wbsd_host *host = (struct wbsd_host *)param;
1069         struct mmc_data *data;
1070
1071         spin_lock(&host->lock);
1072
1073         if (!host->mrq)
1074                 goto end;
1075
1076         data = wbsd_get_data(host);
1077         if (!data)
1078                 goto end;
1079
1080         if (data->flags & MMC_DATA_WRITE)
1081                 wbsd_fill_fifo(host);
1082         else
1083                 wbsd_empty_fifo(host);
1084
1085         /*
1086          * Done?
1087          */
1088         if (host->num_sg == 0) {
1089                 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1090                 tasklet_schedule(&host->finish_tasklet);
1091         }
1092
1093 end:
1094         spin_unlock(&host->lock);
1095 }
1096
1097 static void wbsd_tasklet_crc(unsigned long param)
1098 {
1099         struct wbsd_host *host = (struct wbsd_host *)param;
1100         struct mmc_data *data;
1101
1102         spin_lock(&host->lock);
1103
1104         if (!host->mrq)
1105                 goto end;
1106
1107         data = wbsd_get_data(host);
1108         if (!data)
1109                 goto end;
1110
1111         DBGF("CRC error\n");
1112
1113         data->error = MMC_ERR_BADCRC;
1114
1115         tasklet_schedule(&host->finish_tasklet);
1116
1117 end:
1118         spin_unlock(&host->lock);
1119 }
1120
1121 static void wbsd_tasklet_timeout(unsigned long param)
1122 {
1123         struct wbsd_host *host = (struct wbsd_host *)param;
1124         struct mmc_data *data;
1125
1126         spin_lock(&host->lock);
1127
1128         if (!host->mrq)
1129                 goto end;
1130
1131         data = wbsd_get_data(host);
1132         if (!data)
1133                 goto end;
1134
1135         DBGF("Timeout\n");
1136
1137         data->error = MMC_ERR_TIMEOUT;
1138
1139         tasklet_schedule(&host->finish_tasklet);
1140
1141 end:
1142         spin_unlock(&host->lock);
1143 }
1144
1145 static void wbsd_tasklet_finish(unsigned long param)
1146 {
1147         struct wbsd_host *host = (struct wbsd_host *)param;
1148         struct mmc_data *data;
1149
1150         spin_lock(&host->lock);
1151
1152         WARN_ON(!host->mrq);
1153         if (!host->mrq)
1154                 goto end;
1155
1156         data = wbsd_get_data(host);
1157         if (!data)
1158                 goto end;
1159
1160         wbsd_finish_data(host, data);
1161
1162 end:
1163         spin_unlock(&host->lock);
1164 }
1165
1166 /*
1167  * Interrupt handling
1168  */
1169
1170 static irqreturn_t wbsd_irq(int irq, void *dev_id)
1171 {
1172         struct wbsd_host *host = dev_id;
1173         int isr;
1174
1175         isr = inb(host->base + WBSD_ISR);
1176
1177         /*
1178          * Was it actually our hardware that caused the interrupt?
1179          */
1180         if (isr == 0xff || isr == 0x00)
1181                 return IRQ_NONE;
1182
1183         host->isr |= isr;
1184
1185         /*
1186          * Schedule tasklets as needed.
1187          */
1188         if (isr & WBSD_INT_CARD)
1189                 tasklet_schedule(&host->card_tasklet);
1190         if (isr & WBSD_INT_FIFO_THRE)
1191                 tasklet_schedule(&host->fifo_tasklet);
1192         if (isr & WBSD_INT_CRC)
1193                 tasklet_hi_schedule(&host->crc_tasklet);
1194         if (isr & WBSD_INT_TIMEOUT)
1195                 tasklet_hi_schedule(&host->timeout_tasklet);
1196         if (isr & WBSD_INT_TC)
1197                 tasklet_schedule(&host->finish_tasklet);
1198
1199         return IRQ_HANDLED;
1200 }
1201
1202 /*****************************************************************************\
1203  *                                                                           *
1204  * Device initialisation and shutdown                                        *
1205  *                                                                           *
1206 \*****************************************************************************/
1207
1208 /*
1209  * Allocate/free MMC structure.
1210  */
1211
1212 static int __devinit wbsd_alloc_mmc(struct device *dev)
1213 {
1214         struct mmc_host *mmc;
1215         struct wbsd_host *host;
1216
1217         /*
1218          * Allocate MMC structure.
1219          */
1220         mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1221         if (!mmc)
1222                 return -ENOMEM;
1223
1224         host = mmc_priv(mmc);
1225         host->mmc = mmc;
1226
1227         host->dma = -1;
1228
1229         /*
1230          * Set host parameters.
1231          */
1232         mmc->ops = &wbsd_ops;
1233         mmc->f_min = 375000;
1234         mmc->f_max = 24000000;
1235         mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
1236         mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MULTIWRITE | MMC_CAP_BYTEBLOCK;
1237
1238         spin_lock_init(&host->lock);
1239
1240         /*
1241          * Set up timers
1242          */
1243         init_timer(&host->ignore_timer);
1244         host->ignore_timer.data = (unsigned long)host;
1245         host->ignore_timer.function = wbsd_reset_ignore;
1246
1247         /*
1248          * Maximum number of segments. Worst case is one sector per segment
1249          * so this will be 64kB/512.
1250          */
1251         mmc->max_hw_segs = 128;
1252         mmc->max_phys_segs = 128;
1253
1254         /*
1255          * Maximum request size. Also limited by 64KiB buffer.
1256          */
1257         mmc->max_req_size = 65536;
1258
1259         /*
1260          * Maximum segment size. Could be one segment with the maximum number
1261          * of bytes.
1262          */
1263         mmc->max_seg_size = mmc->max_req_size;
1264
1265         /*
1266          * Maximum block size. We have 12 bits (= 4095) but have to subtract
1267          * space for CRC. So the maximum is 4095 - 4*2 = 4087.
1268          */
1269         mmc->max_blk_size = 4087;
1270
1271         /*
1272          * Maximum block count. There is no real limit so the maximum
1273          * request size will be the only restriction.
1274          */
1275         mmc->max_blk_count = mmc->max_req_size;
1276
1277         dev_set_drvdata(dev, mmc);
1278
1279         return 0;
1280 }
1281
1282 static void __devexit wbsd_free_mmc(struct device *dev)
1283 {
1284         struct mmc_host *mmc;
1285         struct wbsd_host *host;
1286
1287         mmc = dev_get_drvdata(dev);
1288         if (!mmc)
1289                 return;
1290
1291         host = mmc_priv(mmc);
1292         BUG_ON(host == NULL);
1293
1294         del_timer_sync(&host->ignore_timer);
1295
1296         mmc_free_host(mmc);
1297
1298         dev_set_drvdata(dev, NULL);
1299 }
1300
1301 /*
1302  * Scan for known chip id:s
1303  */
1304
1305 static int __devinit wbsd_scan(struct wbsd_host *host)
1306 {
1307         int i, j, k;
1308         int id;
1309
1310         /*
1311          * Iterate through all ports, all codes to
1312          * find hardware that is in our known list.
1313          */
1314         for (i = 0; i < ARRAY_SIZE(config_ports); i++) {
1315                 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1316                         continue;
1317
1318                 for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) {
1319                         id = 0xFFFF;
1320
1321                         host->config = config_ports[i];
1322                         host->unlock_code = unlock_codes[j];
1323
1324                         wbsd_unlock_config(host);
1325
1326                         outb(WBSD_CONF_ID_HI, config_ports[i]);
1327                         id = inb(config_ports[i] + 1) << 8;
1328
1329                         outb(WBSD_CONF_ID_LO, config_ports[i]);
1330                         id |= inb(config_ports[i] + 1);
1331
1332                         wbsd_lock_config(host);
1333
1334                         for (k = 0; k < ARRAY_SIZE(valid_ids); k++) {
1335                                 if (id == valid_ids[k]) {
1336                                         host->chip_id = id;
1337
1338                                         return 0;
1339                                 }
1340                         }
1341
1342                         if (id != 0xFFFF) {
1343                                 DBG("Unknown hardware (id %x) found at %x\n",
1344                                         id, config_ports[i]);
1345                         }
1346                 }
1347
1348                 release_region(config_ports[i], 2);
1349         }
1350
1351         host->config = 0;
1352         host->unlock_code = 0;
1353
1354         return -ENODEV;
1355 }
1356
1357 /*
1358  * Allocate/free io port ranges
1359  */
1360
1361 static int __devinit wbsd_request_region(struct wbsd_host *host, int base)
1362 {
1363         if (base & 0x7)
1364                 return -EINVAL;
1365
1366         if (!request_region(base, 8, DRIVER_NAME))
1367                 return -EIO;
1368
1369         host->base = base;
1370
1371         return 0;
1372 }
1373
1374 static void __devexit wbsd_release_regions(struct wbsd_host *host)
1375 {
1376         if (host->base)
1377                 release_region(host->base, 8);
1378
1379         host->base = 0;
1380
1381         if (host->config)
1382                 release_region(host->config, 2);
1383
1384         host->config = 0;
1385 }
1386
1387 /*
1388  * Allocate/free DMA port and buffer
1389  */
1390
1391 static void __devinit wbsd_request_dma(struct wbsd_host *host, int dma)
1392 {
1393         if (dma < 0)
1394                 return;
1395
1396         if (request_dma(dma, DRIVER_NAME))
1397                 goto err;
1398
1399         /*
1400          * We need to allocate a special buffer in
1401          * order for ISA to be able to DMA to it.
1402          */
1403         host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
1404                 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1405         if (!host->dma_buffer)
1406                 goto free;
1407
1408         /*
1409          * Translate the address to a physical address.
1410          */
1411         host->dma_addr = dma_map_single(mmc_dev(host->mmc), host->dma_buffer,
1412                 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1413
1414         /*
1415          * ISA DMA must be aligned on a 64k basis.
1416          */
1417         if ((host->dma_addr & 0xffff) != 0)
1418                 goto kfree;
1419         /*
1420          * ISA cannot access memory above 16 MB.
1421          */
1422         else if (host->dma_addr >= 0x1000000)
1423                 goto kfree;
1424
1425         host->dma = dma;
1426
1427         return;
1428
1429 kfree:
1430         /*
1431          * If we've gotten here then there is some kind of alignment bug
1432          */
1433         BUG_ON(1);
1434
1435         dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1436                 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1437         host->dma_addr = (dma_addr_t)NULL;
1438
1439         kfree(host->dma_buffer);
1440         host->dma_buffer = NULL;
1441
1442 free:
1443         free_dma(dma);
1444
1445 err:
1446         printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1447                 "Falling back on FIFO.\n", dma);
1448 }
1449
1450 static void __devexit wbsd_release_dma(struct wbsd_host *host)
1451 {
1452         if (host->dma_addr) {
1453                 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1454                         WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1455         }
1456         kfree(host->dma_buffer);
1457         if (host->dma >= 0)
1458                 free_dma(host->dma);
1459
1460         host->dma = -1;
1461         host->dma_buffer = NULL;
1462         host->dma_addr = (dma_addr_t)NULL;
1463 }
1464
1465 /*
1466  * Allocate/free IRQ.
1467  */
1468
1469 static int __devinit wbsd_request_irq(struct wbsd_host *host, int irq)
1470 {
1471         int ret;
1472
1473         /*
1474          * Allocate interrupt.
1475          */
1476
1477         ret = request_irq(irq, wbsd_irq, IRQF_SHARED, DRIVER_NAME, host);
1478         if (ret)
1479                 return ret;
1480
1481         host->irq = irq;
1482
1483         /*
1484          * Set up tasklets.
1485          */
1486         tasklet_init(&host->card_tasklet, wbsd_tasklet_card,
1487                         (unsigned long)host);
1488         tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo,
1489                         (unsigned long)host);
1490         tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc,
1491                         (unsigned long)host);
1492         tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout,
1493                         (unsigned long)host);
1494         tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish,
1495                         (unsigned long)host);
1496
1497         return 0;
1498 }
1499
1500 static void __devexit wbsd_release_irq(struct wbsd_host *host)
1501 {
1502         if (!host->irq)
1503                 return;
1504
1505         free_irq(host->irq, host);
1506
1507         host->irq = 0;
1508
1509         tasklet_kill(&host->card_tasklet);
1510         tasklet_kill(&host->fifo_tasklet);
1511         tasklet_kill(&host->crc_tasklet);
1512         tasklet_kill(&host->timeout_tasklet);
1513         tasklet_kill(&host->finish_tasklet);
1514 }
1515
1516 /*
1517  * Allocate all resources for the host.
1518  */
1519
1520 static int __devinit wbsd_request_resources(struct wbsd_host *host,
1521         int base, int irq, int dma)
1522 {
1523         int ret;
1524
1525         /*
1526          * Allocate I/O ports.
1527          */
1528         ret = wbsd_request_region(host, base);
1529         if (ret)
1530                 return ret;
1531
1532         /*
1533          * Allocate interrupt.
1534          */
1535         ret = wbsd_request_irq(host, irq);
1536         if (ret)
1537                 return ret;
1538
1539         /*
1540          * Allocate DMA.
1541          */
1542         wbsd_request_dma(host, dma);
1543
1544         return 0;
1545 }
1546
1547 /*
1548  * Release all resources for the host.
1549  */
1550
1551 static void __devexit wbsd_release_resources(struct wbsd_host *host)
1552 {
1553         wbsd_release_dma(host);
1554         wbsd_release_irq(host);
1555         wbsd_release_regions(host);
1556 }
1557
1558 /*
1559  * Configure the resources the chip should use.
1560  */
1561
1562 static void wbsd_chip_config(struct wbsd_host *host)
1563 {
1564         wbsd_unlock_config(host);
1565
1566         /*
1567          * Reset the chip.
1568          */
1569         wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1570         wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1571
1572         /*
1573          * Select SD/MMC function.
1574          */
1575         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1576
1577         /*
1578          * Set up card detection.
1579          */
1580         wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1581
1582         /*
1583          * Configure chip
1584          */
1585         wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1586         wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1587
1588         wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1589
1590         if (host->dma >= 0)
1591                 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1592
1593         /*
1594          * Enable and power up chip.
1595          */
1596         wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1597         wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1598
1599         wbsd_lock_config(host);
1600 }
1601
1602 /*
1603  * Check that configured resources are correct.
1604  */
1605
1606 static int wbsd_chip_validate(struct wbsd_host *host)
1607 {
1608         int base, irq, dma;
1609
1610         wbsd_unlock_config(host);
1611
1612         /*
1613          * Select SD/MMC function.
1614          */
1615         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1616
1617         /*
1618          * Read configuration.
1619          */
1620         base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1621         base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1622
1623         irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1624
1625         dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1626
1627         wbsd_lock_config(host);
1628
1629         /*
1630          * Validate against given configuration.
1631          */
1632         if (base != host->base)
1633                 return 0;
1634         if (irq != host->irq)
1635                 return 0;
1636         if ((dma != host->dma) && (host->dma != -1))
1637                 return 0;
1638
1639         return 1;
1640 }
1641
1642 /*
1643  * Powers down the SD function
1644  */
1645
1646 static void wbsd_chip_poweroff(struct wbsd_host *host)
1647 {
1648         wbsd_unlock_config(host);
1649
1650         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1651         wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1652
1653         wbsd_lock_config(host);
1654 }
1655
1656 /*****************************************************************************\
1657  *                                                                           *
1658  * Devices setup and shutdown                                                *
1659  *                                                                           *
1660 \*****************************************************************************/
1661
1662 static int __devinit wbsd_init(struct device *dev, int base, int irq, int dma,
1663         int pnp)
1664 {
1665         struct wbsd_host *host = NULL;
1666         struct mmc_host *mmc = NULL;
1667         int ret;
1668
1669         ret = wbsd_alloc_mmc(dev);
1670         if (ret)
1671                 return ret;
1672
1673         mmc = dev_get_drvdata(dev);
1674         host = mmc_priv(mmc);
1675
1676         /*
1677          * Scan for hardware.
1678          */
1679         ret = wbsd_scan(host);
1680         if (ret) {
1681                 if (pnp && (ret == -ENODEV)) {
1682                         printk(KERN_WARNING DRIVER_NAME
1683                                 ": Unable to confirm device presence. You may "
1684                                 "experience lock-ups.\n");
1685                 } else {
1686                         wbsd_free_mmc(dev);
1687                         return ret;
1688                 }
1689         }
1690
1691         /*
1692          * Request resources.
1693          */
1694         ret = wbsd_request_resources(host, base, irq, dma);
1695         if (ret) {
1696                 wbsd_release_resources(host);
1697                 wbsd_free_mmc(dev);
1698                 return ret;
1699         }
1700
1701         /*
1702          * See if chip needs to be configured.
1703          */
1704         if (pnp) {
1705                 if ((host->config != 0) && !wbsd_chip_validate(host)) {
1706                         printk(KERN_WARNING DRIVER_NAME
1707                                 ": PnP active but chip not configured! "
1708                                 "You probably have a buggy BIOS. "
1709                                 "Configuring chip manually.\n");
1710                         wbsd_chip_config(host);
1711                 }
1712         } else
1713                 wbsd_chip_config(host);
1714
1715         /*
1716          * Power Management stuff. No idea how this works.
1717          * Not tested.
1718          */
1719 #ifdef CONFIG_PM
1720         if (host->config) {
1721                 wbsd_unlock_config(host);
1722                 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1723                 wbsd_lock_config(host);
1724         }
1725 #endif
1726         /*
1727          * Allow device to initialise itself properly.
1728          */
1729         mdelay(5);
1730
1731         /*
1732          * Reset the chip into a known state.
1733          */
1734         wbsd_init_device(host);
1735
1736         mmc_add_host(mmc);
1737
1738         printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
1739         if (host->chip_id != 0)
1740                 printk(" id %x", (int)host->chip_id);
1741         printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1742         if (host->dma >= 0)
1743                 printk(" dma %d", (int)host->dma);
1744         else
1745                 printk(" FIFO");
1746         if (pnp)
1747                 printk(" PnP");
1748         printk("\n");
1749
1750         return 0;
1751 }
1752
1753 static void __devexit wbsd_shutdown(struct device *dev, int pnp)
1754 {
1755         struct mmc_host *mmc = dev_get_drvdata(dev);
1756         struct wbsd_host *host;
1757
1758         if (!mmc)
1759                 return;
1760
1761         host = mmc_priv(mmc);
1762
1763         mmc_remove_host(mmc);
1764
1765         /*
1766          * Power down the SD/MMC function.
1767          */
1768         if (!pnp)
1769                 wbsd_chip_poweroff(host);
1770
1771         wbsd_release_resources(host);
1772
1773         wbsd_free_mmc(dev);
1774 }
1775
1776 /*
1777  * Non-PnP
1778  */
1779
1780 static int __devinit wbsd_probe(struct platform_device *dev)
1781 {
1782         /* Use the module parameters for resources */
1783         return wbsd_init(&dev->dev, io, irq, dma, 0);
1784 }
1785
1786 static int __devexit wbsd_remove(struct platform_device *dev)
1787 {
1788         wbsd_shutdown(&dev->dev, 0);
1789
1790         return 0;
1791 }
1792
1793 /*
1794  * PnP
1795  */
1796
1797 #ifdef CONFIG_PNP
1798
1799 static int __devinit
1800 wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id)
1801 {
1802         int io, irq, dma;
1803
1804         /*
1805          * Get resources from PnP layer.
1806          */
1807         io = pnp_port_start(pnpdev, 0);
1808         irq = pnp_irq(pnpdev, 0);
1809         if (pnp_dma_valid(pnpdev, 0))
1810                 dma = pnp_dma(pnpdev, 0);
1811         else
1812                 dma = -1;
1813
1814         DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1815
1816         return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1817 }
1818
1819 static void __devexit wbsd_pnp_remove(struct pnp_dev *dev)
1820 {
1821         wbsd_shutdown(&dev->dev, 1);
1822 }
1823
1824 #endif /* CONFIG_PNP */
1825
1826 /*
1827  * Power management
1828  */
1829
1830 #ifdef CONFIG_PM
1831
1832 static int wbsd_suspend(struct wbsd_host *host, pm_message_t state)
1833 {
1834         BUG_ON(host == NULL);
1835
1836         return mmc_suspend_host(host->mmc, state);
1837 }
1838
1839 static int wbsd_resume(struct wbsd_host *host)
1840 {
1841         BUG_ON(host == NULL);
1842
1843         wbsd_init_device(host);
1844
1845         return mmc_resume_host(host->mmc);
1846 }
1847
1848 static int wbsd_platform_suspend(struct platform_device *dev,
1849                                  pm_message_t state)
1850 {
1851         struct mmc_host *mmc = platform_get_drvdata(dev);
1852         struct wbsd_host *host;
1853         int ret;
1854
1855         if (mmc == NULL)
1856                 return 0;
1857
1858         DBGF("Suspending...\n");
1859
1860         host = mmc_priv(mmc);
1861
1862         ret = wbsd_suspend(host, state);
1863         if (ret)
1864                 return ret;
1865
1866         wbsd_chip_poweroff(host);
1867
1868         return 0;
1869 }
1870
1871 static int wbsd_platform_resume(struct platform_device *dev)
1872 {
1873         struct mmc_host *mmc = platform_get_drvdata(dev);
1874         struct wbsd_host *host;
1875
1876         if (mmc == NULL)
1877                 return 0;
1878
1879         DBGF("Resuming...\n");
1880
1881         host = mmc_priv(mmc);
1882
1883         wbsd_chip_config(host);
1884
1885         /*
1886          * Allow device to initialise itself properly.
1887          */
1888         mdelay(5);
1889
1890         return wbsd_resume(host);
1891 }
1892
1893 #ifdef CONFIG_PNP
1894
1895 static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1896 {
1897         struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1898         struct wbsd_host *host;
1899
1900         if (mmc == NULL)
1901                 return 0;
1902
1903         DBGF("Suspending...\n");
1904
1905         host = mmc_priv(mmc);
1906
1907         return wbsd_suspend(host, state);
1908 }
1909
1910 static int wbsd_pnp_resume(struct pnp_dev *pnp_dev)
1911 {
1912         struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1913         struct wbsd_host *host;
1914
1915         if (mmc == NULL)
1916                 return 0;
1917
1918         DBGF("Resuming...\n");
1919
1920         host = mmc_priv(mmc);
1921
1922         /*
1923          * See if chip needs to be configured.
1924          */
1925         if (host->config != 0) {
1926                 if (!wbsd_chip_validate(host)) {
1927                         printk(KERN_WARNING DRIVER_NAME
1928                                 ": PnP active but chip not configured! "
1929                                 "You probably have a buggy BIOS. "
1930                                 "Configuring chip manually.\n");
1931                         wbsd_chip_config(host);
1932                 }
1933         }
1934
1935         /*
1936          * Allow device to initialise itself properly.
1937          */
1938         mdelay(5);
1939
1940         return wbsd_resume(host);
1941 }
1942
1943 #endif /* CONFIG_PNP */
1944
1945 #else /* CONFIG_PM */
1946
1947 #define wbsd_platform_suspend NULL
1948 #define wbsd_platform_resume NULL
1949
1950 #define wbsd_pnp_suspend NULL
1951 #define wbsd_pnp_resume NULL
1952
1953 #endif /* CONFIG_PM */
1954
1955 static struct platform_device *wbsd_device;
1956
1957 static struct platform_driver wbsd_driver = {
1958         .probe          = wbsd_probe,
1959         .remove         = __devexit_p(wbsd_remove),
1960
1961         .suspend        = wbsd_platform_suspend,
1962         .resume         = wbsd_platform_resume,
1963         .driver         = {
1964                 .name   = DRIVER_NAME,
1965         },
1966 };
1967
1968 #ifdef CONFIG_PNP
1969
1970 static struct pnp_driver wbsd_pnp_driver = {
1971         .name           = DRIVER_NAME,
1972         .id_table       = pnp_dev_table,
1973         .probe          = wbsd_pnp_probe,
1974         .remove         = __devexit_p(wbsd_pnp_remove),
1975
1976         .suspend        = wbsd_pnp_suspend,
1977         .resume         = wbsd_pnp_resume,
1978 };
1979
1980 #endif /* CONFIG_PNP */
1981
1982 /*
1983  * Module loading/unloading
1984  */
1985
1986 static int __init wbsd_drv_init(void)
1987 {
1988         int result;
1989
1990         printk(KERN_INFO DRIVER_NAME
1991                 ": Winbond W83L51xD SD/MMC card interface driver\n");
1992         printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
1993
1994 #ifdef CONFIG_PNP
1995
1996         if (!nopnp) {
1997                 result = pnp_register_driver(&wbsd_pnp_driver);
1998                 if (result < 0)
1999                         return result;
2000         }
2001 #endif /* CONFIG_PNP */
2002
2003         if (nopnp) {
2004                 result = platform_driver_register(&wbsd_driver);
2005                 if (result < 0)
2006                         return result;
2007
2008                 wbsd_device = platform_device_alloc(DRIVER_NAME, -1);
2009                 if (!wbsd_device) {
2010                         platform_driver_unregister(&wbsd_driver);
2011                         return -ENOMEM;
2012                 }
2013
2014                 result = platform_device_add(wbsd_device);
2015                 if (result) {
2016                         platform_device_put(wbsd_device);
2017                         platform_driver_unregister(&wbsd_driver);
2018                         return result;
2019                 }
2020         }
2021
2022         return 0;
2023 }
2024
2025 static void __exit wbsd_drv_exit(void)
2026 {
2027 #ifdef CONFIG_PNP
2028
2029         if (!nopnp)
2030                 pnp_unregister_driver(&wbsd_pnp_driver);
2031
2032 #endif /* CONFIG_PNP */
2033
2034         if (nopnp) {
2035                 platform_device_unregister(wbsd_device);
2036
2037                 platform_driver_unregister(&wbsd_driver);
2038         }
2039
2040         DBG("unloaded\n");
2041 }
2042
2043 module_init(wbsd_drv_init);
2044 module_exit(wbsd_drv_exit);
2045 #ifdef CONFIG_PNP
2046 module_param(nopnp, uint, 0444);
2047 #endif
2048 module_param(io, uint, 0444);
2049 module_param(irq, uint, 0444);
2050 module_param(dma, int, 0444);
2051
2052 MODULE_LICENSE("GPL");
2053 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
2054 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2055
2056 #ifdef CONFIG_PNP
2057 MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2058 #endif
2059 MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2060 MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2061 MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");