[linux-2.6-block.git] / drivers / scsi / mac_esp.c

/* mac_esp.c: ESP front-end for Macintosh Quadra systems.
 *
 * Adapted from jazz_esp.c and the old mac_esp.c.
 *
 * The pseudo DMA algorithm is based on the one used in NetBSD.
 * See sys/arch/mac68k/obio/esp.c for some background information.
 *
 * Copyright (C) 2007-2008 Finn Thain
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/scatterlist.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/nubus.h>
#include <linux/slab.h>

#include <asm/irq.h>
#include <asm/dma.h>
#include <asm/macints.h>
#include <asm/macintosh.h>
#include <asm/mac_via.h>

#include <scsi/scsi_host.h>

#include "esp_scsi.h"

#define DRV_MODULE_NAME     "mac_esp"
#define PFX                 DRV_MODULE_NAME ": "
#define DRV_VERSION         "1.000"
#define DRV_MODULE_RELDATE  "Sept 15, 2007"

#define MAC_ESP_IO_BASE          0x50F00000
#define MAC_ESP_REGS_QUADRA      (MAC_ESP_IO_BASE + 0x10000)
#define MAC_ESP_REGS_QUADRA2     (MAC_ESP_IO_BASE + 0xF000)
#define MAC_ESP_REGS_QUADRA3     (MAC_ESP_IO_BASE + 0x18000)
#define MAC_ESP_REGS_SPACING     0x402
#define MAC_ESP_PDMA_REG         0xF9800024
#define MAC_ESP_PDMA_REG_SPACING 0x4
#define MAC_ESP_PDMA_IO_OFFSET   0x100

#define esp_read8(REG)		mac_esp_read8(esp, REG)
#define esp_write8(VAL, REG)	mac_esp_write8(esp, VAL, REG)

struct mac_esp_priv {
	struct esp *esp;
	void __iomem *pdma_regs;
	void __iomem *pdma_io;
};
static struct esp *esp_chips[2];
static DEFINE_SPINLOCK(esp_chips_lock);

#define MAC_ESP_GET_PRIV(esp) ((struct mac_esp_priv *) \
			       dev_get_drvdata((esp)->dev))

static inline void mac_esp_write8(struct esp *esp, u8 val, unsigned long reg)
{
	nubus_writeb(val, esp->regs + reg * 16);
}

static inline u8 mac_esp_read8(struct esp *esp, unsigned long reg)
{
	return nubus_readb(esp->regs + reg * 16);
}

static void mac_esp_reset_dma(struct esp *esp)
{
	/* Nothing to do. */
}

static void mac_esp_dma_drain(struct esp *esp)
{
	/* Nothing to do. */
}

static void mac_esp_dma_invalidate(struct esp *esp)
{
	/* Nothing to do. */
}

static int mac_esp_dma_error(struct esp *esp)
{
	return esp->send_cmd_error;
}

static inline int mac_esp_wait_for_empty_fifo(struct esp *esp)
{
	int i = 500000;

	do {
		if (!(esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES))
			return 0;

		if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
			return 1;

		udelay(2);
	} while (--i);

	printk(KERN_ERR PFX "FIFO is not empty (sreg %02x)\n",
	       esp_read8(ESP_STATUS));
	esp->send_cmd_error = 1;
	return 1;
}

static inline int mac_esp_wait_for_dreq(struct esp *esp)
{
	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
	int i = 500000;

	do {
		if (mep->pdma_regs == NULL) {
			if (via2_scsi_drq_pending())
				return 0;
		} else {
			if (nubus_readl(mep->pdma_regs) & 0x200)
				return 0;
		}

		if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
			return 1;

		udelay(2);
	} while (--i);

	printk(KERN_ERR PFX "PDMA timeout (sreg %02x)\n",
	       esp_read8(ESP_STATUS));
	esp->send_cmd_error = 1;
	return 1;
}

