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

/*
 *  Copyright (C) 1995-2000  Linus Torvalds & author (see below)
 */

/*
 *
 *  Version 0.01        Initial version hacked out of ide.c
 *
 *  Version 0.02        Added support for PIO modes, auto-tune
 *
 *  Version 0.03        Some cleanups
 *
 *  Version 0.05        PIO mode cycle timings auto-tune using bus-speed
 *
 *  Version 0.06        Prefetch mode now defaults no OFF. To set
 *                      prefetch mode OFF/ON use "hdparm -p8/-p9".
 *                      Unmask irq is disabled when prefetch mode
 *                      is enabled.
 *
 *  Version 0.07        Trying to fix CD-ROM detection problem.
 *                      "Prefetch" mode bit OFF for ide disks and
 *                      ON for anything else.
 *
 *  Version 0.08        Need to force prefetch for CDs and other non-disk
 *                      devices. (not sure which devices exactly need
 *                      prefetch)
 *
 *  HT-6560B EIDE-controller support
 *  To activate controller support use kernel parameter "ide0=ht6560b".
 *  Use hdparm utility to enable PIO mode support.
 *
 *  Author:    Mikko Ala-Fossi            <maf@iki.fi>
 *             Jan Evert van Grootheest   <janevert@caiway.nl>
 *
 *  Try:  http://www.maf.iki.fi/~maf/ht6560b/
 */

#define DRV_NAME	"ht6560b"
#define HT6560B_VERSION "v0.08"

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/blkdev.h>
#include <linux/hdreg.h>
#include <linux/ide.h>
#include <linux/init.h>

#include <asm/io.h>

/* #define DEBUG */  /* remove comments for DEBUG messages */

/*
 * The special i/o-port that HT-6560B uses to configuration:
 *    bit0 (0x01): "1" selects secondary interface
 *    bit2 (0x04): "1" enables FIFO function
 *    bit5 (0x20): "1" enables prefetched data read function  (???)
 *
 * The special i/o-port that HT-6560A uses to configuration:
 *    bit0 (0x01): "1" selects secondary interface
 *    bit1 (0x02): "1" enables prefetched data read function
 *    bit2 (0x04): "0" enables multi-master system	      (?)
 *    bit3 (0x08): "1" 3 cycle time, "0" 2 cycle time	      (?)
 */
#define HT_CONFIG_PORT	  0x3e6
#define HT_CONFIG(drivea) (u8)(((drivea)->drive_data & 0xff00) >> 8)
/*
 * FIFO + PREFETCH (both a/b-model)
 */
#define HT_CONFIG_DEFAULT 0x1c /* no prefetch */
/* #define HT_CONFIG_DEFAULT 0x3c */ /* with prefetch */
#define HT_SECONDARY_IF	  0x01
#define HT_PREFETCH_MODE  0x20

/*
 * ht6560b Timing values:
 *
 * I reviewed some assembler source listings of htide drivers and found
 * out how they setup those cycle time interfacing values, as they at Holtek
 * call them. IDESETUP.COM that is supplied with the drivers figures out
 * optimal values and fetches those values to drivers. I found out that
 * they use Select register to fetch timings to the ide board right after
 * interface switching. After that it was quite easy to add code to
 * ht6560b.c.
 *
 * IDESETUP.COM gave me values 0x24, 0x45, 0xaa, 0xff that worked fine
 * for hda and hdc. But hdb needed higher values to work, so I guess
 * that sometimes it is necessary to give higher value than IDESETUP
 * gives.   [see cmd640.c for an extreme example of this. -ml]
 *
 * Perhaps I should explain something about these timing values:
 * The higher nibble of value is the Recovery Time  (rt) and the lower nibble
 * of the value is the Active Time  (at). Minimum value 2 is the fastest and
 * the maximum value 15 is the slowest. Default values should be 15 for both.
 * So 0x24 means 2 for rt and 4 for at. Each of the drives should have
 * both values, and IDESETUP gives automatically rt=15 st=15 for CDROMs or
 * similar. If value is too small there will be all sorts of failures.
 *
 * Timing byte consists of
 *	High nibble:  Recovery Cycle Time  (rt)
 *	     The valid values range from 2 to 15. The default is 15.
 *
 *	Low nibble:   Active Cycle Time	   (at)
 *	     The valid values range from 2 to 15. The default is 15.
 *
 * You can obtain optimized timing values by running Holtek IDESETUP.COM
 * for DOS. DOS drivers get their timing values from command line, where
 * the first value is the Recovery Time and the second value is the
 * Active Time for each drive. Smaller value gives higher speed.
 * In case of failures you should probably fall back to a higher value.
 */
