Release 4.7 drivers/scsi/sun_esp.c

/* sun_esp.c: ESP front-end for Sparc SBUS systems.
 *
 * Copyright (C) 2007, 2008 David S. Miller (davem@davemloft.net)
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/gfp.h>

#include <asm/irq.h>
#include <asm/io.h>
#include <asm/dma.h>

#include <scsi/scsi_host.h>

#include "esp_scsi.h"


#define DRV_MODULE_NAME		"sun_esp"

#define PFX DRV_MODULE_NAME ": "

#define DRV_VERSION		"1.100"

#define DRV_MODULE_RELDATE	"August 27, 2008"


#define dma_read32(REG) \
	sbus_readl(esp->dma_regs + (REG))

#define dma_write32(VAL, REG) \
	sbus_writel((VAL), esp->dma_regs + (REG))

/* DVMA chip revisions */

enum dvma_rev {
	
dvmarev0,
	
dvmaesc1,
	
dvmarev1,
	
dvmarev2,
	
dvmarev3,
	
dvmarevplus,
	
dvmahme
};



static int esp_sbus_setup_dma(struct esp *esp, struct platform_device *dma_of)
{
	esp->dma = dma_of;

	esp->dma_regs = of_ioremap(&dma_of->resource[0], 0,
				   resource_size(&dma_of->resource[0]),
				   "espdma");
	if (!esp->dma_regs)
		return -ENOMEM;

	switch (dma_read32(DMA_CSR) & DMA_DEVICE_ID) {
	case DMA_VERS0:
		esp->dmarev = dvmarev0;
		break;
	case DMA_ESCV1:
		esp->dmarev = dvmaesc1;
		break;
	case DMA_VERS1:
		esp->dmarev = dvmarev1;
		break;
	case DMA_VERS2:
		esp->dmarev = dvmarev2;
		break;
	case DMA_VERHME:
		esp->dmarev = dvmahme;
		break;
	case DMA_VERSPLUS:
		esp->dmarev = dvmarevplus;
		break;
	}

	return 0;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
136
99.27%
2
66.67%
grant likely
grant likely
1
0.73%
1
33.33%
Total
137
100.00%
3
100.00%



static int esp_sbus_map_regs(struct esp *esp, int hme)
{
	struct platform_device *op = esp->dev;
	struct resource *res;

	/* On HME, two reg sets exist, first is DVMA,
         * second is ESP registers.
         */
	if (hme)
		res = &op->resource[1];
	else
		res = &op->resource[0];

	esp->regs = of_ioremap(res, 0, SBUS_ESP_REG_SIZE, "ESP");
	if (!esp->regs)
		return -ENOMEM;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
82
98.80%
2
66.67%
grant likely
grant likely
1
1.20%
1
33.33%
Total
83
100.00%
3
100.00%



static int esp_sbus_map_command_block(struct esp *esp)
{
	struct platform_device *op = esp->dev;

	esp->command_block = dma_alloc_coherent(&op->dev, 16,
						&esp->command_block_dma,
						GFP_ATOMIC);
	if (!esp->command_block)
		return -ENOMEM;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
54
98.18%
4
80.00%
grant likely
grant likely
1
1.82%
1
20.00%
Total
55
100.00%
5
100.00%



static int esp_sbus_register_irq(struct esp *esp)
{
	struct Scsi_Host *host = esp->host;
	struct platform_device *op = esp->dev;

	host->irq = op->archdata.irqs[0];
	return request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "ESP", esp);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
55
94.83%
2
50.00%
grant likely
grant likely
3
5.17%
2
50.00%
Total
58
100.00%
4
100.00%



static void esp_get_scsi_id(struct esp *esp, struct platform_device *espdma)
{
	struct platform_device *op = esp->dev;
	struct device_node *dp;

	dp = op->dev.of_node;
	esp->scsi_id = of_getintprop_default(dp, "initiator-id", 0xff);
	if (esp->scsi_id != 0xff)
		goto done;

	esp->scsi_id = of_getintprop_default(dp, "scsi-initiator-id", 0xff);
	if (esp->scsi_id != 0xff)
		goto done;

	esp->scsi_id = of_getintprop_default(espdma->dev.of_node,
					     "scsi-initiator-id", 7);

done:
	esp->host->this_id = esp->scsi_id;
	esp->scsi_id_mask = (1 << esp->scsi_id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
119
93.70%
2
50.00%
grant likely
grant likely
8
6.30%
2
50.00%
Total
127
100.00%
4
100.00%



static void esp_get_differential(struct esp *esp)
{
	struct platform_device *op = esp->dev;
	struct device_node *dp;

	dp = op->dev.of_node;
	if (of_find_property(dp, "differential", NULL))
		esp->flags |= ESP_FLAG_DIFFERENTIAL;
	else
		esp->flags &= ~ESP_FLAG_DIFFERENTIAL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
54
93.10%
2
50.00%
grant likely
grant likely
4
6.90%
2
50.00%
Total
58
100.00%
4
100.00%



static void esp_get_clock_params(struct esp *esp)
{
	struct platform_device *op = esp->dev;
	struct device_node *bus_dp, *dp;
	int fmhz;

	dp = op->dev.of_node;
	bus_dp = dp->parent;

	fmhz = of_getintprop_default(dp, "clock-frequency", 0);
	if (fmhz == 0)
		fmhz = of_getintprop_default(bus_dp, "clock-frequency", 0);

	esp->cfreq = fmhz;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
75
94.94%
2
50.00%
grant likely
grant likely
4
5.06%
2
50.00%
Total
79
100.00%
4
100.00%



static void esp_get_bursts(struct esp *esp, struct platform_device *dma_of)
{
	struct device_node *dma_dp = dma_of->dev.of_node;
	struct platform_device *op = esp->dev;
	struct device_node *dp;
	u8 bursts, val;

	dp = op->dev.of_node;
	bursts = of_getintprop_default(dp, "burst-sizes", 0xff);
	val = of_getintprop_default(dma_dp, "burst-sizes", 0xff);
	if (val != 0xff)
		bursts &= val;

	val = of_getintprop_default(dma_dp->parent, "burst-sizes", 0xff);
	if (val != 0xff)
		bursts &= val;

	if (bursts == 0xff ||
	    (bursts & DMA_BURST16) == 0 ||
	    (bursts & DMA_BURST32) == 0)
		bursts = (DMA_BURST32 - 1);

	esp->bursts = bursts;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
137
94.48%
3
60.00%
grant likely
grant likely
8
5.52%
2
40.00%
Total
145
100.00%
5
100.00%



static void esp_sbus_get_props(struct esp *esp, struct platform_device *espdma)
{
	esp_get_scsi_id(esp, espdma);
	esp_get_differential(esp);
	esp_get_clock_params(esp);
	esp_get_bursts(esp, espdma);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
39
97.50%
2
66.67%
grant likely
grant likely
1
2.50%
1
33.33%
Total
40
100.00%
3
100.00%



static void sbus_esp_write8(struct esp *esp, u8 val, unsigned long reg)
{
	sbus_writeb(val, esp->regs + (reg * 4UL));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
33
100.00%
1
100.00%
Total
33
100.00%
1
100.00%



static u8 sbus_esp_read8(struct esp *esp, unsigned long reg)
{
	return sbus_readb(esp->regs + (reg * 4UL));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
29
100.00%
1
100.00%
Total
29
100.00%
1
100.00%



static dma_addr_t sbus_esp_map_single(struct esp *esp, void *buf,
				      size_t sz, int dir)
{
	struct platform_device *op = esp->dev;

	return dma_map_single(&op->dev, buf, sz, dir);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
44
97.78%
4
80.00%
grant likely
grant likely
1
2.22%
1
20.00%
Total
45
100.00%
5
100.00%



static int sbus_esp_map_sg(struct esp *esp, struct scatterlist *sg,
				  int num_sg, int dir)
{
	struct platform_device *op = esp->dev;

	return dma_map_sg(&op->dev, sg, num_sg, dir);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
45
97.83%
4
80.00%
grant likely
grant likely
1
2.17%
1
20.00%
Total
46
100.00%
5
100.00%



static void sbus_esp_unmap_single(struct esp *esp, dma_addr_t addr,
				  size_t sz, int dir)
{
	struct platform_device *op = esp->dev;

	dma_unmap_single(&op->dev, addr, sz, dir);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
42
97.67%
4
80.00%
grant likely
grant likely
1
2.33%
1
20.00%
Total
43
100.00%
5
100.00%



static void sbus_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
			      int num_sg, int dir)
{
	struct platform_device *op = esp->dev;

	dma_unmap_sg(&op->dev, sg, num_sg, dir);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
44
97.78%
4
80.00%
grant likely
grant likely
1
2.22%
1
20.00%
Total
45
100.00%
5
100.00%



static int sbus_esp_irq_pending(struct esp *esp)
{
	if (dma_read32(DMA_CSR) & (DMA_HNDL_INTR | DMA_HNDL_ERROR))
		return 1;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%



static void sbus_esp_reset_dma(struct esp *esp)
{
	int can_do_burst16, can_do_burst32, can_do_burst64;
	int can_do_sbus64, lim;
	struct platform_device *op;
	u32 val;

	can_do_burst16 = (esp->bursts & DMA_BURST16) != 0;
	can_do_burst32 = (esp->bursts & DMA_BURST32) != 0;
	can_do_burst64 = 0;
	can_do_sbus64 = 0;
	op = esp->dev;
	if (sbus_can_dma_64bit())
		can_do_sbus64 = 1;
	if (sbus_can_burst64())
		can_do_burst64 = (esp->bursts & DMA_BURST64) != 0;

	/* Put the DVMA into a known state. */
	if (esp->dmarev != dvmahme) {
		val = dma_read32(DMA_CSR);
		dma_write32(val | DMA_RST_SCSI, DMA_CSR);
		dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
	}
	switch (esp->dmarev) {
	case dvmahme:
		dma_write32(DMA_RESET_FAS366, DMA_CSR);
		dma_write32(DMA_RST_SCSI, DMA_CSR);

		esp->prev_hme_dmacsr = (DMA_PARITY_OFF | DMA_2CLKS |
					DMA_SCSI_DISAB | DMA_INT_ENAB);

		esp->prev_hme_dmacsr &= ~(DMA_ENABLE | DMA_ST_WRITE |
					  DMA_BRST_SZ);

		if (can_do_burst64)
			esp->prev_hme_dmacsr |= DMA_BRST64;
		else if (can_do_burst32)
			esp->prev_hme_dmacsr |= DMA_BRST32;

		if (can_do_sbus64) {
			esp->prev_hme_dmacsr |= DMA_SCSI_SBUS64;
			sbus_set_sbus64(&op->dev, esp->bursts);
		}

		lim = 1000;
		while (dma_read32(DMA_CSR) & DMA_PEND_READ) {
			if (--lim == 0) {
				printk(KERN_ALERT PFX "esp%d: DMA_PEND_READ "
				       "will not clear!\n",
				       esp->host->unique_id);
				break;
			}
			udelay(1);
		}

		dma_write32(0, DMA_CSR);
		dma_write32(esp->prev_hme_dmacsr, DMA_CSR);

		dma_write32(0, DMA_ADDR);
		break;

	case dvmarev2:
		if (esp->rev != ESP100) {
			val = dma_read32(DMA_CSR);
			dma_write32(val | DMA_3CLKS, DMA_CSR);
		}
		break;

	case dvmarev3:
		val = dma_read32(DMA_CSR);
		val &= ~DMA_3CLKS;
		val |= DMA_2CLKS;
		if (can_do_burst32) {
			val &= ~DMA_BRST_SZ;
			val |= DMA_BRST32;
		}
		dma_write32(val, DMA_CSR);
		break;

	case dvmaesc1:
		val = dma_read32(DMA_CSR);
		val |= DMA_ADD_ENABLE;
		val &= ~DMA_BCNT_ENAB;
		if (!can_do_burst32 && can_do_burst16) {
			val |= DMA_ESC_BURST;
		} else {
			val &= ~(DMA_ESC_BURST);
		}
		dma_write32(val, DMA_CSR);
		break;

	default:
		break;
	}

	/* Enable interrupts.  */
	val = dma_read32(DMA_CSR);
	dma_write32(val | DMA_INT_ENAB, DMA_CSR);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
432
99.77%
4
80.00%
grant likely
grant likely
1
0.23%
1
20.00%
Total
433
100.00%
5
100.00%



static void sbus_esp_dma_drain(struct esp *esp)
{
	u32 csr;
	int lim;

	if (esp->dmarev == dvmahme)
		return;

	csr = dma_read32(DMA_CSR);
	if (!(csr & DMA_FIFO_ISDRAIN))
		return;

	if (esp->dmarev != dvmarev3 && esp->dmarev != dvmaesc1)
		dma_write32(csr | DMA_FIFO_STDRAIN, DMA_CSR);

	lim = 1000;
	while (dma_read32(DMA_CSR) & DMA_FIFO_ISDRAIN) {
		if (--lim == 0) {
			printk(KERN_ALERT PFX "esp%d: DMA will not drain!\n",
			       esp->host->unique_id);
			break;
		}
		udelay(1);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
104
100.00%
2
100.00%
Total
104
100.00%
2
100.00%



static void sbus_esp_dma_invalidate(struct esp *esp)
{
	if (esp->dmarev == dvmahme) {
		dma_write32(DMA_RST_SCSI, DMA_CSR);

		esp->prev_hme_dmacsr = ((esp->prev_hme_dmacsr |
					 (DMA_PARITY_OFF | DMA_2CLKS |
					  DMA_SCSI_DISAB | DMA_INT_ENAB)) &
					~(DMA_ST_WRITE | DMA_ENABLE));

		dma_write32(0, DMA_CSR);
		dma_write32(esp->prev_hme_dmacsr, DMA_CSR);

		/* This is necessary to avoid having the SCSI channel
                 * engine lock up on us.
                 */
		dma_write32(0, DMA_ADDR);
	} else {
		u32 val;
		int lim;

		lim = 1000;
		while ((val = dma_read32(DMA_CSR)) & DMA_PEND_READ) {
			if (--lim == 0) {
				printk(KERN_ALERT PFX "esp%d: DMA will not "
				       "invalidate!\n", esp->host->unique_id);
				break;
			}
			udelay(1);
		}

		val &= ~(DMA_ENABLE | DMA_ST_WRITE | DMA_BCNT_ENAB);
		val |= DMA_FIFO_INV;
		dma_write32(val, DMA_CSR);
		val &= ~DMA_FIFO_INV;
		dma_write32(val, DMA_CSR);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
167
100.00%
2
100.00%
Total
167
100.00%
2
100.00%



static void sbus_esp_send_dma_cmd(struct esp *esp, u32 addr, u32 esp_count,
				  u32 dma_count, int write, u8 cmd)
{
	u32 csr;

	BUG_ON(!(cmd & ESP_CMD_DMA));

	sbus_esp_write8(esp, (esp_count >> 0) & 0xff, ESP_TCLOW);
	sbus_esp_write8(esp, (esp_count >> 8) & 0xff, ESP_TCMED);
	if (esp->rev == FASHME) {
		sbus_esp_write8(esp, (esp_count >> 16) & 0xff, FAS_RLO);
		sbus_esp_write8(esp, 0, FAS_RHI);

		scsi_esp_cmd(esp, cmd);

		csr = esp->prev_hme_dmacsr;
		csr |= DMA_SCSI_DISAB | DMA_ENABLE;
		if (write)
			csr |= DMA_ST_WRITE;
		else
			csr &= ~DMA_ST_WRITE;
		esp->prev_hme_dmacsr = csr;

		dma_write32(dma_count, DMA_COUNT);
		dma_write32(addr, DMA_ADDR);
		dma_write32(csr, DMA_CSR);
	} else {
		csr = dma_read32(DMA_CSR);
		csr |= DMA_ENABLE;
		if (write)
			csr |= DMA_ST_WRITE;
		else
			csr &= ~DMA_ST_WRITE;
		dma_write32(csr, DMA_CSR);
		if (esp->dmarev == dvmaesc1) {
			u32 end = PAGE_ALIGN(addr + dma_count + 16U);
			dma_write32(end - addr, DMA_COUNT);
		}
		dma_write32(addr, DMA_ADDR);

		scsi_esp_cmd(esp, cmd);
	}

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
243
100.00%
2
100.00%
Total
243
100.00%
2
100.00%



static int sbus_esp_dma_error(struct esp *esp)
{
	u32 csr = dma_read32(DMA_CSR);

	if (csr & DMA_HNDL_ERROR)
		return 1;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
31
100.00%
1
100.00%
Total
31
100.00%
1
100.00%


static const struct esp_driver_ops sbus_esp_ops = {
	.esp_write8	=	sbus_esp_write8,
	.esp_read8	=	sbus_esp_read8,
	.map_single	=	sbus_esp_map_single,
	.map_sg		=	sbus_esp_map_sg,
	.unmap_single	=	sbus_esp_unmap_single,
	.unmap_sg	=	sbus_esp_unmap_sg,
	.irq_pending	=	sbus_esp_irq_pending,
	.reset_dma	=	sbus_esp_reset_dma,
	.dma_drain	=	sbus_esp_dma_drain,
	.dma_invalidate	=	sbus_esp_dma_invalidate,
	.send_dma_cmd	=	sbus_esp_send_dma_cmd,
	.dma_error	=	sbus_esp_dma_error,
};



static int esp_sbus_probe_one(struct platform_device *op,
			      struct platform_device *espdma, int hme)
{
	struct scsi_host_template *tpnt = &scsi_esp_template;
	struct Scsi_Host *host;
	struct esp *esp;
	int err;

	host = scsi_host_alloc(tpnt, sizeof(struct esp));

	err = -ENOMEM;
	if (!host)
		goto fail;

	host->max_id = (hme ? 16 : 8);
	esp = shost_priv(host);

	esp->host = host;
	esp->dev = op;
	esp->ops = &sbus_esp_ops;

	if (hme)
		esp->flags |= ESP_FLAG_WIDE_CAPABLE;

	err = esp_sbus_setup_dma(esp, espdma);
	if (err < 0)
		goto fail_unlink;

	err = esp_sbus_map_regs(esp, hme);
	if (err < 0)
		goto fail_unlink;

	err = esp_sbus_map_command_block(esp);
	if (err < 0)
		goto fail_unmap_regs;

	err = esp_sbus_register_irq(esp);
	if (err < 0)
		goto fail_unmap_command_block;

	esp_sbus_get_props(esp, espdma);

	/* Before we try to touch the ESP chip, ESC1 dma can
         * come up with the reset bit set, so make sure that
         * is clear first.
         */
	if (esp->dmarev == dvmaesc1) {
		u32 val = dma_read32(DMA_CSR);

		dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
	}

	dev_set_drvdata(&op->dev, esp);

	err = scsi_esp_register(esp, &op->dev);
	if (err)
		goto fail_free_irq;

	return 0;

fail_free_irq:
	free_irq(host->irq, esp);
fail_unmap_command_block:
	dma_free_coherent(&op->dev, 16,
			  esp->command_block,
			  esp->command_block_dma);
fail_unmap_regs:
	of_iounmap(&op->resource[(hme ? 1 : 0)], esp->regs, SBUS_ESP_REG_SIZE);
fail_unlink:
	scsi_host_put(host);
fail:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
315
99.06%
5
71.43%
grant likely
grant likely
2
0.63%
1
14.29%
christoph hellwig
christoph hellwig
1
0.31%
1
14.29%
Total
318
100.00%
7
100.00%



static int esp_sbus_probe(struct platform_device *op)
{
	struct device_node *dma_node = NULL;
	struct device_node *dp = op->dev.of_node;
	struct platform_device *dma_of = NULL;
	int hme = 0;

	if (dp->parent &&
	    (!strcmp(dp->parent->name, "espdma") ||
	     !strcmp(dp->parent->name, "dma")))
		dma_node = dp->parent;
	else if (!strcmp(dp->name, "SUNW,fas")) {
		dma_node = op->dev.of_node;
		hme = 1;
	}
	if (dma_node)
		dma_of = of_find_device_by_node(dma_node);
	if (!dma_of)
		return -ENODEV;

	return esp_sbus_probe_one(op, dma_of, hme);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
128
94.12%
3
60.00%
grant likely
grant likely
8
5.88%
2
40.00%
Total
136
100.00%
5
100.00%



static int esp_sbus_remove(struct platform_device *op)
{
	struct esp *esp = dev_get_drvdata(&op->dev);
	struct platform_device *dma_of = esp->dma;
	unsigned int irq = esp->host->irq;
	bool is_hme;
	u32 val;

	scsi_esp_unregister(esp);

	/* Disable interrupts.  */
	val = dma_read32(DMA_CSR);
	dma_write32(val & ~DMA_INT_ENAB, DMA_CSR);

	free_irq(irq, esp);

	is_hme = (esp->dmarev == dvmahme);

	dma_free_coherent(&op->dev, 16,
			  esp->command_block,
			  esp->command_block_dma);
	of_iounmap(&op->resource[(is_hme ? 1 : 0)], esp->regs,
		   SBUS_ESP_REG_SIZE);
	of_iounmap(&dma_of->resource[0], esp->dma_regs,
		   resource_size(&dma_of->resource[0]));

	scsi_host_put(esp->host);

	dev_set_drvdata(&op->dev, NULL);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
174
98.86%
5
83.33%
grant likely
grant likely
2
1.14%
1
16.67%
Total
176
100.00%
6
100.00%


static const struct of_device_id esp_match[] = {
	{
		.name = "SUNW,esp",
        },
	{
		.name = "SUNW,fas",
        },
	{
		.name = "esp",
        },
	{},
};
MODULE_DEVICE_TABLE(of, esp_match);


static struct platform_driver esp_sbus_driver = {
	.driver = {
		.name = "esp",
		.of_match_table = esp_match,
        },
	.probe		= esp_sbus_probe,
	.remove		= esp_sbus_remove,
};



static int __init sunesp_init(void)
{
	return platform_driver_register(&esp_sbus_driver);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
15
93.75%
1
50.00%
grant likely
grant likely
1
6.25%
1
50.00%
Total
16
100.00%
2
100.00%



static void __exit sunesp_exit(void)
{
	platform_driver_unregister(&esp_sbus_driver);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
14
93.33%
1
50.00%
grant likely
grant likely
1
6.67%
1
50.00%
Total
15
100.00%
2
100.00%

MODULE_DESCRIPTION("Sun ESP SCSI driver");
MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
MODULE_LICENSE("GPL");

MODULE_VERSION(DRV_VERSION);


module_init(sunesp_init);

module_exit(sunesp_exit);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
david s. miller
david s. miller
2896
97.84%
8
50.00%
grant likely
grant likely
57
1.93%
5
31.25%
andrea righi
andrea righi
3
0.10%
1
6.25%
tejun heo
tejun heo
3
0.10%
1
6.25%
christoph hellwig
christoph hellwig
1
0.03%
1
6.25%
Total
2960
100.00%
16
100.00%
  
Directory: drivers/scsi

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.