#define MAC_ESP_PDMA_LOOP(operands) \
	asm volatile ( \
	     "       tstw %1                   \n" \
	     "       jbeq 20f                  \n" \
	     "1:     movew " operands "        \n" \
	     "2:     movew " operands "        \n" \
	     "3:     movew " operands "        \n" \
	     "4:     movew " operands "        \n" \
	     "5:     movew " operands "        \n" \
	     "6:     movew " operands "        \n" \
	     "7:     movew " operands "        \n" \
	     "8:     movew " operands "        \n" \
	     "9:     movew " operands "        \n" \
	     "10:    movew " operands "        \n" \
	     "11:    movew " operands "        \n" \
	     "12:    movew " operands "        \n" \
	     "13:    movew " operands "        \n" \
	     "14:    movew " operands "        \n" \
	     "15:    movew " operands "        \n" \
	     "16:    movew " operands "        \n" \
	     "       subqw #1,%1               \n" \
	     "       jbne 1b                   \n" \
	     "20:    tstw %2                   \n" \
	     "       jbeq 30f                  \n" \
	     "21:    movew " operands "        \n" \
	     "       subqw #1,%2               \n" \
	     "       jbne 21b                  \n" \
	     "30:    tstw %3                   \n" \
	     "       jbeq 40f                  \n" \
	     "31:    moveb " operands "        \n" \
	     "32:    nop                       \n" \
	     "40:                              \n" \
	     "                                 \n" \
	     "       .section __ex_table,\"a\" \n" \
	     "       .align  4                 \n" \
	     "       .long   1b,40b            \n" \
	     "       .long   2b,40b            \n" \
	     "       .long   3b,40b            \n" \
	     "       .long   4b,40b            \n" \
	     "       .long   5b,40b            \n" \
	     "       .long   6b,40b            \n" \
	     "       .long   7b,40b            \n" \
	     "       .long   8b,40b            \n" \
	     "       .long   9b,40b            \n" \
	     "       .long  10b,40b            \n" \
	     "       .long  11b,40b            \n" \
	     "       .long  12b,40b            \n" \
	     "       .long  13b,40b            \n" \
	     "       .long  14b,40b            \n" \
	     "       .long  15b,40b            \n" \
	     "       .long  16b,40b            \n" \
	     "       .long  21b,40b            \n" \
	     "       .long  31b,40b            \n" \
	     "       .long  32b,40b            \n" \
	     "       .previous                 \n" \
	     : "+a" (addr), "+r" (count32), "+r" (count2) \
	     : "g" (count1), "a" (mep->pdma_io))

static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count,
				  u32 dma_count, int write, u8 cmd)
{
	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);

	esp->send_cmd_error = 0;

	if (!write)
		scsi_esp_cmd(esp, ESP_CMD_FLUSH);

	esp_write8((esp_count >> 0) & 0xFF, ESP_TCLOW);
	esp_write8((esp_count >> 8) & 0xFF, ESP_TCMED);

	scsi_esp_cmd(esp, cmd);

	do {
		unsigned int count32 = esp_count >> 5;
		unsigned int count2 = (esp_count & 0x1F) >> 1;
		unsigned int count1 = esp_count & 1;
		unsigned int start_addr = addr;

		if (mac_esp_wait_for_dreq(esp))
			break;

		if (write) {
			MAC_ESP_PDMA_LOOP("%4@,%0@+");

			esp_count -= addr - start_addr;
		} else {
			unsigned int n;

			MAC_ESP_PDMA_LOOP("%0@+,%4@");

			if (mac_esp_wait_for_empty_fifo(esp))
				break;

			n = (esp_read8(ESP_TCMED) << 8) + esp_read8(ESP_TCLOW);
			addr = start_addr + esp_count - n;
			esp_count = n;
		}
	} while (esp_count);
}

static int mac_esp_irq_pending(struct esp *esp)
{
	if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
		return 1;
	return 0;
}

static u32 mac_esp_dma_length_limit(struct esp *esp, u32 dma_addr, u32 dma_len)
{
	return dma_len > 0xFFFF ? 0xFFFF : dma_len;
}

static irqreturn_t mac_scsi_esp_intr(int irq, void *dev_id)
{
	int got_intr;

	/*
	 * This is an edge triggered IRQ, so we have to be careful to
	 * avoid missing a transition when it is shared by two ESP devices.
	 */

	do {
		got_intr = 0;
		if (esp_chips[0] &&
		    (mac_esp_read8(esp_chips[0], ESP_STATUS) & ESP_STAT_INTR)) {
			(void)scsi_esp_intr(irq, esp_chips[0]);
			got_intr = 1;
		}
		if (esp_chips[1] &&
		    (mac_esp_read8(esp_chips[1], ESP_STATUS) & ESP_STAT_INTR)) {
			(void)scsi_esp_intr(irq, esp_chips[1]);
			got_intr = 1;
		}
	} while (got_intr);

	return IRQ_HANDLED;
}

