sgiioc4.c 19.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 * Copyright (c) 2003-2006 Silicon Graphics, Inc.  All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
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
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 * For further information regarding this notice, see:
 *
 * http://oss.sgi.com/projects/GenInfo/NoticeExplan
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/hdreg.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/blkdev.h>
Jens Axboe's avatar
Jens Axboe committed
32
#include <linux/scatterlist.h>
33
#include <linux/ioc4.h>
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36 37
#include <asm/io.h>

#include <linux/ide.h>

38 39
#define DRV_NAME "SGIIOC4"

Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
/* IOC4 Specific Definitions */
#define IOC4_CMD_OFFSET		0x100
#define IOC4_CTRL_OFFSET	0x120
#define IOC4_DMA_OFFSET		0x140
#define IOC4_INTR_OFFSET	0x0

#define IOC4_TIMING		0x00
#define IOC4_DMA_PTR_L		0x01
#define IOC4_DMA_PTR_H		0x02
#define IOC4_DMA_ADDR_L		0x03
#define IOC4_DMA_ADDR_H		0x04
#define IOC4_BC_DEV		0x05
#define IOC4_BC_MEM		0x06
#define	IOC4_DMA_CTRL		0x07
#define	IOC4_DMA_END_ADDR	0x08

/* Bits in the IOC4 Control/Status Register */
#define	IOC4_S_DMA_START	0x01
#define	IOC4_S_DMA_STOP		0x02
#define	IOC4_S_DMA_DIR		0x04
#define	IOC4_S_DMA_ACTIVE	0x08
#define	IOC4_S_DMA_ERROR	0x10
#define	IOC4_ATA_MEMERR		0x02

/* Read/Write Directions */
#define	IOC4_DMA_WRITE		0x04
#define	IOC4_DMA_READ		0x00

/* Interrupt Register Offsets */
#define IOC4_INTR_REG		0x03
#define	IOC4_INTR_SET		0x05
#define	IOC4_INTR_CLEAR		0x07

#define IOC4_IDE_CACHELINE_SIZE	128
#define IOC4_CMD_CTL_BLK_SIZE	0x20
#define IOC4_SUPPORTED_FIRMWARE_REV 46

typedef struct {
	u32 timing_reg0;
	u32 timing_reg1;
	u32 low_mem_ptr;
	u32 high_mem_ptr;
	u32 low_mem_addr;
	u32 high_mem_addr;
	u32 dev_byte_count;
	u32 mem_byte_count;
	u32 status;
} ioc4_dma_regs_t;

/* Each Physical Region Descriptor Entry size is 16 bytes (2 * 64 bits) */
/* IOC4 has only 1 IDE channel */
#define IOC4_PRD_BYTES       16
#define IOC4_PRD_ENTRIES     (PAGE_SIZE /(4*IOC4_PRD_BYTES))


static void
sgiioc4_init_hwif_ports(hw_regs_t * hw, unsigned long data_port,
			unsigned long ctrl_port, unsigned long irq_port)
{
	unsigned long reg = data_port;
	int i;

	/* Registers are word (32 bit) aligned */
	for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
		hw->io_ports[i] = reg + i * 4;

	if (ctrl_port)
		hw->io_ports[IDE_CONTROL_OFFSET] = ctrl_port;

	if (irq_port)
		hw->io_ports[IDE_IRQ_OFFSET] = irq_port;
}

static void
sgiioc4_maskproc(ide_drive_t * drive, int mask)
{
116 117
	writeb(mask ? (drive->ctl | 2) : (drive->ctl & ~2),
	       (void __iomem *)IDE_CONTROL_REG);
Linus Torvalds's avatar
Linus Torvalds committed
118 119 120 121 122 123
}


static int
sgiioc4_checkirq(ide_hwif_t * hwif)
{
124 125
	unsigned long intr_addr =
		hwif->io_ports[IDE_IRQ_OFFSET] + IOC4_INTR_REG * 4;
Linus Torvalds's avatar
Linus Torvalds committed
126

127
	if ((u8)readl((void __iomem *)intr_addr) & 0x03)
Linus Torvalds's avatar
Linus Torvalds committed
128 129 130 131 132
		return 1;

	return 0;
}

