[linux.git] / drivers / scsi / sgiwd93.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1996 David S. Miller ([email protected])
 * Copyright (C) 1999 Andrew R. Baker ([email protected])
 * Copyright (C) 2001 Florian Lohoff ([email protected])
 * Copyright (C) 2003, 07 Ralf Baechle ([email protected])
 * 
 * (In all truth, Jed Schimmel wrote all this code.)
 */

#undef DEBUG

#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/gfp.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>

#include <asm/sgi/hpc3.h>
#include <asm/sgi/ip22.h>
#include <asm/sgi/wd.h>

#include "scsi.h"
#include "wd33c93.h"

struct ip22_hostdata {
	struct WD33C93_hostdata wh;
	dma_addr_t dma;
	void *cpu;
	struct device *dev;
};

#define host_to_hostdata(host) ((struct ip22_hostdata *)((host)->hostdata))

struct hpc_chunk {
	struct hpc_dma_desc desc;
	u32 _padding;	/* align to quadword boundary */
};

/* space for hpc dma descriptors */
#define HPC_DMA_SIZE   PAGE_SIZE

#define DMA_DIR(d)   ((d == DATA_OUT_DIR) ? DMA_TO_DEVICE : DMA_FROM_DEVICE)

static irqreturn_t sgiwd93_intr(int irq, void *dev_id)
{
	struct Scsi_Host * host = dev_id;
	unsigned long flags;

	spin_lock_irqsave(host->host_lock, flags);
	wd33c93_intr(host);
	spin_unlock_irqrestore(host->host_lock, flags);

	return IRQ_HANDLED;
}

static inline
void fill_hpc_entries(struct ip22_hostdata *hd, struct scsi_cmnd *cmd, int din)
{
	unsigned long len = cmd->SCp.this_residual;
	void *addr = cmd->SCp.ptr;
	dma_addr_t physaddr;
	unsigned long count;
	struct hpc_chunk *hcp;

	physaddr = dma_map_single(hd->dev, addr, len, DMA_DIR(din));
	cmd->SCp.dma_handle = physaddr;
	hcp = hd->cpu;

	while (len) {
		/*
		 * even cntinfo could be up to 16383, without
		 * magic only 8192 works correctly
		 */
		count = len > 8192 ? 8192 : len;
		hcp->desc.pbuf = physaddr;
		hcp->desc.cntinfo = count;
		hcp++;
		len -= count;
		physaddr += count;
	}

	/*
	 * To make sure, if we trip an HPC bug, that we transfer every single
	 * byte, we tag on an extra zero length dma descriptor at the end of
	 * the chain.
	 */
	hcp->desc.pbuf = 0;
	hcp->desc.cntinfo = HPCDMA_EOX;
	dma_cache_sync(hd->dev, hd->cpu,
		       (unsigned long)(hcp + 1) - (unsigned long)hd->cpu,
		       DMA_TO_DEVICE);
}

static int dma_setup(struct scsi_cmnd *cmd, int datainp)
{
	struct ip22_hostdata *hdata = host_to_hostdata(cmd->device->host);
	struct hpc3_scsiregs *hregs =
		(struct hpc3_scsiregs *) cmd->device->host->base;

	pr_debug("dma_setup: datainp<%d> hcp<%p> ", datainp, hdata->cpu);

	hdata->wh.dma_dir = datainp;

	/*
	 * wd33c93 shouldn't pass us bogus dma_setups, but it does:-(  The
	 * other wd33c93 drivers deal with it the same way (which isn't that
	 * obvious).  IMHO a better fix would be, not to do these dma setups
	 * in the first place.
	 */
	if (cmd->SCp.ptr == NULL || cmd->SCp.this_residual == 0)
		return 1;

	fill_hpc_entries(hdata, cmd, datainp);

	pr_debug(" HPCGO\n");

	/* Start up the HPC. */
	hregs->ndptr = hdata->dma;
	if (datainp)
		hregs->ctrl = HPC3_SCTRL_ACTIVE;
	else
		hregs->ctrl = HPC3_SCTRL_ACTIVE | HPC3_SCTRL_DIR;

	return 0;
}

