au1xxx-ide.c 17.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*
 * BRIEF MODULE DESCRIPTION
 * AMD Alchemy Au1xxx IDE interface routines over the Static Bus
 *
 * Copyright (c) 2003-2005 AMD, Personal Connectivity Solutions
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Note: for more information, please refer "AMD Alchemy Au1200/Au1550 IDE
 *       Interface and Linux Device Driver" Application Note.
 */
#include <linux/types.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
34
#include <linux/platform_device.h>
35 36
#include <linux/init.h>
#include <linux/ide.h>
37
#include <linux/scatterlist.h>
38 39 40 41 42 43

#include <asm/mach-au1x00/au1xxx.h>
#include <asm/mach-au1x00/au1xxx_dbdma.h>
#include <asm/mach-au1x00/au1xxx_ide.h>

#define DRV_NAME	"au1200-ide"
44
#define DRV_AUTHOR	"Enrico Walther <enrico.walther@amd.com> / Pete Popov <ppopov@embeddedalley.com>"
45

46 47
/* enable the burstmode in the dbdma */
#define IDE_AU1XXX_BURSTMODE	1
48

49 50
static _auide_hwif auide_hwif;
static int dbdma_init_done;
51

52 53
static int auide_ddma_init(_auide_hwif *auide);

54 55
#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA)

56
void auide_insw(unsigned long port, void *addr, u32 count)
57
{
58 59 60
	_auide_hwif *ahwif = &auide_hwif;
	chan_tab_t *ctp;
	au1x_ddma_desc_t *dp;
61

62 63 64 65 66 67 68 69 70 71
	if(!put_dest_flags(ahwif->rx_chan, (void*)addr, count << 1, 
			   DDMA_FLAGS_NOIE)) {
		printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__);
		return;
	}
	ctp = *((chan_tab_t **)ahwif->rx_chan);
	dp = ctp->cur_ptr;
	while (dp->dscr_cmd0 & DSCR_CMD0_V)
		;
	ctp->cur_ptr = au1xxx_ddma_get_nextptr_virt(dp);
72 73
}

74
void auide_outsw(unsigned long port, void *addr, u32 count)
75
{
76 77 78
	_auide_hwif *ahwif = &auide_hwif;
	chan_tab_t *ctp;
	au1x_ddma_desc_t *dp;
79

80 81 82 83 84 85 86 87 88 89
	if(!put_source_flags(ahwif->tx_chan, (void*)addr,
			     count << 1, DDMA_FLAGS_NOIE)) {
		printk(KERN_ERR "%s failed %d\n", __FUNCTION__, __LINE__);
		return;
	}
	ctp = *((chan_tab_t **)ahwif->tx_chan);
	dp = ctp->cur_ptr;
	while (dp->dscr_cmd0 & DSCR_CMD0_V)
		;
	ctp->cur_ptr = au1xxx_ddma_get_nextptr_virt(dp);
90 91 92 93
}

#endif

94
static void au1xxx_set_pio_mode(ide_drive_t *drive, const u8 pio)
95
{
96
	int mem_sttime = 0, mem_stcfg = au_readl(MEM_STCFG2);
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153

	/* set pio mode! */
	switch(pio) {
	case 0:
		mem_sttime = SBC_IDE_TIMING(PIO0);

		/* set configuration for RCS2# */
		mem_stcfg |= TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_PIO0_TCSOE | SBC_IDE_PIO0_TOECS;
		break;

	case 1:
		mem_sttime = SBC_IDE_TIMING(PIO1);

		/* set configuration for RCS2# */
		mem_stcfg |= TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_PIO1_TCSOE | SBC_IDE_PIO1_TOECS;
		break;

	case 2:
		mem_sttime = SBC_IDE_TIMING(PIO2);

		/* set configuration for RCS2# */
		mem_stcfg &= ~TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_PIO2_TCSOE | SBC_IDE_PIO2_TOECS;
		break;

	case 3:
		mem_sttime = SBC_IDE_TIMING(PIO3);

		/* set configuration for RCS2# */
		mem_stcfg &= ~TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_PIO3_TCSOE | SBC_IDE_PIO3_TOECS;

		break;

	case 4:
		mem_sttime = SBC_IDE_TIMING(PIO4);

		/* set configuration for RCS2# */
		mem_stcfg &= ~TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_PIO4_TCSOE | SBC_IDE_PIO4_TOECS;
		break;
	}

	au_writel(mem_sttime,MEM_STTIME2);
	au_writel(mem_stcfg,MEM_STCFG2);
154 155
}