static struct esp_driver_ops mac_esp_ops = {
	.esp_write8       = mac_esp_write8,
	.esp_read8        = mac_esp_read8,
	.irq_pending      = mac_esp_irq_pending,
	.dma_length_limit = mac_esp_dma_length_limit,
	.reset_dma        = mac_esp_reset_dma,
	.dma_drain        = mac_esp_dma_drain,
	.dma_invalidate   = mac_esp_dma_invalidate,
	.send_dma_cmd     = mac_esp_send_pdma_cmd,
	.dma_error        = mac_esp_dma_error,
};

static int esp_mac_probe(struct platform_device *dev)
{
	struct scsi_host_template *tpnt = &scsi_esp_template;
	struct Scsi_Host *host;
	struct esp *esp;
	int err;
	struct mac_esp_priv *mep;

	if (!MACH_IS_MAC)
		return -ENODEV;

	if (dev->id > 1)
		return -ENODEV;

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

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

	host->max_id = 8;
	host->dma_boundary = PAGE_SIZE - 1;
	esp = shost_priv(host);

	esp->host = host;
	esp->dev = &dev->dev;

	esp->command_block = kzalloc(16, GFP_KERNEL);
	if (!esp->command_block)
		goto fail_unlink;
	esp->command_block_dma = (dma_addr_t)esp->command_block;

	esp->scsi_id = 7;
	host->this_id = esp->scsi_id;
	esp->scsi_id_mask = 1 << esp->scsi_id;

	mep = kzalloc(sizeof(struct mac_esp_priv), GFP_KERNEL);
	if (!mep)
		goto fail_free_command_block;
	mep->esp = esp;
	platform_set_drvdata(dev, mep);

	switch (macintosh_config->scsi_type) {
	case MAC_SCSI_QUADRA:
		esp->cfreq     = 16500000;
		esp->regs      = (void __iomem *)MAC_ESP_REGS_QUADRA;
		mep->pdma_io   = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
		mep->pdma_regs = NULL;
		break;
	case MAC_SCSI_QUADRA2:
		esp->cfreq     = 25000000;
		esp->regs      = (void __iomem *)(MAC_ESP_REGS_QUADRA2 +
				 dev->id * MAC_ESP_REGS_SPACING);
		mep->pdma_io   = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
		mep->pdma_regs = (void __iomem *)(MAC_ESP_PDMA_REG +
				 dev->id * MAC_ESP_PDMA_REG_SPACING);
		nubus_writel(0x1d1, mep->pdma_regs);
		break;
	case MAC_SCSI_QUADRA3:
		/* These quadras have a real DMA controller (the PSC) but we
		 * don't know how to drive it so we must use PIO instead.
		 */
		esp->cfreq     = 25000000;
		esp->regs      = (void __iomem *)MAC_ESP_REGS_QUADRA3;
		mep->pdma_io   = NULL;
		mep->pdma_regs = NULL;
		break;
	}
	esp->fifo_reg = esp->regs + ESP_FDATA * 16;

	esp->ops = &mac_esp_ops;
	esp->flags = ESP_FLAG_NO_DMA_MAP;
	if (mep->pdma_io == NULL) {
		printk(KERN_INFO PFX "using PIO for controller %d\n", dev->id);
		esp_write8(0, ESP_TCLOW);
		esp_write8(0, ESP_TCMED);
		esp->flags |= ESP_FLAG_DISABLE_SYNC;
		mac_esp_ops.send_dma_cmd = esp_send_pio_cmd;
	} else {
		printk(KERN_INFO PFX "using PDMA for controller %d\n", dev->id);
	}

	host->irq = IRQ_MAC_SCSI;

	/* The request_irq() call is intended to succeed for the first device
	 * and fail for the second device.
	 */
	err = request_irq(host->irq, mac_scsi_esp_intr, 0, "ESP", NULL);
	spin_lock(&esp_chips_lock);
	if (err < 0 && esp_chips[!dev->id] == NULL) {
		spin_unlock(&esp_chips_lock);
		goto fail_free_priv;
	}
	esp_chips[dev->id] = esp;
	spin_unlock(&esp_chips_lock);

	err = scsi_esp_register(esp);
	if (err)
		goto fail_free_irq;

	return 0;

fail_free_irq:
	spin_lock(&esp_chips_lock);
	esp_chips[dev->id] = NULL;
	if (esp_chips[!dev->id] == NULL) {
		spin_unlock(&esp_chips_lock);
		free_irq(host->irq, NULL);
	} else
		spin_unlock(&esp_chips_lock);
fail_free_priv:
	kfree(mep);
fail_free_command_block:
	kfree(esp->command_block);
fail_unlink:
	scsi_host_put(host);
fail:
	return err;
}