133
static u8 sgiioc4_INB(unsigned long);
Linus Torvalds's avatar
Linus Torvalds committed
134 135 136 137 138 139 140 141 142 143

static int
sgiioc4_clearirq(ide_drive_t * drive)
{
	u32 intr_reg;
	ide_hwif_t *hwif = HWIF(drive);
	unsigned long other_ir =
	    hwif->io_ports[IDE_IRQ_OFFSET] + (IOC4_INTR_REG << 2);

	/* Code to check for PCI error conditions */
144
	intr_reg = readl((void __iomem *)other_ir);
Linus Torvalds's avatar
Linus Torvalds committed
145 146
	if (intr_reg & 0x03) { /* Valid IOC4-IDE interrupt */
		/*
147
		 * Using sgiioc4_INB to read the IDE_STATUS_REG has a side effect
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151 152
		 * of clearing the interrupt.  The first read should clear it
		 * if it is set.  The second read should return a "clear" status
		 * if it got cleared.  If not, then spin for a bit trying to
		 * clear it.
		 */
153
		u8 stat = sgiioc4_INB(IDE_STATUS_REG);
Linus Torvalds's avatar
Linus Torvalds committed
154
		int count = 0;
155
		stat = sgiioc4_INB(IDE_STATUS_REG);
Linus Torvalds's avatar
Linus Torvalds committed
156 157
		while ((stat & 0x80) && (count++ < 100)) {
			udelay(1);
158
			stat = sgiioc4_INB(IDE_STATUS_REG);
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163 164 165 166
		}

		if (intr_reg & 0x02) {
			/* Error when transferring DMA data on PCI bus */
			u32 pci_err_addr_low, pci_err_addr_high,
			    pci_stat_cmd_reg;

			pci_err_addr_low =
167
				readl((void __iomem *)hwif->io_ports[IDE_IRQ_OFFSET]);
Linus Torvalds's avatar
Linus Torvalds committed
168
			pci_err_addr_high =
169
				readl((void __iomem *)(hwif->io_ports[IDE_IRQ_OFFSET] + 4));
Linus Torvalds's avatar
Linus Torvalds committed
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
			pci_read_config_dword(hwif->pci_dev, PCI_COMMAND,
					      &pci_stat_cmd_reg);
			printk(KERN_ERR
			       "%s(%s) : PCI Bus Error when doing DMA:"
				   " status-cmd reg is 0x%x\n",
			       __FUNCTION__, drive->name, pci_stat_cmd_reg);
			printk(KERN_ERR
			       "%s(%s) : PCI Error Address is 0x%x%x\n",
			       __FUNCTION__, drive->name,
			       pci_err_addr_high, pci_err_addr_low);
			/* Clear the PCI Error indicator */
			pci_write_config_dword(hwif->pci_dev, PCI_COMMAND,
					       0x00000146);
		}

		/* Clear the Interrupt, Error bits on the IOC4 */
186
		writel(0x03, (void __iomem *)other_ir);
Linus Torvalds's avatar
Linus Torvalds committed
187

188
		intr_reg = readl((void __iomem *)other_ir);
Linus Torvalds's avatar
Linus Torvalds committed
189 190 191 192 193 194 195 196
	}

	return intr_reg & 3;
}