156
static void auide_set_dma_mode(ide_drive_t *drive, const u8 speed)
157
{
158
	int mem_sttime = 0, mem_stcfg = au_readl(MEM_STCFG2);
159

160
	switch(speed) {
161
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
	case XFER_MW_DMA_2:
		mem_sttime = SBC_IDE_TIMING(MDMA2);

		/* set configuration for RCS2# */
		mem_stcfg &= ~TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_MDMA2_TCSOE | SBC_IDE_MDMA2_TOECS;

		break;
	case XFER_MW_DMA_1:
		mem_sttime = SBC_IDE_TIMING(MDMA1);

		/* set configuration for RCS2# */
		mem_stcfg &= ~TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_MDMA1_TCSOE | SBC_IDE_MDMA1_TOECS;

		break;
	case XFER_MW_DMA_0:
		mem_sttime = SBC_IDE_TIMING(MDMA0);

		/* set configuration for RCS2# */
		mem_stcfg |= TS_MASK;
		mem_stcfg &= ~TCSOE_MASK;
		mem_stcfg &= ~TOECS_MASK;
		mem_stcfg |= SBC_IDE_MDMA0_TCSOE | SBC_IDE_MDMA0_TOECS;

		break;
192
#endif
193
	}
194

195 196
	au_writel(mem_sttime,MEM_STTIME2);
	au_writel(mem_stcfg,MEM_STCFG2);
197 198 199 200 201 202
}

/*
 * Multi-Word DMA + DbDMA functions
 */

203
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
204 205
static int auide_build_dmatable(ide_drive_t *drive)
{
206 207 208 209 210 211 212 213 214 215 216 217
	int i, iswrite, count = 0;
	ide_hwif_t *hwif = HWIF(drive);

	struct request *rq = HWGROUP(drive)->rq;

	_auide_hwif *ahwif = (_auide_hwif*)hwif->hwif_data;
	struct scatterlist *sg;

	iswrite = (rq_data_dir(rq) == WRITE);
	/* Save for interrupt context */
	ahwif->drive = drive;

218
	hwif->sg_nents = i = ide_build_sglist(drive, rq);
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249

	if (!i)
		return 0;

	/* fill the descriptors */
	sg = hwif->sg_table;
	while (i && sg_dma_len(sg)) {
		u32 cur_addr;
		u32 cur_len;

		cur_addr = sg_dma_address(sg);
		cur_len = sg_dma_len(sg);

		while (cur_len) {
			u32 flags = DDMA_FLAGS_NOIE;
			unsigned int tc = (cur_len < 0xfe00)? cur_len: 0xfe00;

			if (++count >= PRD_ENTRIES) {
				printk(KERN_WARNING "%s: DMA table too small\n",
				       drive->name);
				goto use_pio_instead;
			}

			/* Lets enable intr for the last descriptor only */
			if (1==i)
				flags = DDMA_FLAGS_IE;
			else
				flags = DDMA_FLAGS_NOIE;

			if (iswrite) {
				if(!put_source_flags(ahwif->tx_chan, 
250
						     (void*) sg_virt(sg),
251 252 253
						     tc, flags)) { 
					printk(KERN_ERR "%s failed %d\n", 
					       __FUNCTION__, __LINE__);
254
				}
255
			} else 
256
			{
257
				if(!put_dest_flags(ahwif->rx_chan, 
258
						   (void*) sg_virt(sg),
259 260 261
						   tc, flags)) { 
					printk(KERN_ERR "%s failed %d\n", 
					       __FUNCTION__, __LINE__);
262
				}
263
			}
264

265 266 267
			cur_addr += tc;
			cur_len -= tc;
		}
Jens Axboe's avatar
Jens Axboe committed
268
		sg = sg_next(sg);
269 270
		i--;
	}
271

272 273
	if (count)
		return 1;
274

275
 use_pio_instead:
276
	ide_destroy_dmatable(drive);
277

278
	return 0; /* revert to PIO for this request */
279 280 281 282
}