static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
		     int status)
{
	struct ip22_hostdata *hdata = host_to_hostdata(instance);
	struct hpc3_scsiregs *hregs;

	if (!SCpnt)
		return;

	if (SCpnt->SCp.ptr == NULL || SCpnt->SCp.this_residual == 0)
		return;

	hregs = (struct hpc3_scsiregs *) SCpnt->device->host->base;

	pr_debug("dma_stop: status<%d> ", status);

	/* First stop the HPC and flush it's FIFO. */
	if (hdata->wh.dma_dir) {
		hregs->ctrl |= HPC3_SCTRL_FLUSH;
		while (hregs->ctrl & HPC3_SCTRL_ACTIVE)
			barrier();
	}
	hregs->ctrl = 0;
	dma_unmap_single(hdata->dev, SCpnt->SCp.dma_handle,
			 SCpnt->SCp.this_residual,
			 DMA_DIR(hdata->wh.dma_dir));

	pr_debug("\n");
}

void sgiwd93_reset(unsigned long base)
{
	struct hpc3_scsiregs *hregs = (struct hpc3_scsiregs *) base;

	hregs->ctrl = HPC3_SCTRL_CRESET;
	udelay(50);
	hregs->ctrl = 0;
}
EXPORT_SYMBOL_GPL(sgiwd93_reset);

static inline void init_hpc_chain(struct ip22_hostdata *hdata)
{
	struct hpc_chunk *hcp = (struct hpc_chunk *)hdata->cpu;
	dma_addr_t dma = hdata->dma;
	unsigned long start, end;

	start = (unsigned long) hcp;
	end = start + HPC_DMA_SIZE;
	while (start < end) {
		hcp->desc.pnext = (u32) (dma + sizeof(struct hpc_chunk));
		hcp->desc.cntinfo = HPCDMA_EOX;
		hcp++;
		dma += sizeof(struct hpc_chunk);
		start += sizeof(struct hpc_chunk);
	};
	hcp--;
	hcp->desc.pnext = hdata->dma;
}

static int sgiwd93_bus_reset(struct scsi_cmnd *cmd)
{
	/* FIXME perform bus-specific reset */

	/* FIXME 2: kill this function, and let midlayer fallback
	   to the same result, calling wd33c93_host_reset() */

	spin_lock_irq(cmd->device->host->host_lock);
	wd33c93_host_reset(cmd);
	spin_unlock_irq(cmd->device->host->host_lock);

	return SUCCESS;
}

/*
 * Kludge alert - the SCSI code calls the abort and reset method with int
 * arguments not with pointers.  So this is going to blow up beautyfully
 * on 64-bit systems with memory outside the compat address spaces.
 */
static struct scsi_host_template sgiwd93_template = {
	.module			= THIS_MODULE,
	.proc_name		= "SGIWD93",
	.name			= "SGI WD93",
	.queuecommand		= wd33c93_queuecommand,
	.eh_abort_handler	= wd33c93_abort,
	.eh_bus_reset_handler	= sgiwd93_bus_reset,
	.eh_host_reset_handler	= wd33c93_host_reset,
	.can_queue		= 16,
	.this_id		= 7,
	.sg_tablesize		= SG_ALL,
	.cmd_per_lun		= 8,
	.use_clustering		= DISABLE_CLUSTERING,
};

static int sgiwd93_probe(struct platform_device *pdev)
{
	struct sgiwd93_platform_data *pd = pdev->dev.platform_data;
	unsigned char *wdregs = pd->wdregs;
	struct hpc3_scsiregs *hregs = pd->hregs;
	struct ip22_hostdata *hdata;
	struct Scsi_Host *host;
	wd33c93_regs regs;
	unsigned int unit = pd->unit;
	unsigned int irq = pd->irq;
	int err;

	host = scsi_host_alloc(&sgiwd93_template, sizeof(struct ip22_hostdata));
	if (!host) {
		err = -ENOMEM;
		goto out;
	}

	host->base = (unsigned long) hregs;
	host->irq = irq;

	hdata = host_to_hostdata(host);
	hdata->dev = &pdev->dev;
	hdata->cpu = dma_alloc_noncoherent(&pdev->dev, HPC_DMA_SIZE,
					   &hdata->dma, GFP_KERNEL);
	if (!hdata->cpu) {
		printk(KERN_WARNING "sgiwd93: Could not allocate memory for "
		       "host %d buffer.\n", unit);
		err = -ENOMEM;
		goto out_put;
	}

	init_hpc_chain(hdata);

	regs.SASR = wdregs + 3;
	regs.SCMD = wdregs + 7;

	hdata->wh.no_sync = 0;
	hdata->wh.fast = 1;
	hdata->wh.dma_mode = CTRL_BURST;

	wd33c93_init(host, regs, dma_setup, dma_stop, WD33C93_FS_MHZ(20));

	err = request_irq(irq, sgiwd93_intr, 0, "SGI WD93", host);
	if (err) {
		printk(KERN_WARNING "sgiwd93: Could not register irq %d "
		       "for host %d.\n", irq, unit);
		goto out_free;
	}

	platform_set_drvdata(pdev, host);

	err = scsi_add_host(host, NULL);
	if (err)
		goto out_irq;

	scsi_scan_host(host);

	return 0;

out_irq:
	free_irq(irq, host);
out_free:
	dma_free_noncoherent(&pdev->dev, HPC_DMA_SIZE, hdata->cpu, hdata->dma);
out_put:
	scsi_host_put(host);
out:

	return err;
}