#define HT_TIMING(drivea) (u8)((drivea)->drive_data & 0x00ff)
#define HT_TIMING_DEFAULT 0xff

/*
 * This routine handles interface switching for the peculiar hardware design
 * on the F.G.I./Holtek HT-6560B VLB IDE interface.
 * The HT-6560B can only enable one IDE port at a time, and requires a
 * silly sequence (below) whenever we switch between primary and secondary.
 */

/*
 * This routine is invoked from ide.c to prepare for access to a given drive.
 */
static void ht6560b_selectproc (ide_drive_t *drive)
{
	ide_hwif_t *hwif = drive->hwif;
	unsigned long flags;
	static u8 current_select = 0;
	static u8 current_timing = 0;
	u8 select, timing;
	
	local_irq_save(flags);

	select = HT_CONFIG(drive);
	timing = HT_TIMING(drive);

	/*
	 * Need to enforce prefetch sometimes because otherwise
	 * it'll hang (hard).
	 */
	if (drive->media != ide_disk || !drive->present)
		select |= HT_PREFETCH_MODE;

	if (select != current_select || timing != current_timing) {
		current_select = select;
		current_timing = timing;
		(void)inb(HT_CONFIG_PORT);
		(void)inb(HT_CONFIG_PORT);
		(void)inb(HT_CONFIG_PORT);
		(void)inb(HT_CONFIG_PORT);
		outb(select, HT_CONFIG_PORT);
		/*
		 * Set timing for this drive:
		 */
		outb(timing, hwif->io_ports[IDE_SELECT_OFFSET]);
		(void)inb(hwif->io_ports[IDE_STATUS_OFFSET]);
#ifdef DEBUG
		printk("ht6560b: %s: select=%#x timing=%#x\n",
			drive->name, select, timing);
#endif
	}
	local_irq_restore(flags);
}

/*
 * Autodetection and initialization of ht6560b
 */
static int __init try_to_init_ht6560b(void)
{
	u8 orig_value;
	int i;
	
	/* Autodetect ht6560b */
	if ((orig_value = inb(HT_CONFIG_PORT)) == 0xff)
		return 0;
	
	for (i=3;i>0;i--) {
		outb(0x00, HT_CONFIG_PORT);
		if (!( (~inb(HT_CONFIG_PORT)) & 0x3f )) {
			outb(orig_value, HT_CONFIG_PORT);
			return 0;
		}
	}
	outb(0x00, HT_CONFIG_PORT);
	if ((~inb(HT_CONFIG_PORT))& 0x3f) {
		outb(orig_value, HT_CONFIG_PORT);
		return 0;
	}
	/*
	 * Ht6560b autodetected
	 */
	outb(HT_CONFIG_DEFAULT, HT_CONFIG_PORT);
	outb(HT_TIMING_DEFAULT, 0x1f6);	/* Select register */
	(void)inb(0x1f7);		/* Status register */

	printk("ht6560b " HT6560B_VERSION
	       ": chipset detected and initialized"
#ifdef DEBUG
	       " with debug enabled"
#endif
	       "\n"
		);
	return 1;
}

static u8 ht_pio2timings(ide_drive_t *drive, const u8 pio)
{
	int active_time, recovery_time;
	int active_cycles, recovery_cycles;
	int bus_speed = system_bus_clock();
	
        if (pio) {
		unsigned int cycle_time;

		cycle_time = ide_pio_cycle_time(drive, pio);

		/*
		 *  Just like opti621.c we try to calculate the
		 *  actual cycle time for recovery and activity
		 *  according system bus speed.
		 */
		active_time = ide_pio_timings[pio].active_time;
		recovery_time = cycle_time
			- active_time
			- ide_pio_timings[pio].setup_time;
		/*
		 *  Cycle times should be Vesa bus cycles
		 */
		active_cycles   = (active_time   * bus_speed + 999) / 1000;
		recovery_cycles = (recovery_time * bus_speed + 999) / 1000;
		/*
		 *  Upper and lower limits
		 */
		if (active_cycles   < 2)  active_cycles   = 2;
		if (recovery_cycles < 2)  recovery_cycles = 2;
		if (active_cycles   > 15) active_cycles   = 15;
		if (recovery_cycles > 15) recovery_cycles = 0;  /* 0==16 */
		
#ifdef DEBUG
		printk("ht6560b: drive %s setting pio=%d recovery=%d (%dns) active=%d (%dns)\n", drive->name, pio, recovery_cycles, recovery_time, active_cycles, active_time);
#endif
		
		return (u8)((recovery_cycles << 4) | active_cycles);
	} else {
		
#ifdef DEBUG
		printk("ht6560b: drive %s setting pio=0\n", drive->name);
#endif
		
		return HT_TIMING_DEFAULT;    /* default setting */
	}
}

