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