git.oblomov.eu Git - linux-2.6/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 version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  *
  11  * Warning!
  12  *
  13  * Changes to the FIFO system should be done with extreme care since
  14  * the hardware is full of bugs related to the FIFO. Known issues are:
  15  *
  16  * - FIFO size field in FSR is always zero.
  17  *
  18  * - FIFO interrupts tend not to work as they should. Interrupts are
  19  *   triggered only for full/empty events, not for threshold values.
  20  *
  21  * - On APIC systems the FIFO empty interrupt is sometimes lost.
  22  */
  23
  24 #include <linux/config.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/init.h>
  28 #include <linux/ioport.h>
  29 #include <linux/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.5"
  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                 1 << data->blksz_bits, 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_bits;
 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 = (1 << data->blksz_bits) + 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 = (1 << data->blksz_bits) + 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         DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u width %u\n",
 935                 ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
 936                 ios->vdd, ios->bus_width);
 937
 938         spin_lock_bh(&host->lock);
 939
 940         /*
 941          * Reset the chip on each power off.
 942          * Should clear out any weird states.
 943          */
 944         if (ios->power_mode == MMC_POWER_OFF)
 945                 wbsd_init_device(host);
 946
 947         if (ios->clock >= 24000000)
 948                 clk = WBSD_CLK_24M;
 949         else if (ios->clock >= 16000000)
 950                 clk = WBSD_CLK_16M;
 951         else if (ios->clock >= 12000000)
 952                 clk = WBSD_CLK_12M;
 953         else
 954                 clk = WBSD_CLK_375K;
 955
 956         /*
 957          * Only write to the clock register when
 958          * there is an actual change.
 959          */
 960         if (clk != host->clk) {
 961                 wbsd_write_index(host, WBSD_IDX_CLK, clk);
 962                 host->clk = clk;
 963         }
 964
 965         /*
 966          * Power up card.
 967          */
 968         if (ios->power_mode != MMC_POWER_OFF) {
 969                 pwr = inb(host->base + WBSD_CSR);
 970                 pwr &= ~WBSD_POWER_N;
 971                 outb(pwr, host->base + WBSD_CSR);
 972         }
 973
 974         /*
 975          * MMC cards need to have pin 1 high during init.
 976          * It wreaks havoc with the card detection though so
 977          * that needs to be disabled.
 978          */
 979         setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 980         if (ios->chip_select == MMC_CS_HIGH) {
 981                 BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
 982                 setup |= WBSD_DAT3_H;
 983                 host->flags |= WBSD_FIGNORE_DETECT;
 984         } else {
 985                 if (setup & WBSD_DAT3_H) {
 986                         setup &= ~WBSD_DAT3_H;
 987
 988                         /*
 989                          * We cannot resume card detection immediatly
 990                          * because of capacitance and delays in the chip.
 991                          */
 992                         mod_timer(&host->ignore_timer, jiffies + HZ / 100);
 993                 }
 994         }
 995         wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 996
 997         /*
 998          * Store bus width for later. Will be used when
 999          * setting up the data transfer.
1000          */
1001         host->bus_width = ios->bus_width;
1002
1003         spin_unlock_bh(&host->lock);
1004 }
1005
1006 static int wbsd_get_ro(struct mmc_host *mmc)
1007 {
1008         struct wbsd_host *host = mmc_priv(mmc);
1009         u8 csr;
1010
1011         spin_lock_bh(&host->lock);
1012
1013         csr = inb(host->base + WBSD_CSR);
1014         csr |= WBSD_MSLED;
1015         outb(csr, host->base + WBSD_CSR);
1016
1017         mdelay(1);
1018
1019         csr = inb(host->base + WBSD_CSR);
1020         csr &= ~WBSD_MSLED;
1021         outb(csr, host->base + WBSD_CSR);
1022
1023         spin_unlock_bh(&host->lock);
1024
1025         return csr & WBSD_WRPT;
1026 }
1027
1028 static struct mmc_host_ops wbsd_ops = {
1029         .request        = wbsd_request,
1030         .set_ios        = wbsd_set_ios,
1031         .get_ro         = wbsd_get_ro,
1032 };
1033
1034 /*****************************************************************************\
1035  *                                                                           *
1036  * Interrupt handling                                                        *
1037  *                                                                           *
1038 \*****************************************************************************/
1039
1040 /*
1041  * Helper function to reset detection ignore
1042  */
1043
1044 static void wbsd_reset_ignore(unsigned long data)
1045 {
1046         struct wbsd_host *host = (struct wbsd_host *)data;
1047
1048         BUG_ON(host == NULL);
1049
1050         DBG("Resetting card detection ignore\n");
1051
1052         spin_lock_bh(&host->lock);
1053
1054         host->flags &= ~WBSD_FIGNORE_DETECT;
1055
1056         /*
1057          * Card status might have changed during the
1058          * blackout.
1059          */
1060         tasklet_schedule(&host->card_tasklet);
1061
1062         spin_unlock_bh(&host->lock);
1063 }
1064
1065 /*
1066  * Tasklets
1067  */
1068
1069 static inline struct mmc_data *wbsd_get_data(struct wbsd_host *host)
1070 {
1071         WARN_ON(!host->mrq);
1072         if (!host->mrq)
1073                 return NULL;
1074
1075         WARN_ON(!host->mrq->cmd);
1076         if (!host->mrq->cmd)
1077                 return NULL;
1078
1079         WARN_ON(!host->mrq->cmd->data);
1080         if (!host->mrq->cmd->data)
1081                 return NULL;
1082
1083         return host->mrq->cmd->data;
1084 }
1085
1086 static void wbsd_tasklet_card(unsigned long param)
1087 {
1088         struct wbsd_host *host = (struct wbsd_host *)param;
1089         u8 csr;
1090         int delay = -1;
1091
1092         spin_lock(&host->lock);
1093
1094         if (host->flags & WBSD_FIGNORE_DETECT) {
1095                 spin_unlock(&host->lock);
1096                 return;
1097         }
1098
1099         csr = inb(host->base + WBSD_CSR);
1100         WARN_ON(csr == 0xff);
1101
1102         if (csr & WBSD_CARDPRESENT) {
1103                 if (!(host->flags & WBSD_FCARD_PRESENT)) {
1104                         DBG("Card inserted\n");
1105                         host->flags |= WBSD_FCARD_PRESENT;
1106
1107                         delay = 500;
1108                 }
1109         } else if (host->flags & WBSD_FCARD_PRESENT) {
1110                 DBG("Card removed\n");
1111                 host->flags &= ~WBSD_FCARD_PRESENT;
1112
1113                 if (host->mrq) {
1114                         printk(KERN_ERR "%s: Card removed during transfer!\n",
1115                                 mmc_hostname(host->mmc));
1116                         wbsd_reset(host);
1117
1118                         host->mrq->cmd->error = MMC_ERR_FAILED;
1119                         tasklet_schedule(&host->finish_tasklet);
1120                 }
1121
1122                 delay = 0;
1123         }
1124
1125         /*
1126          * Unlock first since we might get a call back.
1127          */
1128
1129         spin_unlock(&host->lock);
1130
1131         if (delay != -1)
1132                 mmc_detect_change(host->mmc, msecs_to_jiffies(delay));
1133 }
1134
1135 static void wbsd_tasklet_fifo(unsigned long param)
1136 {
1137         struct wbsd_host *host = (struct wbsd_host *)param;
1138         struct mmc_data *data;
1139
1140         spin_lock(&host->lock);
1141
1142         if (!host->mrq)
1143                 goto end;
1144
1145         data = wbsd_get_data(host);
1146         if (!data)
1147                 goto end;
1148
1149         if (data->flags & MMC_DATA_WRITE)
1150                 wbsd_fill_fifo(host);
1151         else
1152                 wbsd_empty_fifo(host);
1153
1154         /*
1155          * Done?
1156          */
1157         if (host->size == data->bytes_xfered) {
1158                 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1159                 tasklet_schedule(&host->finish_tasklet);
1160         }
1161
1162 end:
1163         spin_unlock(&host->lock);
1164 }
1165
1166 static void wbsd_tasklet_crc(unsigned long param)
1167 {
1168         struct wbsd_host *host = (struct wbsd_host *)param;
1169         struct mmc_data *data;
1170
1171         spin_lock(&host->lock);
1172
1173         if (!host->mrq)
1174                 goto end;
1175
1176         data = wbsd_get_data(host);
1177         if (!data)
1178                 goto end;
1179
1180         DBGF("CRC error\n");
1181
1182         data->error = MMC_ERR_BADCRC;
1183
1184         tasklet_schedule(&host->finish_tasklet);
1185
1186 end:
1187         spin_unlock(&host->lock);
1188 }
1189
1190 static void wbsd_tasklet_timeout(unsigned long param)
1191 {
1192         struct wbsd_host *host = (struct wbsd_host *)param;
1193         struct mmc_data *data;
1194
1195         spin_lock(&host->lock);
1196
1197         if (!host->mrq)
1198                 goto end;
1199
1200         data = wbsd_get_data(host);
1201         if (!data)
1202                 goto end;
1203
1204         DBGF("Timeout\n");
1205
1206         data->error = MMC_ERR_TIMEOUT;
1207
1208         tasklet_schedule(&host->finish_tasklet);
1209
1210 end:
1211         spin_unlock(&host->lock);
1212 }
1213
1214 static void wbsd_tasklet_finish(unsigned long param)
1215 {
1216         struct wbsd_host *host = (struct wbsd_host *)param;
1217         struct mmc_data *data;
1218
1219         spin_lock(&host->lock);
1220
1221         WARN_ON(!host->mrq);
1222         if (!host->mrq)
1223                 goto end;
1224
1225         data = wbsd_get_data(host);
1226         if (!data)
1227                 goto end;
1228
1229         wbsd_finish_data(host, data);
1230
1231 end:
1232         spin_unlock(&host->lock);
1233 }
1234
1235 static void wbsd_tasklet_block(unsigned long param)
1236 {
1237         struct wbsd_host *host = (struct wbsd_host *)param;
1238         struct mmc_data *data;
1239
1240         spin_lock(&host->lock);
1241
1242         if ((wbsd_read_index(host, WBSD_IDX_CRCSTATUS) & WBSD_CRC_MASK) !=
1243                 WBSD_CRC_OK) {
1244                 data = wbsd_get_data(host);
1245                 if (!data)
1246                         goto end;
1247
1248                 DBGF("CRC error\n");
1249
1250                 data->error = MMC_ERR_BADCRC;
1251
1252                 tasklet_schedule(&host->finish_tasklet);
1253         }
1254
1255 end:
1256         spin_unlock(&host->lock);
1257 }
1258
1259 /*
1260  * Interrupt handling
1261  */
1262
1263 static irqreturn_t wbsd_irq(int irq, void *dev_id, struct pt_regs *regs)
1264 {
1265         struct wbsd_host *host = dev_id;
1266         int isr;
1267
1268         isr = inb(host->base + WBSD_ISR);
1269
1270         /*
1271          * Was it actually our hardware that caused the interrupt?
1272          */
1273         if (isr == 0xff || isr == 0x00)
1274                 return IRQ_NONE;
1275
1276         host->isr |= isr;
1277
1278         /*
1279          * Schedule tasklets as needed.
1280          */
1281         if (isr & WBSD_INT_CARD)
1282                 tasklet_schedule(&host->card_tasklet);
1283         if (isr & WBSD_INT_FIFO_THRE)
1284                 tasklet_schedule(&host->fifo_tasklet);
1285         if (isr & WBSD_INT_CRC)
1286                 tasklet_hi_schedule(&host->crc_tasklet);
1287         if (isr & WBSD_INT_TIMEOUT)
1288                 tasklet_hi_schedule(&host->timeout_tasklet);
1289         if (isr & WBSD_INT_BUSYEND)
1290                 tasklet_hi_schedule(&host->block_tasklet);
1291         if (isr & WBSD_INT_TC)
1292                 tasklet_schedule(&host->finish_tasklet);
1293
1294         return IRQ_HANDLED;
1295 }
1296
1297 /*****************************************************************************\
1298  *                                                                           *
1299  * Device initialisation and shutdown                                        *
1300  *                                                                           *
1301 \*****************************************************************************/
1302
1303 /*
1304  * Allocate/free MMC structure.
1305  */
1306
1307 static int __devinit wbsd_alloc_mmc(struct device *dev)
1308 {
1309         struct mmc_host *mmc;
1310         struct wbsd_host *host;
1311
1312         /*
1313          * Allocate MMC structure.
1314          */
1315         mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1316         if (!mmc)
1317                 return -ENOMEM;
1318
1319         host = mmc_priv(mmc);
1320         host->mmc = mmc;
1321
1322         host->dma = -1;
1323
1324         /*
1325          * Set host parameters.
1326          */
1327         mmc->ops = &wbsd_ops;
1328         mmc->f_min = 375000;
1329         mmc->f_max = 24000000;
1330         mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
1331         mmc->caps = MMC_CAP_4_BIT_DATA;
1332
1333         spin_lock_init(&host->lock);
1334
1335         /*
1336          * Set up timers
1337          */
1338         init_timer(&host->ignore_timer);
1339         host->ignore_timer.data = (unsigned long)host;
1340         host->ignore_timer.function = wbsd_reset_ignore;
1341
1342         /*
1343          * Maximum number of segments. Worst case is one sector per segment
1344          * so this will be 64kB/512.
1345          */
1346         mmc->max_hw_segs = 128;
1347         mmc->max_phys_segs = 128;
1348
1349         /*
1350          * Maximum number of sectors in one transfer. Also limited by 64kB
1351          * buffer.
1352          */
1353         mmc->max_sectors = 128;
1354
1355         /*
1356          * Maximum segment size. Could be one segment with the maximum number
1357          * of segments.
1358          */
1359         mmc->max_seg_size = mmc->max_sectors * 512;
1360
1361         dev_set_drvdata(dev, mmc);
1362
1363         return 0;
1364 }
1365
1366 static void __devexit wbsd_free_mmc(struct device *dev)
1367 {
1368         struct mmc_host *mmc;
1369         struct wbsd_host *host;
1370
1371         mmc = dev_get_drvdata(dev);
1372         if (!mmc)
1373                 return;
1374
1375         host = mmc_priv(mmc);
1376         BUG_ON(host == NULL);
1377
1378         del_timer_sync(&host->ignore_timer);
1379
1380         mmc_free_host(mmc);
1381
1382         dev_set_drvdata(dev, NULL);
1383 }
1384
1385 /*
1386  * Scan for known chip id:s
1387  */
1388
1389 static int __devinit wbsd_scan(struct wbsd_host *host)
1390 {
1391         int i, j, k;
1392         int id;
1393
1394         /*
1395          * Iterate through all ports, all codes to
1396          * find hardware that is in our known list.
1397          */
1398         for (i = 0; i < ARRAY_SIZE(config_ports); i++) {
1399                 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1400                         continue;
1401
1402                 for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) {
1403                         id = 0xFFFF;
1404
1405                         host->config = config_ports[i];
1406                         host->unlock_code = unlock_codes[j];
1407
1408                         wbsd_unlock_config(host);
1409
1410                         outb(WBSD_CONF_ID_HI, config_ports[i]);
1411                         id = inb(config_ports[i] + 1) << 8;
1412
1413                         outb(WBSD_CONF_ID_LO, config_ports[i]);
1414                         id |= inb(config_ports[i] + 1);
1415
1416                         wbsd_lock_config(host);
1417
1418                         for (k = 0; k < ARRAY_SIZE(valid_ids); k++) {
1419                                 if (id == valid_ids[k]) {
1420                                         host->chip_id = id;
1421
1422                                         return 0;
1423                                 }
1424                         }
1425
1426                         if (id != 0xFFFF) {
1427                                 DBG("Unknown hardware (id %x) found at %x\n",
1428                                         id, config_ports[i]);
1429                         }
1430                 }
1431
1432                 release_region(config_ports[i], 2);
1433         }
1434
1435         host->config = 0;
1436         host->unlock_code = 0;
1437
1438         return -ENODEV;
1439 }
1440
1441 /*
1442  * Allocate/free io port ranges
1443  */
1444
1445 static int __devinit wbsd_request_region(struct wbsd_host *host, int base)
1446 {
1447         if (io & 0x7)
1448                 return -EINVAL;
1449
1450         if (!request_region(base, 8, DRIVER_NAME))
1451                 return -EIO;
1452
1453         host->base = io;
1454
1455         return 0;
1456 }
1457
1458 static void __devexit wbsd_release_regions(struct wbsd_host *host)
1459 {
1460         if (host->base)
1461                 release_region(host->base, 8);
1462
1463         host->base = 0;
1464
1465         if (host->config)
1466                 release_region(host->config, 2);
1467
1468         host->config = 0;
1469 }
1470
1471 /*
1472  * Allocate/free DMA port and buffer
1473  */
1474
1475 static void __devinit wbsd_request_dma(struct wbsd_host *host, int dma)
1476 {
1477         if (dma < 0)
1478                 return;
1479
1480         if (request_dma(dma, DRIVER_NAME))
1481                 goto err;
1482
1483         /*
1484          * We need to allocate a special buffer in
1485          * order for ISA to be able to DMA to it.
1486          */
1487         host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
1488                 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1489         if (!host->dma_buffer)
1490                 goto free;
1491
1492         /*
1493          * Translate the address to a physical address.
1494          */
1495         host->dma_addr = dma_map_single(host->mmc->dev, host->dma_buffer,
1496                 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1497
1498         /*
1499          * ISA DMA must be aligned on a 64k basis.
1500          */
1501         if ((host->dma_addr & 0xffff) != 0)
1502                 goto kfree;
1503         /*
1504          * ISA cannot access memory above 16 MB.
1505          */
1506         else if (host->dma_addr >= 0x1000000)
1507                 goto kfree;
1508
1509         host->dma = dma;
1510
1511         return;
1512
1513 kfree:
1514         /*
1515          * If we've gotten here then there is some kind of alignment bug
1516          */
1517         BUG_ON(1);
1518
1519         dma_unmap_single(host->mmc->dev, host->dma_addr,
1520                 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1521         host->dma_addr = (dma_addr_t)NULL;
1522
1523         kfree(host->dma_buffer);
1524         host->dma_buffer = NULL;
1525
1526 free:
1527         free_dma(dma);
1528
1529 err:
1530         printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1531                 "Falling back on FIFO.\n", dma);
1532 }
1533
1534 static void __devexit wbsd_release_dma(struct wbsd_host *host)
1535 {
1536         if (host->dma_addr) {
1537                 dma_unmap_single(host->mmc->dev, host->dma_addr,
1538                         WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1539         }
1540         kfree(host->dma_buffer);
1541         if (host->dma >= 0)
1542                 free_dma(host->dma);
1543
1544         host->dma = -1;
1545         host->dma_buffer = NULL;
1546         host->dma_addr = (dma_addr_t)NULL;
1547 }
1548
1549 /*
1550  * Allocate/free IRQ.
1551  */
1552
1553 static int __devinit wbsd_request_irq(struct wbsd_host *host, int irq)
1554 {
1555         int ret;
1556
1557         /*
1558          * Allocate interrupt.
1559          */
1560
1561         ret = request_irq(irq, wbsd_irq, SA_SHIRQ, DRIVER_NAME, host);
1562         if (ret)
1563                 return ret;
1564
1565         host->irq = irq;
1566
1567         /*
1568          * Set up tasklets.
1569          */
1570         tasklet_init(&host->card_tasklet, wbsd_tasklet_card,
1571                         (unsigned long)host);
1572         tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo,
1573                         (unsigned long)host);
1574         tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc,
1575                         (unsigned long)host);
1576         tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout,
1577                         (unsigned long)host);
1578         tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish,
1579                         (unsigned long)host);
1580         tasklet_init(&host->block_tasklet, wbsd_tasklet_block,
1581                         (unsigned long)host);
1582
1583         return 0;
1584 }
1585
1586 static void __devexit wbsd_release_irq(struct wbsd_host *host)
1587 {
1588         if (!host->irq)
1589                 return;
1590
1591         free_irq(host->irq, host);
1592
1593         host->irq = 0;
1594
1595         tasklet_kill(&host->card_tasklet);
1596         tasklet_kill(&host->fifo_tasklet);
1597         tasklet_kill(&host->crc_tasklet);
1598         tasklet_kill(&host->timeout_tasklet);
1599         tasklet_kill(&host->finish_tasklet);
1600         tasklet_kill(&host->block_tasklet);
1601 }
1602
1603 /*
1604  * Allocate all resources for the host.
1605  */
1606
1607 static int __devinit wbsd_request_resources(struct wbsd_host *host,
1608         int base, int irq, int dma)
1609 {
1610         int ret;
1611
1612         /*
1613          * Allocate I/O ports.
1614          */
1615         ret = wbsd_request_region(host, base);
1616         if (ret)
1617                 return ret;
1618
1619         /*
1620          * Allocate interrupt.
1621          */
1622         ret = wbsd_request_irq(host, irq);
1623         if (ret)
1624                 return ret;
1625
1626         /*
1627          * Allocate DMA.
1628          */
1629         wbsd_request_dma(host, dma);
1630
1631         return 0;
1632 }
1633
1634 /*
1635  * Release all resources for the host.
1636  */
1637
1638 static void __devexit wbsd_release_resources(struct wbsd_host *host)
1639 {
1640         wbsd_release_dma(host);
1641         wbsd_release_irq(host);
1642         wbsd_release_regions(host);
1643 }
1644
1645 /*
1646  * Configure the resources the chip should use.
1647  */
1648
1649 static void wbsd_chip_config(struct wbsd_host *host)
1650 {
1651         wbsd_unlock_config(host);
1652
1653         /*
1654          * Reset the chip.
1655          */
1656         wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1657         wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1658
1659         /*
1660          * Select SD/MMC function.
1661          */
1662         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1663
1664         /*
1665          * Set up card detection.
1666          */
1667         wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1668
1669         /*
1670          * Configure chip
1671          */
1672         wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1673         wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1674
1675         wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1676
1677         if (host->dma >= 0)
1678                 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1679
1680         /*
1681          * Enable and power up chip.
1682          */
1683         wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1684         wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1685
1686         wbsd_lock_config(host);
1687 }
1688
1689 /*
1690  * Check that configured resources are correct.
1691  */
1692
1693 static int wbsd_chip_validate(struct wbsd_host *host)
1694 {
1695         int base, irq, dma;
1696
1697         wbsd_unlock_config(host);
1698
1699         /*
1700          * Select SD/MMC function.
1701          */
1702         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1703
1704         /*
1705          * Read configuration.
1706          */
1707         base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1708         base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1709
1710         irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1711
1712         dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1713
1714         wbsd_lock_config(host);
1715
1716         /*
1717          * Validate against given configuration.
1718          */
1719         if (base != host->base)
1720                 return 0;
1721         if (irq != host->irq)
1722                 return 0;
1723         if ((dma != host->dma) && (host->dma != -1))
1724                 return 0;
1725
1726         return 1;
1727 }
1728
1729 /*
1730  * Powers down the SD function
1731  */
1732
1733 static void wbsd_chip_poweroff(struct wbsd_host *host)
1734 {
1735         wbsd_unlock_config(host);
1736
1737         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1738         wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1739
1740         wbsd_lock_config(host);
1741 }
1742
1743 /*****************************************************************************\
1744  *                                                                           *
1745  * Devices setup and shutdown                                                *
1746  *                                                                           *
1747 \*****************************************************************************/
1748
1749 static int __devinit wbsd_init(struct device *dev, int base, int irq, int dma,
1750         int pnp)
1751 {
1752         struct wbsd_host *host = NULL;
1753         struct mmc_host *mmc = NULL;
1754         int ret;
1755
1756         ret = wbsd_alloc_mmc(dev);
1757         if (ret)
1758                 return ret;
1759
1760         mmc = dev_get_drvdata(dev);
1761         host = mmc_priv(mmc);
1762
1763         /*
1764          * Scan for hardware.
1765          */
1766         ret = wbsd_scan(host);
1767         if (ret) {
1768                 if (pnp && (ret == -ENODEV)) {
1769                         printk(KERN_WARNING DRIVER_NAME
1770                                 ": Unable to confirm device presence. You may "
1771                                 "experience lock-ups.\n");
1772                 } else {
1773                         wbsd_free_mmc(dev);
1774                         return ret;
1775                 }
1776         }
1777
1778         /*
1779          * Request resources.
1780          */
1781         ret = wbsd_request_resources(host, io, irq, dma);
1782         if (ret) {
1783                 wbsd_release_resources(host);
1784                 wbsd_free_mmc(dev);
1785                 return ret;
1786         }
1787
1788         /*
1789          * See if chip needs to be configured.
1790          */
1791         if (pnp) {
1792                 if ((host->config != 0) && !wbsd_chip_validate(host)) {
1793                         printk(KERN_WARNING DRIVER_NAME
1794                                 ": PnP active but chip not configured! "
1795                                 "You probably have a buggy BIOS. "
1796                                 "Configuring chip manually.\n");
1797                         wbsd_chip_config(host);
1798                 }
1799         } else
1800                 wbsd_chip_config(host);
1801
1802         /*
1803          * Power Management stuff. No idea how this works.
1804          * Not tested.
1805          */
1806 #ifdef CONFIG_PM
1807         if (host->config) {
1808                 wbsd_unlock_config(host);
1809                 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1810                 wbsd_lock_config(host);
1811         }
1812 #endif
1813         /*
1814          * Allow device to initialise itself properly.
1815          */
1816         mdelay(5);
1817
1818         /*
1819          * Reset the chip into a known state.
1820          */
1821         wbsd_init_device(host);
1822
1823         mmc_add_host(mmc);
1824
1825         printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
1826         if (host->chip_id != 0)
1827                 printk(" id %x", (int)host->chip_id);
1828         printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1829         if (host->dma >= 0)
1830                 printk(" dma %d", (int)host->dma);
1831         else
1832                 printk(" FIFO");
1833         if (pnp)
1834                 printk(" PnP");
1835         printk("\n");
1836
1837         return 0;
1838 }
1839
1840 static void __devexit wbsd_shutdown(struct device *dev, int pnp)
1841 {
1842         struct mmc_host *mmc = dev_get_drvdata(dev);
1843         struct wbsd_host *host;
1844
1845         if (!mmc)
1846                 return;
1847
1848         host = mmc_priv(mmc);
1849
1850         mmc_remove_host(mmc);
1851
1852         /*
1853          * Power down the SD/MMC function.
1854          */
1855         if (!pnp)
1856                 wbsd_chip_poweroff(host);
1857
1858         wbsd_release_resources(host);
1859
1860         wbsd_free_mmc(dev);
1861 }
1862
1863 /*
1864  * Non-PnP
1865  */
1866
1867 static int __devinit wbsd_probe(struct platform_device *dev)
1868 {
1869         return wbsd_init(&dev->dev, io, irq, dma, 0);
1870 }
1871
1872 static int __devexit wbsd_remove(struct platform_device *dev)
1873 {
1874         wbsd_shutdown(&dev->dev, 0);
1875
1876         return 0;
1877 }
1878
1879 /*
1880  * PnP
1881  */
1882
1883 #ifdef CONFIG_PNP
1884
1885 static int __devinit
1886 wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id)
1887 {
1888         int io, irq, dma;
1889
1890         /*
1891          * Get resources from PnP layer.
1892          */
1893         io = pnp_port_start(pnpdev, 0);
1894         irq = pnp_irq(pnpdev, 0);
1895         if (pnp_dma_valid(pnpdev, 0))
1896                 dma = pnp_dma(pnpdev, 0);
1897         else
1898                 dma = -1;
1899
1900         DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1901
1902         return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1903 }
1904
1905 static void __devexit wbsd_pnp_remove(struct pnp_dev *dev)
1906 {
1907         wbsd_shutdown(&dev->dev, 1);
1908 }
1909
1910 #endif /* CONFIG_PNP */
1911
1912 /*
1913  * Power management
1914  */
1915
1916 #ifdef CONFIG_PM
1917
1918 static int wbsd_suspend(struct wbsd_host *host, pm_message_t state)
1919 {
1920         BUG_ON(host == NULL);
1921
1922         return mmc_suspend_host(host->mmc, state);
1923 }
1924
1925 static int wbsd_resume(struct wbsd_host *host)
1926 {
1927         BUG_ON(host == NULL);
1928
1929         wbsd_init_device(host);
1930
1931         return mmc_resume_host(host->mmc);
1932 }
1933
1934 static int wbsd_platform_suspend(struct platform_device *dev,
1935                                  pm_message_t state)
1936 {
1937         struct mmc_host *mmc = platform_get_drvdata(dev);
1938         struct wbsd_host *host;
1939         int ret;
1940
1941         if (mmc == NULL)
1942                 return 0;
1943
1944         DBGF("Suspending...\n");
1945
1946         host = mmc_priv(mmc);
1947
1948         ret = wbsd_suspend(host, state);
1949         if (ret)
1950                 return ret;
1951
1952         wbsd_chip_poweroff(host);
1953
1954         return 0;
1955 }
1956
1957 static int wbsd_platform_resume(struct platform_device *dev)
1958 {
1959         struct mmc_host *mmc = platform_get_drvdata(dev);
1960         struct wbsd_host *host;
1961
1962         if (mmc == NULL)
1963                 return 0;
1964
1965         DBGF("Resuming...\n");
1966
1967         host = mmc_priv(mmc);
1968
1969         wbsd_chip_config(host);
1970
1971         /*
1972          * Allow device to initialise itself properly.
1973          */
1974         mdelay(5);
1975
1976         return wbsd_resume(host);
1977 }
1978
1979 #ifdef CONFIG_PNP
1980
1981 static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1982 {
1983         struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1984         struct wbsd_host *host;
1985
1986         if (mmc == NULL)
1987                 return 0;
1988
1989         DBGF("Suspending...\n");
1990
1991         host = mmc_priv(mmc);
1992
1993         return wbsd_suspend(host, state);
1994 }
1995
1996 static int wbsd_pnp_resume(struct pnp_dev *pnp_dev)
1997 {
1998         struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1999         struct wbsd_host *host;
2000
2001         if (mmc == NULL)
2002                 return 0;
2003
2004         DBGF("Resuming...\n");
2005
2006         host = mmc_priv(mmc);
2007
2008         /*
2009          * See if chip needs to be configured.
2010          */
2011         if (host->config != 0) {
2012                 if (!wbsd_chip_validate(host)) {
2013                         printk(KERN_WARNING DRIVER_NAME
2014                                 ": PnP active but chip not configured! "
2015                                 "You probably have a buggy BIOS. "
2016                                 "Configuring chip manually.\n");
2017                         wbsd_chip_config(host);
2018                 }
2019         }
2020
2021         /*
2022          * Allow device to initialise itself properly.
2023          */
2024         mdelay(5);
2025
2026         return wbsd_resume(host);
2027 }
2028
2029 #endif /* CONFIG_PNP */
2030
2031 #else /* CONFIG_PM */
2032
2033 #define wbsd_platform_suspend NULL
2034 #define wbsd_platform_resume NULL
2035
2036 #define wbsd_pnp_suspend NULL
2037 #define wbsd_pnp_resume NULL
2038
2039 #endif /* CONFIG_PM */
2040
2041 static struct platform_device *wbsd_device;
2042
2043 static struct platform_driver wbsd_driver = {
2044         .probe          = wbsd_probe,
2045         .remove         = __devexit_p(wbsd_remove),
2046
2047         .suspend        = wbsd_platform_suspend,
2048         .resume         = wbsd_platform_resume,
2049         .driver         = {
2050                 .name   = DRIVER_NAME,
2051         },
2052 };
2053
2054 #ifdef CONFIG_PNP
2055
2056 static struct pnp_driver wbsd_pnp_driver = {
2057         .name           = DRIVER_NAME,
2058         .id_table       = pnp_dev_table,
2059         .probe          = wbsd_pnp_probe,
2060         .remove         = __devexit_p(wbsd_pnp_remove),
2061
2062         .suspend        = wbsd_pnp_suspend,
2063         .resume         = wbsd_pnp_resume,
2064 };
2065
2066 #endif /* CONFIG_PNP */
2067
2068 /*
2069  * Module loading/unloading
2070  */
2071
2072 static int __init wbsd_drv_init(void)
2073 {
2074         int result;
2075
2076         printk(KERN_INFO DRIVER_NAME
2077                 ": Winbond W83L51xD SD/MMC card interface driver, "
2078                 DRIVER_VERSION "\n");
2079         printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
2080
2081 #ifdef CONFIG_PNP
2082
2083         if (!nopnp) {
2084                 result = pnp_register_driver(&wbsd_pnp_driver);
2085                 if (result < 0)
2086                         return result;
2087         }
2088 #endif /* CONFIG_PNP */
2089
2090         if (nopnp) {
2091                 result = platform_driver_register(&wbsd_driver);
2092                 if (result < 0)
2093                         return result;
2094
2095                 wbsd_device = platform_device_alloc(DRIVER_NAME, -1);
2096                 if (!wbsd_device) {
2097                         platform_driver_unregister(&wbsd_driver);
2098                         return -ENOMEM;
2099                 }
2100
2101                 result = platform_device_add(wbsd_device);
2102                 if (result) {
2103                         platform_device_put(wbsd_device);
2104                         platform_driver_unregister(&wbsd_driver);
2105                         return result;
2106                 }
2107         }
2108
2109         return 0;
2110 }
2111
2112 static void __exit wbsd_drv_exit(void)
2113 {
2114 #ifdef CONFIG_PNP
2115
2116         if (!nopnp)
2117                 pnp_unregister_driver(&wbsd_pnp_driver);
2118
2119 #endif /* CONFIG_PNP */
2120
2121         if (nopnp) {
2122                 platform_device_unregister(wbsd_device);
2123
2124                 platform_driver_unregister(&wbsd_driver);
2125         }
2126
2127         DBG("unloaded\n");
2128 }
2129
2130 module_init(wbsd_drv_init);
2131 module_exit(wbsd_drv_exit);
2132 #ifdef CONFIG_PNP
2133 module_param(nopnp, uint, 0444);
2134 #endif
2135 module_param(io, uint, 0444);
2136 module_param(irq, uint, 0444);
2137 module_param(dma, int, 0444);
2138
2139 MODULE_LICENSE("GPL");
2140 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
2141 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2142 MODULE_VERSION(DRIVER_VERSION);
2143
2144 #ifdef CONFIG_PNP
2145 MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2146 #endif
2147 MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2148 MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2149 MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");