static int esp_mac_remove(struct platform_device *dev)
{
	struct mac_esp_priv *mep = platform_get_drvdata(dev);
	struct esp *esp = mep->esp;
	unsigned int irq = esp->host->irq;

	scsi_esp_unregister(esp);

	spin_lock(&esp_chips_lock);
	esp_chips[dev->id] = NULL;
	if (esp_chips[!dev->id] == NULL) {
		spin_unlock(&esp_chips_lock);
		free_irq(irq, NULL);
	} else
		spin_unlock(&esp_chips_lock);

	kfree(mep);

	kfree(esp->command_block);

	scsi_host_put(esp->host);

	return 0;
}

static struct platform_driver esp_mac_driver = {
	.probe    = esp_mac_probe,
	.remove   = esp_mac_remove,
	.driver   = {
		.name	= DRV_MODULE_NAME,
	},
};

static int __init mac_esp_init(void)
{
	return platform_driver_register(&esp_mac_driver);
}

static void __exit mac_esp_exit(void)
{
	platform_driver_unregister(&esp_mac_driver);
}

MODULE_DESCRIPTION("Mac ESP SCSI driver");
MODULE_AUTHOR("Finn Thain");
MODULE_LICENSE("GPL v2");
MODULE_VERSION(DRV_VERSION);
MODULE_ALIAS("platform:" DRV_MODULE_NAME);

