wbsd.c

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