static int __exit sgiwd93_remove(struct platform_device *pdev)
{
	struct Scsi_Host *host = platform_get_drvdata(pdev);
	struct ip22_hostdata *hdata = (struct ip22_hostdata *) host->hostdata;
	struct sgiwd93_platform_data *pd = pdev->dev.platform_data;

	scsi_remove_host(host);
	free_irq(pd->irq, host);
	dma_free_noncoherent(&pdev->dev, HPC_DMA_SIZE, hdata->cpu, hdata->dma);
	scsi_host_put(host);
	return 0;
}

static struct platform_driver sgiwd93_driver = {
	.probe  = sgiwd93_probe,
	.remove = sgiwd93_remove,
	.driver = {
		.name   = "sgiwd93",
	}
};

static int __init sgiwd93_module_init(void)
{
	return platform_driver_register(&sgiwd93_driver);
}

static void __exit sgiwd93_module_exit(void)
{
	return platform_driver_unregister(&sgiwd93_driver);
}

module_init(sgiwd93_module_init);
module_exit(sgiwd93_module_exit);

MODULE_DESCRIPTION("SGI WD33C93 driver");
MODULE_AUTHOR("Ralf Baechle <[email protected]>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:sgiwd93");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
79add627	6	* Copyright (C) 1996 David S. Miller ([email protected])
1da177e4 LT	7	* Copyright (C) 1999 Andrew R. Baker ([email protected])
1da177e4 LT	8	* Copyright (C) 2001 Florian Lohoff ([email protected])
df9f5408	9	* Copyright (C) 2003, 07 Ralf Baechle ([email protected])
1da177e4 LT	10	*
	11	* (In all truth, Jed Schimmel wrote all this code.)
	12	*/
df9f5408 RB	13
	14	#undef DEBUG
	15
1da177e4 LT	16	#include <linux/delay.h>
1da177e4 LT	17	#include <linux/dma-mapping.h>
df9f5408 RB	18	#include <linux/gfp.h>
	19	#include <linux/interrupt.h>
	20	#include <linux/init.h>
	21	#include <linux/kernel.h>
	22	#include <linux/types.h>
	23	#include <linux/module.h>
	24	#include <linux/platform_device.h>
1da177e4 LT	25	#include <linux/spinlock.h>
1da177e4 LT	26
1da177e4 LT	27	#include <asm/sgi/hpc3.h>
1da177e4 LT	28	#include <asm/sgi/ip22.h>
df9f5408	29	#include <asm/sgi/wd.h>
1da177e4 LT	30
1da177e4 LT	31	#include "scsi.h"
1da177e4	32	#include "wd33c93.h"
1da177e4	33
1da177e4 LT	34	struct ip22_hostdata {
1da177e4 LT	35	struct WD33C93_hostdata wh;
2adbfa33 TB	36	dma_addr_t dma;
	37	void *cpu;
	38	struct device *dev;
1da177e4 LT	39	};
1da177e4 LT	40
df9f5408 RB	41	#define host_to_hostdata(host) ((struct ip22_hostdata *)((host)->hostdata))
df9f5408 RB	42
1da177e4 LT	43	struct hpc_chunk {
	44	struct hpc_dma_desc desc;
	45	u32 _padding; /* align to quadword boundary */
	46	};
	47
2adbfa33 TB	48	/* space for hpc dma descriptors */
	49	#define HPC_DMA_SIZE PAGE_SIZE
	50
	51	#define DMA_DIR(d) ((d == DATA_OUT_DIR) ? DMA_TO_DEVICE : DMA_FROM_DEVICE)
	52
