[linux-2.6-block.git] / drivers / ide / falconide.c

/*
 *  Atari Falcon IDE Driver
 *
 *     Created 12 Jul 1997 by Geert Uytterhoeven
 *
 *  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.
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/blkdev.h>
#include <linux/ide.h>
#include <linux/init.h>

#include <asm/setup.h>
#include <asm/atarihw.h>
#include <asm/atariints.h>
#include <asm/atari_stdma.h>

#define DRV_NAME "falconide"

    /*
     *  Base of the IDE interface
     */

#define ATA_HD_BASE	0xfff00000

    /*
     *  Offsets from the above base
     */

#define ATA_HD_CONTROL	0x39

    /*
     *  falconide_intr_lock is used to obtain access to the IDE interrupt,
     *  which is shared between several drivers.
     */

int falconide_intr_lock;
EXPORT_SYMBOL(falconide_intr_lock);

static void falconide_input_data(ide_drive_t *drive, struct request *rq,
				 void *buf, unsigned int len)
{
	unsigned long data_addr = drive->hwif->io_ports.data_addr;

	if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
		return insw(data_addr, buf, (len + 1) / 2);

	insw_swapw(data_addr, buf, (len + 1) / 2);
}

static void falconide_output_data(ide_drive_t *drive, struct request *rq,
				  void *buf, unsigned int len)
{
	unsigned long data_addr = drive->hwif->io_ports.data_addr;

	if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
		return outsw(data_addr, buf, (len + 1) / 2);

	outsw_swapw(data_addr, buf, (len + 1) / 2);
}

/* Atari has a byte-swapped IDE interface */
static const struct ide_tp_ops falconide_tp_ops = {
	.exec_command		= ide_exec_command,
	.read_status		= ide_read_status,
	.read_altstatus		= ide_read_altstatus,
	.read_sff_dma_status	= ide_read_sff_dma_status,

	.set_irq		= ide_set_irq,

	.tf_load		= ide_tf_load,
	.tf_read		= ide_tf_read,

	.input_data		= falconide_input_data,
	.output_data		= falconide_output_data,
};

static const struct ide_port_info falconide_port_info = {
	.tp_ops			= &falconide_tp_ops,
	.host_flags		= IDE_HFLAG_NO_DMA,
};

static void __init falconide_setup_ports(hw_regs_t *hw)
{
	int i;

	memset(hw, 0, sizeof(*hw));

	hw->io_ports.data_addr = ATA_HD_BASE;

	for (i = 1; i < 8; i++)
		hw->io_ports_array[i] = ATA_HD_BASE + 1 + i * 4;

	hw->io_ports.ctl_addr = ATA_HD_BASE + ATA_HD_CONTROL;

	hw->irq = IRQ_MFP_IDE;
	hw->ack_intr = NULL;

	hw->chipset = ide_generic;
}

    /*
     *  Probe for a Falcon IDE interface
     */

static int __init falconide_init(void)
{
	struct ide_host *host;
	hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };
	int rc;

	if (!MACH_IS_ATARI || !ATARIHW_PRESENT(IDE))
		return -ENODEV;

	printk(KERN_INFO "ide: Falcon IDE controller\n");

	if (!request_mem_region(ATA_HD_BASE, 0x40, DRV_NAME)) {
		printk(KERN_ERR "%s: resources busy\n", DRV_NAME);
		return -EBUSY;
	}

	falconide_setup_ports(&hw);

	host = ide_host_alloc(&falconide_port_info, hws);
	if (host == NULL) {
		rc = -ENOMEM;
		goto err;
	}

	ide_get_lock(NULL, NULL);
	rc = ide_host_register(host, &falconide_port_info, hws);
	ide_release_lock();

	if (rc)
		goto err_free;

	return 0;
err_free:
	ide_host_free(host);
err:
	release_mem_region(ATA_HD_BASE, 0x40);
	return rc;
}

module_init(falconide_init);

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4	1	/*
58f189fc	2	* Atari Falcon IDE Driver
1da177e4 LT	3	*
	4	* Created 12 Jul 1997 by Geert Uytterhoeven
	5	*
	6	* This file is subject to the terms and conditions of the GNU General Public
	7	* License. See the file COPYING in the main directory of this archive for
	8	* more details.
	9	*/
	10
88f8bb78	11	#include <linux/module.h>
1da177e4 LT	12	#include <linux/types.h>
	13	#include <linux/mm.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/blkdev.h>
1da177e4 LT	16	#include <linux/ide.h>
	17	#include <linux/init.h>
	18
	19	#include <asm/setup.h>
	20	#include <asm/atarihw.h>
	21	#include <asm/atariints.h>
	22	#include <asm/atari_stdma.h>
	23
cb5528ab	24	#define DRV_NAME "falconide"
1da177e4 LT	25
	26	/*
	27	* Base of the IDE interface
	28	*/
	29
	30	#define ATA_HD_BASE 0xfff00000
	31
	32	/*
	33	* Offsets from the above base
	34	*/
	35