module_init(mac_esp_init);
module_exit(mac_esp_exit);
Commit	Line	Data
6fe07aaf FT	1	/* mac_esp.c: ESP front-end for Macintosh Quadra systems.
	2	*
	3	* Adapted from jazz_esp.c and the old mac_esp.c.
	4	*
	5	* The pseudo DMA algorithm is based on the one used in NetBSD.
	6	* See sys/arch/mac68k/obio/esp.c for some background information.
	7	*
	8	* Copyright (C) 2007-2008 Finn Thain
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/types.h>
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/interrupt.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/dma-mapping.h>
	18	#include <linux/scatterlist.h>
	19	#include <linux/delay.h>
	20	#include <linux/io.h>
	21	#include <linux/nubus.h>
5a0e3ad6	22	#include <linux/slab.h>
6fe07aaf FT	23
	24	#include <asm/irq.h>
	25	#include <asm/dma.h>
6fe07aaf FT	26	#include <asm/macints.h>
6fe07aaf FT	27	#include <asm/macintosh.h>
30c0527d	28	#include <asm/mac_via.h>
6fe07aaf FT	29
	30	#include <scsi/scsi_host.h>
	31
	32	#include "esp_scsi.h"
	33
	34	#define DRV_MODULE_NAME "mac_esp"
	35	#define PFX DRV_MODULE_NAME ": "
	36	#define DRV_VERSION "1.000"
	37	#define DRV_MODULE_RELDATE "Sept 15, 2007"
	38
	39	#define MAC_ESP_IO_BASE 0x50F00000
	40	#define MAC_ESP_REGS_QUADRA (MAC_ESP_IO_BASE + 0x10000)
	41	#define MAC_ESP_REGS_QUADRA2 (MAC_ESP_IO_BASE + 0xF000)
	42	#define MAC_ESP_REGS_QUADRA3 (MAC_ESP_IO_BASE + 0x18000)
	43	#define MAC_ESP_REGS_SPACING 0x402
	44	#define MAC_ESP_PDMA_REG 0xF9800024
	45	#define MAC_ESP_PDMA_REG_SPACING 0x4
	46	#define MAC_ESP_PDMA_IO_OFFSET 0x100
	47
	48	#define esp_read8(REG) mac_esp_read8(esp, REG)
	49	#define esp_write8(VAL, REG) mac_esp_write8(esp, VAL, REG)
	50
	51	struct mac_esp_priv {
	52	struct esp *esp;
	53	void __iomem *pdma_regs;
	54	void __iomem *pdma_io;
6fe07aaf	55	};
da244654	56	static struct esp *esp_chips[2];
4da2b1eb	57	static DEFINE_SPINLOCK(esp_chips_lock);
6fe07aaf FT	58
6fe07aaf FT	59	#define MAC_ESP_GET_PRIV(esp) ((struct mac_esp_priv *) \
98cda6a2	60	dev_get_drvdata((esp)->dev))
6fe07aaf FT	61
	62	static inline void mac_esp_write8(struct esp *esp, u8 val, unsigned long reg)
	63	{
	64	nubus_writeb(val, esp->regs + reg * 16);
	65	}
	66
	67	static inline u8 mac_esp_read8(struct esp *esp, unsigned long reg)
	68	{
	69	return nubus_readb(esp->regs + reg * 16);
	70	}
	71
6fe07aaf FT	72	static void mac_esp_reset_dma(struct esp *esp)
	73	{
	74	/* Nothing to do. */
	75	}
	76
	77	static void mac_esp_dma_drain(struct esp *esp)
	78	{
	79	/* Nothing to do. */
	80	}
	81
	82	static void mac_esp_dma_invalidate(struct esp *esp)
	83	{
	84	/* Nothing to do. */
	85	}
	86
	87	static int mac_esp_dma_error(struct esp *esp)
	88	{
53dce332	89	return esp->send_cmd_error;
6fe07aaf FT	90	}
	91
	92	static inline int mac_esp_wait_for_empty_fifo(struct esp *esp)
	93	{
6fe07aaf FT	94	int i = 500000;
	95
	96	do {
	97	if (!(esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES))
	98	return 0;
	99
	100	if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
	101	return 1;
	102
	103	udelay(2);
	104	} while (--i);
	105
	106	printk(KERN_ERR PFX "FIFO is not empty (sreg %02x)\n",
	107	esp_read8(ESP_STATUS));
53dce332	108	esp->send_cmd_error = 1;
6fe07aaf FT	109	return 1;
	110	}
	111
	112	static inline int mac_esp_wait_for_dreq(struct esp *esp)
	113	{
	114	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
	115	int i = 500000;
	116
	117	do {
	118	if (mep->pdma_regs == NULL) {
30c0527d	119	if (via2_scsi_drq_pending())
6fe07aaf FT	120	return 0;
	121	} else {
	122	if (nubus_readl(mep->pdma_regs) & 0x200)
	123	return 0;
	124	}
	125
	126	if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
	127	return 1;
	128
	129	udelay(2);
	130	} while (--i);
	131
	132	printk(KERN_ERR PFX "PDMA timeout (sreg %02x)\n",
	133	esp_read8(ESP_STATUS));
53dce332	134	esp->send_cmd_error = 1;
6fe07aaf FT	135	return 1;
	136	}
	137
	138	#define MAC_ESP_PDMA_LOOP(operands) \
	139	asm volatile ( \
09e13e91	140	" tstw %1 \n" \
6fe07aaf FT	141	" jbeq 20f \n" \
	142	"1: movew " operands " \n" \
	143	"2: movew " operands " \n" \
	144	"3: movew " operands " \n" \
	145	"4: movew " operands " \n" \
	146	"5: movew " operands " \n" \
	147	"6: movew " operands " \n" \
	148	"7: movew " operands " \n" \
	149	"8: movew " operands " \n" \
	150	"9: movew " operands " \n" \
	151	"10: movew " operands " \n" \
	152	"11: movew " operands " \n" \
	153	"12: movew " operands " \n" \
	154	"13: movew " operands " \n" \
	155	"14: movew " operands " \n" \
	156	"15: movew " operands " \n" \
	157	"16: movew " operands " \n" \
09e13e91	158	" subqw #1,%1 \n" \
6fe07aaf	159	" jbne 1b \n" \
09e13e91	160	"20: tstw %2 \n" \
6fe07aaf FT	161	" jbeq 30f \n" \
6fe07aaf FT	162	"21: movew " operands " \n" \
09e13e91	163	" subqw #1,%2 \n" \
6fe07aaf	164	" jbne 21b \n" \
09e13e91	165	"30: tstw %3 \n" \
6fe07aaf FT	166	" jbeq 40f \n" \
	167	"31: moveb " operands " \n" \
	168	"32: nop \n" \
	169	"40: \n" \
	170	" \n" \
	171	" .section __ex_table,\"a\" \n" \
	172	" .align 4 \n" \
	173	" .long 1b,40b \n" \
	174	" .long 2b,40b \n" \
	175	" .long 3b,40b \n" \
	176	" .long 4b,40b \n" \
	177	" .long 5b,40b \n" \
	178	" .long 6b,40b \n" \
	179	" .long 7b,40b \n" \
	180	" .long 8b,40b \n" \
	181	" .long 9b,40b \n" \
	182	" .long 10b,40b \n" \
	183	" .long 11b,40b \n" \
	184	" .long 12b,40b \n" \
	185	" .long 13b,40b \n" \
	186	" .long 14b,40b \n" \
	187	" .long 15b,40b \n" \
	188	" .long 16b,40b \n" \
	189	" .long 21b,40b \n" \
	190	" .long 31b,40b \n" \
	191	" .long 32b,40b \n" \
	192	" .previous \n" \
09e13e91 FT	193	: "+a" (addr), "+r" (count32), "+r" (count2) \
09e13e91 FT	194	: "g" (count1), "a" (mep->pdma_io))
6fe07aaf FT	195
	196	static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count,
	197	u32 dma_count, int write, u8 cmd)
	198	{
	199	struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
6fe07aaf	200
53dce332	201	esp->send_cmd_error = 0;
6fe07aaf FT	202
	203	if (!write)
	204	scsi_esp_cmd(esp, ESP_CMD_FLUSH);
	205
	206	esp_write8((esp_count >> 0) & 0xFF, ESP_TCLOW);
	207	esp_write8((esp_count >> 8) & 0xFF, ESP_TCMED);
	208
	209	scsi_esp_cmd(esp, cmd);
	210
	211	do {
	212	unsigned int count32 = esp_count >> 5;
	213	unsigned int count2 = (esp_count & 0x1F) >> 1;
09e13e91	214	unsigned int count1 = esp_count & 1;
6fe07aaf FT	215	unsigned int start_addr = addr;
	216
	217	if (mac_esp_wait_for_dreq(esp))
	218	break;
	219
	220	if (write) {
09e13e91	221	MAC_ESP_PDMA_LOOP("%4@,%0@+");
6fe07aaf FT	222
	223	esp_count -= addr - start_addr;
	224	} else {
	225	unsigned int n;
	226
09e13e91	227	MAC_ESP_PDMA_LOOP("%0@+,%4@");
6fe07aaf FT	228
	229	if (mac_esp_wait_for_empty_fifo(esp))
	230	break;
	231
	232	n = (esp_read8(ESP_TCMED) << 8) + esp_read8(ESP_TCLOW);
	233	addr = start_addr + esp_count - n;
	234	esp_count = n;
	235	}
	236	} while (esp_count);
6fe07aaf FT	237	}
6fe07aaf FT	238
6fe07aaf FT	239	static int mac_esp_irq_pending(struct esp *esp)
	240	{
	241	if (esp_read8(ESP_STATUS) & ESP_STAT_INTR)
	242	return 1;
	243	return 0;
	244	}
	245
	246	static u32 mac_esp_dma_length_limit(struct esp *esp, u32 dma_addr, u32 dma_len)
	247	{
	248	return dma_len > 0xFFFF ? 0xFFFF : dma_len;
	249	}
	250