7d12e780	53	static irqreturn_t sgiwd93_intr(int irq, void *dev_id)
1da177e4	54	{
df9f5408	55	struct Scsi_Host * host = dev_id;
1da177e4 LT	56	unsigned long flags;
	57
	58	spin_lock_irqsave(host->host_lock, flags);
	59	wd33c93_intr(host);
	60	spin_unlock_irqrestore(host->host_lock, flags);
	61
	62	return IRQ_HANDLED;
	63	}
	64
	65	static inline
2adbfa33	66	void fill_hpc_entries(struct ip22_hostdata hd, struct scsi_cmnd cmd, int din)
1da177e4 LT	67	{
	68	unsigned long len = cmd->SCp.this_residual;
	69	void *addr = cmd->SCp.ptr;
	70	dma_addr_t physaddr;
	71	unsigned long count;
2adbfa33	72	struct hpc_chunk *hcp;
1da177e4	73
2adbfa33	74	physaddr = dma_map_single(hd->dev, addr, len, DMA_DIR(din));
1da177e4	75	cmd->SCp.dma_handle = physaddr;
2adbfa33	76	hcp = hd->cpu;
1da177e4 LT	77
	78	while (len) {
	79	/*
	80	* even cntinfo could be up to 16383, without
	81	* magic only 8192 works correctly
	82	*/
	83	count = len > 8192 ? 8192 : len;
	84	hcp->desc.pbuf = physaddr;
	85	hcp->desc.cntinfo = count;
	86	hcp++;
	87	len -= count;
	88	physaddr += count;
	89	}
	90
	91	/*
	92	* To make sure, if we trip an HPC bug, that we transfer every single
	93	* byte, we tag on an extra zero length dma descriptor at the end of
	94	* the chain.
	95	*/
	96	hcp->desc.pbuf = 0;
	97	hcp->desc.cntinfo = HPCDMA_EOX;
2adbfa33 TB	98	dma_cache_sync(hd->dev, hd->cpu,
	99	(unsigned long)(hcp + 1) - (unsigned long)hd->cpu,
	100	DMA_TO_DEVICE);
1da177e4 LT	101	}
1da177e4 LT	102
65396410	103	static int dma_setup(struct scsi_cmnd *cmd, int datainp)
1da177e4	104	{
df9f5408	105	struct ip22_hostdata *hdata = host_to_hostdata(cmd->device->host);
1da177e4 LT	106	struct hpc3_scsiregs *hregs =
1da177e4 LT	107	(struct hpc3_scsiregs *) cmd->device->host->base;
1da177e4	108
2adbfa33	109	pr_debug("dma_setup: datainp<%d> hcp<%p> ", datainp, hdata->cpu);
1da177e4 LT	110
	111	hdata->wh.dma_dir = datainp;
	112
	113	/*
	114	* wd33c93 shouldn't pass us bogus dma_setups, but it does:-( The
	115	* other wd33c93 drivers deal with it the same way (which isn't that
	116	* obvious). IMHO a better fix would be, not to do these dma setups
	117	* in the first place.
	118	*/
	119	if (cmd->SCp.ptr == NULL \|\| cmd->SCp.this_residual == 0)
	120	return 1;
	121
2adbfa33	122	fill_hpc_entries(hdata, cmd, datainp);
1da177e4	123
df9f5408	124	pr_debug(" HPCGO\n");
1da177e4 LT	125
1da177e4 LT	126	/* Start up the HPC. */
2adbfa33	127	hregs->ndptr = hdata->dma;
1da177e4 LT	128	if (datainp)
	129	hregs->ctrl = HPC3_SCTRL_ACTIVE;
	130	else
	131	hregs->ctrl = HPC3_SCTRL_ACTIVE \| HPC3_SCTRL_DIR;
	132
	133	return 0;
	134	}
	135
