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 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 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         dev_set_drvdata(dev, mmc);
1358
1359         return 0;
1360 }
1361
1362 static void __devexit wbsd_free_mmc(struct device *dev)
1363 {
1364         struct mmc_host *mmc;
1365         struct wbsd_host *host;
1366
1367         mmc = dev_get_drvdata(dev);
1368         if (!mmc)
1369                 return;
1370
1371         host = mmc_priv(mmc);
1372         BUG_ON(host == NULL);
1373
1374         del_timer_sync(&host->ignore_timer);
1375
1376         mmc_free_host(mmc);
1377
1378         dev_set_drvdata(dev, NULL);
1379 }
1380
1381 /*
1382  * Scan for known chip id:s
1383  */
1384
1385 static int __devinit wbsd_scan(struct wbsd_host *host)
1386 {
1387         int i, j, k;
1388         int id;
1389
1390         /*
1391          * Iterate through all ports, all codes to
1392          * find hardware that is in our known list.
1393          */
1394         for (i = 0; i < ARRAY_SIZE(config_ports); i++) {
1395                 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1396                         continue;
1397
1398                 for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) {
1399                         id = 0xFFFF;
1400
1401                         host->config = config_ports[i];
1402                         host->unlock_code = unlock_codes[j];
1403
1404                         wbsd_unlock_config(host);
1405
1406                         outb(WBSD_CONF_ID_HI, config_ports[i]);
1407                         id = inb(config_ports[i] + 1) << 8;
1408
1409                         outb(WBSD_CONF_ID_LO, config_ports[i]);
1410                         id |= inb(config_ports[i] + 1);
1411
1412                         wbsd_lock_config(host);
1413
1414                         for (k = 0; k < ARRAY_SIZE(valid_ids); k++) {
1415                                 if (id == valid_ids[k]) {
1416                                         host->chip_id = id;
1417
1418                                         return 0;
1419                                 }
1420                         }
1421
1422                         if (id != 0xFFFF) {
1423                                 DBG("Unknown hardware (id %x) found at %x\n",
1424                                         id, config_ports[i]);
1425                         }
1426                 }
1427
1428                 release_region(config_ports[i], 2);
1429         }
1430
1431         host->config = 0;
1432         host->unlock_code = 0;
1433
1434         return -ENODEV;
1435 }
1436
1437 /*
1438  * Allocate/free io port ranges
1439  */
1440
1441 static int __devinit wbsd_request_region(struct wbsd_host *host, int base)
1442 {
1443         if (base & 0x7)
1444                 return -EINVAL;
1445
1446         if (!request_region(base, 8, DRIVER_NAME))
1447                 return -EIO;
1448
1449         host->base = base;
1450
1451         return 0;
1452 }
1453
1454 static void __devexit wbsd_release_regions(struct wbsd_host *host)
1455 {
1456         if (host->base)
1457                 release_region(host->base, 8);
1458
1459         host->base = 0;
1460
1461         if (host->config)
1462                 release_region(host->config, 2);
1463
1464         host->config = 0;
1465 }
1466
1467 /*
1468  * Allocate/free DMA port and buffer
1469  */
1470
1471 static void __devinit wbsd_request_dma(struct wbsd_host *host, int dma)
1472 {
1473         if (dma < 0)
1474                 return;
1475
1476         if (request_dma(dma, DRIVER_NAME))
1477                 goto err;
1478
1479         /*
1480          * We need to allocate a special buffer in
1481          * order for ISA to be able to DMA to it.
1482          */
1483         host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
1484                 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1485         if (!host->dma_buffer)
1486                 goto free;
1487
1488         /*
1489          * Translate the address to a physical address.
1490          */
1491         host->dma_addr = dma_map_single(mmc_dev(host->mmc), host->dma_buffer,
1492                 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1493
1494         /*
1495          * ISA DMA must be aligned on a 64k basis.
1496          */
1497         if ((host->dma_addr & 0xffff) != 0)
1498                 goto kfree;
1499         /*
1500          * ISA cannot access memory above 16 MB.
1501          */
1502         else if (host->dma_addr >= 0x1000000)
1503                 goto kfree;
1504
1505         host->dma = dma;
1506
1507         return;
1508
1509 kfree:
1510         /*
1511          * If we've gotten here then there is some kind of alignment bug
1512          */
1513         BUG_ON(1);
1514
1515         dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1516                 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1517         host->dma_addr = (dma_addr_t)NULL;
1518
1519         kfree(host->dma_buffer);
1520         host->dma_buffer = NULL;
1521
1522 free:
1523         free_dma(dma);
1524
1525 err:
1526         printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1527                 "Falling back on FIFO.\n", dma);
1528 }
1529
1530 static void __devexit wbsd_release_dma(struct wbsd_host *host)
1531 {
1532         if (host->dma_addr) {
1533                 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1534                         WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1535         }
1536         kfree(host->dma_buffer);
1537         if (host->dma >= 0)
1538                 free_dma(host->dma);
1539
1540         host->dma = -1;
1541         host->dma_buffer = NULL;
1542         host->dma_addr = (dma_addr_t)NULL;
1543 }
1544
1545 /*
1546  * Allocate/free IRQ.
1547  */
1548
1549 static int __devinit wbsd_request_irq(struct wbsd_host *host, int irq)
1550 {
1551         int ret;
1552
1553         /*
1554          * Allocate interrupt.
1555          */
1556
1557         ret = request_irq(irq, wbsd_irq, IRQF_SHARED, DRIVER_NAME, host);
1558         if (ret)
1559                 return ret;
1560
1561         host->irq = irq;
1562
1563         /*
1564          * Set up tasklets.
1565          */
1566         tasklet_init(&host->card_tasklet, wbsd_tasklet_card,
1567                         (unsigned long)host);
1568         tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo,
1569                         (unsigned long)host);
1570         tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc,
1571                         (unsigned long)host);
1572         tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout,
1573                         (unsigned long)host);
1574         tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish,
1575                         (unsigned long)host);
1576         tasklet_init(&host->block_tasklet, wbsd_tasklet_block,
1577                         (unsigned long)host);
1578
1579         return 0;
1580 }
1581
1582 static void __devexit wbsd_release_irq(struct wbsd_host *host)
1583 {
1584         if (!host->irq)
1585                 return;
1586
1587         free_irq(host->irq, host);
1588
1589         host->irq = 0;
1590
1591         tasklet_kill(&host->card_tasklet);
1592         tasklet_kill(&host->fifo_tasklet);
1593         tasklet_kill(&host->crc_tasklet);
1594         tasklet_kill(&host->timeout_tasklet);
1595         tasklet_kill(&host->finish_tasklet);
1596         tasklet_kill(&host->block_tasklet);
1597 }
1598
1599 /*
1600  * Allocate all resources for the host.
1601  */
1602
1603 static int __devinit wbsd_request_resources(struct wbsd_host *host,
1604         int base, int irq, int dma)
1605 {
1606         int ret;
1607
1608         /*
1609          * Allocate I/O ports.
1610          */
1611         ret = wbsd_request_region(host, base);
1612         if (ret)
1613                 return ret;
1614
1615         /*
1616          * Allocate interrupt.
1617          */
1618         ret = wbsd_request_irq(host, irq);
1619         if (ret)
1620                 return ret;
1621
1622         /*
1623          * Allocate DMA.
1624          */
1625         wbsd_request_dma(host, dma);
1626
1627         return 0;
1628 }
1629
1630 /*
1631  * Release all resources for the host.
1632  */
1633
1634 static void __devexit wbsd_release_resources(struct wbsd_host *host)
1635 {
1636         wbsd_release_dma(host);
1637         wbsd_release_irq(host);
1638         wbsd_release_regions(host);
1639 }
1640
1641 /*
1642  * Configure the resources the chip should use.
1643  */
1644
1645 static void wbsd_chip_config(struct wbsd_host *host)
1646 {
1647         wbsd_unlock_config(host);
1648
1649         /*
1650          * Reset the chip.
1651          */
1652         wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1653         wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1654
1655         /*
1656          * Select SD/MMC function.
1657          */
1658         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1659
1660         /*
1661          * Set up card detection.
1662          */
1663         wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1664
1665         /*
1666          * Configure chip
1667          */
1668         wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1669         wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1670
1671         wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1672
1673         if (host->dma >= 0)
1674                 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1675
1676         /*
1677          * Enable and power up chip.
1678          */
1679         wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1680         wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1681
1682         wbsd_lock_config(host);
1683 }
1684
1685 /*
1686  * Check that configured resources are correct.
1687  */
1688
1689 static int wbsd_chip_validate(struct wbsd_host *host)
1690 {
1691         int base, irq, dma;
1692
1693         wbsd_unlock_config(host);
1694
1695         /*
1696          * Select SD/MMC function.
1697          */
1698         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1699
1700         /*
1701          * Read configuration.
1702          */
1703         base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1704         base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1705
1706         irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1707
1708         dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1709
1710         wbsd_lock_config(host);
1711
1712         /*
1713          * Validate against given configuration.
1714          */
1715         if (base != host->base)
1716                 return 0;
1717         if (irq != host->irq)
1718                 return 0;
1719         if ((dma != host->dma) && (host->dma != -1))
1720                 return 0;
1721
1722         return 1;
1723 }
1724
1725 /*
1726  * Powers down the SD function
1727  */
1728
1729 static void wbsd_chip_poweroff(struct wbsd_host *host)
1730 {
1731         wbsd_unlock_config(host);
1732
1733         wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1734         wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1735
1736         wbsd_lock_config(host);
1737 }
1738
1739 /*****************************************************************************\
1740  *                                                                           *
1741  * Devices setup and shutdown                                                *
1742  *                                                                           *
1743 \*****************************************************************************/
1744
1745 static int __devinit wbsd_init(struct device *dev, int base, int irq, int dma,
1746         int pnp)
1747 {
1748         struct wbsd_host *host = NULL;
1749         struct mmc_host *mmc = NULL;
1750         int ret;
1751
1752         ret = wbsd_alloc_mmc(dev);
1753         if (ret)
1754                 return ret;
1755
1756         mmc = dev_get_drvdata(dev);
1757         host = mmc_priv(mmc);
1758
1759         /*
1760          * Scan for hardware.
1761          */
1762         ret = wbsd_scan(host);
1763         if (ret) {
1764                 if (pnp && (ret == -ENODEV)) {
1765                         printk(KERN_WARNING DRIVER_NAME
1766                                 ": Unable to confirm device presence. You may "
1767                                 "experience lock-ups.\n");
1768                 } else {
1769                         wbsd_free_mmc(dev);
1770                         return ret;
1771                 }
1772         }
1773
1774         /*
1775          * Request resources.
1776          */
1777         ret = wbsd_request_resources(host, base, irq, dma);
1778         if (ret) {
1779                 wbsd_release_resources(host);
1780                 wbsd_free_mmc(dev);
1781                 return ret;
1782         }
1783
1784         /*
1785          * See if chip needs to be configured.
1786          */
1787         if (pnp) {
1788                 if ((host->config != 0) && !wbsd_chip_validate(host)) {
1789                         printk(KERN_WARNING DRIVER_NAME
1790                                 ": PnP active but chip not configured! "
1791                                 "You probably have a buggy BIOS. "
1792                                 "Configuring chip manually.\n");
1793                         wbsd_chip_config(host);
1794                 }
1795         } else
1796                 wbsd_chip_config(host);
1797
1798         /*
1799          * Power Management stuff. No idea how this works.
1800          * Not tested.
1801          */
1802 #ifdef CONFIG_PM
1803         if (host->config) {
1804                 wbsd_unlock_config(host);
1805                 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1806                 wbsd_lock_config(host);
1807         }
1808 #endif
1809         /*
1810          * Allow device to initialise itself properly.
1811          */
1812         mdelay(5);
1813
1814         /*
1815          * Reset the chip into a known state.
1816          */
1817         wbsd_init_device(host);
1818
1819         mmc_add_host(mmc);
1820
1821         printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
1822         if (host->chip_id != 0)
1823                 printk(" id %x", (int)host->chip_id);
1824         printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1825         if (host->dma >= 0)
1826                 printk(" dma %d", (int)host->dma);
1827         else
1828                 printk(" FIFO");
1829         if (pnp)
1830                 printk(" PnP");
1831         printk("\n");
1832
1833         return 0;
1834 }
1835
1836 static void __devexit wbsd_shutdown(struct device *dev, int pnp)
1837 {
1838         struct mmc_host *mmc = dev_get_drvdata(dev);
1839         struct wbsd_host *host;
1840
1841         if (!mmc)
1842                 return;
1843
1844         host = mmc_priv(mmc);
1845
1846         mmc_remove_host(mmc);
1847
1848         /*
1849          * Power down the SD/MMC function.
1850          */
1851         if (!pnp)
1852                 wbsd_chip_poweroff(host);
1853
1854         wbsd_release_resources(host);
1855
1856         wbsd_free_mmc(dev);
1857 }
1858
1859 /*
1860  * Non-PnP
1861  */
1862
1863 static int __devinit wbsd_probe(struct platform_device *dev)
1864 {
1865         /* Use the module parameters for resources */
1866         return wbsd_init(&dev->dev, io, irq, dma, 0);
1867 }
1868
1869 static int __devexit wbsd_remove(struct platform_device *dev)
1870 {
1871         wbsd_shutdown(&dev->dev, 0);
1872
1873         return 0;
1874 }
1875
1876 /*
1877  * PnP
1878  */
1879
1880 #ifdef CONFIG_PNP
1881
1882 static int __devinit
1883 wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id)
1884 {
1885         int io, irq, dma;
1886
1887         /*
1888          * Get resources from PnP layer.
1889          */
1890         io = pnp_port_start(pnpdev, 0);
1891         irq = pnp_irq(pnpdev, 0);
1892         if (pnp_dma_valid(pnpdev, 0))
1893                 dma = pnp_dma(pnpdev, 0);
1894         else
1895                 dma = -1;
1896
1897         DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1898
1899         return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1900 }
1901
1902 static void __devexit wbsd_pnp_remove(struct pnp_dev *dev)
1903 {
1904         wbsd_shutdown(&dev->dev, 1);
1905 }
1906
1907 #endif /* CONFIG_PNP */
1908
1909 /*
1910  * Power management
1911  */
1912
1913 #ifdef CONFIG_PM
1914
1915 static int wbsd_suspend(struct wbsd_host *host, pm_message_t state)
1916 {
1917         BUG_ON(host == NULL);
1918
1919         return mmc_suspend_host(host->mmc, state);
1920 }
1921
1922 static int wbsd_resume(struct wbsd_host *host)
1923 {
1924         BUG_ON(host == NULL);
1925
1926         wbsd_init_device(host);
1927
1928         return mmc_resume_host(host->mmc);
1929 }
1930
1931 static int wbsd_platform_suspend(struct platform_device *dev,
1932                                  pm_message_t state)
1933 {
1934         struct mmc_host *mmc = platform_get_drvdata(dev);
1935         struct wbsd_host *host;
1936         int ret;
1937
1938         if (mmc == NULL)
1939                 return 0;
1940
1941         DBGF("Suspending...\n");
1942
1943         host = mmc_priv(mmc);
1944
1945         ret = wbsd_suspend(host, state);
1946         if (ret)
1947                 return ret;
1948
1949         wbsd_chip_poweroff(host);
1950
1951         return 0;
1952 }
1953
1954 static int wbsd_platform_resume(struct platform_device *dev)
1955 {
1956         struct mmc_host *mmc = platform_get_drvdata(dev);
1957         struct wbsd_host *host;
1958
1959         if (mmc == NULL)
1960                 return 0;
1961
1962         DBGF("Resuming...\n");
1963
1964         host = mmc_priv(mmc);
1965
1966         wbsd_chip_config(host);
1967
1968         /*
1969          * Allow device to initialise itself properly.
1970          */
1971         mdelay(5);
1972
1973         return wbsd_resume(host);
1974 }
1975
1976 #ifdef CONFIG_PNP
1977
1978 static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1979 {
1980         struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1981         struct wbsd_host *host;
1982
1983         if (mmc == NULL)
1984                 return 0;
1985
1986         DBGF("Suspending...\n");
1987
1988         host = mmc_priv(mmc);
1989
1990         return wbsd_suspend(host, state);
1991 }
1992
1993 static int wbsd_pnp_resume(struct pnp_dev *pnp_dev)
1994 {
1995         struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1996         struct wbsd_host *host;
1997
1998         if (mmc == NULL)
1999                 return 0;
2000
2001         DBGF("Resuming...\n");
2002
2003         host = mmc_priv(mmc);
2004
2005         /*
2006          * See if chip needs to be configured.
2007          */
2008         if (host->config != 0) {
2009                 if (!wbsd_chip_validate(host)) {
2010                         printk(KERN_WARNING DRIVER_NAME
2011                                 ": PnP active but chip not configured! "
2012                                 "You probably have a buggy BIOS. "
2013                                 "Configuring chip manually.\n");
2014                         wbsd_chip_config(host);
2015                 }
2016         }
2017
2018         /*
2019          * Allow device to initialise itself properly.
2020          */
2021         mdelay(5);
2022
2023         return wbsd_resume(host);
2024 }
2025
2026 #endif /* CONFIG_PNP */
2027
2028 #else /* CONFIG_PM */
2029
2030 #define wbsd_platform_suspend NULL
2031 #define wbsd_platform_resume NULL
2032
2033 #define wbsd_pnp_suspend NULL
2034 #define wbsd_pnp_resume NULL
2035
2036 #endif /* CONFIG_PM */
2037
2038 static struct platform_device *wbsd_device;
2039
2040 static struct platform_driver wbsd_driver = {
2041         .probe          = wbsd_probe,
2042         .remove         = __devexit_p(wbsd_remove),
2043
2044         .suspend        = wbsd_platform_suspend,
2045         .resume         = wbsd_platform_resume,
2046         .driver         = {
2047                 .name   = DRIVER_NAME,
2048         },
2049 };
2050
2051 #ifdef CONFIG_PNP
2052
2053 static struct pnp_driver wbsd_pnp_driver = {
2054         .name           = DRIVER_NAME,
2055         .id_table       = pnp_dev_table,
2056         .probe          = wbsd_pnp_probe,
2057         .remove         = __devexit_p(wbsd_pnp_remove),
2058
2059         .suspend        = wbsd_pnp_suspend,
2060         .resume         = wbsd_pnp_resume,
2061 };
2062
2063 #endif /* CONFIG_PNP */
2064
2065 /*
2066  * Module loading/unloading
2067  */
2068
2069 static int __init wbsd_drv_init(void)
2070 {
2071         int result;
2072
2073         printk(KERN_INFO DRIVER_NAME
2074                 ": Winbond W83L51xD SD/MMC card interface driver, "
2075                 DRIVER_VERSION "\n");
2076         printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
2077
2078 #ifdef CONFIG_PNP
2079
2080         if (!nopnp) {
2081                 result = pnp_register_driver(&wbsd_pnp_driver);
2082                 if (result < 0)
2083                         return result;
2084         }
2085 #endif /* CONFIG_PNP */
2086
2087         if (nopnp) {
2088                 result = platform_driver_register(&wbsd_driver);
2089                 if (result < 0)
2090                         return result;
2091
2092                 wbsd_device = platform_device_alloc(DRIVER_NAME, -1);
2093                 if (!wbsd_device) {
2094                         platform_driver_unregister(&wbsd_driver);
2095                         return -ENOMEM;
2096                 }
2097
2098                 result = platform_device_add(wbsd_device);
2099                 if (result) {
2100                         platform_device_put(wbsd_device);
2101                         platform_driver_unregister(&wbsd_driver);
2102                         return result;
2103                 }
2104         }
2105
2106         return 0;
2107 }
2108
2109 static void __exit wbsd_drv_exit(void)
2110 {
2111 #ifdef CONFIG_PNP
2112
2113         if (!nopnp)
2114                 pnp_unregister_driver(&wbsd_pnp_driver);
2115
2116 #endif /* CONFIG_PNP */
2117
2118         if (nopnp) {
2119                 platform_device_unregister(wbsd_device);
2120
2121                 platform_driver_unregister(&wbsd_driver);
2122         }
2123
2124         DBG("unloaded\n");
2125 }
2126
2127 module_init(wbsd_drv_init);
2128 module_exit(wbsd_drv_exit);
2129 #ifdef CONFIG_PNP
2130 module_param(nopnp, uint, 0444);
2131 #endif
2132 module_param(io, uint, 0444);
2133 module_param(irq, uint, 0444);
2134 module_param(dma, int, 0444);
2135
2136 MODULE_LICENSE("GPL");
2137 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
2138 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2139 MODULE_VERSION(DRIVER_VERSION);
2140
2141 #ifdef CONFIG_PNP
2142 MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2143 #endif
2144 MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2145 MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2146 MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");