static DEFINE_SPINLOCK(ht6560b_lock);

/*
 *  Enable/Disable so called prefetch mode
 */
static void ht_set_prefetch(ide_drive_t *drive, u8 state)
{
	unsigned long flags;
	int t = HT_PREFETCH_MODE << 8;

	spin_lock_irqsave(&ht6560b_lock, flags);

	/*
	 *  Prefetch mode and unmask irq seems to conflict
	 */
	if (state) {
		drive->drive_data |= t;   /* enable prefetch mode */
		drive->no_unmask = 1;
		drive->unmask = 0;
	} else {
		drive->drive_data &= ~t;  /* disable prefetch mode */
		drive->no_unmask = 0;
	}

	spin_unlock_irqrestore(&ht6560b_lock, flags);

#ifdef DEBUG
	printk("ht6560b: drive %s prefetch mode %sabled\n", drive->name, (state ? "en" : "dis"));
#endif
}

static void ht6560b_set_pio_mode(ide_drive_t *drive, const u8 pio)
{
	unsigned long flags;
	u8 timing;
	
	switch (pio) {
	case 8:         /* set prefetch off */
	case 9:         /* set prefetch on */
		ht_set_prefetch(drive, pio & 1);
		return;
	}

	timing = ht_pio2timings(drive, pio);

	spin_lock_irqsave(&ht6560b_lock, flags);
	drive->drive_data &= 0xff00;
	drive->drive_data |= timing;
	spin_unlock_irqrestore(&ht6560b_lock, flags);

#ifdef DEBUG
	printk("ht6560b: drive %s tuned to pio mode %#x timing=%#x\n", drive->name, pio, timing);
#endif
}

static void __init ht6560b_port_init_devs(ide_hwif_t *hwif)
{
	/* Setting default configurations for drives. */
	int t = (HT_CONFIG_DEFAULT << 8) | HT_TIMING_DEFAULT;

	if (hwif->channel)
		t |= (HT_SECONDARY_IF << 8);

	hwif->drives[0].drive_data = t;
	hwif->drives[1].drive_data = t;
}

int probe_ht6560b = 0;

module_param_named(probe, probe_ht6560b, bool, 0);
MODULE_PARM_DESC(probe, "probe for HT6560B chipset");

static const struct ide_port_ops ht6560b_port_ops = {
	.port_init_devs		= ht6560b_port_init_devs,
	.set_pio_mode		= ht6560b_set_pio_mode,
	.selectproc		= ht6560b_selectproc,
};

static const struct ide_port_info ht6560b_port_info __initdata = {
	.chipset		= ide_ht6560b,
	.port_ops		= &ht6560b_port_ops,
	.host_flags		= IDE_HFLAG_SERIALIZE | /* is this needed? */
				  IDE_HFLAG_NO_DMA |
				  IDE_HFLAG_NO_AUTOTUNE |
				  IDE_HFLAG_ABUSE_PREFETCH,
	.pio_mask		= ATA_PIO4,
};

static int __init ht6560b_init(void)
{
	if (probe_ht6560b == 0)
		return -ENODEV;

	if (!request_region(HT_CONFIG_PORT, 1, DRV_NAME)) {
		printk(KERN_NOTICE "%s: HT_CONFIG_PORT not found\n",
			__FUNCTION__);
		return -ENODEV;
	}

	if (!try_to_init_ht6560b()) {
		printk(KERN_NOTICE "%s: HBA not found\n", __FUNCTION__);
		goto release_region;
	}

	return ide_legacy_device_add(&ht6560b_port_info);

release_region:
	release_region(HT_CONFIG_PORT, 1);
	return -ENODEV;
}