da244654 FT	251	static irqreturn_t mac_scsi_esp_intr(int irq, void *dev_id)
	252	{
	253	int got_intr;
	254
	255	/*
	256	* This is an edge triggered IRQ, so we have to be careful to
	257	* avoid missing a transition when it is shared by two ESP devices.
	258	*/
	259
	260	do {
	261	got_intr = 0;
	262	if (esp_chips[0] &&
	263	(mac_esp_read8(esp_chips[0], ESP_STATUS) & ESP_STAT_INTR)) {
	264	(void)scsi_esp_intr(irq, esp_chips[0]);
	265	got_intr = 1;
	266	}
	267	if (esp_chips[1] &&
	268	(mac_esp_read8(esp_chips[1], ESP_STATUS) & ESP_STAT_INTR)) {
	269	(void)scsi_esp_intr(irq, esp_chips[1]);
	270	got_intr = 1;
	271	}
	272	} while (got_intr);
	273
	274	return IRQ_HANDLED;
	275	}
	276
6fe07aaf FT	277	static struct esp_driver_ops mac_esp_ops = {
	278	.esp_write8 = mac_esp_write8,
	279	.esp_read8 = mac_esp_read8,
6fe07aaf FT	280	.irq_pending = mac_esp_irq_pending,
	281	.dma_length_limit = mac_esp_dma_length_limit,
	282	.reset_dma = mac_esp_reset_dma,
	283	.dma_drain = mac_esp_dma_drain,
	284	.dma_invalidate = mac_esp_dma_invalidate,
	285	.send_dma_cmd = mac_esp_send_pdma_cmd,
	286	.dma_error = mac_esp_dma_error,
	287	};
	288