1da177e4 LT	36	#define ATA_HD_CONTROL 0x39
1da177e4 LT	37
1da177e4 LT	38	/*
	39	* falconide_intr_lock is used to obtain access to the IDE interrupt,
	40	* which is shared between several drivers.
	41	*/
	42
	43	int falconide_intr_lock;
88f8bb78	44	EXPORT_SYMBOL(falconide_intr_lock);
1da177e4	45
9567b349 BZ	46	static void falconide_input_data(ide_drive_t drive, struct request rq,
9567b349 BZ	47	void *buf, unsigned int len)
92d3ab27	48	{
9567b349	49	unsigned long data_addr = drive->hwif->io_ports.data_addr;
92d3ab27	50
92d3ab27	51	if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
9567b349	52	return insw(data_addr, buf, (len + 1) / 2);
92d3ab27	53
9567b349	54	insw_swapw(data_addr, buf, (len + 1) / 2);
92d3ab27 BZ	55	}
92d3ab27 BZ	56
9567b349 BZ	57	static void falconide_output_data(ide_drive_t drive, struct request rq,
9567b349 BZ	58	void *buf, unsigned int len)
92d3ab27	59	{
9567b349 BZ	60	unsigned long data_addr = drive->hwif->io_ports.data_addr;
9567b349 BZ	61
92d3ab27	62	if (drive->media == ide_disk && rq && rq->cmd_type == REQ_TYPE_FS)
ab1a8521	63	return outsw(data_addr, buf, (len + 1) / 2);
92d3ab27	64
9567b349	65	outsw_swapw(data_addr, buf, (len + 1) / 2);
92d3ab27 BZ	66	}
92d3ab27 BZ	67
374e042c BZ	68	/* Atari has a byte-swapped IDE interface */
	69	static const struct ide_tp_ops falconide_tp_ops = {
	70	.exec_command = ide_exec_command,
	71	.read_status = ide_read_status,
	72	.read_altstatus = ide_read_altstatus,
	73	.read_sff_dma_status = ide_read_sff_dma_status,
	74
	75	.set_irq = ide_set_irq,
	76
	77	.tf_load = ide_tf_load,
	78	.tf_read = ide_tf_read,
	79
	80	.input_data = falconide_input_data,
	81	.output_data = falconide_output_data,
	82	};
	83
	84	static const struct ide_port_info falconide_port_info = {
	85	.tp_ops = &falconide_tp_ops,
	86	.host_flags = IDE_HFLAG_NO_DMA,
	87	};
	88
29dd5975 BZ	89	static void __init falconide_setup_ports(hw_regs_t *hw)
	90	{
	91	int i;
	92
	93	memset(hw, 0, sizeof(*hw));
	94
4c3032d8	95	hw->io_ports.data_addr = ATA_HD_BASE;
29dd5975 BZ	96
29dd5975 BZ	97	for (i = 1; i < 8; i++)
4c3032d8	98	hw->io_ports_array[i] = ATA_HD_BASE + 1 + i * 4;
29dd5975	99
4c3032d8	100	hw->io_ports.ctl_addr = ATA_HD_BASE + ATA_HD_CONTROL;
29dd5975 BZ	101
	102	hw->irq = IRQ_MFP_IDE;
	103	hw->ack_intr = NULL;
d427e836 BZ	104
d427e836 BZ	105	hw->chipset = ide_generic;
29dd5975	106	}
1da177e4 LT	107
	108	/*
	109	* Probe for a Falcon IDE interface
	110	*/
	111
ade2daf9	112	static int __init falconide_init(void)
1da177e4	113	{
48c3c107	114	struct ide_host *host;
c97c6aca	115	hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };
8a69580e	116	int rc;
1da177e4	117
29dd5975	118	if (!MACH_IS_ATARI \|\| !ATARIHW_PRESENT(IDE))
8a69580e	119	return -ENODEV;
29dd5975	120
c99c92c5 BZ	121	printk(KERN_INFO "ide: Falcon IDE controller\n");
c99c92c5 BZ	122
cb5528ab BZ	123	if (!request_mem_region(ATA_HD_BASE, 0x40, DRV_NAME)) {
	124	printk(KERN_ERR "%s: resources busy\n", DRV_NAME);
	125	return -EBUSY;
	126	}
	127
29dd5975	128	falconide_setup_ports(&hw);
1da177e4	129
48c3c107	130	host = ide_host_alloc(&falconide_port_info, hws);
8a69580e BZ	131	if (host == NULL) {
	132	rc = -ENOMEM;
	133	goto err;
cbb010c1	134	}
ade2daf9	135
8a69580e BZ	136	ide_get_lock(NULL, NULL);
	137	rc = ide_host_register(host, &falconide_port_info, hws);
	138	ide_release_lock();
	139
	140	if (rc)
	141	goto err_free;
	142
29dd5975	143	return 0;
8a69580e BZ	144	err_free:
	145	ide_host_free(host);
	146	err:
	147	release_mem_region(ATA_HD_BASE, 0x40);
	148	return rc;
1da177e4	149	}
ade2daf9 BZ	150
ade2daf9 BZ	151	module_init(falconide_init);
0c5ec97b AB	152
0c5ec97b AB	153	MODULE_LICENSE("GPL");