65396410	136	static void dma_stop(struct Scsi_Host instance, struct scsi_cmnd SCpnt,
1da177e4 LT	137	int status)
1da177e4 LT	138	{
df9f5408	139	struct ip22_hostdata *hdata = host_to_hostdata(instance);
1da177e4 LT	140	struct hpc3_scsiregs *hregs;
	141
	142	if (!SCpnt)
	143	return;
	144
2adbfa33 TB	145	if (SCpnt->SCp.ptr == NULL \|\| SCpnt->SCp.this_residual == 0)
	146	return;
	147
1da177e4 LT	148	hregs = (struct hpc3_scsiregs *) SCpnt->device->host->base;
1da177e4 LT	149
df9f5408	150	pr_debug("dma_stop: status<%d> ", status);
1da177e4 LT	151
	152	/* First stop the HPC and flush it's FIFO. */
	153	if (hdata->wh.dma_dir) {
	154	hregs->ctrl \|= HPC3_SCTRL_FLUSH;
	155	while (hregs->ctrl & HPC3_SCTRL_ACTIVE)
	156	barrier();
	157	}
	158	hregs->ctrl = 0;
2adbfa33 TB	159	dma_unmap_single(hdata->dev, SCpnt->SCp.dma_handle,
	160	SCpnt->SCp.this_residual,
	161	DMA_DIR(hdata->wh.dma_dir));
1da177e4	162
df9f5408	163	pr_debug("\n");
1da177e4 LT	164	}
	165
	166	void sgiwd93_reset(unsigned long base)
	167	{
	168	struct hpc3_scsiregs hregs = (struct hpc3_scsiregs ) base;
	169
	170	hregs->ctrl = HPC3_SCTRL_CRESET;
	171	udelay(50);
	172	hregs->ctrl = 0;
	173	}
fc9b5118	174	EXPORT_SYMBOL_GPL(sgiwd93_reset);
1da177e4	175
2adbfa33	176	static inline void init_hpc_chain(struct ip22_hostdata *hdata)
1da177e4	177	{
2adbfa33 TB	178	struct hpc_chunk hcp = (struct hpc_chunk )hdata->cpu;
2adbfa33 TB	179	dma_addr_t dma = hdata->dma;
1da177e4 LT	180	unsigned long start, end;
	181
	182	start = (unsigned long) hcp;
2adbfa33	183	end = start + HPC_DMA_SIZE;
1da177e4	184	while (start < end) {
2adbfa33	185	hcp->desc.pnext = (u32) (dma + sizeof(struct hpc_chunk));
1da177e4	186	hcp->desc.cntinfo = HPCDMA_EOX;
2adbfa33 TB	187	hcp++;
2adbfa33 TB	188	dma += sizeof(struct hpc_chunk);
1da177e4 LT	189	start += sizeof(struct hpc_chunk);
	190	};
	191	hcp--;
2adbfa33	192	hcp->desc.pnext = hdata->dma;
1da177e4 LT	193	}
1da177e4 LT	194
df9f5408 RB	195	static int sgiwd93_bus_reset(struct scsi_cmnd *cmd)
	196	{
	197	/* FIXME perform bus-specific reset */
	198
	199	/* FIXME 2: kill this function, and let midlayer fallback
	200	to the same result, calling wd33c93_host_reset() */
	201
	202	spin_lock_irq(cmd->device->host->host_lock);
	203	wd33c93_host_reset(cmd);
	204	spin_unlock_irq(cmd->device->host->host_lock);
	205
	206	return SUCCESS;
	207	}
	208
	209	/*
	210	* Kludge alert - the SCSI code calls the abort and reset method with int
	211	* arguments not with pointers. So this is going to blow up beautyfully
	212	* on 64-bit systems with memory outside the compat address spaces.
	213	*/
	214	static struct scsi_host_template sgiwd93_template = {
	215	.module = THIS_MODULE,
	216	.proc_name = "SGIWD93",
	217	.name = "SGI WD93",
	218	.queuecommand = wd33c93_queuecommand,
	219	.eh_abort_handler = wd33c93_abort,
	220	.eh_bus_reset_handler = sgiwd93_bus_reset,
	221	.eh_host_reset_handler = wd33c93_host_reset,
	222	.can_queue = 16,
	223	.this_id = 7,
	224	.sg_tablesize = SG_ALL,
	225	.cmd_per_lun = 8,
	226	.use_clustering = DISABLE_CLUSTERING,
	227	};
	228