module_init(ht6560b_init);

MODULE_AUTHOR("See Local File");
MODULE_DESCRIPTION("HT-6560B EIDE-controller support");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Copyright (C) 1995-2000 Linus Torvalds & author (see below)
	3	*/
	4
	5	/*
	6	*
	7	* Version 0.01 Initial version hacked out of ide.c
	8	*
	9	* Version 0.02 Added support for PIO modes, auto-tune
	10	*
	11	* Version 0.03 Some cleanups
	12	*
	13	* Version 0.05 PIO mode cycle timings auto-tune using bus-speed
	14	*
	15	* Version 0.06 Prefetch mode now defaults no OFF. To set
	16	* prefetch mode OFF/ON use "hdparm -p8/-p9".
	17	* Unmask irq is disabled when prefetch mode
	18	* is enabled.
	19	*
	20	* Version 0.07 Trying to fix CD-ROM detection problem.
	21	* "Prefetch" mode bit OFF for ide disks and
	22	* ON for anything else.
	23	*
0e7d8d48 JEG	24	* Version 0.08 Need to force prefetch for CDs and other non-disk
	25	* devices. (not sure which devices exactly need
	26	* prefetch)
1da177e4 LT	27	*
	28	* HT-6560B EIDE-controller support
	29	* To activate controller support use kernel parameter "ide0=ht6560b".
	30	* Use hdparm utility to enable PIO mode support.
	31	*
	32	* Author: Mikko Ala-Fossi <maf@iki.fi>
0e7d8d48	33	* Jan Evert van Grootheest <janevert@caiway.nl>
1da177e4 LT	34	*
	35	* Try: http://www.maf.iki.fi/~maf/ht6560b/
	36	*/
	37
