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