6f039790	229	static int sgiwd93_probe(struct platform_device *pdev)
1da177e4	230	{
df9f5408 RB	231	struct sgiwd93_platform_data *pd = pdev->dev.platform_data;
	232	unsigned char *wdregs = pd->wdregs;
	233	struct hpc3_scsiregs *hregs = pd->hregs;
1da177e4 LT	234	struct ip22_hostdata *hdata;
	235	struct Scsi_Host *host;
	236	wd33c93_regs regs;
df9f5408 RB	237	unsigned int unit = pd->unit;
	238	unsigned int irq = pd->irq;
	239	int err;
	240
	241	host = scsi_host_alloc(&sgiwd93_template, sizeof(struct ip22_hostdata));
	242	if (!host) {
	243	err = -ENOMEM;
	244	goto out;
	245	}
1da177e4 LT	246
	247	host->base = (unsigned long) hregs;
	248	host->irq = irq;
	249
df9f5408	250	hdata = host_to_hostdata(host);
2adbfa33 TB	251	hdata->dev = &pdev->dev;
	252	hdata->cpu = dma_alloc_noncoherent(&pdev->dev, HPC_DMA_SIZE,
	253	&hdata->dma, GFP_KERNEL);
	254	if (!hdata->cpu) {
1da177e4 LT	255	printk(KERN_WARNING "sgiwd93: Could not allocate memory for "
1da177e4 LT	256	"host %d buffer.\n", unit);
df9f5408 RB	257	err = -ENOMEM;
df9f5408 RB	258	goto out_put;
1da177e4	259	}
df9f5408	260
2adbfa33	261	init_hpc_chain(hdata);
1da177e4 LT	262
	263	regs.SASR = wdregs + 3;
	264	regs.SCMD = wdregs + 7;
	265
be3cb3d8 TB	266	hdata->wh.no_sync = 0;
	267	hdata->wh.fast = 1;
	268	hdata->wh.dma_mode = CTRL_BURST;
1da177e4	269
be3cb3d8	270	wd33c93_init(host, regs, dma_setup, dma_stop, WD33C93_FS_MHZ(20));
1da177e4	271
df9f5408 RB	272	err = request_irq(irq, sgiwd93_intr, 0, "SGI WD93", host);
df9f5408 RB	273	if (err) {
1da177e4 LT	274	printk(KERN_WARNING "sgiwd93: Could not register irq %d "
	275	"for host %d.\n", irq, unit);
	276	goto out_free;
	277	}
1da177e4	278
df9f5408	279	platform_set_drvdata(pdev, host);
1da177e4	280
df9f5408 RB	281	err = scsi_add_host(host, NULL);
	282	if (err)
	283	goto out_irq;
1da177e4	284
df9f5408	285	scsi_scan_host(host);
1da177e4	286
df9f5408	287	return 0;
1da177e4	288
df9f5408 RB	289	out_irq:
	290	free_irq(irq, host);
	291	out_free:
2adbfa33	292	dma_free_noncoherent(&pdev->dev, HPC_DMA_SIZE, hdata->cpu, hdata->dma);
df9f5408 RB	293	out_put:
	294	scsi_host_put(host);
	295	out:
1da177e4	296
df9f5408	297	return err;
1da177e4 LT	298	}
1da177e4 LT	299
b99b4c67	300	static int __exit sgiwd93_remove(struct platform_device *pdev)
1da177e4	301	{
df9f5408 RB	302	struct Scsi_Host *host = platform_get_drvdata(pdev);
	303	struct ip22_hostdata hdata = (struct ip22_hostdata ) host->hostdata;
	304	struct sgiwd93_platform_data *pd = pdev->dev.platform_data;
	305
	306	scsi_remove_host(host);
	307	free_irq(pd->irq, host);
2adbfa33	308	dma_free_noncoherent(&pdev->dev, HPC_DMA_SIZE, hdata->cpu, hdata->dma);
df9f5408	309	scsi_host_put(host);
b99b4c67	310	return 0;
df9f5408	311	}
68b3aa7c	312
df9f5408 RB	313	static struct platform_driver sgiwd93_driver = {
df9f5408 RB	314	.probe = sgiwd93_probe,
6f039790	315	.remove = sgiwd93_remove,
df9f5408	316	.driver = {
ecc1241e	317	.name = "sgiwd93",
df9f5408 RB	318	}
df9f5408 RB	319	};
df0ae249	320
df9f5408 RB	321	static int __init sgiwd93_module_init(void)
	322	{
	323	return platform_driver_register(&sgiwd93_driver);
	324	}
68b3aa7c	325
df9f5408 RB	326	static void __exit sgiwd93_module_exit(void)
	327	{
	328	return platform_driver_unregister(&sgiwd93_driver);
1da177e4 LT	329	}
1da177e4 LT	330
df9f5408 RB	331	module_init(sgiwd93_module_init);
	332	module_exit(sgiwd93_module_exit);
	333
	334	MODULE_DESCRIPTION("SGI WD33C93 driver");
	335	MODULE_AUTHOR("Ralf Baechle <[email protected]>");
	336	MODULE_LICENSE("GPL");
ecc1241e	337	MODULE_ALIAS("platform:sgiwd93");