6f039790	289	static int esp_mac_probe(struct platform_device *dev)
6fe07aaf FT	290	{
	291	struct scsi_host_template *tpnt = &scsi_esp_template;
	292	struct Scsi_Host *host;
	293	struct esp *esp;
	294	int err;
6fe07aaf FT	295	struct mac_esp_priv *mep;
	296
	297	if (!MACH_IS_MAC)
	298	return -ENODEV;
	299
cff75f1f	300	if (dev->id > 1)
6fe07aaf FT	301	return -ENODEV;
	302
	303	host = scsi_host_alloc(tpnt, sizeof(struct esp));
	304
	305	err = -ENOMEM;
	306	if (!host)
	307	goto fail;
	308
	309	host->max_id = 8;
4af14d11	310	host->dma_boundary = PAGE_SIZE - 1;
6fe07aaf FT	311	esp = shost_priv(host);
	312
	313	esp->host = host;
98cda6a2	314	esp->dev = &dev->dev;
6fe07aaf FT	315
	316	esp->command_block = kzalloc(16, GFP_KERNEL);
	317	if (!esp->command_block)
	318	goto fail_unlink;
	319	esp->command_block_dma = (dma_addr_t)esp->command_block;
	320
	321	esp->scsi_id = 7;
	322	host->this_id = esp->scsi_id;
	323	esp->scsi_id_mask = 1 << esp->scsi_id;
	324
	325	mep = kzalloc(sizeof(struct mac_esp_priv), GFP_KERNEL);
	326	if (!mep)
	327	goto fail_free_command_block;
	328	mep->esp = esp;
	329	platform_set_drvdata(dev, mep);
	330
	331	switch (macintosh_config->scsi_type) {
	332	case MAC_SCSI_QUADRA:
	333	esp->cfreq = 16500000;
	334	esp->regs = (void __iomem *)MAC_ESP_REGS_QUADRA;
	335	mep->pdma_io = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
	336	mep->pdma_regs = NULL;
	337	break;
	338	case MAC_SCSI_QUADRA2:
	339	esp->cfreq = 25000000;
	340	esp->regs = (void __iomem *)(MAC_ESP_REGS_QUADRA2 +
	341	dev->id * MAC_ESP_REGS_SPACING);
	342	mep->pdma_io = esp->regs + MAC_ESP_PDMA_IO_OFFSET;
	343	mep->pdma_regs = (void __iomem *)(MAC_ESP_PDMA_REG +
	344	dev->id * MAC_ESP_PDMA_REG_SPACING);
	345	nubus_writel(0x1d1, mep->pdma_regs);
	346	break;
	347	case MAC_SCSI_QUADRA3:
	348	/* These quadras have a real DMA controller (the PSC) but we
	349	* don't know how to drive it so we must use PIO instead.
	350	*/
	351	esp->cfreq = 25000000;
	352	esp->regs = (void __iomem *)MAC_ESP_REGS_QUADRA3;
	353	mep->pdma_io = NULL;
	354	mep->pdma_regs = NULL;
	355	break;
	356	}
53dce332	357	esp->fifo_reg = esp->regs + ESP_FDATA * 16;
6fe07aaf FT	358
6fe07aaf FT	359	esp->ops = &mac_esp_ops;
3f9295b6	360	esp->flags = ESP_FLAG_NO_DMA_MAP;
6fe07aaf FT	361	if (mep->pdma_io == NULL) {
	362	printk(KERN_INFO PFX "using PIO for controller %d\n", dev->id);
	363	esp_write8(0, ESP_TCLOW);
	364	esp_write8(0, ESP_TCMED);
3f9295b6	365	esp->flags \|= ESP_FLAG_DISABLE_SYNC;
53dce332	366	mac_esp_ops.send_dma_cmd = esp_send_pio_cmd;
6fe07aaf FT	367	} else {
	368	printk(KERN_INFO PFX "using PDMA for controller %d\n", dev->id);
	369	}
	370
	371	host->irq = IRQ_MAC_SCSI;
4da2b1eb FT	372
	373	/* The request_irq() call is intended to succeed for the first device
	374	* and fail for the second device.
	375	*/
	376	err = request_irq(host->irq, mac_scsi_esp_intr, 0, "ESP", NULL);
	377	spin_lock(&esp_chips_lock);
	378	if (err < 0 && esp_chips[!dev->id] == NULL) {
	379	spin_unlock(&esp_chips_lock);
	380	goto fail_free_priv;
da244654	381	}
4da2b1eb FT	382	esp_chips[dev->id] = esp;
4da2b1eb FT	383	spin_unlock(&esp_chips_lock);
6fe07aaf	384
44b1b4d2	385	err = scsi_esp_register(esp);
6fe07aaf FT	386	if (err)
	387	goto fail_free_irq;
	388
	389	return 0;
	390
	391	fail_free_irq:
4da2b1eb FT	392	spin_lock(&esp_chips_lock);
	393	esp_chips[dev->id] = NULL;
	394	if (esp_chips[!dev->id] == NULL) {
	395	spin_unlock(&esp_chips_lock);
c0e3a6ac	396	free_irq(host->irq, NULL);
4da2b1eb FT	397	} else
4da2b1eb FT	398	spin_unlock(&esp_chips_lock);
6fe07aaf FT	399	fail_free_priv:
	400	kfree(mep);
	401	fail_free_command_block:
	402	kfree(esp->command_block);
	403	fail_unlink:
	404	scsi_host_put(host);
	405	fail:
	406	return err;
	407	}
	408
