drivers/mmc/host/wbsd.c

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

DEFINITIONS