2e4ed295	38	#define DRV_NAME "ht6560b"
0e7d8d48	39	#define HT6560B_VERSION "v0.08"
1da177e4	40
1da177e4	41	#include <linux/module.h>
1da177e4 LT	42	#include <linux/types.h>
	43	#include <linux/kernel.h>
	44	#include <linux/delay.h>
	45	#include <linux/timer.h>
	46	#include <linux/mm.h>
	47	#include <linux/ioport.h>
	48	#include <linux/blkdev.h>
	49	#include <linux/hdreg.h>
	50	#include <linux/ide.h>
	51	#include <linux/init.h>
	52
	53	#include <asm/io.h>
	54
	55	/* #define DEBUG / / remove comments for DEBUG messages */
	56
	57	/*
	58	* The special i/o-port that HT-6560B uses to configuration:
	59	* bit0 (0x01): "1" selects secondary interface
	60	* bit2 (0x04): "1" enables FIFO function
	61	* bit5 (0x20): "1" enables prefetched data read function (???)
	62	*
	63	* The special i/o-port that HT-6560A uses to configuration:
	64	* bit0 (0x01): "1" selects secondary interface
	65	* bit1 (0x02): "1" enables prefetched data read function
	66	* bit2 (0x04): "0" enables multi-master system (?)
	67	* bit3 (0x08): "1" 3 cycle time, "0" 2 cycle time (?)
	68	*/
	69	#define HT_CONFIG_PORT 0x3e6
	70	#define HT_CONFIG(drivea) (u8)(((drivea)->drive_data & 0xff00) >> 8)
	71	/*
	72	* FIFO + PREFETCH (both a/b-model)
	73	*/
	74	#define HT_CONFIG_DEFAULT 0x1c /* no prefetch */
	75	/* #define HT_CONFIG_DEFAULT 0x3c / / with prefetch */
	76	#define HT_SECONDARY_IF 0x01
	77	#define HT_PREFETCH_MODE 0x20
	78
	79	/*
	80	* ht6560b Timing values:
	81	*
	82	* I reviewed some assembler source listings of htide drivers and found
	83	* out how they setup those cycle time interfacing values, as they at Holtek
	84	* call them. IDESETUP.COM that is supplied with the drivers figures out
	85	* optimal values and fetches those values to drivers. I found out that
23579a2a	86	* they use Select register to fetch timings to the ide board right after
1da177e4 LT	87	* interface switching. After that it was quite easy to add code to
	88	* ht6560b.c.
	89	*
	90	* IDESETUP.COM gave me values 0x24, 0x45, 0xaa, 0xff that worked fine
	91	* for hda and hdc. But hdb needed higher values to work, so I guess
	92	* that sometimes it is necessary to give higher value than IDESETUP
	93	* gives. [see cmd640.c for an extreme example of this. -ml]
	94	*
	95	* Perhaps I should explain something about these timing values:
	96	* The higher nibble of value is the Recovery Time (rt) and the lower nibble
	97	* of the value is the Active Time (at). Minimum value 2 is the fastest and
	98	* the maximum value 15 is the slowest. Default values should be 15 for both.
	99	* So 0x24 means 2 for rt and 4 for at. Each of the drives should have
	100	* both values, and IDESETUP gives automatically rt=15 st=15 for CDROMs or
	101	* similar. If value is too small there will be all sorts of failures.
	102	*
	103	* Timing byte consists of
	104	* High nibble: Recovery Cycle Time (rt)
	105	* The valid values range from 2 to 15. The default is 15.
	106	*
	107	* Low nibble: Active Cycle Time (at)
	108	* The valid values range from 2 to 15. The default is 15.
	109	*
	110	* You can obtain optimized timing values by running Holtek IDESETUP.COM
	111	* for DOS. DOS drivers get their timing values from command line, where
	112	* the first value is the Recovery Time and the second value is the
	113	* Active Time for each drive. Smaller value gives higher speed.
	114	* In case of failures you should probably fall back to a higher value.
	115	*/
	116	#define HT_TIMING(drivea) (u8)((drivea)->drive_data & 0x00ff)
	117	#define HT_TIMING_DEFAULT 0xff
	118
	119	/*
	120	* This routine handles interface switching for the peculiar hardware design
	121	* on the F.G.I./Holtek HT-6560B VLB IDE interface.
	122	* The HT-6560B can only enable one IDE port at a time, and requires a
	123	* silly sequence (below) whenever we switch between primary and secondary.
	124	*/
	125
	126	/*
	127	* This routine is invoked from ide.c to prepare for access to a given drive.
	128	*/
	129	static void ht6560b_selectproc (ide_drive_t *drive)
	130	{
23579a2a	131	ide_hwif_t *hwif = drive->hwif;
1da177e4 LT	132	unsigned long flags;
	133	static u8 current_select = 0;
	134	static u8 current_timing = 0;
	135	u8 select, timing;
	136
	137	local_irq_save(flags);
0e7d8d48	138
1da177e4 LT	139	select = HT_CONFIG(drive);
1da177e4 LT	140	timing = HT_TIMING(drive);
0e7d8d48 JEG	141
	142	/*
	143	* Need to enforce prefetch sometimes because otherwise
	144	* it'll hang (hard).
	145	*/
	146	if (drive->media != ide_disk \|\| !drive->present)
	147	select \|= HT_PREFETCH_MODE;
	148
1da177e4 LT	149	if (select != current_select \|\| timing != current_timing) {
	150	current_select = select;
	151	current_timing = timing;
0ecdca26 BZ	152	(void)inb(HT_CONFIG_PORT);
	153	(void)inb(HT_CONFIG_PORT);
	154	(void)inb(HT_CONFIG_PORT);
	155	(void)inb(HT_CONFIG_PORT);
	156	outb(select, HT_CONFIG_PORT);
1da177e4 LT	157	/*
	158	* Set timing for this drive:
	159	*/
23579a2a BZ	160	outb(timing, hwif->io_ports[IDE_SELECT_OFFSET]);
23579a2a BZ	161	(void)inb(hwif->io_ports[IDE_STATUS_OFFSET]);
1da177e4 LT	162	#ifdef DEBUG
	163	printk("ht6560b: %s: select=%#x timing=%#x\n",
	164	drive->name, select, timing);
	165	#endif
	166	}
	167	local_irq_restore(flags);
	168	}
	169
	170	/*
	171	* Autodetection and initialization of ht6560b
	172	*/
	173	static int __init try_to_init_ht6560b(void)
	174	{
	175	u8 orig_value;
	176	int i;
	177
	178	/* Autodetect ht6560b */
	179	if ((orig_value = inb(HT_CONFIG_PORT)) == 0xff)
	180	return 0;
	181
	182	for (i=3;i>0;i--) {
	183	outb(0x00, HT_CONFIG_PORT);
	184	if (!( (~inb(HT_CONFIG_PORT)) & 0x3f )) {
	185	outb(orig_value, HT_CONFIG_PORT);
	186	return 0;
	187	}
	188	}
	189	outb(0x00, HT_CONFIG_PORT);
	190	if ((~inb(HT_CONFIG_PORT))& 0x3f) {
	191	outb(orig_value, HT_CONFIG_PORT);
	192	return 0;
	193	}
	194	/*
	195	* Ht6560b autodetected
	196	*/
	197	outb(HT_CONFIG_DEFAULT, HT_CONFIG_PORT);
23579a2a BZ	198	outb(HT_TIMING_DEFAULT, 0x1f6); /* Select register */
	199	(void)inb(0x1f7); /* Status register */
	200
0e7d8d48	201	printk("ht6560b " HT6560B_VERSION
1da177e4 LT	202	": chipset detected and initialized"
	203	#ifdef DEBUG
	204	" with debug enabled"
	205	#endif
0e7d8d48	206	"\n"
1da177e4 LT	207	);
	208	return 1;
	209	}
	210