static void sgiioc4_ide_dma_start(ide_drive_t * drive)
{
	ide_hwif_t *hwif = HWIF(drive);
197 198
	unsigned long ioc4_dma_addr = hwif->dma_base + IOC4_DMA_CTRL * 4;
	unsigned int reg = readl((void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
199 200
	unsigned int temp_reg = reg | IOC4_S_DMA_START;

201
	writel(temp_reg, (void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
202 203 204 205 206
}

static u32
sgiioc4_ide_dma_stop(ide_hwif_t *hwif, u64 dma_base)
{
207
	unsigned long ioc4_dma_addr = dma_base + IOC4_DMA_CTRL * 4;
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211
	u32	ioc4_dma;
	int	count;

	count = 0;
212
	ioc4_dma = readl((void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
213 214
	while ((ioc4_dma & IOC4_S_DMA_STOP) && (count++ < 200)) {
		udelay(1);
215
		ioc4_dma = readl((void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
216 217 218 219 220 221 222 223 224 225
	}
	return ioc4_dma;
}

/* Stops the IOC4 DMA Engine */
static int
sgiioc4_ide_dma_end(ide_drive_t * drive)
{
	u32 ioc4_dma, bc_dev, bc_mem, num, valid = 0, cnt = 0;
	ide_hwif_t *hwif = HWIF(drive);
226
	unsigned long dma_base = hwif->dma_base;
Linus Torvalds's avatar
Linus Torvalds committed
227
	int dma_stat = 0;
228
	unsigned long *ending_dma = ide_get_hwifdata(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
229

230
	writel(IOC4_S_DMA_STOP, (void __iomem *)(dma_base + IOC4_DMA_CTRL * 4));
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261

	ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base);

	if (ioc4_dma & IOC4_S_DMA_STOP) {
		printk(KERN_ERR
		       "%s(%s): IOC4 DMA STOP bit is still 1 :"
		       "ioc4_dma_reg 0x%x\n",
		       __FUNCTION__, drive->name, ioc4_dma);
		dma_stat = 1;
	}

	/*
	 * The IOC4 will DMA 1's to the ending dma area to indicate that
	 * previous data DMA is complete.  This is necessary because of relaxed
	 * ordering between register reads and DMA writes on the Altix.
	 */
	while ((cnt++ < 200) && (!valid)) {
		for (num = 0; num < 16; num++) {
			if (ending_dma[num]) {
				valid = 1;
				break;
			}
		}
		udelay(1);
	}
	if (!valid) {
		printk(KERN_ERR "%s(%s) : DMA incomplete\n", __FUNCTION__,
		       drive->name);
		dma_stat = 1;
	}

262 263
	bc_dev = readl((void __iomem *)(dma_base + IOC4_BC_DEV * 4));
	bc_mem = readl((void __iomem *)(dma_base + IOC4_BC_MEM * 4));
Linus Torvalds's avatar
Linus Torvalds committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284

	if ((bc_dev & 0x01FF) || (bc_mem & 0x1FF)) {
		if (bc_dev > bc_mem + 8) {
			printk(KERN_ERR
			       "%s(%s): WARNING!! byte_count_dev %d "
			       "!= byte_count_mem %d\n",
			       __FUNCTION__, drive->name, bc_dev, bc_mem);
		}
	}

	drive->waiting_for_dma = 0;
	ide_destroy_dmatable(drive);

	return dma_stat;
}

static int
sgiioc4_ide_dma_on(ide_drive_t * drive)
{
	drive->using_dma = 1;

285
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
286 287
}

288
static void sgiioc4_dma_off_quietly(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
289 290 291
{
	drive->using_dma = 0;

292
	drive->hwif->dma_host_off(drive);
Linus Torvalds's avatar
Linus Torvalds committed
293 294
}

295
static void sgiioc4_set_dma_mode(ide_drive_t *drive, const u8 speed)
296 297 298
{
}

Linus Torvalds's avatar
Linus Torvalds committed
299 300 301 302 303 304 305
/* returns 1 if dma irq issued, 0 otherwise */
static int
sgiioc4_ide_dma_test_irq(ide_drive_t * drive)
{
	return sgiioc4_checkirq(HWIF(drive));
}

306
static void sgiioc4_dma_host_on(ide_drive_t * drive)
Linus Torvalds's avatar
Linus Torvalds committed
307 308 309
{
}

310
static void sgiioc4_dma_host_off(ide_drive_t * drive)
Linus Torvalds's avatar
Linus Torvalds committed
311 312 313 314 315 316 317 318 319 320 321
{
	sgiioc4_clearirq(drive);
}

static void
sgiioc4_resetproc(ide_drive_t * drive)
{
	sgiioc4_ide_dma_end(drive);
	sgiioc4_clearirq(drive);
}

322 323 324 325 326 327 328 329
static void
sgiioc4_dma_lost_irq(ide_drive_t * drive)
{
	sgiioc4_resetproc(drive);

	ide_dma_lost_irq(drive);
}

Linus Torvalds's avatar
Linus Torvalds committed
330 331 332
static u8
sgiioc4_INB(unsigned long port)
{
333
	u8 reg = (u8) readb((void __iomem *) port);
Linus Torvalds's avatar
Linus Torvalds committed
334 335 336 337

	if ((port & 0xFFF) == 0x11C) {	/* Status register of IOC4 */
		if (reg & 0x51) {	/* Not busy...check for interrupt */
			unsigned long other_ir = port - 0x110;
338
			unsigned int intr_reg = (u32) readl((void __iomem *) other_ir);
Linus Torvalds's avatar
Linus Torvalds committed
339 340 341

			/* Clear the Interrupt, Error bits on the IOC4 */
			if (intr_reg & 0x03) {
342 343
				writel(0x03, (void __iomem *) other_ir);
				intr_reg = (u32) readl((void __iomem *) other_ir);
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346 347 348 349 350 351
			}
		}
	}

	return reg;
}

/* Creates a dma map for the scatter-gather list entries */
352
static int __devinit
Linus Torvalds's avatar
Linus Torvalds committed
353 354
ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
{
355
	void __iomem *virt_dma_base;
Linus Torvalds's avatar
Linus Torvalds committed
356
	int num_ports = sizeof (ioc4_dma_regs_t);
357
	void *pad;
Linus Torvalds's avatar
Linus Torvalds committed
358 359 360 361

	printk(KERN_INFO "%s: BM-DMA at 0x%04lx-0x%04lx\n", hwif->name,
	       dma_base, dma_base + num_ports - 1);

362
	if (!request_mem_region(dma_base, num_ports, hwif->name)) {
Linus Torvalds's avatar
Linus Torvalds committed
363 364 365 366 367
		printk(KERN_ERR
		       "%s(%s) -- ERROR, Addresses 0x%p to 0x%p "
		       "ALREADY in use\n",
		       __FUNCTION__, hwif->name, (void *) dma_base,
		       (void *) dma_base + num_ports - 1);
368
		return -1;
Linus Torvalds's avatar
Linus Torvalds committed
369 370
	}

371 372 373 374 375 376 377 378 379
	virt_dma_base = ioremap(dma_base, num_ports);
	if (virt_dma_base == NULL) {
		printk(KERN_ERR
		       "%s(%s) -- ERROR, Unable to map addresses 0x%lx to 0x%lx\n",
		       __FUNCTION__, hwif->name, dma_base, dma_base + num_ports - 1);
		goto dma_remap_failure;
	}
	hwif->dma_base = (unsigned long) virt_dma_base;

Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384
	hwif->dmatable_cpu = pci_alloc_consistent(hwif->pci_dev,
					  IOC4_PRD_ENTRIES * IOC4_PRD_BYTES,
					  &hwif->dmatable_dma);

	if (!hwif->dmatable_cpu)
385
		goto dma_pci_alloc_failure;
Linus Torvalds's avatar
Linus Torvalds committed
386 387 388

	hwif->sg_max_nents = IOC4_PRD_ENTRIES;

389 390
	pad = pci_alloc_consistent(hwif->pci_dev, IOC4_IDE_CACHELINE_SIZE,
				   (dma_addr_t *) &(hwif->dma_status));
Linus Torvalds's avatar
Linus Torvalds committed
391

392 393
	if (pad) {
		ide_set_hwifdata(hwif, pad);
394
		return 0;
395
	}
Linus Torvalds's avatar
Linus Torvalds committed
396 397 398 399 400 401 402 403 404 405

	pci_free_consistent(hwif->pci_dev,
			    IOC4_PRD_ENTRIES * IOC4_PRD_BYTES,
			    hwif->dmatable_cpu, hwif->dmatable_dma);
	printk(KERN_INFO
	       "%s() -- Error! Unable to allocate DMA Maps for drive %s\n",
	       __FUNCTION__, hwif->name);
	printk(KERN_INFO
	       "Changing from DMA to PIO mode for Drive %s\n", hwif->name);

406 407 408 409 410 411
dma_pci_alloc_failure:
	iounmap(virt_dma_base);

dma_remap_failure:
	release_mem_region(dma_base, num_ports);

412
	return -1;
Linus Torvalds's avatar
Linus Torvalds committed
413 414 415 416 417 418 419 420
}

/* Initializes the IOC4 DMA Engine */
static void
sgiioc4_configure_for_dma(int dma_direction, ide_drive_t * drive)
{
	u32 ioc4_dma;
	ide_hwif_t *hwif = HWIF(drive);
421 422
	unsigned long dma_base = hwif->dma_base;
	unsigned long ioc4_dma_addr = dma_base + IOC4_DMA_CTRL * 4;
Linus Torvalds's avatar
Linus Torvalds committed
423 424
	u32 dma_addr, ending_dma_addr;

425
	ioc4_dma = readl((void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
426 427 428 429 430

	if (ioc4_dma & IOC4_S_DMA_ACTIVE) {
		printk(KERN_WARNING
			"%s(%s):Warning!! DMA from previous transfer was still active\n",
		       __FUNCTION__, drive->name);
431
		writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
432 433 434 435 436 437 438 439
		ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base);

		if (ioc4_dma & IOC4_S_DMA_STOP)
			printk(KERN_ERR
			       "%s(%s) : IOC4 Dma STOP bit is still 1\n",
			       __FUNCTION__, drive->name);
	}

440
	ioc4_dma = readl((void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
441 442 443 444 445
	if (ioc4_dma & IOC4_S_DMA_ERROR) {
		printk(KERN_WARNING
		       "%s(%s) : Warning!! - DMA Error during Previous"
		       " transfer | status 0x%x\n",
		       __FUNCTION__, drive->name, ioc4_dma);
446
		writel(IOC4_S_DMA_STOP, (void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449 450 451 452 453 454 455 456
		ioc4_dma = sgiioc4_ide_dma_stop(hwif, dma_base);

		if (ioc4_dma & IOC4_S_DMA_STOP)
			printk(KERN_ERR
			       "%s(%s) : IOC4 DMA STOP bit is still 1\n",
			       __FUNCTION__, drive->name);
	}

	/* Address of the Scatter Gather List */
	dma_addr = cpu_to_le32(hwif->dmatable_dma);
457
	writel(dma_addr, (void __iomem *)(dma_base + IOC4_DMA_PTR_L * 4));
Linus Torvalds's avatar
Linus Torvalds committed
458 459

	/* Address of the Ending DMA */
460
	memset(ide_get_hwifdata(hwif), 0, IOC4_IDE_CACHELINE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
461
	ending_dma_addr = cpu_to_le32(hwif->dma_status);
462
	writel(ending_dma_addr, (void __iomem *)(dma_base + IOC4_DMA_END_ADDR * 4));
Linus Torvalds's avatar
Linus Torvalds committed
463

464
	writel(dma_direction, (void __iomem *)ioc4_dma_addr);
Linus Torvalds's avatar
Linus Torvalds committed
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
	drive->waiting_for_dma = 1;
}

/* IOC4 Scatter Gather list Format 					 */
/* 128 Bit entries to support 64 bit addresses in the future		 */
/* The Scatter Gather list Entry should be in the BIG-ENDIAN Format	 */
/* --------------------------------------------------------------------- */
/* | Upper 32 bits - Zero           |	 	Lower 32 bits- address | */
/* --------------------------------------------------------------------- */
/* | Upper 32 bits - Zero	    |EOL| 15 unused     | 16 Bit Length| */
/* --------------------------------------------------------------------- */
/* Creates the scatter gather list, DMA Table */
static unsigned int
sgiioc4_build_dma_table(ide_drive_t * drive, struct request *rq, int ddir)
{
	ide_hwif_t *hwif = HWIF(drive);
	unsigned int *table = hwif->dmatable_cpu;
	unsigned int count = 0, i = 1;
	struct scatterlist *sg;

	hwif->sg_nents = i = ide_build_sglist(drive, rq);

	if (!i)
		return 0;	/* sglist of length Zero */

	sg = hwif->sg_table;
	while (i && sg_dma_len(sg)) {
		dma_addr_t cur_addr;
		int cur_len;
		cur_addr = sg_dma_address(sg);
		cur_len = sg_dma_len(sg);

		while (cur_len) {
			if (count++ >= IOC4_PRD_ENTRIES) {
				printk(KERN_WARNING
				       "%s: DMA table too small\n",
				       drive->name);
				goto use_pio_instead;
			} else {
504
				u32 bcount =
Linus Torvalds's avatar
Linus Torvalds committed
505 506 507 508 509 510 511 512 513 514 515 516 517 518
				    0x10000 - (cur_addr & 0xffff);

				if (bcount > cur_len)
					bcount = cur_len;

				/* put the addr, length in
				 * the IOC4 dma-table format */
				*table = 0x0;
				table++;
				*table = cpu_to_be32(cur_addr);
				table++;
				*table = 0x0;
				table++;

519
				*table = cpu_to_be32(bcount);
Linus Torvalds's avatar
Linus Torvalds committed
520 521 522 523 524 525 526
				table++;

				cur_addr += bcount;
				cur_len -= bcount;
			}
		}

Jens Axboe's avatar
Jens Axboe committed
527
		sg = sg_next(sg);
Linus Torvalds's avatar
Linus Torvalds committed
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
		i--;
	}

	if (count) {
		table--;
		*table |= cpu_to_be32(0x80000000);
		return count;
	}

use_pio_instead:
	pci_unmap_sg(hwif->pci_dev, hwif->sg_table, hwif->sg_nents,
		     hwif->sg_dma_direction);

	return 0;		/* revert to PIO for this request */
}

static int sgiioc4_ide_dma_setup(ide_drive_t *drive)
{
	struct request *rq = HWGROUP(drive)->rq;
	unsigned int count = 0;
	int ddir;

	if (rq_data_dir(rq))
		ddir = PCI_DMA_TODEVICE;
	else
		ddir = PCI_DMA_FROMDEVICE;

	if (!(count = sgiioc4_build_dma_table(drive, rq, ddir))) {
		/* try PIO instead of DMA */
		ide_map_sg(drive, rq);
		return 1;
	}

	if (rq_data_dir(rq))
		/* Writes TO the IOC4 FROM Main Memory */
		ddir = IOC4_DMA_READ;
	else
		/* Writes FROM the IOC4 TO Main Memory */
		ddir = IOC4_DMA_WRITE;

	sgiioc4_configure_for_dma(ddir, drive);

	return 0;
}

static void __devinit
ide_init_sgiioc4(ide_hwif_t * hwif)
{
576
	hwif->mmio = 1;
577
	hwif->pio_mask = 0x00;
578
	hwif->set_pio_mode = NULL; /* Sets timing for PIO mode */
579
	hwif->set_dma_mode = &sgiioc4_set_dma_mode;
Linus Torvalds's avatar
Linus Torvalds committed
580 581 582 583 584 585 586 587 588
	hwif->selectproc = NULL;/* Use the default routine to select drive */
	hwif->reset_poll = NULL;/* No HBA specific reset_poll needed */
	hwif->pre_reset = NULL;	/* No HBA specific pre_set needed */
	hwif->resetproc = &sgiioc4_resetproc;/* Reset DMA engine,
						clear interrupts */
	hwif->maskproc = &sgiioc4_maskproc;	/* Mask on/off NIEN register */
	hwif->quirkproc = NULL;
	hwif->busproc = NULL;

589 590 591 592 593
	hwif->INB = &sgiioc4_INB;

	if (hwif->dma_base == 0)
		return;

594
	hwif->mwdma_mask = ATA_MWDMA2_ONLY;
595

Linus Torvalds's avatar
Linus Torvalds committed
596 597 598 599
	hwif->dma_setup = &sgiioc4_ide_dma_setup;
	hwif->dma_start = &sgiioc4_ide_dma_start;
	hwif->ide_dma_end = &sgiioc4_ide_dma_end;
	hwif->ide_dma_on = &sgiioc4_ide_dma_on;
600
	hwif->dma_off_quietly = &sgiioc4_dma_off_quietly;
Linus Torvalds's avatar
Linus Torvalds committed
601
	hwif->ide_dma_test_irq = &sgiioc4_ide_dma_test_irq;
602
	hwif->dma_host_on = &sgiioc4_dma_host_on;
603
	hwif->dma_host_off = &sgiioc4_dma_host_off;
604
	hwif->dma_lost_irq = &sgiioc4_dma_lost_irq;
605
	hwif->dma_timeout = &ide_dma_timeout;
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608
}

static int __devinit
609
sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
610
{
611 612 613
	unsigned long cmd_base, dma_base, irqport;
	unsigned long bar0, cmd_phys_base, ctl;
	void __iomem *virt_base;
Linus Torvalds's avatar
Linus Torvalds committed
614 615
	ide_hwif_t *hwif;
	int h;
616
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
Linus Torvalds's avatar
Linus Torvalds committed
617

618 619 620
	/*
	 * Find an empty HWIF; if none available, return -ENOMEM.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
621 622 623 624 625
	for (h = 0; h < MAX_HWIFS; ++h) {
		hwif = &ide_hwifs[h];
		if (hwif->chipset == ide_unknown)
			break;
	}
626
	if (h == MAX_HWIFS) {
627 628
		printk(KERN_ERR "%s: too many IDE interfaces, no room in table\n",
				DRV_NAME);
629 630
		return -ENOMEM;
	}
Linus Torvalds's avatar
Linus Torvalds committed
631 632

	/*  Get the CmdBlk and CtrlBlk Base Registers */
633 634 635 636
	bar0 = pci_resource_start(dev, 0);
	virt_base = ioremap(bar0, pci_resource_len(dev, 0));
	if (virt_base == NULL) {
		printk(KERN_ERR "%s: Unable to remap BAR 0 address: 0x%lx\n",
637
				DRV_NAME, bar0);
638 639 640 641 642
		return -ENOMEM;
	}
	cmd_base = (unsigned long) virt_base + IOC4_CMD_OFFSET;
	ctl = (unsigned long) virt_base + IOC4_CTRL_OFFSET;
	irqport = (unsigned long) virt_base + IOC4_INTR_OFFSET;
Linus Torvalds's avatar
Linus Torvalds committed
643 644
	dma_base = pci_resource_start(dev, 0) + IOC4_DMA_OFFSET;

645 646 647
	cmd_phys_base = bar0 + IOC4_CMD_OFFSET;
	if (!request_mem_region(cmd_phys_base, IOC4_CMD_CTL_BLK_SIZE,
	    hwif->name)) {
Linus Torvalds's avatar
Linus Torvalds committed
648
		printk(KERN_ERR
649
			"%s : %s -- ERROR, Addresses "
Linus Torvalds's avatar
Linus Torvalds committed
650
			"0x%p to 0x%p ALREADY in use\n",
651 652
		       __FUNCTION__, hwif->name, (void *) cmd_phys_base,
		       (void *) cmd_phys_base + IOC4_CMD_CTL_BLK_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
653 654 655
		return -ENOMEM;
	}

656
	if (hwif->io_ports[IDE_DATA_OFFSET] != cmd_base) {
657 658
		hw_regs_t hw;

Linus Torvalds's avatar
Linus Torvalds committed
659
		/* Initialize the IO registers */
660 661 662
		memset(&hw, 0, sizeof(hw));
		sgiioc4_init_hwif_ports(&hw, cmd_base, ctl, irqport);
		memcpy(hwif->io_ports, hw.io_ports, sizeof(hwif->io_ports));
Linus Torvalds's avatar
Linus Torvalds committed
663 664 665 666 667 668 669 670 671
		hwif->noprobe = !hwif->io_ports[IDE_DATA_OFFSET];
	}

	hwif->irq = dev->irq;
	hwif->chipset = ide_pci;
	hwif->pci_dev = dev;
	hwif->channel = 0;	/* Single Channel chip */
	hwif->gendev.parent = &dev->dev;/* setup proper ancestral information */

672 673 674
	/* The IOC4 uses MMIO rather than Port IO. */
	default_hwif_mmiops(hwif);

Linus Torvalds's avatar
Linus Torvalds committed
675
	/* Initializing chipset IRQ Registers */
676
	writel(0x03, (void __iomem *)(irqport + IOC4_INTR_SET * 4));
Linus Torvalds's avatar
Linus Torvalds committed
677

678
	if (dma_base == 0 || ide_dma_sgiioc4(hwif, dma_base))
Linus Torvalds's avatar
Linus Torvalds committed
679
		printk(KERN_INFO "%s: %s Bus-Master DMA disabled\n",
680
				 hwif->name, DRV_NAME);
Linus Torvalds's avatar
Linus Torvalds committed
681

682 683
	ide_init_sgiioc4(hwif);

684
	idx[0] = hwif->index;
Linus Torvalds's avatar
Linus Torvalds committed
685

686 687
	if (ide_device_add(idx))
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
688 689 690 691 692

	return 0;
}

static unsigned int __devinit
693
pci_init_sgiioc4(struct pci_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
694 695 696 697
{
	int ret;

	printk(KERN_INFO "%s: IDE controller at PCI slot %s, revision %d\n",
698 699 700
			 DRV_NAME, pci_name(dev), dev->revision);

	if (dev->revision < IOC4_SUPPORTED_FIRMWARE_REV) {
Linus Torvalds's avatar
Linus Torvalds committed
701
		printk(KERN_ERR "Skipping %s IDE controller in slot %s: "
702 703 704
				"firmware is obsolete - please upgrade to "
				"revision46 or higher\n",
				DRV_NAME, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
705 706 707
		ret = -EAGAIN;
		goto out;
	}
708
	ret = sgiioc4_ide_setup_pci_device(dev);
Linus Torvalds's avatar
Linus Torvalds committed
709 710 711 712 713
out:
	return ret;
}

int
714
ioc4_ide_attach_one(struct ioc4_driver_data *idd)
Linus Torvalds's avatar
Linus Torvalds committed
715
{
716 717 718 719 720 721
	/* PCI-RT does not bring out IDE connection.
	 * Do not attach to this particular IOC4.
	 */
	if (idd->idd_variant == IOC4_VARIANT_PCI_RT)
		return 0;

722
	return pci_init_sgiioc4(idd->idd_pdev);
Linus Torvalds's avatar
Linus Torvalds committed
723 724
}

725 726 727 728 729 730 731
static struct ioc4_submodule ioc4_ide_submodule = {
	.is_name = "IOC4_ide",
	.is_owner = THIS_MODULE,
	.is_probe = ioc4_ide_attach_one,
/*	.is_remove = ioc4_ide_remove_one,	*/
};

732
static int __init ioc4_ide_init(void)
733 734 735 736
{
	return ioc4_register_submodule(&ioc4_ide_submodule);
}

737
late_initcall(ioc4_ide_init); /* Call only after IDE init is done */
Linus Torvalds's avatar
Linus Torvalds committed
738

739
MODULE_AUTHOR("Aniket Malatpure/Jeremy Higdon");
Linus Torvalds's avatar
Linus Torvalds committed
740 741
MODULE_DESCRIPTION("IDE PCI driver module for SGI IOC4 Base-IO Card");
MODULE_LICENSE("GPL");