6f039790	409	static int esp_mac_remove(struct platform_device *dev)
6fe07aaf FT	410	{
	411	struct mac_esp_priv *mep = platform_get_drvdata(dev);
	412	struct esp *esp = mep->esp;
	413	unsigned int irq = esp->host->irq;
	414
	415	scsi_esp_unregister(esp);
	416
4da2b1eb	417	spin_lock(&esp_chips_lock);
da244654	418	esp_chips[dev->id] = NULL;
4da2b1eb FT	419	if (esp_chips[!dev->id] == NULL) {
4da2b1eb FT	420	spin_unlock(&esp_chips_lock);
da244654	421	free_irq(irq, NULL);
4da2b1eb FT	422	} else
4da2b1eb FT	423	spin_unlock(&esp_chips_lock);
6fe07aaf FT	424
	425	kfree(mep);
	426
	427	kfree(esp->command_block);
	428
	429	scsi_host_put(esp->host);
	430
	431	return 0;
	432	}
	433
	434	static struct platform_driver esp_mac_driver = {
	435	.probe = esp_mac_probe,
6f039790	436	.remove = esp_mac_remove,
6fe07aaf	437	.driver = {
cff75f1f	438	.name = DRV_MODULE_NAME,
6fe07aaf FT	439	},
	440	};
	441
	442	static int __init mac_esp_init(void)
	443	{
cff75f1f	444	return platform_driver_register(&esp_mac_driver);
6fe07aaf FT	445	}
	446
	447	static void __exit mac_esp_exit(void)
	448	{
	449	platform_driver_unregister(&esp_mac_driver);
6fe07aaf FT	450	}
	451
	452	MODULE_DESCRIPTION("Mac ESP SCSI driver");
d0c2c269	453	MODULE_AUTHOR("Finn Thain");
839cd310	454	MODULE_LICENSE("GPL v2");
6fe07aaf	455	MODULE_VERSION(DRV_VERSION);
cff75f1f	456	MODULE_ALIAS("platform:" DRV_MODULE_NAME);
6fe07aaf FT	457
	458	module_init(mac_esp_init);
	459	module_exit(mac_esp_exit);