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_warn("%s: Data command %d is not supported by this controller\n",
 
 807				mmc_hostname(host->mmc), cmd->opcode);
 808#endif
 809			cmd->error = -EINVAL;
 810
 811			goto done;
 812		}
 813	}
 814
 815	/*
 816	 * Does the request include data?
 817	 */
 818	if (cmd->data) {
 819		wbsd_prepare_data(host, cmd->data);
 820
 821		if (cmd->data->error)
 822			goto done;
 823	}
 824
 825	wbsd_send_command(host, cmd);
 826
 827	/*
 828	 * If this is a data transfer the request
 829	 * will be finished after the data has
 830	 * transferred.
 831	 */
 832	if (cmd->data && !cmd->error) {
 833		/*
 834		 * Dirty fix for hardware bug.
 835		 */
 836		if (host->dma == -1)
 837			tasklet_schedule(&host->fifo_tasklet);
 838
 839		spin_unlock_bh(&host->lock);
 840
 841		return;
 842	}
 843
 844done:
 845	wbsd_request_end(host, mrq);
 846
 847	spin_unlock_bh(&host->lock);
 848}
 849
 850static void wbsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 851{
 852	struct wbsd_host *host = mmc_priv(mmc);
 853	u8 clk, setup, pwr;
 854
 855	spin_lock_bh(&host->lock);
 856
 857	/*
 858	 * Reset the chip on each power off.
 859	 * Should clear out any weird states.
 860	 */
 861	if (ios->power_mode == MMC_POWER_OFF)
 862		wbsd_init_device(host);
 863
 864	if (ios->clock >= 24000000)
 865		clk = WBSD_CLK_24M;
 866	else if (ios->clock >= 16000000)
 867		clk = WBSD_CLK_16M;
 868	else if (ios->clock >= 12000000)
 869		clk = WBSD_CLK_12M;
 870	else
 871		clk = WBSD_CLK_375K;
 872
 873	/*
 874	 * Only write to the clock register when
 875	 * there is an actual change.
 876	 */
 877	if (clk != host->clk) {
 878		wbsd_write_index(host, WBSD_IDX_CLK, clk);
 879		host->clk = clk;
 880	}
 881
 882	/*
 883	 * Power up card.
 884	 */
 885	if (ios->power_mode != MMC_POWER_OFF) {
 886		pwr = inb(host->base + WBSD_CSR);
 887		pwr &= ~WBSD_POWER_N;
 888		outb(pwr, host->base + WBSD_CSR);
 889	}
 890
 891	/*
 892	 * MMC cards need to have pin 1 high during init.
 893	 * It wreaks havoc with the card detection though so
 894	 * that needs to be disabled.
 895	 */
 896	setup = wbsd_read_index(host, WBSD_IDX_SETUP);
 897	if (ios->chip_select == MMC_CS_HIGH) {
 898		BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
 899		setup |= WBSD_DAT3_H;
 900		host->flags |= WBSD_FIGNORE_DETECT;
 901	} else {
 902		if (setup & WBSD_DAT3_H) {
 903			setup &= ~WBSD_DAT3_H;
 904
 905			/*
 906			 * We cannot resume card detection immediately
 907			 * because of capacitance and delays in the chip.
 908			 */
 909			mod_timer(&host->ignore_timer, jiffies + HZ / 100);
 910		}
 911	}
 912	wbsd_write_index(host, WBSD_IDX_SETUP, setup);
 913
 914	/*
 915	 * Store bus width for later. Will be used when
 916	 * setting up the data transfer.
 917	 */
 918	host->bus_width = ios->bus_width;
 919
 920	spin_unlock_bh(&host->lock);
 921}
 922
 923static int wbsd_get_ro(struct mmc_host *mmc)
 924{
 925	struct wbsd_host *host = mmc_priv(mmc);
 926	u8 csr;
 927
 928	spin_lock_bh(&host->lock);
 929
 930	csr = inb(host->base + WBSD_CSR);
 931	csr |= WBSD_MSLED;
 932	outb(csr, host->base + WBSD_CSR);
 933
 934	mdelay(1);
 935
 936	csr = inb(host->base + WBSD_CSR);
 937	csr &= ~WBSD_MSLED;
 938	outb(csr, host->base + WBSD_CSR);
 939
 940	spin_unlock_bh(&host->lock);
 941
 942	return !!(csr & WBSD_WRPT);
 943}
 944
 945static const struct mmc_host_ops wbsd_ops = {
 946	.request	= wbsd_request,
 947	.set_ios	= wbsd_set_ios,
 948	.get_ro		= wbsd_get_ro,
 949};
 950
 951/*****************************************************************************\
 952 *                                                                           *
 953 * Interrupt handling                                                        *
 954 *                                                                           *
 955\*****************************************************************************/
 956
 957/*
 958 * Helper function to reset detection ignore
 959 */
 960
 961static void wbsd_reset_ignore(unsigned long data)
 962{
 963	struct wbsd_host *host = (struct wbsd_host *)data;
 964
 965	BUG_ON(host == NULL);
 966
 967	DBG("Resetting card detection ignore\n");
 968
 969	spin_lock_bh(&host->lock);
 970
 971	host->flags &= ~WBSD_FIGNORE_DETECT;
 972
 973	/*
 974	 * Card status might have changed during the
 975	 * blackout.
 976	 */
 977	tasklet_schedule(&host->card_tasklet);
 978
 979	spin_unlock_bh(&host->lock);
 980}
 981
 982/*
 983 * Tasklets
 984 */
 985
 986static inline struct mmc_data *wbsd_get_data(struct wbsd_host *host)
 987{
 988	WARN_ON(!host->mrq);
 989	if (!host->mrq)
 990		return NULL;
 991
 992	WARN_ON(!host->mrq->cmd);
 993	if (!host->mrq->cmd)
 994		return NULL;
 995
 996	WARN_ON(!host->mrq->cmd->data);
 997	if (!host->mrq->cmd->data)
 998		return NULL;
 999
1000	return host->mrq->cmd->data;
1001}
1002
1003static void wbsd_tasklet_card(unsigned long param)
1004{
1005	struct wbsd_host *host = (struct wbsd_host *)param;
1006	u8 csr;
1007	int delay = -1;
1008
1009	spin_lock(&host->lock);
1010
1011	if (host->flags & WBSD_FIGNORE_DETECT) {
1012		spin_unlock(&host->lock);
1013		return;
1014	}
1015
1016	csr = inb(host->base + WBSD_CSR);
1017	WARN_ON(csr == 0xff);
1018
1019	if (csr & WBSD_CARDPRESENT) {
1020		if (!(host->flags & WBSD_FCARD_PRESENT)) {
1021			DBG("Card inserted\n");
1022			host->flags |= WBSD_FCARD_PRESENT;
1023
1024			delay = 500;
1025		}
1026	} else if (host->flags & WBSD_FCARD_PRESENT) {
1027		DBG("Card removed\n");
1028		host->flags &= ~WBSD_FCARD_PRESENT;
1029
1030		if (host->mrq) {
1031			pr_err("%s: Card removed during transfer!\n",
1032				mmc_hostname(host->mmc));
1033			wbsd_reset(host);
1034
1035			host->mrq->cmd->error = -ENOMEDIUM;
1036			tasklet_schedule(&host->finish_tasklet);
1037		}
1038
1039		delay = 0;
1040	}
1041
1042	/*
1043	 * Unlock first since we might get a call back.
1044	 */
1045
1046	spin_unlock(&host->lock);
1047
1048	if (delay != -1)
1049		mmc_detect_change(host->mmc, msecs_to_jiffies(delay));
1050}
1051
1052static void wbsd_tasklet_fifo(unsigned long param)
1053{
1054	struct wbsd_host *host = (struct wbsd_host *)param;
1055	struct mmc_data *data;
1056
1057	spin_lock(&host->lock);
1058
1059	if (!host->mrq)
1060		goto end;
1061
1062	data = wbsd_get_data(host);
1063	if (!data)
1064		goto end;
1065
1066	if (data->flags & MMC_DATA_WRITE)
1067		wbsd_fill_fifo(host);
1068	else
1069		wbsd_empty_fifo(host);
1070
1071	/*
1072	 * Done?
1073	 */
1074	if (host->num_sg == 0) {
1075		wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1076		tasklet_schedule(&host->finish_tasklet);
1077	}
1078
1079end:
1080	spin_unlock(&host->lock);
1081}
1082
1083static void wbsd_tasklet_crc(unsigned long param)
1084{
1085	struct wbsd_host *host = (struct wbsd_host *)param;
1086	struct mmc_data *data;
1087
1088	spin_lock(&host->lock);
1089
1090	if (!host->mrq)
1091		goto end;
1092
1093	data = wbsd_get_data(host);
1094	if (!data)
1095		goto end;
1096
1097	DBGF("CRC error\n");
1098
1099	data->error = -EILSEQ;
1100
1101	tasklet_schedule(&host->finish_tasklet);
1102
1103end:
1104	spin_unlock(&host->lock);
1105}
1106
1107static void wbsd_tasklet_timeout(unsigned long param)
1108{
1109	struct wbsd_host *host = (struct wbsd_host *)param;
1110	struct mmc_data *data;
1111
1112	spin_lock(&host->lock);
1113
1114	if (!host->mrq)
1115		goto end;
1116
1117	data = wbsd_get_data(host);
1118	if (!data)
1119		goto end;
1120
1121	DBGF("Timeout\n");
1122
1123	data->error = -ETIMEDOUT;
1124
1125	tasklet_schedule(&host->finish_tasklet);
1126
1127end:
1128	spin_unlock(&host->lock);
1129}
1130
1131static void wbsd_tasklet_finish(unsigned long param)
1132{
1133	struct wbsd_host *host = (struct wbsd_host *)param;
1134	struct mmc_data *data;
1135
1136	spin_lock(&host->lock);
1137
1138	WARN_ON(!host->mrq);
1139	if (!host->mrq)
1140		goto end;
1141
1142	data = wbsd_get_data(host);
1143	if (!data)
1144		goto end;
1145
1146	wbsd_finish_data(host, data);
1147
1148end:
1149	spin_unlock(&host->lock);
1150}
1151
1152/*
1153 * Interrupt handling
1154 */
1155
1156static irqreturn_t wbsd_irq(int irq, void *dev_id)
1157{
1158	struct wbsd_host *host = dev_id;
1159	int isr;
1160
1161	isr = inb(host->base + WBSD_ISR);
1162
1163	/*
1164	 * Was it actually our hardware that caused the interrupt?
1165	 */
1166	if (isr == 0xff || isr == 0x00)
1167		return IRQ_NONE;
1168
1169	host->isr |= isr;
1170
1171	/*
1172	 * Schedule tasklets as needed.
1173	 */
1174	if (isr & WBSD_INT_CARD)
1175		tasklet_schedule(&host->card_tasklet);
1176	if (isr & WBSD_INT_FIFO_THRE)
1177		tasklet_schedule(&host->fifo_tasklet);
1178	if (isr & WBSD_INT_CRC)
1179		tasklet_hi_schedule(&host->crc_tasklet);
1180	if (isr & WBSD_INT_TIMEOUT)
1181		tasklet_hi_schedule(&host->timeout_tasklet);
1182	if (isr & WBSD_INT_TC)
1183		tasklet_schedule(&host->finish_tasklet);
1184
1185	return IRQ_HANDLED;
1186}
1187
1188/*****************************************************************************\
1189 *                                                                           *
1190 * Device initialisation and shutdown                                        *
1191 *                                                                           *
1192\*****************************************************************************/
1193
1194/*
1195 * Allocate/free MMC structure.
1196 */
1197
1198static int wbsd_alloc_mmc(struct device *dev)
1199{
1200	struct mmc_host *mmc;
1201	struct wbsd_host *host;
1202
1203	/*
1204	 * Allocate MMC structure.
1205	 */
1206	mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1207	if (!mmc)
1208		return -ENOMEM;
1209
1210	host = mmc_priv(mmc);
1211	host->mmc = mmc;
1212
1213	host->dma = -1;
1214
1215	/*
1216	 * Set host parameters.
1217	 */
1218	mmc->ops = &wbsd_ops;
1219	mmc->f_min = 375000;
1220	mmc->f_max = 24000000;
1221	mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
1222	mmc->caps = MMC_CAP_4_BIT_DATA;
1223
1224	spin_lock_init(&host->lock);
1225
1226	/*
1227	 * Set up timers
1228	 */
1229	init_timer(&host->ignore_timer);
1230	host->ignore_timer.data = (unsigned long)host;
1231	host->ignore_timer.function = wbsd_reset_ignore;
1232
1233	/*
1234	 * Maximum number of segments. Worst case is one sector per segment
1235	 * so this will be 64kB/512.
1236	 */
1237	mmc->max_segs = 128;
1238
1239	/*
1240	 * Maximum request size. Also limited by 64KiB buffer.
1241	 */
1242	mmc->max_req_size = 65536;
1243
1244	/*
1245	 * Maximum segment size. Could be one segment with the maximum number
1246	 * of bytes.
1247	 */
1248	mmc->max_seg_size = mmc->max_req_size;
1249
1250	/*
1251	 * Maximum block size. We have 12 bits (= 4095) but have to subtract
1252	 * space for CRC. So the maximum is 4095 - 4*2 = 4087.
1253	 */
1254	mmc->max_blk_size = 4087;
1255
1256	/*
1257	 * Maximum block count. There is no real limit so the maximum
1258	 * request size will be the only restriction.
1259	 */
1260	mmc->max_blk_count = mmc->max_req_size;
1261
1262	dev_set_drvdata(dev, mmc);
1263
1264	return 0;
1265}
1266
1267static void wbsd_free_mmc(struct device *dev)
1268{
1269	struct mmc_host *mmc;
1270	struct wbsd_host *host;
1271
1272	mmc = dev_get_drvdata(dev);
1273	if (!mmc)
1274		return;
1275
1276	host = mmc_priv(mmc);
1277	BUG_ON(host == NULL);
1278
1279	del_timer_sync(&host->ignore_timer);
1280
1281	mmc_free_host(mmc);
1282
1283	dev_set_drvdata(dev, NULL);
1284}
1285
1286/*
1287 * Scan for known chip id:s
1288 */
1289
1290static int wbsd_scan(struct wbsd_host *host)
1291{
1292	int i, j, k;
1293	int id;
1294
1295	/*
1296	 * Iterate through all ports, all codes to
1297	 * find hardware that is in our known list.
1298	 */
1299	for (i = 0; i < ARRAY_SIZE(config_ports); i++) {
1300		if (!request_region(config_ports[i], 2, DRIVER_NAME))
1301			continue;
1302
1303		for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) {
1304			id = 0xFFFF;
1305
1306			host->config = config_ports[i];
1307			host->unlock_code = unlock_codes[j];
1308
1309			wbsd_unlock_config(host);
1310
1311			outb(WBSD_CONF_ID_HI, config_ports[i]);
1312			id = inb(config_ports[i] + 1) << 8;
1313
1314			outb(WBSD_CONF_ID_LO, config_ports[i]);
1315			id |= inb(config_ports[i] + 1);
1316
1317			wbsd_lock_config(host);
1318
1319			for (k = 0; k < ARRAY_SIZE(valid_ids); k++) {
1320				if (id == valid_ids[k]) {
1321					host->chip_id = id;
1322
1323					return 0;
1324				}
1325			}
1326
1327			if (id != 0xFFFF) {
1328				DBG("Unknown hardware (id %x) found at %x\n",
1329					id, config_ports[i]);
1330			}
1331		}
1332
1333		release_region(config_ports[i], 2);
1334	}
1335
1336	host->config = 0;
1337	host->unlock_code = 0;
1338
1339	return -ENODEV;
1340}
1341
1342/*
1343 * Allocate/free io port ranges
1344 */
1345
1346static int wbsd_request_region(struct wbsd_host *host, int base)
1347{
1348	if (base & 0x7)
1349		return -EINVAL;
1350
1351	if (!request_region(base, 8, DRIVER_NAME))
1352		return -EIO;
1353
1354	host->base = base;
1355
1356	return 0;
1357}
1358
1359static void wbsd_release_regions(struct wbsd_host *host)
1360{
1361	if (host->base)
1362		release_region(host->base, 8);
1363
1364	host->base = 0;
1365
1366	if (host->config)
1367		release_region(host->config, 2);
1368
1369	host->config = 0;
1370}
1371
1372/*
1373 * Allocate/free DMA port and buffer
1374 */
1375
1376static void wbsd_request_dma(struct wbsd_host *host, int dma)
1377{
1378	if (dma < 0)
1379		return;
1380
1381	if (request_dma(dma, DRIVER_NAME))
1382		goto err;
1383
1384	/*
1385	 * We need to allocate a special buffer in
1386	 * order for ISA to be able to DMA to it.
1387	 */
1388	host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
1389		GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1390	if (!host->dma_buffer)
1391		goto free;
1392
1393	/*
1394	 * Translate the address to a physical address.
1395	 */
1396	host->dma_addr = dma_map_single(mmc_dev(host->mmc), host->dma_buffer,
1397		WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1398
1399	/*
1400	 * ISA DMA must be aligned on a 64k basis.
1401	 */
1402	if ((host->dma_addr & 0xffff) != 0)
1403		goto kfree;
1404	/*
1405	 * ISA cannot access memory above 16 MB.
1406	 */
1407	else if (host->dma_addr >= 0x1000000)
1408		goto kfree;
1409
1410	host->dma = dma;
1411
1412	return;
1413
1414kfree:
1415	/*
1416	 * If we've gotten here then there is some kind of alignment bug
1417	 */
1418	BUG_ON(1);
1419
1420	dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1421		WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1422	host->dma_addr = 0;
1423
1424	kfree(host->dma_buffer);
1425	host->dma_buffer = NULL;
1426
1427free:
1428	free_dma(dma);
1429
1430err:
1431	pr_warn(DRIVER_NAME ": Unable to allocate DMA %d - falling back on FIFO\n",
1432		dma);
1433}
1434
1435static void wbsd_release_dma(struct wbsd_host *host)
1436{
1437	if (host->dma_addr) {
1438		dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1439			WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1440	}
1441	kfree(host->dma_buffer);
1442	if (host->dma >= 0)
1443		free_dma(host->dma);
1444
1445	host->dma = -1;
1446	host->dma_buffer = NULL;
1447	host->dma_addr = 0;
1448}
1449
1450/*
1451 * Allocate/free IRQ.
1452 */
1453
1454static int wbsd_request_irq(struct wbsd_host *host, int irq)
1455{
1456	int ret;
1457
1458	/*
1459	 * Set up tasklets. Must be done before requesting interrupt.
1460	 */
1461	tasklet_init(&host->card_tasklet, wbsd_tasklet_card,
1462			(unsigned long)host);
1463	tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo,
1464			(unsigned long)host);
1465	tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc,
1466			(unsigned long)host);
1467	tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout,
1468			(unsigned long)host);
1469	tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish,
1470			(unsigned long)host);
1471
1472	/*
1473	 * Allocate interrupt.
1474	 */
1475	ret = request_irq(irq, wbsd_irq, IRQF_SHARED, DRIVER_NAME, host);
1476	if (ret)
1477		return ret;
1478
1479	host->irq = irq;
1480
1481	return 0;
1482}
1483
1484static void  wbsd_release_irq(struct wbsd_host *host)
1485{
1486	if (!host->irq)
1487		return;
1488
1489	free_irq(host->irq, host);
1490
1491	host->irq = 0;
1492
1493	tasklet_kill(&host->card_tasklet);
1494	tasklet_kill(&host->fifo_tasklet);
1495	tasklet_kill(&host->crc_tasklet);
1496	tasklet_kill(&host->timeout_tasklet);
1497	tasklet_kill(&host->finish_tasklet);
1498}
1499
1500/*
1501 * Allocate all resources for the host.
1502 */
1503
1504static int wbsd_request_resources(struct wbsd_host *host,
1505	int base, int irq, int dma)
1506{
1507	int ret;
1508
1509	/*
1510	 * Allocate I/O ports.
1511	 */
1512	ret = wbsd_request_region(host, base);
1513	if (ret)
1514		return ret;
1515
1516	/*
1517	 * Allocate interrupt.
1518	 */
1519	ret = wbsd_request_irq(host, irq);
1520	if (ret)
1521		return ret;
1522
1523	/*
1524	 * Allocate DMA.
1525	 */
1526	wbsd_request_dma(host, dma);
1527
1528	return 0;
1529}
1530
1531/*
1532 * Release all resources for the host.
1533 */
1534
1535static void wbsd_release_resources(struct wbsd_host *host)
1536{
1537	wbsd_release_dma(host);
1538	wbsd_release_irq(host);
1539	wbsd_release_regions(host);
1540}
1541
1542/*
1543 * Configure the resources the chip should use.
1544 */
1545
1546static void wbsd_chip_config(struct wbsd_host *host)
1547{
1548	wbsd_unlock_config(host);
1549
1550	/*
1551	 * Reset the chip.
1552	 */
1553	wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1554	wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1555
1556	/*
1557	 * Select SD/MMC function.
1558	 */
1559	wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1560
1561	/*
1562	 * Set up card detection.
1563	 */
1564	wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1565
1566	/*
1567	 * Configure chip
1568	 */
1569	wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1570	wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1571
1572	wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1573
1574	if (host->dma >= 0)
1575		wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1576
1577	/*
1578	 * Enable and power up chip.
1579	 */
1580	wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1581	wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1582
1583	wbsd_lock_config(host);
1584}
1585
1586/*
1587 * Check that configured resources are correct.
1588 */
1589
1590static int wbsd_chip_validate(struct wbsd_host *host)
1591{
1592	int base, irq, dma;
1593
1594	wbsd_unlock_config(host);
1595
1596	/*
1597	 * Select SD/MMC function.
1598	 */
1599	wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1600
1601	/*
1602	 * Read configuration.
1603	 */
1604	base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1605	base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1606
1607	irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1608
1609	dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1610
1611	wbsd_lock_config(host);
1612
1613	/*
1614	 * Validate against given configuration.
1615	 */
1616	if (base != host->base)
1617		return 0;
1618	if (irq != host->irq)
1619		return 0;
1620	if ((dma != host->dma) && (host->dma != -1))
1621		return 0;
1622
1623	return 1;
1624}
1625
1626/*
1627 * Powers down the SD function
1628 */
1629
1630static void wbsd_chip_poweroff(struct wbsd_host *host)
1631{
1632	wbsd_unlock_config(host);
1633
1634	wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1635	wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1636
1637	wbsd_lock_config(host);
1638}
1639
1640/*****************************************************************************\
1641 *                                                                           *
1642 * Devices setup and shutdown                                                *
1643 *                                                                           *
1644\*****************************************************************************/
1645
1646static int wbsd_init(struct device *dev, int base, int irq, int dma,
1647	int pnp)
1648{
1649	struct wbsd_host *host = NULL;
1650	struct mmc_host *mmc = NULL;
1651	int ret;
1652
1653	ret = wbsd_alloc_mmc(dev);
1654	if (ret)
1655		return ret;
1656
1657	mmc = dev_get_drvdata(dev);
1658	host = mmc_priv(mmc);
1659
1660	/*
1661	 * Scan for hardware.
1662	 */
1663	ret = wbsd_scan(host);
1664	if (ret) {
1665		if (pnp && (ret == -ENODEV)) {
1666			pr_warn(DRIVER_NAME ": Unable to confirm device presence - you may experience lock-ups\n");
 
 
1667		} else {
1668			wbsd_free_mmc(dev);
1669			return ret;
1670		}
1671	}
1672
1673	/*
1674	 * Request resources.
1675	 */
1676	ret = wbsd_request_resources(host, base, irq, dma);
1677	if (ret) {
1678		wbsd_release_resources(host);
1679		wbsd_free_mmc(dev);
1680		return ret;
1681	}
1682
1683	/*
1684	 * See if chip needs to be configured.
1685	 */
1686	if (pnp) {
1687		if ((host->config != 0) && !wbsd_chip_validate(host)) {
1688			pr_warn(DRIVER_NAME ": PnP active but chip not configured! You probably have a buggy BIOS. Configuring chip manually.\n");
 
 
 
1689			wbsd_chip_config(host);
1690		}
1691	} else
1692		wbsd_chip_config(host);
1693
1694	/*
1695	 * Power Management stuff. No idea how this works.
1696	 * Not tested.
1697	 */
1698#ifdef CONFIG_PM
1699	if (host->config) {
1700		wbsd_unlock_config(host);
1701		wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1702		wbsd_lock_config(host);
1703	}
1704#endif
1705	/*
1706	 * Allow device to initialise itself properly.
1707	 */
1708	mdelay(5);
1709
1710	/*
1711	 * Reset the chip into a known state.
1712	 */
1713	wbsd_init_device(host);
1714
1715	mmc_add_host(mmc);
1716
1717	pr_info("%s: W83L51xD", mmc_hostname(mmc));
1718	if (host->chip_id != 0)
1719		printk(" id %x", (int)host->chip_id);
1720	printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1721	if (host->dma >= 0)
1722		printk(" dma %d", (int)host->dma);
1723	else
1724		printk(" FIFO");
1725	if (pnp)
1726		printk(" PnP");
1727	printk("\n");
1728
1729	return 0;
1730}
1731
1732static void wbsd_shutdown(struct device *dev, int pnp)
1733{
1734	struct mmc_host *mmc = dev_get_drvdata(dev);
1735	struct wbsd_host *host;
1736
1737	if (!mmc)
1738		return;
1739
1740	host = mmc_priv(mmc);
1741
1742	mmc_remove_host(mmc);
1743
1744	/*
1745	 * Power down the SD/MMC function.
1746	 */
1747	if (!pnp)
1748		wbsd_chip_poweroff(host);
1749
1750	wbsd_release_resources(host);
1751
1752	wbsd_free_mmc(dev);
1753}
1754
1755/*
1756 * Non-PnP
1757 */
1758
1759static int wbsd_probe(struct platform_device *dev)
1760{
1761	/* Use the module parameters for resources */
1762	return wbsd_init(&dev->dev, param_io, param_irq, param_dma, 0);
1763}
1764
1765static int wbsd_remove(struct platform_device *dev)
1766{
1767	wbsd_shutdown(&dev->dev, 0);
1768
1769	return 0;
1770}
1771
1772/*
1773 * PnP
1774 */
1775
1776#ifdef CONFIG_PNP
1777
1778static int
1779wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id)
1780{
1781	int io, irq, dma;
1782
1783	/*
1784	 * Get resources from PnP layer.
1785	 */
1786	io = pnp_port_start(pnpdev, 0);
1787	irq = pnp_irq(pnpdev, 0);
1788	if (pnp_dma_valid(pnpdev, 0))
1789		dma = pnp_dma(pnpdev, 0);
1790	else
1791		dma = -1;
1792
1793	DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1794
1795	return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1796}
1797
1798static void wbsd_pnp_remove(struct pnp_dev *dev)
1799{
1800	wbsd_shutdown(&dev->dev, 1);
1801}
1802
1803#endif /* CONFIG_PNP */
1804
1805/*
1806 * Power management
1807 */
1808
1809#ifdef CONFIG_PM
1810
1811static int wbsd_platform_suspend(struct platform_device *dev,
1812				 pm_message_t state)
1813{
1814	struct mmc_host *mmc = platform_get_drvdata(dev);
1815	struct wbsd_host *host;
1816
1817	if (mmc == NULL)
1818		return 0;
1819
1820	DBGF("Suspending...\n");
1821
1822	host = mmc_priv(mmc);
1823
1824	wbsd_chip_poweroff(host);
1825	return 0;
1826}
1827
1828static int wbsd_platform_resume(struct platform_device *dev)
1829{
1830	struct mmc_host *mmc = platform_get_drvdata(dev);
1831	struct wbsd_host *host;
1832
1833	if (mmc == NULL)
1834		return 0;
1835
1836	DBGF("Resuming...\n");
1837
1838	host = mmc_priv(mmc);
1839
1840	wbsd_chip_config(host);
1841
1842	/*
1843	 * Allow device to initialise itself properly.
1844	 */
1845	mdelay(5);
1846
1847	wbsd_init_device(host);
1848	return 0;
1849}
1850
1851#ifdef CONFIG_PNP
1852
1853static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1854{
1855	struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1856
1857	if (mmc == NULL)
1858		return 0;
1859
1860	DBGF("Suspending...\n");
1861	return 0;
1862}
1863
1864static int wbsd_pnp_resume(struct pnp_dev *pnp_dev)
1865{
1866	struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1867	struct wbsd_host *host;
1868
1869	if (mmc == NULL)
1870		return 0;
1871
1872	DBGF("Resuming...\n");
1873
1874	host = mmc_priv(mmc);
1875
1876	/*
1877	 * See if chip needs to be configured.
1878	 */
1879	if (host->config != 0) {
1880		if (!wbsd_chip_validate(host)) {
1881			pr_warn(DRIVER_NAME ": PnP active but chip not configured! You probably have a buggy BIOS. Configuring chip manually.\n");
 
 
 
1882			wbsd_chip_config(host);
1883		}
1884	}
1885
1886	/*
1887	 * Allow device to initialise itself properly.
1888	 */
1889	mdelay(5);
1890
1891	wbsd_init_device(host);
1892	return 0;
1893}
1894
1895#endif /* CONFIG_PNP */
1896
1897#else /* CONFIG_PM */
1898
1899#define wbsd_platform_suspend NULL
1900#define wbsd_platform_resume NULL
1901
1902#define wbsd_pnp_suspend NULL
1903#define wbsd_pnp_resume NULL
1904
1905#endif /* CONFIG_PM */
1906
1907static struct platform_device *wbsd_device;
1908
1909static struct platform_driver wbsd_driver = {
1910	.probe		= wbsd_probe,
1911	.remove		= wbsd_remove,
1912
1913	.suspend	= wbsd_platform_suspend,
1914	.resume		= wbsd_platform_resume,
1915	.driver		= {
1916		.name	= DRIVER_NAME,
 
1917	},
1918};
1919
1920#ifdef CONFIG_PNP
1921
1922static struct pnp_driver wbsd_pnp_driver = {
1923	.name		= DRIVER_NAME,
1924	.id_table	= pnp_dev_table,
1925	.probe		= wbsd_pnp_probe,
1926	.remove		= wbsd_pnp_remove,
1927
1928	.suspend	= wbsd_pnp_suspend,
1929	.resume		= wbsd_pnp_resume,
1930};
1931
1932#endif /* CONFIG_PNP */
1933
1934/*
1935 * Module loading/unloading
1936 */
1937
1938static int __init wbsd_drv_init(void)
1939{
1940	int result;
1941
1942	pr_info(DRIVER_NAME
1943		": Winbond W83L51xD SD/MMC card interface driver\n");
1944	pr_info(DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
1945
1946#ifdef CONFIG_PNP
1947
1948	if (!param_nopnp) {
1949		result = pnp_register_driver(&wbsd_pnp_driver);
1950		if (result < 0)
1951			return result;
1952	}
1953#endif /* CONFIG_PNP */
1954
1955	if (param_nopnp) {
1956		result = platform_driver_register(&wbsd_driver);
1957		if (result < 0)
1958			return result;
1959
1960		wbsd_device = platform_device_alloc(DRIVER_NAME, -1);
1961		if (!wbsd_device) {
1962			platform_driver_unregister(&wbsd_driver);
1963			return -ENOMEM;
1964		}
1965
1966		result = platform_device_add(wbsd_device);
1967		if (result) {
1968			platform_device_put(wbsd_device);
1969			platform_driver_unregister(&wbsd_driver);
1970			return result;
1971		}
1972	}
1973
1974	return 0;
1975}
1976
1977static void __exit wbsd_drv_exit(void)
1978{
1979#ifdef CONFIG_PNP
1980
1981	if (!param_nopnp)
1982		pnp_unregister_driver(&wbsd_pnp_driver);
1983
1984#endif /* CONFIG_PNP */
1985
1986	if (param_nopnp) {
1987		platform_device_unregister(wbsd_device);
1988
1989		platform_driver_unregister(&wbsd_driver);
1990	}
1991
1992	DBG("unloaded\n");
1993}
1994
1995module_init(wbsd_drv_init);
1996module_exit(wbsd_drv_exit);
1997#ifdef CONFIG_PNP
1998module_param_named(nopnp, param_nopnp, uint, 0444);
1999#endif
2000module_param_named(io, param_io, uint, 0444);
2001module_param_named(irq, param_irq, uint, 0444);
2002module_param_named(dma, param_dma, int, 0444);
2003
2004MODULE_LICENSE("GPL");
2005MODULE_AUTHOR("Pierre Ossman <pierre@ossman.eu>");
2006MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2007
2008#ifdef CONFIG_PNP
2009MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2010#endif
2011MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2012MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2013MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");