static int auide_dma_end(ide_drive_t *drive)
{
283
	ide_hwif_t *hwif = HWIF(drive);
284

285
	if (hwif->sg_nents) {
286
		ide_destroy_dmatable(drive);
287 288
		hwif->sg_nents = 0;
	}
289

290
	return 0;
291 292 293 294 295 296 297 298 299
}

static void auide_dma_start(ide_drive_t *drive )
{
}


static void auide_dma_exec_cmd(ide_drive_t *drive, u8 command)
{
300 301 302
	/* issue cmd to drive */
	ide_execute_command(drive, command, &ide_dma_intr,
			    (2*WAIT_CMD), NULL);
303 304 305
}

static int auide_dma_setup(ide_drive_t *drive)
306 307
{       	
	struct request *rq = HWGROUP(drive)->rq;
308

309 310 311 312
	if (!auide_build_dmatable(drive)) {
		ide_map_sg(drive, rq);
		return 1;
	}
313

314 315
	drive->waiting_for_dma = 1;
	return 0;
316 317
}

318
static u8 auide_mdma_filter(ide_drive_t *drive)
319
{
320 321 322 323 324 325 326 327
	/*
	 * FIXME: ->white_list and ->black_list are based on completely bogus
	 * ->ide_dma_check implementation which didn't set neither the host
	 * controller timings nor the device for the desired transfer mode.
	 *
	 * They should be either removed or 0x00 MWDMA mask should be
	 * returned for devices on the ->black_list.
	 */
328

329
	if (dbdma_init_done == 0) {
330 331 332 333 334 335 336 337
		auide_hwif.white_list = ide_in_drive_list(drive->id,
							  dma_white_list);
		auide_hwif.black_list = ide_in_drive_list(drive->id,
							  dma_black_list);
		auide_hwif.drive = drive;
		auide_ddma_init(&auide_hwif);
		dbdma_init_done = 1;
	}
338

339
	/* Is the drive in our DMA black list? */
340
	if (auide_hwif.black_list)
341
		printk(KERN_WARNING "%s: Disabling DMA for %s (blacklisted)\n",
342
				    drive->name, drive->id->model);
343

344 345 346
	return drive->hwif->mwdma_mask;
}

