Subversion Repositories or1k

/*

 *  linux/drivers/ide/legacy/ht6560b.c          Version 0.07    Feb  1, 2000

 *

 *  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.

 *

 *

 *  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@iae.nl>

 *

 *  Try:  http://www.maf.iki.fi/~maf/ht6560b/

 */

#define HT6560B_VERSION "v0.07"

#undef REALLY_SLOW_IO           /* most systems can safely undef this */

#include <linux/module.h>

#include <linux/config.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>

#ifdef CONFIG_BLK_DEV_HT6560B_MODULE

# define _IDE_C

# include "ide_modes.h"

# undef _IDE_C

#else

# include "ide_modes.h"

#endif /* CONFIG_BLK_DEV_HT6560B_MODULE */

/* #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 IDE_SELECT_REG 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)

{

        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);

        if (select != current_select || timing != current_timing) {

                current_select = select;

                current_timing = timing;

                if (drive->media != ide_disk || !drive->present)

                        select |= HT_PREFETCH_MODE;

                (void) HWIF(drive)->INB(HT_CONFIG_PORT);

                (void) HWIF(drive)->INB(HT_CONFIG_PORT);

                (void) HWIF(drive)->INB(HT_CONFIG_PORT);

                (void) HWIF(drive)->INB(HT_CONFIG_PORT);

                HWIF(drive)->OUTB(select, HT_CONFIG_PORT);

                /*

                 * Set timing for this drive:

                 */

                HWIF(drive)->OUTB(timing, IDE_SELECT_REG);

                (void) HWIF(drive)->INB(IDE_STATUS_REG);

#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);  /* IDE_SELECT_REG */

        (void) inb(0x1f7);               /* IDE_STATUS_REG */

        printk("\nht6560b " HT6560B_VERSION

               ": chipset detected and initialized"

#ifdef DEBUG

               " with debug enabled"

#endif

                );

        return 1;

}

static u8 ht_pio2timings(ide_drive_t *drive, u8 pio)

{

        int active_time, recovery_time;

        int active_cycles, recovery_cycles;

        ide_pio_data_t d;

        int bus_speed = system_bus_clock();

        if (pio) {

                pio = ide_get_best_pio_mode(drive, pio, 5, &d);

                /*

                 *  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 = d.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 */

        }

}

/*

 *  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(&io_request_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(&io_request_lock, flags);

#ifdef DEBUG

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

#endif

}

static void tune_ht6560b (ide_drive_t *drive, 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(&io_request_lock, flags);

        drive->drive_data &= 0xff00;

        drive->drive_data |= timing;

        spin_unlock_irqrestore(&io_request_lock, flags);

#ifdef DEBUG

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

#endif

}

void __init probe_ht6560b (void)

{

        int t;

        request_region(HT_CONFIG_PORT, 1, ide_hwifs[0].name);

        ide_hwifs[0].chipset = ide_ht6560b;

        ide_hwifs[1].chipset = ide_ht6560b;

        ide_hwifs[0].selectproc = &ht6560b_selectproc;

        ide_hwifs[1].selectproc = &ht6560b_selectproc;

        ide_hwifs[0].tuneproc = &tune_ht6560b;

        ide_hwifs[1].tuneproc = &tune_ht6560b;

        ide_hwifs[0].serialized = 1;  /* is this needed? */

        ide_hwifs[1].serialized = 1;  /* is this needed? */

        ide_hwifs[0].mate = &ide_hwifs[1];

        ide_hwifs[1].mate = &ide_hwifs[0];

        ide_hwifs[1].channel = 1;

        /*

         * Setting default configurations for drives

         */

        t = (HT_CONFIG_DEFAULT << 8);

        t |= HT_TIMING_DEFAULT;

        ide_hwifs[0].drives[0].drive_data = t;

        ide_hwifs[0].drives[1].drive_data = t;

        t |= (HT_SECONDARY_IF << 8);

        ide_hwifs[1].drives[0].drive_data = t;

        ide_hwifs[1].drives[1].drive_data = t;

#ifndef HWIF_PROBE_CLASSIC_METHOD

        probe_hwif_init(&ide_hwifs[0]);

        probe_hwif_init(&ide_hwifs[1]);

#endif /* HWIF_PROBE_CLASSIC_METHOD */

}

void __init ht6560b_release (void)

{

        if (ide_hwifs[0].chipset != ide_ht6560b &&

            ide_hwifs[1].chipset != ide_ht6560b)

                return;

        ide_hwifs[0].chipset = ide_unknown;

        ide_hwifs[1].chipset = ide_unknown;

        ide_hwifs[0].tuneproc = NULL;

        ide_hwifs[1].tuneproc = NULL;

        ide_hwifs[0].selectproc = NULL;

        ide_hwifs[1].selectproc = NULL;

        ide_hwifs[0].serialized = 0;

        ide_hwifs[1].serialized = 0;

        ide_hwifs[0].mate = NULL;

        ide_hwifs[1].mate = NULL;

        ide_hwifs[0].drives[0].drive_data = 0;

        ide_hwifs[0].drives[1].drive_data = 0;

        ide_hwifs[1].drives[0].drive_data = 0;

        ide_hwifs[1].drives[1].drive_data = 0;

        release_region(HT_CONFIG_PORT, 1);

}

#ifndef MODULE

/*

 * init_ht6560b:

 *

 * called by ide.c when parsing command line

 */

void __init init_ht6560b (void)

{

        if (check_region(HT_CONFIG_PORT,1)) {

                printk(KERN_NOTICE "%s: HT_CONFIG_PORT not found\n",

                        __FUNCTION__);

                return;

        }

        if (!try_to_init_ht6560b()) {

                printk(KERN_NOTICE "%s: HBA not found\n", __FUNCTION__);

                return;

        }

        probe_ht6560b();

}

#else

MODULE_AUTHOR("See Local File");

MODULE_DESCRIPTION("HT-6560B EIDE-controller support");

MODULE_LICENSE("GPL");

int __init ht6560b_mod_init(void)

{

        if (check_region(HT_CONFIG_PORT,1)) {

                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__);

                return -ENODEV;

        }

        probe_ht6560b();

        if (ide_hwifs[0].chipset != ide_ht6560b &&

            ide_hwifs[1].chipset != ide_ht6560b) {

                ht6560b_release();

                return -ENODEV;

        }

        return 0;

}

module_init(ht6560b_mod_init);

void __init ht6560b_mod_exit(void)

{

        ht6560b_release();

}

module_exit(ht6560b_mod_exit);

#endif