26bcb879	211	static u8 ht_pio2timings(ide_drive_t *drive, const u8 pio)
1da177e4 LT	212	{
	213	int active_time, recovery_time;
	214	int active_cycles, recovery_cycles;
1da177e4 LT	215	int bus_speed = system_bus_clock();
	216
	217	if (pio) {
7dd00083 BZ	218	unsigned int cycle_time;
7dd00083 BZ	219
7dd00083 BZ	220	cycle_time = ide_pio_cycle_time(drive, pio);
7dd00083 BZ	221
1da177e4 LT	222	/*
	223	* Just like opti621.c we try to calculate the
	224	* actual cycle time for recovery and activity
	225	* according system bus speed.
	226	*/
	227	active_time = ide_pio_timings[pio].active_time;
7dd00083	228	recovery_time = cycle_time
1da177e4 LT	229	- active_time
	230	- ide_pio_timings[pio].setup_time;
	231	/*
	232	* Cycle times should be Vesa bus cycles
	233	*/
	234	active_cycles = (active_time * bus_speed + 999) / 1000;
	235	recovery_cycles = (recovery_time * bus_speed + 999) / 1000;
	236	/*
	237	* Upper and lower limits
	238	*/
	239	if (active_cycles < 2) active_cycles = 2;
	240	if (recovery_cycles < 2) recovery_cycles = 2;
	241	if (active_cycles > 15) active_cycles = 15;
	242	if (recovery_cycles > 15) recovery_cycles = 0; /* 0==16 */
	243
	244	#ifdef DEBUG
	245	printk("ht6560b: drive %s setting pio=%d recovery=%d (%dns) active=%d (%dns)\n", drive->name, pio, recovery_cycles, recovery_time, active_cycles, active_time);
	246	#endif
	247
	248	return (u8)((recovery_cycles << 4) \| active_cycles);
	249	} else {
	250
	251	#ifdef DEBUG
	252	printk("ht6560b: drive %s setting pio=0\n", drive->name);
	253	#endif
	254
	255	return HT_TIMING_DEFAULT; /* default setting */
	256	}
	257	}
	258
69e88d2a BZ	259	static DEFINE_SPINLOCK(ht6560b_lock);
69e88d2a BZ	260
1da177e4 LT	261	/*
	262	* Enable/Disable so called prefetch mode
	263	*/
	264	static void ht_set_prefetch(ide_drive_t *drive, u8 state)
	265	{
	266	unsigned long flags;
	267	int t = HT_PREFETCH_MODE << 8;
69e88d2a BZ	268
	269	spin_lock_irqsave(&ht6560b_lock, flags);
	270
1da177e4 LT	271	/*
	272	* Prefetch mode and unmask irq seems to conflict
	273	*/
	274	if (state) {
	275	drive->drive_data \|= t; /* enable prefetch mode */
	276	drive->no_unmask = 1;
	277	drive->unmask = 0;
	278	} else {
	279	drive->drive_data &= ~t; /* disable prefetch mode */
	280	drive->no_unmask = 0;
	281	}
69e88d2a BZ	282
	283	spin_unlock_irqrestore(&ht6560b_lock, flags);
	284
1da177e4 LT	285	#ifdef DEBUG
	286	printk("ht6560b: drive %s prefetch mode %sabled\n", drive->name, (state ? "en" : "dis"));
	287	#endif
	288	}
	289