347
static int auide_dma_test_irq(ide_drive_t *drive)
348 349 350
{	
	if (drive->waiting_for_dma == 0)
		printk(KERN_WARNING "%s: ide_dma_test_irq \
351 352
                                     called while not waiting\n", drive->name);

353 354
	/* If dbdma didn't execute the STOP command yet, the
	 * active bit is still set
355
	 */
356 357 358
	drive->waiting_for_dma++;
	if (drive->waiting_for_dma >= DMA_WAIT_TIMEOUT) {
		printk(KERN_WARNING "%s: timeout waiting for ddma to \
359
                                     complete\n", drive->name);
360 361 362 363
		return 1;
	}
	udelay(10);
	return 0;
364 365
}

366
static void auide_dma_host_set(ide_drive_t *drive, int on)
367 368 369
{
}

370
static void auide_dma_lost_irq(ide_drive_t *drive)
371
{
372
	printk(KERN_ERR "%s: IRQ lost\n", drive->name);
373 374
}

375
static void auide_ddma_tx_callback(int irq, void *param)
376
{
377 378
	_auide_hwif *ahwif = (_auide_hwif*)param;
	ahwif->drive->waiting_for_dma = 0;
379 380
}

381
static void auide_ddma_rx_callback(int irq, void *param)
382
{
383 384 385 386 387
	_auide_hwif *ahwif = (_auide_hwif*)param;
	ahwif->drive->waiting_for_dma = 0;
}

#endif /* end CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA */
388

389 390 391 392 393 394 395 396 397
static void auide_init_dbdma_dev(dbdev_tab_t *dev, u32 dev_id, u32 tsize, u32 devwidth, u32 flags)
{
	dev->dev_id          = dev_id;
	dev->dev_physaddr    = (u32)AU1XXX_ATA_PHYS_ADDR;
	dev->dev_intlevel    = 0;
	dev->dev_intpolarity = 0;
	dev->dev_tsize       = tsize;
	dev->dev_devwidth    = devwidth;
	dev->dev_flags       = flags;
398
}
399 400
  
#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
401

402
static void auide_dma_timeout(ide_drive_t *drive)
403
{
404
	ide_hwif_t *hwif = HWIF(drive);
405

406
	printk(KERN_ERR "%s: DMA timeout occurred: ", drive->name);
407

408 409
	if (hwif->ide_dma_test_irq(drive))
		return;
410

411
	hwif->ide_dma_end(drive);
412
}
413
					
414

415 416 417 418 419
static int auide_ddma_init(_auide_hwif *auide) {
	
	dbdev_tab_t source_dev_tab, target_dev_tab;
	u32 dev_id, tsize, devwidth, flags;
	ide_hwif_t *hwif = auide->hwif;
420

421
	dev_id   = AU1XXX_ATA_DDMA_REQ;
422

423 424 425 426 427 428 429 430 431 432 433
	if (auide->white_list || auide->black_list) {
		tsize    = 8;
		devwidth = 32;
	}
	else { 
		tsize    = 1;
		devwidth = 16;
		
		printk(KERN_ERR "au1xxx-ide: %s is not on ide driver whitelist.\n",auide_hwif.drive->id->model);
		printk(KERN_ERR "            please read 'Documentation/mips/AU1xxx_IDE.README'");
	}
434

435 436
#ifdef IDE_AU1XXX_BURSTMODE 
	flags = DEV_FLAGS_SYNC | DEV_FLAGS_BURSTABLE;
437
#else
438
	flags = DEV_FLAGS_SYNC;
439 440
#endif

441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
	/* setup dev_tab for tx channel */
	auide_init_dbdma_dev( &source_dev_tab,
			      dev_id,
			      tsize, devwidth, DEV_FLAGS_OUT | flags);
 	auide->tx_dev_id = au1xxx_ddma_add_device( &source_dev_tab );

	auide_init_dbdma_dev( &source_dev_tab,
			      dev_id,
			      tsize, devwidth, DEV_FLAGS_IN | flags);
 	auide->rx_dev_id = au1xxx_ddma_add_device( &source_dev_tab );
	
	/* We also need to add a target device for the DMA */
	auide_init_dbdma_dev( &target_dev_tab,
			      (u32)DSCR_CMD0_ALWAYS,
			      tsize, devwidth, DEV_FLAGS_ANYUSE);
	auide->target_dev_id = au1xxx_ddma_add_device(&target_dev_tab);	
 
	/* Get a channel for TX */
	auide->tx_chan = au1xxx_dbdma_chan_alloc(auide->target_dev_id,
						 auide->tx_dev_id,
						 auide_ddma_tx_callback,
						 (void*)auide);
 
	/* Get a channel for RX */
	auide->rx_chan = au1xxx_dbdma_chan_alloc(auide->rx_dev_id,
						 auide->target_dev_id,
						 auide_ddma_rx_callback,
						 (void*)auide);

	auide->tx_desc_head = (void*)au1xxx_dbdma_ring_alloc(auide->tx_chan,
							     NUM_DESCRIPTORS);
	auide->rx_desc_head = (void*)au1xxx_dbdma_ring_alloc(auide->rx_chan,
							     NUM_DESCRIPTORS);
 
475
	hwif->dmatable_cpu = dma_alloc_coherent(hwif->dev,
476 477 478 479 480 481 482 483
						PRD_ENTRIES * PRD_BYTES,        /* 1 Page */
						&hwif->dmatable_dma, GFP_KERNEL);
	
	au1xxx_dbdma_start( auide->tx_chan );
	au1xxx_dbdma_start( auide->rx_chan );
 
	return 0;
} 
484
#else
485 486 487 488 489
 
static int auide_ddma_init( _auide_hwif *auide )
{
	dbdev_tab_t source_dev_tab;
	int flags;
490

491 492 493 494
#ifdef IDE_AU1XXX_BURSTMODE 
	flags = DEV_FLAGS_SYNC | DEV_FLAGS_BURSTABLE;
#else
	flags = DEV_FLAGS_SYNC;
495 496
#endif

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
	/* setup dev_tab for tx channel */
	auide_init_dbdma_dev( &source_dev_tab,
			      (u32)DSCR_CMD0_ALWAYS,
			      8, 32, DEV_FLAGS_OUT | flags);
 	auide->tx_dev_id = au1xxx_ddma_add_device( &source_dev_tab );

	auide_init_dbdma_dev( &source_dev_tab,
			      (u32)DSCR_CMD0_ALWAYS,
			      8, 32, DEV_FLAGS_IN | flags);
 	auide->rx_dev_id = au1xxx_ddma_add_device( &source_dev_tab );
	
	/* Get a channel for TX */
	auide->tx_chan = au1xxx_dbdma_chan_alloc(DSCR_CMD0_ALWAYS,
						 auide->tx_dev_id,
						 NULL,
						 (void*)auide);
 
	/* Get a channel for RX */
	auide->rx_chan = au1xxx_dbdma_chan_alloc(auide->rx_dev_id,
						 DSCR_CMD0_ALWAYS,
						 NULL,
						 (void*)auide);
 
	auide->tx_desc_head = (void*)au1xxx_dbdma_ring_alloc(auide->tx_chan,
							     NUM_DESCRIPTORS);
	auide->rx_desc_head = (void*)au1xxx_dbdma_ring_alloc(auide->rx_chan,
							     NUM_DESCRIPTORS);
 
	au1xxx_dbdma_start( auide->tx_chan );
	au1xxx_dbdma_start( auide->rx_chan );
 	
	return 0;
529
}
530
#endif
531 532 533

static void auide_setup_ports(hw_regs_t *hw, _auide_hwif *ahwif)
{
534 535 536 537 538 539 540 541 542 543
	int i;
	unsigned long *ata_regs = hw->io_ports;

	/* FIXME? */
	for (i = 0; i < IDE_CONTROL_OFFSET; i++) {
		*ata_regs++ = ahwif->regbase + (i << AU1XXX_ATA_REG_OFFSET);
	}

	/* set the Alternative Status register */
	*ata_regs = ahwif->regbase + (14 << AU1XXX_ATA_REG_OFFSET);
544 545
}

546 547 548 549 550 551 552 553
static const struct ide_port_ops au1xxx_port_ops = {
	.set_pio_mode		= au1xxx_set_pio_mode,
	.set_dma_mode		= auide_set_dma_mode,
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
	.mdma_filter		= auide_mdma_filter,
#endif
};

554
static const struct ide_port_info au1xxx_port_info = {
555
	.port_ops		= &au1xxx_port_ops,
556 557
	.host_flags		= IDE_HFLAG_POST_SET_MODE |
				  IDE_HFLAG_NO_DMA | /* no SFF-style DMA */
558
				  IDE_HFLAG_NO_IO_32BIT |
559 560 561 562 563 564 565
				  IDE_HFLAG_UNMASK_IRQS,
	.pio_mask		= ATA_PIO4,
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
	.mwdma_mask		= ATA_MWDMA2,
#endif
};

566 567 568
static int au_ide_probe(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
569 570
	_auide_hwif *ahwif = &auide_hwif;
	ide_hwif_t *hwif;
571 572
	struct resource *res;
	int ret = 0;
573
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
574
	hw_regs_t hw;
575 576

#if defined(CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA)
577
	char *mode = "MWDMA2";
578
#elif defined(CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA)
579
	char *mode = "PIO+DDMA(offload)";
580 581
#endif

582
	memset(&auide_hwif, 0, sizeof(_auide_hwif));
583 584 585 586 587 588 589
	ahwif->irq = platform_get_irq(pdev, 0);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (res == NULL) {
		pr_debug("%s %d: no base address\n", DRV_NAME, pdev->id);
		ret = -ENODEV;
590 591 592 593 594
		goto out;
	}
	if (ahwif->irq < 0) {
		pr_debug("%s %d: no IRQ\n", DRV_NAME, pdev->id);
		ret = -ENODEV;
595 596 597
		goto out;
	}

598 599
	if (!request_mem_region(res->start, res->end - res->start + 1,
				pdev->name)) {
600
		pr_debug("%s: request_mem_region failed\n", DRV_NAME);
601
		ret =  -EBUSY;
602
		goto out;
603
	}
604

605
	ahwif->regbase = (u32)ioremap(res->start, res->end - res->start + 1);
606 607 608 609 610
	if (ahwif->regbase == 0) {
		ret = -ENOMEM;
		goto out;
	}

611 612 613 614 615
	hwif = ide_find_port();
	if (hwif == NULL) {
		ret = -ENOENT;
		goto out;
	}
616

617 618
	memset(&hw, 0, sizeof(hw));
	auide_setup_ports(&hw, ahwif);
619
	hw.irq = ahwif->irq;
620
	hw.dev = dev;
621 622 623
	hw.chipset = ide_au1xxx;

	ide_init_port_hw(hwif, &hw);
624

625 626
	hwif->dev = dev;

627 628 629 630 631 632 633
	/* If the user has selected DDMA assisted copies,
	   then set up a few local I/O function entry points 
	*/

#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA	
	hwif->INSW                      = auide_insw;
	hwif->OUTSW                     = auide_outsw;
634 635
#endif
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
636
	hwif->dma_timeout		= &auide_dma_timeout;
637
	hwif->dma_host_set		= &auide_dma_host_set;
638 639 640 641 642
	hwif->dma_exec_cmd              = &auide_dma_exec_cmd;
	hwif->dma_start                 = &auide_dma_start;
	hwif->ide_dma_end               = &auide_dma_end;
	hwif->dma_setup                 = &auide_dma_setup;
	hwif->ide_dma_test_irq          = &auide_dma_test_irq;
643
	hwif->dma_lost_irq		= &auide_dma_lost_irq;
644
#endif
645 646 647 648 649
	hwif->select_data               = 0;    /* no chipset-specific code */
	hwif->config_data               = 0;    /* no chipset-specific code */

	auide_hwif.hwif                 = hwif;
	hwif->hwif_data                 = &auide_hwif;
650

651 652 653
#ifdef CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA           
	auide_ddma_init(&auide_hwif);
	dbdma_init_done = 1;
654 655
#endif

656
	idx[0] = hwif->index;
657

658
	ide_device_add(idx, &au1xxx_port_info);
659

660 661
	dev_set_drvdata(dev, hwif);

662
	printk(KERN_INFO "Au1xxx IDE(builtin) configured for %s\n", mode );
663

664 665
 out:
	return ret;
666 667 668 669 670 671 672
}

static int au_ide_remove(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct resource *res;
	ide_hwif_t *hwif = dev_get_drvdata(dev);
673
	_auide_hwif *ahwif = &auide_hwif;
674

675
	ide_unregister(hwif->index);
676 677 678 679

	iounmap((void *)ahwif->regbase);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
680
	release_mem_region(res->start, res->end - res->start + 1);
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696

	return 0;
}

static struct device_driver au1200_ide_driver = {
	.name		= "au1200-ide",
	.bus		= &platform_bus_type,
	.probe 		= au_ide_probe,
	.remove		= au_ide_remove,
};

static int __init au_ide_init(void)
{
	return driver_register(&au1200_ide_driver);
}

697
static void __exit au_ide_exit(void)
698 699 700 701 702 703 704 705 706
{
	driver_unregister(&au1200_ide_driver);
}

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("AU1200 IDE driver");

module_init(au_ide_init);
module_exit(au_ide_exit);