26bcb879	290	static void ht6560b_set_pio_mode(ide_drive_t *drive, const u8 pio)
1da177e4 LT	291	{
	292	unsigned long flags;
	293	u8 timing;
	294
	295	switch (pio) {
	296	case 8: /* set prefetch off */
	297	case 9: /* set prefetch on */
	298	ht_set_prefetch(drive, pio & 1);
	299	return;
	300	}
69e88d2a	301
1da177e4	302	timing = ht_pio2timings(drive, pio);
69e88d2a BZ	303
69e88d2a BZ	304	spin_lock_irqsave(&ht6560b_lock, flags);
1da177e4 LT	305	drive->drive_data &= 0xff00;
1da177e4 LT	306	drive->drive_data \|= timing;
69e88d2a BZ	307	spin_unlock_irqrestore(&ht6560b_lock, flags);
69e88d2a BZ	308
1da177e4 LT	309	#ifdef DEBUG
	310	printk("ht6560b: drive %s tuned to pio mode %#x timing=%#x\n", drive->name, pio, timing);
	311	#endif
	312	}
	313
1f2cf8b0 BZ	314	static void __init ht6560b_port_init_devs(ide_hwif_t *hwif)
	315	{
	316	/* Setting default configurations for drives. */
	317	int t = (HT_CONFIG_DEFAULT << 8) \| HT_TIMING_DEFAULT;
	318
	319	if (hwif->channel)
	320	t \|= (HT_SECONDARY_IF << 8);
	321
	322	hwif->drives[0].drive_data = t;
	323	hwif->drives[1].drive_data = t;
	324	}
	325
84913882 BZ	326	int probe_ht6560b = 0;
	327
	328	module_param_named(probe, probe_ht6560b, bool, 0);
	329	MODULE_PARM_DESC(probe, "probe for HT6560B chipset");
	330
ac95beed BZ	331	static const struct ide_port_ops ht6560b_port_ops = {
	332	.port_init_devs = ht6560b_port_init_devs,
	333	.set_pio_mode = ht6560b_set_pio_mode,
	334	.selectproc = ht6560b_selectproc,
	335	};
	336
c413b9b9 BZ	337	static const struct ide_port_info ht6560b_port_info __initdata = {
c413b9b9 BZ	338	.chipset = ide_ht6560b,
ac95beed	339	.port_ops = &ht6560b_port_ops,
c413b9b9 BZ	340	.host_flags = IDE_HFLAG_SERIALIZE \| /* is this needed? */
	341	IDE_HFLAG_NO_DMA \|
	342	IDE_HFLAG_NO_AUTOTUNE \|
	343	IDE_HFLAG_ABUSE_PREFETCH,
1a1990f5	344	.pio_mask = ATA_PIO4,
c413b9b9 BZ	345	};
c413b9b9 BZ	346
ade2daf9	347	static int __init ht6560b_init(void)
1da177e4	348	{
84913882 BZ	349	if (probe_ht6560b == 0)
	350	return -ENODEV;
	351
2e4ed295	352	if (!request_region(HT_CONFIG_PORT, 1, DRV_NAME)) {
1da177e4 LT	353	printk(KERN_NOTICE "%s: HT_CONFIG_PORT not found\n",
	354	__FUNCTION__);
	355	return -ENODEV;
	356	}
	357
	358	if (!try_to_init_ht6560b()) {
	359	printk(KERN_NOTICE "%s: HBA not found\n", __FUNCTION__);
	360	goto release_region;
	361	}
	362
3b36f66b	363	return ide_legacy_device_add(&ht6560b_port_info);
1da177e4 LT	364
	365	release_region:
	366	release_region(HT_CONFIG_PORT, 1);
	367	return -ENODEV;
	368	}
	369
1da177e4	370	module_init(ht6560b_init);
1da177e4 LT	371
	372	MODULE_AUTHOR("See Local File");
	373	MODULE_DESCRIPTION("HT-6560B EIDE-controller support");
	374	MODULE_LICENSE("GPL");