Skip to content

L
linux
Commit 4478f040 authored by Martin Dalecki's avatar Martin Dalecki Committed by Linus Torvalds
Browse files
Options

[PATCH] 2.5.18 IDE 71 

 - Rewritten Artop host chip driver by Vojtech Pavlik. His log entries are:

   Cleanup whitespace.

   Remove superfluous chip entries in chip table.  Remove global variables to
   allow more than one controller.  Remove other forgotten stuff.

   This is a new driver for the Artop (Acard) controllers. It's completely
   untested, as I have never seen the hardware. However, I suspect it is much
   less broken than the previous one ...

   UDMA33 controller cannot detect 80-wire cable.

 - Separate ioctl handling out from ide.c. It's big enough.

 - Move atapi_read and atapi_write to the new atapi module.  Fix the declaration
   of those functions. The data buffer did have the void * type!

 - Separate module handling code out from actual transfer handling code in to a
   new module called main.c. Slowly we are at the stage where the code indeed
   has to be organized logically and not just "sporadically" as was the case
   before.

 - Apply patch by Adam Richter for the ide-scsi.c attach method implementation.
   This particular driver is still broken due to generic SCSI layer issues.

 - Apply true modularization patch for qd65xx.c by Samuel Thibault. Here
   are his notes about it:

   Then, patch-modularize-2.[45] is a proposal for modularizing qd65xx.o. As a
   single module, one can choose to insmod it before being able to do some
   hdparm -p /dev/hd[a-d]. But one can't remove it while tuned, since selectproc
   may be needed.

   I am sorry I wasn't able to test it under 2.5 series, lacking a functionning
   kernel for my test computer, but it seemed to work perfectly under 2.4
   series, and patches are almost the same.

 - Move PCI device id's to where they belong. Patch by Vojtech Pavlik.

 - Don't use BH_Lock in ide-tape.c - somehow this driver scares me sometimes.
parent cd556cb5
Hide whitespace changes
Inline Side-by-side
Showing with 2436 additions and 2657 deletions
drivers/ide/Config.help
View file @ 4478f040
......@@ -295,28 +295,13 @@ CONFIG_IDEDMA_IVB
It is normally safe to answer Y; however, the default is N.
CONFIG_BLK_DEV_AEC62XX
This driver adds up to 4 more EIDE devices sharing a single
interrupt. This add-on card is a bootable PCI UDMA controller. In
order to get this card to initialize correctly in some cases, you
should say Y here, and preferably also to "Use DMA by default when
available".
The ATP850U/UF is an UltraDMA 33 chipset base.
The ATP860 is an UltraDMA 66 chipset base.
The ATP860M(acintosh) version is an UltraDMA 66 chipset base.
The ATP865 is an ATA100/133 chipset.
Please read the comments at the top of <file:drivers/ide/aec62xx.c>.
If you say Y here, then say Y to "Use DMA by default when available"
as well.
CONFIG_AEC62XX_TUNING
Please read the comments at the top of <file:drivers/ide/aec62xx.c>.
If unsure, say N.
This driver adds explicit support for Acard AEC62xx (Artop ATP8xx)
IDE controllers. This allows the kernel to change PIO, DMA and UDMA
speeds and to configure the chip to optimum performance.
CONFIG_AEC6280_BURST
Use burst mode for DMA transfers. Higher speed, but causes more load
on the bus.
Use burst mode for DMA transfers. This helps to achieve higher
transfer rates, but causes more load on the PCI bus.
If unsure, say N.
......
drivers/ide/Config.in
View file @ 4478f040
......@@ -40,9 +40,8 @@ if [ "$CONFIG_BLK_DEV_IDE" != "n" ]; then
int ' Default queue depth' CONFIG_BLK_DEV_IDE_TCQ_DEPTH 32
fi
dep_bool ' Good-Bad DMA Model-Firmware (EXPERIMENTAL)' CONFIG_IDEDMA_NEW_DRIVE_LISTINGS $CONFIG_EXPERIMENTAL
dep_bool ' AEC62XX chip set support' CONFIG_BLK_DEV_AEC62XX $CONFIG_BLK_DEV_IDEDMA_PCI
dep_mbool ' AEC62XX Tuning support' CONFIG_AEC62XX_TUNING $CONFIG_BLK_DEV_AEC62XX
dep_mbool ' AEC6280 Burst mode' CONFIG_AEC6280_BURST $CONFIG_BLK_DEV_AEC62XX
dep_bool ' Acard (Artop) chipset support' CONFIG_BLK_DEV_AEC62XX $CONFIG_BLK_DEV_IDEDMA_PCI
dep_mbool ' ATP865 burst mode' CONFIG_AEC6280_BURST $CONFIG_BLK_DEV_AEC62XX
dep_bool ' ALI M15x3 chipset support' CONFIG_BLK_DEV_ALI15X3 $CONFIG_BLK_DEV_IDEDMA_PCI
dep_mbool ' ALI M15x3 WDC support (DANGEROUS)' CONFIG_WDC_ALI15X3 $CONFIG_BLK_DEV_ALI15X3 $CONFIG_EXPERIMENTAL
dep_bool ' AMD and nVidia chipset support' CONFIG_BLK_DEV_AMD74XX $CONFIG_BLK_DEV_IDEDMA_PCI
......@@ -122,7 +121,7 @@ if [ "$CONFIG_BLK_DEV_IDE" != "n" ]; then
if [ "$CONFIG_BLK_DEV_IDEDISK" = "y" -a "$CONFIG_EXPERIMENTAL" = "y" ]; then
bool ' PROMISE DC4030 support (EXPERIMENTAL)' CONFIG_BLK_DEV_PDC4030
fi
bool ' QDI QD65xx support' CONFIG_BLK_DEV_QD65XX
dep_tristate ' QDI QD65xx support' CONFIG_BLK_DEV_QD65XX $CONFIG_BLK_DEV_IDE
bool ' UMC-8672 support' CONFIG_BLK_DEV_UMC8672
fi
if [ "$CONFIG_BLK_DEV_IDEDMA_PCI" = "y" -o \
......
drivers/ide/Makefile
View file @ 4478f040
......@@ -10,7 +10,7 @@
O_TARGET := idedriver.o
export-objs := ide-taskfile.o ide.o ide-features.o ide-probe.o quirks.o pcidma.o tcq.o \
export-objs := ide-taskfile.o main.o ide.o ide-features.o ide-probe.o quirks.o pcidma.o tcq.o \
atapi.o ataraid.o
obj-y :=
......@@ -27,6 +27,7 @@ obj-$(CONFIG_BLK_DEV_IDETAPE) += ide-tape.o
obj-$(CONFIG_BLK_DEV_IDEFLOPPY) += ide-floppy.o
obj-$(CONFIG_BLK_DEV_IT8172) += it8172.o
obj-$(CONFIG_BLK_DEV_QD65XX) += qd65xx.o
ide-obj-$(CONFIG_BLK_DEV_AEC62XX) += aec62xx.o
ide-obj-$(CONFIG_BLK_DEV_ALI14XX) += ali14xx.o
......@@ -58,7 +59,6 @@ ide-obj-$(CONFIG_BLK_DEV_SVWKS) += serverworks.o
ide-obj-$(CONFIG_BLK_DEV_PDC202XX) += pdc202xx.o
ide-obj-$(CONFIG_BLK_DEV_PDC4030) += pdc4030.o
ide-obj-$(CONFIG_BLK_DEV_PIIX) += piix.o
ide-obj-$(CONFIG_BLK_DEV_QD65XX) += qd65xx.o
ide-obj-$(CONFIG_BLK_DEV_IDE_RAPIDE) += rapide.o
ide-obj-$(CONFIG_BLK_DEV_RZ1000) += rz1000.o
ide-obj-$(CONFIG_BLK_DEV_SIS5513) += sis5513.o
......@@ -74,6 +74,7 @@ obj-$(CONFIG_BLK_DEV_ATARAID) += ataraid.o
obj-$(CONFIG_BLK_DEV_ATARAID_PDC) += pdcraid.o
obj-$(CONFIG_BLK_DEV_ATARAID_HPT) += hptraid.o
ide-mod-objs := ide-taskfile.o ide.o ide-probe.o ide-geometry.o ide-features.o ata-timing.o atapi.o $(ide-obj-y)
ide-mod-objs := ide-taskfile.o main.o ide.o ide-probe.o ide-geometry.o ide-features.o \
ioctl.o atapi.o ata-timing.o$(ide-obj-y)
include $(TOPDIR)/Rules.make
drivers/ide/aec62xx.c
View file @ 4478f040
/**** vi:set ts=8 sts=8 sw=8:************************************************
/*
*
* $Id: aec62xx.c,v 1.0 2002/05/24 14:37:19 vojtech Exp $
*
* Version 0.11 March 27, 2002
* Copyright (c) 2002 Vojtech Pavlik
*
* Copyright (C) 1999-2000 Andre Hedrick (andre@linux-ide.org)
* Based on the work of:
* Andre Hedrick
*/
/*
* AEC 6210UF (ATP850UF), AEC6260 (ATP860) and AEC6280 (ATP865) IDE driver for Linux.
*
* UDMA66 and higher modes are autoenabled only in case the BIOS has detected a
* 80 wire cable. To ignore the BIOS data and assume the cable is present, use
* 'ide0=ata66' or 'ide1=ata66' on the kernel command line.
*/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Should you need to contact me, the author, you can do so either by
* e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
* Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
*/
#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/interrupt.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/ide.h>
#include <asm/io.h>
#include <asm/irq.h>
#include "ata-timing.h"
#include "pcihost.h"
#undef DISPLAY_AEC62XX_TIMINGS
#define AEC_DRIVE_TIMING 0x40
#define AEC_UDMA_NEW 0x44
#define AEC_MISC 0x49
#define AEC_IDE_ENABLE 0x4a
#define AEC_UDMA_OLD 0x54
#ifndef HIGH_4
#define HIGH_4(H) ((H)=(H>>4))
#endif
#ifndef LOW_4
#define LOW_4(L) ((L)=(L-((L>>4)<<4)))
#endif
#ifndef SPLIT_BYTE
#define SPLIT_BYTE(B,H,L) ((H)=(B>>4), (L)=(B-((B>>4)<<4)))
#endif
#ifndef MAKE_WORD
#define MAKE_WORD(W,HB,LB) ((W)=((HB<<8)+LB))
#endif
#if defined(DISPLAY_AEC62XX_TIMINGS) && defined(CONFIG_PROC_FS)
#include <linux/stat.h>
#include <linux/proc_fs.h>
static unsigned char aec_cyc2udma[17] = { 0, 0, 7, 6, 5, 4, 4, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1 };
static int aec62xx_get_info(char *, char **, off_t, int);
extern int (*aec62xx_display_info)(char *, char **, off_t, int); /* ide-proc.c */
static struct pci_dev *bmide_dev;
/*
* aec_set_speed_old() writes timing values to
* the chipset registers for ATP850UF
*/
static const char *aec6280_get_speed(u8 speed)
static void aec_set_speed_old(struct pci_dev *dev, unsigned char dn, struct ata_timing *timing)
{
switch(speed) {
case 7: return "6";
case 6: return "5";
case 5: return "4";
case 4: return "3";
case 3: return "2";
case 2: return "1";
case 1: return "0";
case 0: return "?";
}
return "?";
}
unsigned char t;
static int aec62xx_get_info (char *buffer, char **addr, off_t offset, int count)
{
char *p = buffer;
u32 bibma = pci_resource_start(bmide_dev, 4);
u8 c0 = 0, c1 = 0;
u8 art = 0, uart = 0;
switch(bmide_dev->device) {
case PCI_DEVICE_ID_ARTOP_ATP850UF:
p += sprintf(p, "\n AEC6210 Chipset.\n");
break;
case PCI_DEVICE_ID_ARTOP_ATP860:
p += sprintf(p, "\n AEC6260 No Bios Chipset.\n");
break;
case PCI_DEVICE_ID_ARTOP_ATP860R:
p += sprintf(p, "\n AEC6260 Chipset.\n");
break;
case PCI_DEVICE_ID_ARTOP_ATP865:
p += sprintf(p, "\n AEC6280 Chipset without ROM.\n");
break;
case PCI_DEVICE_ID_ARTOP_ATP865R:
p += sprintf(p, "\n AEC6280 Chipset with ROM.\n");
break;
default:
p += sprintf(p, "\n AEC62?? Chipset.\n");
break;
}
pci_write_config_byte(dev, AEC_DRIVE_TIMING + (dn << 1), FIT(timing->active, 0, 15));
pci_write_config_byte(dev, AEC_DRIVE_TIMING + (dn << 1) + 1, FIT(timing->recover, 0, 15));
/*
* at that point bibma+0x2 et bibma+0xa are byte registers
* to investigate:
*/
c0 = inb_p((unsigned short)bibma + 0x02);
c1 = inb_p((unsigned short)bibma + 0x0a);
p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------\n");
(void) pci_read_config_byte(bmide_dev, 0x4a, &art);
p += sprintf(p, " %sabled %sabled\n",
(art&0x02)?" en":"dis",(art&0x04)?" en":"dis");
p += sprintf(p, "--------------- drive0 --------- drive1 -------- drive0 ---------- drive1 ------\n");
p += sprintf(p, "DMA enabled: %s %s %s %s\n",
(c0&0x20)?"yes":"no ",(c0&0x40)?"yes":"no ",(c1&0x20)?"yes":"no ",(c1&0x40)?"yes":"no ");
switch(bmide_dev->device) {
case PCI_DEVICE_ID_ARTOP_ATP850UF:
(void) pci_read_config_byte(bmide_dev, 0x54, &art);
p += sprintf(p, "DMA Mode: %s(%s) %s(%s) %s(%s) %s(%s)\n",
(c0&0x20)?((art&0x03)?"UDMA":" DMA"):" PIO",
(art&0x02)?"2":(art&0x01)?"1":"0",
(c0&0x40)?((art&0x0c)?"UDMA":" DMA"):" PIO",
(art&0x08)?"2":(art&0x04)?"1":"0",
(c1&0x20)?((art&0x30)?"UDMA":" DMA"):" PIO",
(art&0x20)?"2":(art&0x10)?"1":"0",
(c1&0x40)?((art&0xc0)?"UDMA":" DMA"):" PIO",
(art&0x80)?"2":(art&0x40)?"1":"0");
(void) pci_read_config_byte(bmide_dev, 0x40, &art);
p += sprintf(p, "Active: 0x%02x", art);
(void) pci_read_config_byte(bmide_dev, 0x42, &art);
p += sprintf(p, " 0x%02x", art);
(void) pci_read_config_byte(bmide_dev, 0x44, &art);
p += sprintf(p, " 0x%02x", art);
(void) pci_read_config_byte(bmide_dev, 0x46, &art);
p += sprintf(p, " 0x%02x\n", art);
(void) pci_read_config_byte(bmide_dev, 0x41, &art);
p += sprintf(p, "Recovery: 0x%02x", art);
(void) pci_read_config_byte(bmide_dev, 0x43, &art);
p += sprintf(p, " 0x%02x", art);
(void) pci_read_config_byte(bmide_dev, 0x45, &art);
p += sprintf(p, " 0x%02x", art);
(void) pci_read_config_byte(bmide_dev, 0x47, &art);
p += sprintf(p, " 0x%02x\n", art);
break;
case PCI_DEVICE_ID_ARTOP_ATP860:
case PCI_DEVICE_ID_ARTOP_ATP860R:
(void) pci_read_config_byte(bmide_dev, 0x44, &art);
p += sprintf(p, "DMA Mode: %s(%s) %s(%s)",
(c0&0x20)?((art&0x07)?"UDMA":" DMA"):" PIO",
((art&0x06)==0x06)?"4":((art&0x05)==0x05)?"4":((art&0x04)==0x04)?"3":((art&0x03)==0x03)?"2":((art&0x02)==0x02)?"1":((art&0x01)==0x01)?"0":"?",
(c0&0x40)?((art&0x70)?"UDMA":" DMA"):" PIO",
((art&0x60)==0x60)?"4":((art&0x50)==0x50)?"4":((art&0x40)==0x40)?"3":((art&0x30)==0x30)?"2":((art&0x20)==0x20)?"1":((art&0x10)==0x10)?"0":"?");
(void) pci_read_config_byte(bmide_dev, 0x45, &art);
p += sprintf(p, " %s(%s) %s(%s)\n",
(c1&0x20)?((art&0x07)?"UDMA":" DMA"):" PIO",
((art&0x06)==0x06)?"4":((art&0x05)==0x05)?"4":((art&0x04)==0x04)?"3":((art&0x03)==0x03)?"2":((art&0x02)==0x02)?"1":((art&0x01)==0x01)?"0":"?",
(c1&0x40)?((art&0x70)?"UDMA":" DMA"):" PIO",
((art&0x60)==0x60)?"4":((art&0x50)==0x50)?"4":((art&0x40)==0x40)?"3":((art&0x30)==0x30)?"2":((art&0x20)==0x20)?"1":((art&0x10)==0x10)?"0":"?");
(void) pci_read_config_byte(bmide_dev, 0x40, &art);
p += sprintf(p, "Active: 0x%02x", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x41, &art);
p += sprintf(p, " 0x%02x", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x42, &art);
p += sprintf(p, " 0x%02x", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x43, &art);
p += sprintf(p, " 0x%02x\n", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x40, &art);
p += sprintf(p, "Recovery: 0x%02x", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x41, &art);
p += sprintf(p, " 0x%02x", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x42, &art);
p += sprintf(p, " 0x%02x", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x43, &art);
p += sprintf(p, " 0x%02x\n", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x49, &uart);
p += sprintf(p, "reg49h = 0x%02x ", uart);
(void) pci_read_config_byte(bmide_dev, 0x4a, &uart);
p += sprintf(p, "reg4ah = 0x%02x\n", uart);
break;
case PCI_DEVICE_ID_ARTOP_ATP865:
case PCI_DEVICE_ID_ARTOP_ATP865R:
(void) pci_read_config_byte(bmide_dev, 0x44, &art);
p += sprintf(p, "DMA Mode: %s(%s) %s(%s)",
(c0&0x20)?((art&0x0f)?"UDMA":" DMA"):" PIO",
aec6280_get_speed(art&0x0f),
(c0&0x40)?((art&0xf0)?"UDMA":" DMA"):" PIO",
aec6280_get_speed(art>>4));
(void) pci_read_config_byte(bmide_dev, 0x45, &art);
p += sprintf(p, " %s(%s) %s(%s)\n",
(c0&0x20)?((art&0x0f)?"UDMA":" DMA"):" PIO",
aec6280_get_speed(art&0x0f),
(c0&0x40)?((art&0xf0)?"UDMA":" DMA"):" PIO",
aec6280_get_speed(art>>4));
(void) pci_read_config_byte(bmide_dev, 0x40, &art);
p += sprintf(p, "Active: 0x%02x", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x41, &art);
p += sprintf(p, " 0x%02x", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x42, &art);
p += sprintf(p, " 0x%02x", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x43, &art);
p += sprintf(p, " 0x%02x\n", HIGH_4(art));
(void) pci_read_config_byte(bmide_dev, 0x40, &art);
p += sprintf(p, "Recovery: 0x%02x", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x41, &art);
p += sprintf(p, " 0x%02x", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x42, &art);
p += sprintf(p, " 0x%02x", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x43, &art);
p += sprintf(p, " 0x%02x\n", LOW_4(art));
(void) pci_read_config_byte(bmide_dev, 0x49, &uart);
p += sprintf(p, "reg49h = 0x%02x ", uart);
(void) pci_read_config_byte(bmide_dev, 0x4a, &uart);
p += sprintf(p, "reg4ah = 0x%02x\n", uart);
break;
default:
break;
}
return p-buffer;/* => must be less than 4k! */
pci_read_config_byte(dev, AEC_UDMA_OLD, &t);
t &= ~(3 << (dn << 1));
if (timing->udma)
t |= (5 - FIT(timing->udma, 2, 4)) << (dn << 1);
pci_write_config_byte(dev, AEC_UDMA_OLD, t);
}
#endif /* defined(DISPLAY_AEC62xx_TIMINGS) && defined(CONFIG_PROC_FS) */
byte aec62xx_proc = 0;
struct chipset_bus_clock_list_entry {
byte xfer_speed;
/*
* aec_set_speed_new() writes timing values to the chipset registers for all
* other Artop chips
*/
byte chipset_settings_34;
byte ultra_settings_34;
static void aec_set_speed_new(struct pci_dev *dev, unsigned char dn, struct ata_timing *timing)
{
unsigned char t;
byte chipset_settings_33;
byte ultra_settings_33;
};
pci_write_config_byte(dev, AEC_DRIVE_TIMING + dn,
(FIT(timing->active, 0, 15) << 4) | FIT(timing->recover, 0, 15));
struct chipset_bus_clock_list_entry aec62xx_base [] = {
#ifdef CONFIG_BLK_DEV_IDEDMA
{ XFER_UDMA_6, 0x41, 0x06, 0x31, 0x07 },
{ XFER_UDMA_5, 0x41, 0x05, 0x31, 0x06 },
{ XFER_UDMA_4, 0x41, 0x04, 0x31, 0x05 },
{ XFER_UDMA_3, 0x41, 0x03, 0x31, 0x04 },
{ XFER_UDMA_2, 0x41, 0x02, 0x31, 0x03 },
{ XFER_UDMA_1, 0x41, 0x01, 0x31, 0x02 },
{ XFER_UDMA_0, 0x41, 0x01, 0x31, 0x01 },
{ XFER_MW_DMA_2, 0x41, 0x00, 0x31, 0x00 },
{ XFER_MW_DMA_1, 0x42, 0x00, 0x31, 0x00 },
{ XFER_MW_DMA_0, 0x7a, 0x00, 0x0a, 0x00 },
#endif /* CONFIG_BLK_DEV_IDEDMA */
{ XFER_PIO_4, 0x41, 0x00, 0x31, 0x00 },
{ XFER_PIO_3, 0x43, 0x00, 0x33, 0x00 },
{ XFER_PIO_2, 0x78, 0x00, 0x08, 0x00 },
{ XFER_PIO_1, 0x7a, 0x00, 0x0a, 0x00 },
{ XFER_PIO_0, 0x70, 0x00, 0x00, 0x00 },
{ 0, 0x00, 0x00, 0x00, 0x00 }
};
pci_read_config_byte(dev, AEC_UDMA_NEW + (dn >> 1), &t);
t &= ~(0xf << ((dn & 1) << 2));
if (timing->udma)
t |= aec_cyc2udma[FIT(timing->udma, 2, 16)] << ((dn & 1) << 2);
pci_write_config_byte(dev, AEC_UDMA_NEW + (dn >> 1), t);
}
/*
* TO DO: active tuning and correction of cards without a bios.
* aec_set_drive() computes timing values configures the drive and
* the chipset to a desired transfer mode. It also can be called
* by upper layers.
*/
static byte pci_bus_clock_list (byte speed, struct chipset_bus_clock_list_entry * chipset_table)
{
for ( ; chipset_table->xfer_speed ; chipset_table++)
if (chipset_table->xfer_speed == speed) {
return ((byte) ((system_bus_speed <= 33333) ? chipset_table->chipset_settings_33 : chipset_table->chipset_settings_34));
}
return 0x00;
}
static byte pci_bus_clock_list_ultra (byte speed, struct chipset_bus_clock_list_entry * chipset_table)
static int aec_set_drive(struct ata_device *drive, unsigned char speed)
{
for ( ; chipset_table->xfer_speed ; chipset_table++)
if (chipset_table->xfer_speed == speed) {
return ((byte) ((system_bus_speed <= 33333) ? chipset_table->ultra_settings_33 : chipset_table->ultra_settings_34));
}
return 0x00;
}
struct ata_timing t;
int T, UT;
int aec_old;
static int aec62xx_ratemask(struct ata_device *drive)
{
struct pci_dev *dev = drive->channel->pci_dev;
u32 bmide = pci_resource_start(dev, 4);
int map = 0;
aec_old = (drive->channel->pci_dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF);
if (!eighty_ninty_three(drive))
return XFER_UDMA;
if (speed != XFER_PIO_SLOW && speed != drive->current_speed)
if (ide_config_drive_speed(drive, speed))
printk(KERN_WARNING "ide%d: Drive %d didn't accept speed setting. Oh, well.\n",
drive->dn >> 1, drive->dn & 1);
switch(dev->device) {
case PCI_DEVICE_ID_ARTOP_ATP865R:
case PCI_DEVICE_ID_ARTOP_ATP865:
if (IN_BYTE(bmide+2) & 0x10)
map |= XFER_UDMA_133;
else
map |= XFER_UDMA_100;
case PCI_DEVICE_ID_ARTOP_ATP860R:
case PCI_DEVICE_ID_ARTOP_ATP860:
map |= XFER_UDMA_66;
case PCI_DEVICE_ID_ARTOP_ATP850UF:
map |= XFER_UDMA;
}
return map;
}
T = 1000000000 / system_bus_speed;
UT = T / (aec_old ? 1 : 4);
static int aec6210_tune_chipset(struct ata_device *drive, byte speed)
{
struct pci_dev *dev = drive->channel->pci_dev;
unsigned short d_conf = 0x0000;
byte ultra = 0x00;
byte ultra_conf = 0x00;
byte tmp0 = 0x00;
byte tmp1 = 0x00;
byte tmp2 = 0x00;
unsigned long flags;
__save_flags(flags); /* local CPU only */
__cli(); /* local CPU only */
pci_read_config_word(dev, 0x40|(2*drive->dn), &d_conf);
tmp0 = pci_bus_clock_list(speed, aec62xx_base);
SPLIT_BYTE(tmp0,tmp1,tmp2);
MAKE_WORD(d_conf,tmp1,tmp2);
pci_write_config_word(dev, 0x40|(2*drive->dn), d_conf);
tmp1 = 0x00;
tmp2 = 0x00;
pci_read_config_byte(dev, 0x54, &ultra);
tmp1 = ((0x00 << (2*drive->dn)) | (ultra & ~(3 << (2*drive->dn))));
ultra_conf = pci_bus_clock_list_ultra(speed, aec62xx_base);
tmp2 = ((ultra_conf << (2*drive->dn)) | (tmp1 & ~(3 << (2*drive->dn))));
pci_write_config_byte(dev, 0x54, tmp2);
__restore_flags(flags); /* local CPU only */
return ide_config_drive_speed(drive, speed);
}
ata_timing_compute(drive, speed, &t, T, UT);
static int aec6260_tune_chipset(struct ata_device *drive, byte speed)
{
struct pci_dev *dev = drive->channel->pci_dev;
byte unit = (drive->select.b.unit & 0x01);
u8 ultra_pci = drive->channel->unit ? 0x45 : 0x44;
byte drive_conf = 0x00;
byte ultra_conf = 0x00;
byte ultra = 0x00;
byte tmp1 = 0x00;
byte tmp2 = 0x00;
unsigned long flags;
__save_flags(flags); /* local CPU only */
__cli(); /* local CPU only */
pci_read_config_byte(dev, 0x40|drive->dn, &drive_conf);
drive_conf = pci_bus_clock_list(speed, aec62xx_base);
pci_write_config_byte(dev, 0x40|drive->dn, drive_conf);
pci_read_config_byte(dev, ultra_pci, &ultra);
tmp1 = ((0x00 << (4*unit)) | (ultra & ~(7 << (4*unit))));
ultra_conf = pci_bus_clock_list_ultra(speed, aec62xx_base);
tmp2 = ((ultra_conf << (4*unit)) | (tmp1 & ~(7 << (4*unit))));
pci_write_config_byte(dev, ultra_pci, tmp2);
__restore_flags(flags); /* local CPU only */
if (aec_old)
aec_set_speed_old(drive->channel->pci_dev, drive->dn, &t);
else
aec_set_speed_new(drive->channel->pci_dev, drive->dn, &t);
if (!drive->init_speed)
drive->init_speed = speed;
drive->current_speed = speed;
return ide_config_drive_speed(drive, speed);
return 0;
}
/*
* aec62xx_tune_drive() is a callback from upper layers for
* PIO-only tuning.
*/
static int aec62xx_tune_chipset(struct ata_device *drive, byte speed)
static void aec62xx_tune_drive(struct ata_device *drive, unsigned char pio)
{
switch (drive->channel->pci_dev->device) {
case PCI_DEVICE_ID_ARTOP_ATP865:
case PCI_DEVICE_ID_ARTOP_ATP865R:
case PCI_DEVICE_ID_ARTOP_ATP860:
case PCI_DEVICE_ID_ARTOP_ATP860R:
return aec6260_tune_chipset(drive, speed);
case PCI_DEVICE_ID_ARTOP_ATP850UF:
return aec6210_tune_chipset(drive, speed);
default:
return -1;
if (pio == 255) {
aec_set_drive(drive, ata_timing_mode(drive, XFER_PIO | XFER_EPIO));
return;
}
aec_set_drive(drive, XFER_PIO_0 + min_t(byte, pio, 5));
}
#ifdef CONFIG_BLK_DEV_IDEDMA
static int config_chipset_for_dma(struct ata_device *drive, u8 udma)
static int aec62xx_dmaproc(struct ata_device *drive)
{
short speed;
int map;
u8 mode;
if (drive->type != ATA_DISK)
return 0;
if (udma)
map = aec62xx_ratemask(drive);
else
map = XFER_SWDMA | XFER_MWDMA;
map = XFER_PIO | XFER_EPIO | XFER_MWDMA | XFER_UDMA | XFER_SWDMA | XFER_UDMA;
mode = ata_timing_mode(drive, map);
if (drive->channel->udma_four)
switch (drive->channel->pci_dev->device) {
case PCI_DEVICE_ID_ARTOP_ATP865R:
case PCI_DEVICE_ID_ARTOP_ATP865:
map |= XFER_UDMA_100 | XFER_UDMA_133;
case PCI_DEVICE_ID_ARTOP_ATP860R:
case PCI_DEVICE_ID_ARTOP_ATP860:
map |= XFER_UDMA_66;
}
if (mode < XFER_SW_DMA_0)
return 0;
speed = ata_timing_mode(drive, map);
aec_set_drive(drive, speed);
udma_enable(drive, drive->channel->autodma && (speed & XFER_MODE) != XFER_PIO, 0);
return !aec62xx_tune_chipset(drive, mode);
return 0;
}
#endif /* CONFIG_BLK_DEV_IDEDMA */
#endif
/*
* The initialization callback. Here we determine the IDE chip type
* and initialize its drive independent registers.
*/
static void aec62xx_tune_drive(struct ata_device *drive, byte pio)
static unsigned int __init aec62xx_init_chipset(struct pci_dev *dev)
{
byte speed;
unsigned char t;
if (pio == 255)
speed = ata_timing_mode(drive, XFER_PIO | XFER_EPIO);
else
speed = XFER_PIO_0 + min_t(byte, pio, 4);
/*
* Initialize if needed.
*/
(void) aec62xx_tune_chipset(drive, speed);
}
switch (dev->device) {
#ifdef CONFIG_BLK_DEV_IDEDMA
static int config_drive_xfer_rate(struct ata_device *drive)
{
struct hd_driveid *id = drive->id;
int on = 1;
int verbose = 1;
if (id && (id->capability & 1) && drive->channel->autodma) {
/* Consult the list of known "bad" drives */
if (udma_black_list(drive)) {
on = 0;
goto fast_ata_pio;
}
on = 0;
verbose = 0;
if (id->field_valid & 4) {
if (id->dma_ultra & 0x007F) {
/* Force if Capable UltraDMA */
on = config_chipset_for_dma(drive, 1);
if ((id->field_valid & 2) &&
(!on))
goto try_dma_modes;
}
} else if (id->field_valid & 2) {
try_dma_modes:
if ((id->dma_mword & 0x0007) ||
(id->dma_1word & 0x0007)) {
/* Force if Capable regular DMA modes */
on = config_chipset_for_dma(drive, 0);
if (!on)
goto no_dma_set;
}
} else if (udma_white_list(drive)) {
if (id->eide_dma_time > 150) {
goto no_dma_set;
}
/* Consult the list of known "good" drives */
on = config_chipset_for_dma(drive, 0);
if (!on)
goto no_dma_set;
} else {
goto fast_ata_pio;
}
} else if ((id->capability & 8) || (id->field_valid & 2)) {
fast_ata_pio:
on = 0;
verbose = 0;
no_dma_set:
aec62xx_tune_drive(drive, 5);
}
udma_enable(drive, on, verbose);
return 0;
}
case PCI_DEVICE_ID_ARTOP_ATP865R:
case PCI_DEVICE_ID_ARTOP_ATP865:
int aec62xx_dmaproc(struct ata_device *drive)
{
return config_drive_xfer_rate(drive);
}
#endif
/* Clear reset and test bits. */
pci_read_config_byte(dev, AEC_MISC, &t);
pci_write_config_byte(dev, AEC_MISC, t & ~0x30);
static unsigned int __init aec62xx_init_chipset(struct pci_dev *dev)
{
u8 reg49h = 0;
u8 reg4ah = 0;
/* Enable chip interrupt output. */
pci_read_config_byte(dev, AEC_IDE_ENABLE, &t);
pci_write_config_byte(dev, AEC_IDE_ENABLE, t & ~0x01);
switch(dev->device) {
case PCI_DEVICE_ID_ARTOP_ATP865:
case PCI_DEVICE_ID_ARTOP_ATP865R:
/* Clear reset and test bits. */
pci_read_config_byte(dev, 0x49, &reg49h);
pci_write_config_byte(dev, 0x49, reg49h & ~0x30);
/* Enable chip interrupt output. */
pci_read_config_byte(dev, 0x4a, &reg4ah);
pci_write_config_byte(dev, 0x4a, reg4ah & ~0x01);
#ifdef CONFIG_AEC6280_BURST
/* Must be greater than 0x80 for burst mode. */
/* Must be greater than 0x80 for burst mode. */
pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x90);
/* Enable burst mode. */
pci_read_config_byte(dev, 0x4a, &reg4ah);
pci_write_config_byte(dev, 0x4a, reg4ah | 0x80);
/* Enable burst mode. */
pci_read_config_byte(dev, AEC_IDE_ENABLE, &t);
pci_write_config_byte(dev, AEC_IDE_ENABLE, t | 0x80);
#endif
break;
default:
break;
}
if (dev->resource[PCI_ROM_RESOURCE].start) {
pci_write_config_dword(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
printk("%s: ROM enabled at 0x%08lx\n", dev->name, dev->resource[PCI_ROM_RESOURCE].start);
}
/*
* Print the boot message.
*/
#if defined(DISPLAY_AEC62XX_TIMINGS) && defined(CONFIG_PROC_FS)
if (!aec62xx_proc) {
aec62xx_proc = 1;
bmide_dev = dev;
aec62xx_display_info = &aec62xx_get_info;
}
#endif
pci_read_config_byte(dev, PCI_REVISION_ID, &t);
printk(KERN_INFO "AEC_IDE: %s (rev %02x) controller on pci%s\n",
dev->name, t, dev->slot_name);
return dev->irq;
return 0;
}
static unsigned int __init aec62xx_ata66_check(struct ata_channel *ch)
{
u8 mask = ch->unit ? 0x02 : 0x01;
u8 ata66 = 0;
unsigned char t;
pci_read_config_byte(ch->pci_dev, 0x49, &ata66);
if (ch->pci_dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF)
return 0;
return ((ata66 & mask) ? 0 : 1);
pci_read_config_byte(ch->pci_dev, AEC_MISC, &t);
return ((t & (1 << ch->unit)) ? 0 : 1);
}
static void __init aec62xx_init_channel(struct ata_channel *hwif)
static void __init aec62xx_init_channel(struct ata_channel *ch)
{
hwif->tuneproc = aec62xx_tune_drive;
hwif->speedproc = aec62xx_tune_chipset;
hwif->drives[0].autotune = 1;
hwif->drives[1].autotune = 1;
int i;
ch->tuneproc = &aec62xx_tune_drive;
ch->speedproc = &aec_set_drive;
ch->autodma = 0;
ch->io_32bit = 1;
ch->unmask = 1;
for (i = 0; i < 2; i++) {
ch->drives[i].autotune = 1;
ch->drives[i].dn = ch->unit * 2 + i;
}
#ifdef CONFIG_BLK_DEV_IDEDMA
if (hwif->dma_base) {
hwif->XXX_udma = aec62xx_dmaproc;
hwif->highmem = 1;
# ifdef CONFIG_IDEDMA_AUTO
if (ch->dma_base) {
ch->highmem = 1;
ch->XXX_udma = aec62xx_dmaproc;
#ifdef CONFIG_IDEDMA_AUTO
if (!noautodma)
hwif->autodma = 1;
# endif
ch->autodma = 1;
#endif
}
#endif
}
static void __init aec62xx_init_dma(struct ata_channel *hwif, unsigned long dmabase)
/*
* We allow the BM-DMA driver only work on enabled interfaces.
*/
static void __init aec62xx_init_dma(struct ata_channel *ch, unsigned long dmabase)
{
u8 reg54h = 0;
unsigned char t;
/* FIXME: we need some locking here */
pci_read_config_byte(hwif->pci_dev, 0x54, &reg54h);
pci_write_config_byte(hwif->pci_dev, 0x54, reg54h & ~(hwif->unit ? 0xF0 : 0x0F));
ata_init_dma(hwif, dmabase);
pci_read_config_byte(ch->pci_dev, AEC_IDE_ENABLE, &t);
if (t & (1 << ((ch->unit << 1) + 2)))
ata_init_dma(ch, dmabase);
}
/* module data table */
......@@ -574,7 +288,7 @@ static struct ata_pci_device chipsets[] __initdata = {
init_chipset: aec62xx_init_chipset,
ata66_check: aec62xx_ata66_check,
init_channel: aec62xx_init_channel,
enablebits: { {0x00,0x00,0x00}, {0x00,0x00,0x00} },
enablebits: { {0x4a,0x02,0x02}, {0x4a,0x04,0x04} },
bootable: NEVER_BOARD,
flags: ATA_F_IRQ | ATA_F_NOADMA | ATA_F_DMA
},
......@@ -594,7 +308,7 @@ static struct ata_pci_device chipsets[] __initdata = {
init_chipset: aec62xx_init_chipset,
ata66_check: aec62xx_ata66_check,
init_channel: aec62xx_init_channel,
enablebits: { {0x00,0x00,0x00}, {0x00,0x00,0x00} },
enablebits: { {0x4a,0x02,0x02}, {0x4a,0x04,0x04} },
bootable: NEVER_BOARD,
flags: ATA_F_IRQ | ATA_F_DMA
},
......@@ -604,7 +318,7 @@ static struct ata_pci_device chipsets[] __initdata = {
init_chipset: aec62xx_init_chipset,
ata66_check: aec62xx_ata66_check,
init_channel: aec62xx_init_channel,
enablebits: { {0x00,0x00,0x00}, {0x00,0x00,0x00} },
enablebits: { {0x4a,0x02,0x02}, {0x4a,0x04,0x04} },
bootable: OFF_BOARD,
flags: ATA_F_IRQ | ATA_F_DMA
}
......@@ -614,9 +328,8 @@ int __init init_aec62xx(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(chipsets); ++i) {
ata_register_chipset(&chipsets[i]);
}
for (i = 0; i < ARRAY_SIZE(chipsets); i++)
ata_register_chipset(chipsets + i);
return 0;
}
drivers/ide/atapi.c
View file @ 4478f040
......@@ -37,6 +37,21 @@
#include <asm/bitops.h>
#include <asm/uaccess.h>
/*
* Initializes a packet command. Used by tape and floppy driver.
*/
void atapi_init_pc(struct atapi_packet_command *pc)
{
memset(pc->c, 0, 12);
pc->retries = 0;
pc->flags = 0;
pc->request_transfer = 0;
pc->buffer = pc->pc_buffer;
pc->buffer_size = IDEFLOPPY_PC_BUFFER_SIZE;
pc->b_data = NULL;
pc->bio = NULL;
}
/*
* Too bad. The drive wants to send us data which we are not ready to accept.
* Just throw it away.
......@@ -54,22 +69,57 @@ void atapi_write_zeros(struct ata_device *drive, unsigned int bcount)
}
/*
* Initializes a packet command. Used by tape and floppy driver.
* The following routines are mainly used by the ATAPI drivers.
*
* These routines will round up any request for an odd number of bytes, so if
* an odd n is specified, be sure that there's at least one extra byte
* allocated for the buffer.
*/
void atapi_init_pc(struct atapi_packet_command *pc)
void atapi_read(struct ata_device *drive, u8 *buf, unsigned int n)
{
memset(pc->c, 0, 12);
pc->retries = 0;
pc->flags = 0;
pc->request_transfer = 0;
pc->buffer = pc->pc_buffer;
pc->buffer_size = IDEFLOPPY_PC_BUFFER_SIZE;
pc->b_data = NULL;
pc->bio = NULL;
if (drive->channel->atapi_read) {
drive->channel->atapi_read(drive, buf, n);
return;
}
++n;
#if defined(CONFIG_ATARI) || defined(CONFIG_Q40)
if (MACH_IS_ATARI || MACH_IS_Q40) {
/* Atari has a byte-swapped IDE interface */
insw_swapw(IDE_DATA_REG, buf, n / 2);
return;
}
#endif
ata_read(drive, buf, n / 4);
if ((n & 0x03) >= 2)
insw(IDE_DATA_REG, buf + (n & ~0x03), 1);
}
void atapi_write(struct ata_device *drive, u8 *buf, unsigned int n)
{
if (drive->channel->atapi_write) {
drive->channel->atapi_write(drive, buf, n);
return;
}
++n;
#if defined(CONFIG_ATARI) || defined(CONFIG_Q40)
if (MACH_IS_ATARI || MACH_IS_Q40) {
/* Atari has a byte-swapped IDE interface */
outsw_swapw(IDE_DATA_REG, buf, n / 2);
return;
}
#endif
ata_write(drive, buf, n / 4);
if ((n & 0x03) >= 2)
outsw(IDE_DATA_REG, buf + (n & ~0x03), 1);
}
EXPORT_SYMBOL(atapi_discard_data);
EXPORT_SYMBOL(atapi_write_zeros);
EXPORT_SYMBOL(atapi_init_pc);
EXPORT_SYMBOL(atapi_read);
EXPORT_SYMBOL(atapi_write);
MODULE_LICENSE("GPL");
drivers/ide/ide-cd.c
View file @ 4478f040
......@@ -314,6 +314,7 @@
#include <asm/uaccess.h>
#include <asm/unaligned.h>
#include <linux/atapi.h>
#include "ide-cd.h"
/****************************************************************************
......@@ -2988,7 +2989,7 @@ static void ide_cdrom_attach(struct ata_device *drive)
channel = drive->channel;
unit = drive - channel->drives;
ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
ata_revalidate(mk_kdev(channel->major, unit << PARTN_BITS));
}
MODULE_PARM(ignore, "s");
......
drivers/ide/ide-disk.c
View file @ 4478f040
......@@ -361,8 +361,8 @@ static int idedisk_open (struct inode *inode, struct file *filp, struct ata_devi
/*
* Ignore the return code from door_lock, since the open() has
* already succeeded, and the door_lock is irrelevant at this
* point.
* already succeeded once, and the door_lock is irrelevant at this
* time.
*/
if (drive->doorlocking && ide_raw_taskfile(drive, &args))
......@@ -1196,7 +1196,7 @@ static void idedisk_attach(struct ata_device *drive)
channel = drive->channel;
unit = drive - channel->drives;
ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
ata_revalidate(mk_kdev(channel->major, unit << PARTN_BITS));
}
static void __exit idedisk_exit(void)
......
drivers/ide/ide-floppy.c
View file @ 4478f040
......@@ -2036,7 +2036,7 @@ static void idefloppy_attach(struct ata_device *drive)
channel = drive->channel;
unit = drive - channel->drives;
ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
ata_revalidate(mk_kdev(channel->major, unit << PARTN_BITS));
}
MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
......
drivers/ide/ide-pci.c
View file @ 4478f040
......@@ -27,10 +27,6 @@
#include "pcihost.h"
/* Missing PCI device IDs: */
#define PCI_VENDOR_ID_HINT 0x3388
#define PCI_DEVICE_ID_HINT 0x8013
/*
* This is the list of registered PCI chipset driver data structures.
*/
......@@ -756,7 +752,7 @@ static struct ata_pci_device chipsets[] __initdata = {
},
{
vendor: PCI_VENDOR_ID_HINT,
device: PCI_DEVICE_ID_HINT,
device: PCI_DEVICE_ID_HINT_VXPROII_IDE,
bootable: ON_BOARD
},
{
......
drivers/ide/ide-pnp.c
View file @ 4478f040
/*
* linux/drivers/ide/ide-pnp.c
/**** vi:set ts=8 sts=8 sw=8:************************************************
*
* This file provides autodetection for ISA PnP IDE interfaces.
* It was tested with "ESS ES1868 Plug and Play AudioDrive" IDE interface.
......@@ -33,19 +32,27 @@
#define DEV_NAME(dev) (dev->bus->name ? dev->bus->name : "ISA PnP")
#define GENERIC_HD_DATA 0
#define GENERIC_HD_ERROR 1
#define GENERIC_HD_NSECTOR 2
#define GENERIC_HD_SECTOR 3
#define GENERIC_HD_LCYL 4
#define GENERIC_HD_HCYL 5
#define GENERIC_HD_SELECT 6
#define GENERIC_HD_STATUS 7
enum {
GENERIC_HD_DATA,
GENERIC_HD_ERROR,
GENERIC_HD_NSECTOR,
GENERIC_HD_SECTOR,
GENERIC_HD_LCYL,
GENERIC_HD_HCYL,
GENERIC_HD_SELECT,
GENERIC_HD_STATUS
};
static int generic_ide_offsets[IDE_NR_PORTS] __initdata = {
GENERIC_HD_DATA, GENERIC_HD_ERROR, GENERIC_HD_NSECTOR,
GENERIC_HD_SECTOR, GENERIC_HD_LCYL, GENERIC_HD_HCYL,
GENERIC_HD_SELECT, GENERIC_HD_STATUS, -1, -1
GENERIC_HD_DATA,
GENERIC_HD_ERROR,
GENERIC_HD_NSECTOR,
GENERIC_HD_SECTOR,
GENERIC_HD_LCYL,
GENERIC_HD_HCYL,
GENERIC_HD_SELECT,
GENERIC_HD_STATUS,
-1, -1
};
/* ISA PnP device table entry */
......@@ -83,11 +90,13 @@ static int __init pnpide_generic_init(struct pci_dev *dev, int enable)
}
/* Add your devices here :)) */
struct pnp_dev_t idepnp_devices[] __initdata = {
/* Generic ESDI/IDE/ATA compatible hard disk controller */
{ ISAPNP_ANY_ID, ISAPNP_ANY_ID,
static struct pnp_dev_t pnp_devices[] __initdata = {
/* Generic ESDI/IDE/ATA compatible hard disk controller */
{
ISAPNP_ANY_ID, ISAPNP_ANY_ID,
ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0x0600),
pnpide_generic_init },
pnpide_generic_init
},
{ 0 }
};
......@@ -125,14 +134,14 @@ void __init pnpide_init(int enable)
return;
}
#endif
for (dev_type = idepnp_devices; dev_type->vendor; dev_type++) {
for (dev_type = pnp_devices; dev_type->vendor; dev_type++) {
while ((dev = isapnp_find_dev(NULL, dev_type->vendor,
dev_type->device, dev))) {
if (dev->active)
continue;
if (PREPARE_FUNC(dev) && (PREPARE_FUNC(dev))(dev) < 0) {
if (PREPARE_FUNC(dev) && (PREPARE_FUNC(dev))(dev) < 0) {
printk(KERN_ERR "ide: %s prepare failed\n", DEV_NAME(dev));
continue;
}
......
drivers/ide/ide-tape.c
View file @ 4478f040
......@@ -2789,14 +2789,14 @@ static idetape_stage_t *__idetape_kmalloc_stage (idetape_tape_t *tape, int full,
struct bio *prev_bio, *bio;
int pages = tape->pages_per_stage;
char *b_data = NULL;
struct bio_vec *bv;
struct bio_vec *bv;
if ((stage = (idetape_stage_t *) kmalloc (sizeof (idetape_stage_t),GFP_KERNEL)) == NULL)
return NULL;
stage->next = NULL;
bio = stage->bio = bio_alloc(GFP_KERNEL,1);
bv = bio_iovec(bio);
bv = bio_iovec(bio);
bv->bv_len = 0;
if (bio == NULL)
goto abort;
......@@ -2806,9 +2806,14 @@ static idetape_stage_t *__idetape_kmalloc_stage (idetape_tape_t *tape, int full,
if (clear)
memset(bio_data(bio), 0, PAGE_SIZE);
bio->bi_size = PAGE_SIZE;
if(bv->bv_len == full) bv->bv_len = bio->bi_size;
set_bit (BH_Lock, &bio->bi_flags);
if(bv->bv_len == full)
bv->bv_len = bio->bi_size;
#if 0
/* FIXME: What what this supposed to achieve? */
set_bit (BH_Lock, &bio->bi_flags);
#endif
while (--pages) {
if ((bio->bi_io_vec[pages].bv_page = alloc_page(GFP_KERNEL)) == NULL)
goto abort;
......@@ -2837,7 +2842,11 @@ static idetape_stage_t *__idetape_kmalloc_stage (idetape_tape_t *tape, int full,
//bio->bi_io_vec[0].bv_offset = b_data;
bio->bi_size = PAGE_SIZE;
atomic_set(&bio->bi_cnt, full ? bio->bi_size : 0);
#if 0
/* FIXME: What what this supposed to achieve? */
set_bit (BH_Lock, &bio->bi_flags);
#endif
prev_bio->bi_next = bio;
}
bio->bi_size -= tape->excess_bh_size;
......@@ -6153,7 +6162,7 @@ static void idetape_attach(struct ata_device *drive)
channel = drive->channel;
unit = drive - channel->drives;
ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
ata_revalidate(mk_kdev(channel->major, unit << PARTN_BITS));
}
MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
......
drivers/ide/ide-taskfile.c
View file @ 4478f040
......@@ -160,53 +160,6 @@ void ata_write(struct ata_device *drive, void *buffer, unsigned int wcount)
}
}
/*
* The following routines are mainly used by the ATAPI drivers.
*
* These routines will round up any request for an odd number of bytes,
* so if an odd bytecount is specified, be sure that there's at least one
* extra byte allocated for the buffer.
*/
void atapi_read(struct ata_device *drive, void *buffer, unsigned int bytecount)
{
if (drive->channel->atapi_read) {
drive->channel->atapi_read(drive, buffer, bytecount);
return;
}
++bytecount;
#if defined(CONFIG_ATARI) || defined(CONFIG_Q40)
if (MACH_IS_ATARI || MACH_IS_Q40) {
/* Atari has a byte-swapped IDE interface */
insw_swapw(IDE_DATA_REG, buffer, bytecount / 2);
return;
}
#endif
ata_read(drive, buffer, bytecount / 4);
if ((bytecount & 0x03) >= 2)
insw(IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
}
void atapi_write(struct ata_device *drive, void *buffer, unsigned int bytecount)
{
if (drive->channel->atapi_write) {
drive->channel->atapi_write(drive, buffer, bytecount);
return;
}
++bytecount;
#if defined(CONFIG_ATARI) || defined(CONFIG_Q40)
if (MACH_IS_ATARI || MACH_IS_Q40) {
/* Atari has a byte-swapped IDE interface */
outsw_swapw(IDE_DATA_REG, buffer, bytecount / 2);
return;
}
#endif
ata_write(drive, buffer, bytecount / 4);
if ((bytecount & 0x03) >= 2)
outsw(IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
}
/*
* Needed for PCI irq sharing
*/
......@@ -1032,8 +985,6 @@ int ide_cmd_ioctl(struct ata_device *drive, unsigned long arg)
EXPORT_SYMBOL(drive_is_ready);
EXPORT_SYMBOL(ata_read);
EXPORT_SYMBOL(ata_write);
EXPORT_SYMBOL(atapi_read);
EXPORT_SYMBOL(atapi_write);
EXPORT_SYMBOL(ata_taskfile);
EXPORT_SYMBOL(recal_intr);
EXPORT_SYMBOL(task_no_data_intr);
......
drivers/ide/ide.c
View file @ 4478f040
......@@ -32,8 +32,6 @@
* Some additional driver compile-time options are in <linux/ide.h>
*/
#define VERSION "7.0.0"
#include <linux/config.h>
#include <linux/module.h>
#include <linux/types.h>
......@@ -67,163 +65,11 @@
#include "ata-timing.h"
#include "pcihost.h"
MODULE_DESCRIPTION("ATA/ATAPI driver infrastructure");
MODULE_PARM(options,"s");
MODULE_LICENSE("GPL");
/*
* Those will be moved into separate header files eventually.
*/
#ifdef CONFIG_ETRAX_IDE
extern void init_e100_ide(void);
#endif
#ifdef CONFIG_BLK_DEV_CMD640
extern void ide_probe_for_cmd640x(void);
#endif
#ifdef CONFIG_BLK_DEV_PDC4030
extern int ide_probe_for_pdc4030(void);
#endif
#ifdef CONFIG_BLK_DEV_IDE_PMAC
extern void pmac_ide_probe(void);
#endif
#ifdef CONFIG_BLK_DEV_IDE_ICSIDE
extern void icside_init(void);
#endif
#ifdef CONFIG_BLK_DEV_IDE_RAPIDE
extern void rapide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_GAYLE
extern void gayle_init(void);
#endif
#ifdef CONFIG_BLK_DEV_FALCON_IDE
extern void falconide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_MAC_IDE
extern void macide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_Q40IDE
extern void q40ide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_BUDDHA
extern void buddha_init(void);
#endif
#if defined(CONFIG_BLK_DEV_ISAPNP) && defined(CONFIG_ISAPNP)
extern void pnpide_init(int);
#endif
#include "ioctl.h"
/* default maximum number of failures */
#define IDE_DEFAULT_MAX_FAILURES 1
static int idebus_parameter; /* holds the "idebus=" parameter */
int system_bus_speed; /* holds what we think is VESA/PCI bus speed */
static int initializing; /* set while initializing built-in drivers */
/*
* Protects access to global structures etc.
*/
spinlock_t ide_lock __cacheline_aligned = SPIN_LOCK_UNLOCKED;
#ifdef CONFIG_PCI
static int ide_scan_direction; /* THIS was formerly 2.2.x pci=reverse */
#endif
#if defined(__mc68000__) || defined(CONFIG_APUS)
/*
* This is used by the Atari code to obtain access to the IDE interrupt,
* which is shared between several drivers.
*/
static int irq_lock;
#endif
int noautodma = 0;
/* Single linked list of sub device type drivers */
static struct ata_operations *ata_drivers; /* = NULL */
static spinlock_t ata_drivers_lock = SPIN_LOCK_UNLOCKED;
/*
* This is declared extern in ide.h, for access by other IDE modules:
*/
struct ata_channel ide_hwifs[MAX_HWIFS]; /* master data repository */
static void init_hwif_data(struct ata_channel *ch, unsigned int index)
{
static const byte ide_major[] = {
IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR, IDE4_MAJOR,
IDE5_MAJOR, IDE6_MAJOR, IDE7_MAJOR, IDE8_MAJOR, IDE9_MAJOR
};
unsigned int unit;
hw_regs_t hw;
/* bulk initialize channel & drive info with zeros */
memset(ch, 0, sizeof(struct ata_channel));
memset(&hw, 0, sizeof(hw_regs_t));
/* fill in any non-zero initial values */
ch->index = index;
ide_init_hwif_ports(&hw, ide_default_io_base(index), 0, &ch->irq);
memcpy(&ch->hw, &hw, sizeof(hw));
memcpy(ch->io_ports, hw.io_ports, sizeof(hw.io_ports));
ch->noprobe = !ch->io_ports[IDE_DATA_OFFSET];
#ifdef CONFIG_BLK_DEV_HD
if (ch->io_ports[IDE_DATA_OFFSET] == HD_DATA)
ch->noprobe = 1; /* may be overridden by ide_setup() */
#endif
ch->major = ide_major[index];
sprintf(ch->name, "ide%d", index);
ch->bus_state = BUSSTATE_ON;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
drive->type = ATA_DISK;
drive->select.all = (unit<<4)|0xa0;
drive->channel = ch;
drive->ctl = 0x08;
drive->ready_stat = READY_STAT;
drive->bad_wstat = BAD_W_STAT;
sprintf(drive->name, "hd%c", 'a' + (index * MAX_DRIVES) + unit);
drive->max_failures = IDE_DEFAULT_MAX_FAILURES;
init_waitqueue_head(&drive->wqueue);
}
}
/*
* init_ide_data() sets reasonable default values into all fields
* of all instances of the hwifs and drives, but only on the first call.
* Subsequent calls have no effect (they don't wipe out anything).
*
* This routine is normally called at driver initialization time,
* but may also be called MUCH earlier during kernel "command-line"
* parameter processing. As such, we cannot depend on any other parts
* of the kernel (such as memory allocation) to be functioning yet.
*
* This is too bad, as otherwise we could dynamically allocate the
* ata_device structs as needed, rather than always consuming memory
* for the max possible number (MAX_HWIFS * MAX_DRIVES) of them.
*/
#define MAGIC_COOKIE 0x12345678
static void __init init_ide_data (void)
{
unsigned int h;
static unsigned long magic_cookie = MAGIC_COOKIE;
if (magic_cookie != MAGIC_COOKIE)
return; /* already initialized */
magic_cookie = 0;
/* Initialize all interface structures */
for (h = 0; h < MAX_HWIFS; ++h)
init_hwif_data(&ide_hwifs[h], h);
/* Add default hw interfaces */
ide_init_default_hwifs();
}
/*
* CompactFlash cards and their relatives pretend to be removable hard disks, except:
* (1) they never have a slave unit, and
......@@ -396,31 +242,6 @@ sector_t ata_capacity(struct ata_device *drive)
extern struct block_device_operations ide_fops[];
/*
* This is called exactly *once* for each channel.
*/
void ide_geninit(struct ata_channel *ch)
{
unsigned int unit;
struct gendisk *gd = ch->gd;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (!drive->present)
continue;
if (drive->type != ATA_DISK && drive->type != ATA_FLOPPY)
continue;
register_disk(gd,mk_kdev(ch->major,unit<<PARTN_BITS),
#ifdef CONFIG_BLK_DEV_ISAPNP
(drive->forced_geom && drive->noprobe) ? 1 :
#endif
1 << PARTN_BITS, ide_fops, ata_capacity(drive));
}
}
static ide_startstop_t do_reset1(struct ata_device *, int); /* needed below */
/*
......@@ -1617,136 +1438,18 @@ void ata_irq_request(int irq, void *data, struct pt_regs *regs)
spin_unlock_irqrestore(ch->lock, flags);
}
/*
* get_info_ptr() returns the (struct ata_device *) for a given device number.
* It returns NULL if the given device number does not match any present drives.
*/
struct ata_device *get_info_ptr(kdev_t i_rdev)
{
unsigned int major = major(i_rdev);
int h;
for (h = 0; h < MAX_HWIFS; ++h) {
struct ata_channel *ch = &ide_hwifs[h];
if (ch->present && major == ch->major) {
int unit = DEVICE_NR(i_rdev);
if (unit < MAX_DRIVES) {
struct ata_device *drive = &ch->drives[unit];
if (drive->present)
return drive;
}
break;
}
}
return NULL;
}
/*
* FIXME: rename to ata_wipe_partitions.
*
* This routine is called to flush all partitions and partition tables
* for a changed disk, and then re-read the new partition table.
* If we are revalidating a disk because of a media change, then we
* enter with usage == 0. If we are using an ioctl, we automatically have
* usage == 1 (we need an open channel to use an ioctl :-), so this
* is our limit.
*/
int ide_revalidate_disk(kdev_t i_rdev)
{
struct ata_device *drive;
unsigned long flags;
int res;
if ((drive = get_info_ptr(i_rdev)) == NULL)
return -ENODEV;
/* FIXME: The locking here doesn't make the slightest sense! */
spin_lock_irqsave(&ide_lock, flags);
if (drive->busy || (drive->usage > 1)) {
spin_unlock_irqrestore(&ide_lock, flags);
return -EBUSY;
}
drive->busy = 1;
MOD_INC_USE_COUNT;
spin_unlock_irqrestore(&ide_lock, flags);
res = wipe_partitions(i_rdev);
if (!res) {
if (ata_ops(drive) && ata_ops(drive)->revalidate) {
ata_get(ata_ops(drive));
/* this is a no-op for tapes and SCSI based access */
ata_ops(drive)->revalidate(drive);
ata_put(ata_ops(drive));
} else
grok_partitions(i_rdev, ata_capacity(drive));
}
drive->busy = 0;
wake_up(&drive->wqueue);
MOD_DEC_USE_COUNT;
return res;
}
/*
* Look again for all drives in the system on all interfaces.
*/
static void revalidate_drives(void)
{
int i;
for (i = 0; i < MAX_HWIFS; ++i) {
int unit;
struct ata_channel *ch = &ide_hwifs[i];
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (drive->revalidate) {
drive->revalidate = 0;
if (!initializing)
ide_revalidate_disk(mk_kdev(ch->major, unit<<PARTN_BITS));
}
}
}
}
static void ide_driver_module(void)
{
int i;
/* Don't reinit the probe if there is already one channel detected. */
for (i = 0; i < MAX_HWIFS; ++i) {
if (ide_hwifs[i].present)
goto revalidate;
}
ideprobe_init();
revalidate:
revalidate_drives();
}
static int ide_open(struct inode * inode, struct file * filp)
{
struct ata_device *drive;
if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
return -ENXIO;
if (drive->driver == NULL)
ide_driver_module();
/* Request a particular device type module.
*
* FIXME: The function which should rather requests the drivers in
* FIXME: The function which should rather requests the drivers is
* ide_driver_module(), since it seems illogical and even a bit
* dangerous to delay this until open time!
* dangerous to postpone this until open time!
*/
#ifdef CONFIG_KMOD
......@@ -1776,8 +1479,13 @@ static int ide_open(struct inode * inode, struct file * filp)
request_module(module);
}
#endif
if (drive->driver == NULL)
ide_driver_module();
while (drive->busy)
sleep_on(&drive->wqueue);
++drive->usage;
if (ata_ops(drive) && ata_ops(drive)->open)
return ata_ops(drive)->open(inode, filp, drive);
......@@ -1787,7 +1495,8 @@ static int ide_open(struct inode * inode, struct file * filp)
}
printk(KERN_INFO "%s: driver not present\n", drive->name);
drive->usage--;
--drive->usage;
return -ENXIO;
}
......@@ -1808,219 +1517,6 @@ static int ide_release(struct inode * inode, struct file * file)
return 0;
}
void ide_unregister(struct ata_channel *ch)
{
struct gendisk *gd;
struct ata_device *d;
spinlock_t *lock;
int unit;
int i;
unsigned long flags;
unsigned int p, minor;
struct ata_channel old;
int n_irq;
int n_ch;
spin_lock_irqsave(&ide_lock, flags);
if (!ch->present)
goto abort;
put_device(&ch->dev);
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device * drive = &ch->drives[unit];
if (!drive->present)
continue;
if (drive->busy || drive->usage)
goto abort;
if (ata_ops(drive)) {
if (ata_ops(drive)->cleanup) {
if (ata_ops(drive)->cleanup(drive))
goto abort;
} else
ide_unregister_subdriver(drive);
}
}
ch->present = 0;
/*
* All clear? Then blow away the buffer cache
*/
spin_unlock_irqrestore(&ide_lock, flags);
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device * drive = &ch->drives[unit];
if (!drive->present)
continue;
minor = drive->select.b.unit << PARTN_BITS;
for (p = 0; p < (1<<PARTN_BITS); ++p) {
if (drive->part[p].nr_sects > 0) {
kdev_t devp = mk_kdev(ch->major, minor+p);
invalidate_device(devp, 0);
}
}
}
spin_lock_irqsave(&ide_lock, flags);
/*
* Note that we only release the standard ports, and do not even try to
* handle any extra ports allocated for weird IDE interface chipsets.
*/
if (ch->straight8) {
release_region(ch->io_ports[IDE_DATA_OFFSET], 8);
} else {
for (i = 0; i < 8; i++)
if (ch->io_ports[i])
release_region(ch->io_ports[i], 1);
}
if (ch->io_ports[IDE_CONTROL_OFFSET])
release_region(ch->io_ports[IDE_CONTROL_OFFSET], 1);
/* FIXME: check if we can remove this ifdef */
#if defined(CONFIG_AMIGA) || defined(CONFIG_MAC)
if (ch->io_ports[IDE_IRQ_OFFSET])
release_region(ch->io_ports[IDE_IRQ_OFFSET], 1);
#endif
/*
* Remove us from the lock group.
*/
lock = ch->lock;
d = ch->drive;
for (i = 0; i < MAX_DRIVES; ++i) {
struct ata_device *drive = &ch->drives[i];
if (drive->de) {
devfs_unregister (drive->de);
drive->de = NULL;
}
if (!drive->present)
continue;
/* FIXME: possibly unneccessary */
if (ch->drive == drive)
ch->drive = NULL;
if (drive->id != NULL) {
kfree(drive->id);
drive->id = NULL;
}
drive->present = 0;
blk_cleanup_queue(&drive->queue);
}
if (d->present)
ch->drive = d;
/*
* Free the irq if we were the only channel using it.
*
* Free the lock group if we were the only member.
*/
n_irq = n_ch = 0;
for (i = 0; i < MAX_HWIFS; ++i) {
struct ata_channel *tmp = &ide_hwifs[i];
if (!tmp->present)
continue;
if (tmp->irq == ch->irq)
++n_irq;
if (tmp->lock == ch->lock)
++n_ch;
}
if (n_irq == 1)
free_irq(ch->irq, ch);
if (n_ch == 1) {
kfree(ch->lock);
kfree(ch->active);
ch->lock = NULL;
ch->active = NULL;
}
#ifdef CONFIG_BLK_DEV_IDEDMA
ide_release_dma(ch);
#endif
/*
* Remove us from the kernel's knowledge.
*/
unregister_blkdev(ch->major, ch->name);
blk_dev[ch->major].data = NULL;
blk_dev[ch->major].queue = NULL;
blk_clear(ch->major);
gd = ch->gd;
if (gd) {
del_gendisk(gd);
kfree(gd->sizes);
kfree(gd->part);
if (gd->de_arr)
kfree (gd->de_arr);
if (gd->flags)
kfree (gd->flags);
kfree(gd);
ch->gd = NULL;
}
/*
* Reinitialize the channel handler, but preserve any special methods for
* it.
*/
old = *ch;
init_hwif_data(ch, ch->index);
ch->lock = old.lock;
ch->tuneproc = old.tuneproc;
ch->speedproc = old.speedproc;
ch->selectproc = old.selectproc;
ch->resetproc = old.resetproc;
ch->intrproc = old.intrproc;
ch->maskproc = old.maskproc;
ch->quirkproc = old.quirkproc;
ch->ata_read = old.ata_read;
ch->ata_write = old.ata_write;
ch->atapi_read = old.atapi_read;
ch->atapi_write = old.atapi_write;
ch->XXX_udma = old.XXX_udma;
ch->udma_enable = old.udma_enable;
ch->udma_start = old.udma_start;
ch->udma_stop = old.udma_stop;
ch->udma_read = old.udma_read;
ch->udma_write = old.udma_write;
ch->udma_irq_status = old.udma_irq_status;
ch->udma_timeout = old.udma_timeout;
ch->udma_irq_lost = old.udma_irq_lost;
ch->busproc = old.busproc;
ch->bus_state = old.bus_state;
ch->dma_base = old.dma_base;
ch->dma_extra = old.dma_extra;
ch->config_data = old.config_data;
ch->select_data = old.select_data;
ch->proc = old.proc;
/* FIXME: most propably this is always right:! */
#ifndef CONFIG_BLK_DEV_IDECS
ch->irq = old.irq;
#endif
ch->major = old.major;
ch->chipset = old.chipset;
ch->autodma = old.autodma;
ch->udma_four = old.udma_four;
#ifdef CONFIG_PCI
ch->pci_dev = old.pci_dev;
#endif
ch->straight8 = old.straight8;
abort:
spin_unlock_irqrestore(&ide_lock, flags);
}
/*
* Setup hw_regs_t structure described by parameters. You
* may set up the hw structure yourself OR use this routine to
......@@ -2051,119 +1547,6 @@ void ide_setup_ports(hw_regs_t *hw,
hw->ack_intr = ack_intr;
}
static int subdriver_match(struct ata_channel *channel, struct ata_operations *ops)
{
int count, unit;
if (!channel->present)
return 0;
count = 0;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &channel->drives[unit];
if (drive->present && !drive->driver) {
(*ops->attach)(drive);
if (drive->driver != NULL)
count++;
}
}
return count;
}
static struct ata_operations * subdriver_interator(struct ata_operations *prev)
{
struct ata_operations *tmp;
unsigned long flags;
spin_lock_irqsave(&ata_drivers_lock, flags);
/* Restart from beginning if current ata_operations was deallocated,
or if prev is NULL. */
for(tmp = ata_drivers; tmp != prev && tmp; tmp = tmp->next);
if (!tmp)
tmp = ata_drivers;
else
tmp = tmp->next;
spin_unlock_irqrestore(&ata_drivers_lock, flags);
return tmp;
}
/*
* Register an IDE interface, specifing exactly the registers etc
* Set init=1 iff calling before probes have taken place.
*/
int ide_register_hw(hw_regs_t *hw, struct ata_channel **hwifp)
{
int h;
int retry = 1;
struct ata_channel *ch;
struct ata_operations *subdriver;
do {
for (h = 0; h < MAX_HWIFS; ++h) {
ch = &ide_hwifs[h];
if (ch->hw.io_ports[IDE_DATA_OFFSET] == hw->io_ports[IDE_DATA_OFFSET])
goto found;
}
for (h = 0; h < MAX_HWIFS; ++h) {
ch = &ide_hwifs[h];
if ((!ch->present && (ch->unit == ATA_PRIMARY) && !initializing) ||
(!ch->hw.io_ports[IDE_DATA_OFFSET] && initializing))
goto found;
}
for (h = 0; h < MAX_HWIFS; ++h)
ide_unregister(&ide_hwifs[h]);
} while (retry--);
return -1;
found:
ide_unregister(ch);
if (ch->present)
return -1;
memcpy(&ch->hw, hw, sizeof(*hw));
memcpy(ch->io_ports, ch->hw.io_ports, sizeof(ch->hw.io_ports));
ch->irq = hw->irq;
ch->noprobe = 0;
ch->chipset = hw->chipset;
if (!initializing) {
ideprobe_init();
revalidate_drives();
/* FIXME: Do we really have to call it second time here?! */
ide_driver_module();
}
/* Look up whatever there is a subdriver, which will serve this
* device.
*/
subdriver = NULL;
while ((subdriver = subdriver_interator(subdriver))) {
if (subdriver_match(ch, subdriver) > 0)
break;
}
if (hwifp)
*hwifp = ch;
return (initializing || ch->present) ? h : -1;
}
/*
* Compatability function for existing drivers. If you want
* something different, use the function above.
*/
int ide_register(int arg1, int arg2, int irq)
{
hw_regs_t hw;
ide_init_hwif_ports(&hw, (ide_ioreg_t) arg1, (ide_ioreg_t) arg2, NULL);
hw.irq = irq;
return ide_register_hw(&hw, NULL);
}
int ide_spin_wait_hwgroup(struct ata_device *drive)
{
/* FIXME: Wait on a proper timer. Instead of playing games on the
......@@ -2189,40 +1572,6 @@ int ide_spin_wait_hwgroup(struct ata_device *drive)
return 0;
}
static int set_io_32bit(struct ata_device *drive, int arg)
{
if (drive->channel->no_io_32bit)
return -EIO;
drive->channel->io_32bit = arg;
return 0;
}
static int set_using_dma(struct ata_device *drive, int arg)
{
if (!drive->driver)
return -EPERM;
if (!drive->id || !(drive->id->capability & 1) || !drive->channel->XXX_udma)
return -EPERM;
udma_enable(drive, arg, 1);
return 0;
}
static int set_pio_mode(struct ata_device *drive, int arg)
{
if (!drive->channel->tuneproc)
return -ENOSYS;
if (drive->channel->tuneproc != NULL)
drive->channel->tuneproc(drive, (u8) arg);
return 0;
}
/*
* Delay for *at least* 50ms. As we don't know how much time is left
* until the next tick occurs, we wait an extra tick to be safe.
......@@ -2241,254 +1590,6 @@ void ide_delay_50ms (void)
#endif
}
/*
* Handle ioctls.
*
* NOTE: Due to ridiculous coding habbits in the hdparm utility we have to
* always return unsigned long in case we are returning simple values.
*/
static int ide_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
unsigned int major, minor;
struct ata_device *drive;
struct request rq;
kdev_t dev;
dev = inode->i_rdev;
major = major(dev);
minor = minor(dev);
if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
return -ENODEV;
/* Contrary to popular beleve we disallow even the reading of the ioctl
* values for users which don't have permission too. We do this becouse
* such information could be used by an attacker to deply a simple-user
* attack, which triggers bugs present only on a particular
* configuration.
*/
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
ide_init_drive_cmd(&rq);
switch (cmd) {
case HDIO_GET_32BIT: {
unsigned long val = drive->channel->io_32bit;
if (put_user(val, (unsigned long *) arg))
return -EFAULT;
return 0;
}
case HDIO_SET_32BIT: {
int val;
if (arg < 0 || arg > 1)
return -EINVAL;
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
val = set_io_32bit(drive, arg);
spin_unlock_irq(drive->channel->lock);
return val;
}
case HDIO_SET_PIO_MODE: {
int val;
if (arg < 0 || arg > 255)
return -EINVAL;
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
val = set_pio_mode(drive, arg);
spin_unlock_irq(drive->channel->lock);
return val;
}
case HDIO_GET_UNMASKINTR: {
unsigned long val = drive->channel->unmask;
if (put_user(val, (unsigned long *) arg))
return -EFAULT;
return 0;
}
case HDIO_SET_UNMASKINTR: {
if (arg < 0 || arg > 1)
return -EINVAL;
if (drive->channel->no_unmask)
return -EIO;
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
drive->channel->unmask = arg;
spin_unlock_irq(drive->channel->lock);
return 0;
}
case HDIO_GET_DMA: {
unsigned long val = drive->using_dma;
if (put_user(val, (unsigned long *) arg))
return -EFAULT;
return 0;
}
case HDIO_SET_DMA: {
int val;
if (arg < 0 || arg > 1)
return -EINVAL;
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
val = set_using_dma(drive, arg);
spin_unlock_irq(drive->channel->lock);
return val;
}
case HDIO_GETGEO: {
struct hd_geometry *loc = (struct hd_geometry *) arg;
unsigned short bios_cyl = drive->bios_cyl; /* truncate */
if (!loc || (drive->type != ATA_DISK && drive->type != ATA_FLOPPY))
return -EINVAL;
if (put_user(drive->bios_head, (byte *) &loc->heads))
return -EFAULT;
if (put_user(drive->bios_sect, (byte *) &loc->sectors))
return -EFAULT;
if (put_user(bios_cyl, (unsigned short *) &loc->cylinders))
return -EFAULT;
if (put_user((unsigned)drive->part[minor(inode->i_rdev)&PARTN_MASK].start_sect,
(unsigned long *) &loc->start))
return -EFAULT;
return 0;
}
case HDIO_GETGEO_BIG_RAW: {
struct hd_big_geometry *loc = (struct hd_big_geometry *) arg;
if (!loc || (drive->type != ATA_DISK && drive->type != ATA_FLOPPY))
return -EINVAL;
if (put_user(drive->head, (u8 *) &loc->heads))
return -EFAULT;
if (put_user(drive->sect, (u8 *) &loc->sectors))
return -EFAULT;
if (put_user(drive->cyl, (unsigned int *) &loc->cylinders))
return -EFAULT;
if (put_user((unsigned)drive->part[minor(inode->i_rdev)&PARTN_MASK].start_sect,
(unsigned long *) &loc->start))
return -EFAULT;
return 0;
}
case BLKRRPART: /* Re-read partition tables */
return ide_revalidate_disk(inode->i_rdev);
case HDIO_GET_IDENTITY:
if (minor(inode->i_rdev) & PARTN_MASK)
return -EINVAL;
if (drive->id == NULL)
return -ENOMSG;
if (copy_to_user((char *)arg, (char *)drive->id, sizeof(*drive->id)))
return -EFAULT;
return 0;
case HDIO_GET_NICE:
return put_user(drive->dsc_overlap << IDE_NICE_DSC_OVERLAP |
drive->atapi_overlap << IDE_NICE_ATAPI_OVERLAP,
(long *) arg);
case HDIO_DRIVE_CMD:
if (!capable(CAP_SYS_RAWIO))
return -EACCES;
return ide_cmd_ioctl(drive, arg);
case HDIO_SET_NICE:
if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP))))
return -EPERM;
drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1;
/* Only CD-ROM's and tapes support DSC overlap. */
if (drive->dsc_overlap && !(drive->type == ATA_ROM || drive->type == ATA_TAPE)) {
drive->dsc_overlap = 0;
return -EPERM;
}
return 0;
case BLKGETSIZE:
case BLKGETSIZE64:
case BLKROSET:
case BLKROGET:
case BLKFLSBUF:
case BLKSSZGET:
case BLKPG:
case BLKELVGET:
case BLKELVSET:
case BLKBSZGET:
case BLKBSZSET:
return blk_ioctl(inode->i_bdev, cmd, arg);
/*
* uniform packet command handling
*/
case CDROMEJECT:
case CDROMCLOSETRAY:
return block_ioctl(inode->i_bdev, cmd, arg);
case HDIO_GET_BUSSTATE:
if (put_user(drive->channel->bus_state, (long *)arg))
return -EFAULT;
return 0;
case HDIO_SET_BUSSTATE:
if (drive->channel->busproc)
drive->channel->busproc(drive, (int)arg);
return 0;
/* Now check whatever this particular ioctl has a device type
* specific implementation.
*/
default:
if (ata_ops(drive) && ata_ops(drive)->ioctl)
return ata_ops(drive)->ioctl(drive, inode, file, cmd, arg);
return -EINVAL;
}
}
static int ide_check_media_change(kdev_t i_rdev)
{
struct ata_device *drive;
......@@ -2537,642 +1638,28 @@ void ide_fixstring (byte *s, const int bytecount, const int byteswap)
*p++ = '\0';
}
/****************************************************************************
* FIXME: rewrite the following crap:
*/
/*
* stridx() returns the offset of c within s,
* or -1 if c is '\0' or not found within s.
*/
static int __init stridx (const char *s, char c)
{
char *i = strchr(s, c);
return (i && c) ? i - s : -1;
}
/*
* Parsing for ide_setup():
*
* 1. the first char of s must be '='.
* 2. if the remainder matches one of the supplied keywords,
* the index (1 based) of the keyword is negated and returned.
* 3. if the remainder is a series of no more than max_vals numbers
* separated by commas, the numbers are saved in vals[] and a
* count of how many were saved is returned. Base10 is assumed,
* and base16 is allowed when prefixed with "0x".
* 4. otherwise, zero is returned.
*/
static int __init match_parm (char *s, const char *keywords[], int vals[], int max_vals)
{
static const char *decimal = "0123456789";
static const char *hex = "0123456789abcdef";
int i, n;
if (*s++ == '=') {
/*
* Try matching against the supplied keywords,
* and return -(index+1) if we match one
*/
if (keywords != NULL) {
for (i = 0; *keywords != NULL; ++i) {
if (!strcmp(s, *keywords++))
return -(i+1);
}
}
/*
* Look for a series of no more than "max_vals"
* numeric values separated by commas, in base10,
* or base16 when prefixed with "0x".
* Return a count of how many were found.
*/
for (n = 0; (i = stridx(decimal, *s)) >= 0;) {
vals[n] = i;
while ((i = stridx(decimal, *++s)) >= 0)
vals[n] = (vals[n] * 10) + i;
if (*s == 'x' && !vals[n]) {
while ((i = stridx(hex, *++s)) >= 0)
vals[n] = (vals[n] * 0x10) + i;
}
if (++n == max_vals)
break;
if (*s == ',' || *s == ';')
++s;
}
if (!*s)
return n;
}
return 0; /* zero = nothing matched */
}
/*
* This gets called VERY EARLY during initialization, to handle kernel "command
* line" strings beginning with "hdx=" or "ide".It gets called even before the
* actual module gets initialized.
*
* Here is the complete set currently supported comand line options:
*
* "hdx=" is recognized for all "x" from "a" to "h", such as "hdc".
* "idex=" is recognized for all "x" from "0" to "3", such as "ide1".
*
* "hdx=noprobe" : drive may be present, but do not probe for it
* "hdx=none" : drive is NOT present, ignore cmos and do not probe
* "hdx=nowerr" : ignore the WRERR_STAT bit on this drive
* "hdx=cdrom" : drive is present, and is a cdrom drive
* "hdx=cyl,head,sect" : disk drive is present, with specified geometry
* "hdx=noremap" : do not remap 0->1 even though EZD was detected
* "hdx=autotune" : driver will attempt to tune interface speed
* to the fastest PIO mode supported,
* if possible for this drive only.
* Not fully supported by all chipset types,
* and quite likely to cause trouble with
* older/odd IDE drives.
*
* "hdx=slow" : insert a huge pause after each access to the data
* port. Should be used only as a last resort.
*
* "hdxlun=xx" : set the drive last logical unit.
* "hdx=flash" : allows for more than one ata_flash disk to be
* registered. In most cases, only one device
* will be present.
* "hdx=ide-scsi" : the return of the ide-scsi flag, this is useful for
* allowwing ide-floppy, ide-tape, and ide-cdrom|writers
* to use ide-scsi emulation on a device specific option.
* "idebus=xx" : inform IDE driver of VESA/PCI bus speed in MHz,
* where "xx" is between 20 and 66 inclusive,
* used when tuning chipset PIO modes.
* For PCI bus, 25 is correct for a P75 system,
* 30 is correct for P90,P120,P180 systems,
* and 33 is used for P100,P133,P166 systems.
* If in doubt, use idebus=33 for PCI.
* As for VLB, it is safest to not specify it.
*
* "idex=noprobe" : do not attempt to access/use this interface
* "idex=base" : probe for an interface at the address specified,
* where "base" is usually 0x1f0 or 0x170
* and "ctl" is assumed to be "base"+0x206
* "idex=base,ctl" : specify both base and ctl
* "idex=base,ctl,irq" : specify base, ctl, and irq number
* "idex=autotune" : driver will attempt to tune interface speed
* to the fastest PIO mode supported,
* for all drives on this interface.
* Not fully supported by all chipset types,
* and quite likely to cause trouble with
* older/odd IDE drives.
* "idex=noautotune" : driver will NOT attempt to tune interface speed
* This is the default for most chipsets,
* except the cmd640.
* "idex=serialize" : do not overlap operations on idex and ide(x^1)
* "idex=four" : four drives on idex and ide(x^1) share same ports
* "idex=reset" : reset interface before first use
* "idex=dma" : enable DMA by default on both drives if possible
* "idex=ata66" : informs the interface that it has an 80c cable
* for chipsets that are ATA-66 capable, but
* the ablity to bit test for detection is
* currently unknown.
* "ide=reverse" : Formerly called to pci sub-system, but now local.
*
* The following are valid ONLY on ide0, (except dc4030)
* and the defaults for the base,ctl ports must not be altered.
*
* "ide0=dtc2278" : probe/support DTC2278 interface
* "ide0=ht6560b" : probe/support HT6560B interface
* "ide0=cmd640_vlb" : *REQUIRED* for VLB cards with the CMD640 chip
* (not for PCI -- automatically detected)
* "ide0=qd65xx" : probe/support qd65xx interface
* "ide0=ali14xx" : probe/support ali14xx chipsets (ALI M1439, M1443, M1445)
* "ide0=umc8672" : probe/support umc8672 chipsets
* "idex=dc4030" : probe/support Promise DC4030VL interface
* "ide=doubler" : probe/support IDE doublers on Amiga
*/
int __init ide_setup (char *s)
{
int i, vals[3];
struct ata_channel *hwif;
struct ata_device *drive;
unsigned int hw, unit;
const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1);
const char max_hwif = '0' + (MAX_HWIFS - 1);
if (!strncmp(s, "hd=", 3)) /* hd= is for hd.c driver and not us */
return 0;
if (strncmp(s,"ide",3) &&
strncmp(s,"idebus",6) &&
strncmp(s,"hd",2)) /* hdx= & hdxlun= */
return 0;
printk(KERN_INFO "ide_setup: %s", s);
init_ide_data ();
#ifdef CONFIG_BLK_DEV_IDEDOUBLER
if (!strcmp(s, "ide=doubler")) {
extern int ide_doubler;
printk(KERN_INFO" : Enabled support for IDE doublers\n");
ide_doubler = 1;
return 1;
}
#endif
if (!strcmp(s, "ide=nodma")) {
printk(KERN_INFO "ATA: Prevented DMA\n");
noautodma = 1;
return 1;
}
#ifdef CONFIG_PCI
if (!strcmp(s, "ide=reverse")) {
ide_scan_direction = 1;
printk(" : Enabled support for IDE inverse scan order.\n");
return 1;
}
#endif
/*
* Look for drive options: "hdx="
*/
if (!strncmp(s, "hd", 2) && s[2] >= 'a' && s[2] <= max_drive) {
const char *hd_words[] = {"none", "noprobe", "nowerr", "cdrom",
"serialize", "autotune", "noautotune",
"slow", "flash", "remap", "noremap", "scsi", NULL};
unit = s[2] - 'a';
hw = unit / MAX_DRIVES;
unit = unit % MAX_DRIVES;
hwif = &ide_hwifs[hw];
drive = &hwif->drives[unit];
if (!strncmp(s + 4, "ide-", 4)) {
strncpy(drive->driver_req, s + 4, 9);
goto done;
}
/*
* Look for last lun option: "hdxlun="
*/
if (!strncmp(&s[3], "lun", 3)) {
if (match_parm(&s[6], NULL, vals, 1) != 1)
goto bad_option;
if (vals[0] >= 0 && vals[0] <= 7) {
drive->last_lun = vals[0];
drive->forced_lun = 1;
} else
printk(" -- BAD LAST LUN! Expected value from 0 to 7");
goto done;
}
switch (match_parm(&s[3], hd_words, vals, 3)) {
case -1: /* "none" */
drive->nobios = 1; /* drop into "noprobe" */
case -2: /* "noprobe" */
drive->noprobe = 1;
goto done;
case -3: /* "nowerr" */
drive->bad_wstat = BAD_R_STAT;
hwif->noprobe = 0;
goto done;
case -4: /* "cdrom" */
drive->present = 1;
drive->type = ATA_ROM;
hwif->noprobe = 0;
goto done;
case -5: /* "serialize" */
printk(" -- USE \"ide%d=serialize\" INSTEAD", hw);
goto do_serialize;
case -6: /* "autotune" */
drive->autotune = 1;
goto done;
case -7: /* "noautotune" */
drive->autotune = 2;
goto done;
case -8: /* "slow" */
hwif->slow = 1;
goto done;
case -9: /* "flash" */
drive->ata_flash = 1;
goto done;
case -10: /* "remap" */
drive->remap_0_to_1 = 1;
goto done;
case -11: /* "noremap" */
drive->remap_0_to_1 = 2;
goto done;
case -12: /* "scsi" */
#if defined(CONFIG_BLK_DEV_IDESCSI) && defined(CONFIG_SCSI)
drive->scsi = 1;
goto done;
#else
drive->scsi = 0;
goto bad_option;
#endif
case 3: /* cyl,head,sect */
drive->type = ATA_DISK;
drive->cyl = drive->bios_cyl = vals[0];
drive->head = drive->bios_head = vals[1];
drive->sect = drive->bios_sect = vals[2];
drive->present = 1;
drive->forced_geom = 1;
hwif->noprobe = 0;
goto done;
default:
goto bad_option;
}
}
/*
* Look for bus speed option: "idebus="
*/
if (!strncmp(s, "idebus", 6)) {
if (match_parm(&s[6], NULL, vals, 1) != 1)
goto bad_option;
idebus_parameter = vals[0];
goto done;
}
/*
* Look for interface options: "idex="
*/
if (!strncmp(s, "ide", 3) && s[3] >= '0' && s[3] <= max_hwif) {
/*
* Be VERY CAREFUL changing this: note hardcoded indexes below
* -8,-9,-10. -11 : are reserved for future idex calls to ease the hardcoding.
*/
const char *ide_words[] = {
"noprobe", "serialize", "autotune", "noautotune", "reset", "dma", "ata66",
"minus8", "minus9", "minus10", "minus11",
"qd65xx", "ht6560b", "cmd640_vlb", "dtc2278", "umc8672", "ali14xx", "dc4030", NULL };
hw = s[3] - '0';
hwif = &ide_hwifs[hw];
i = match_parm(&s[4], ide_words, vals, 3);
/*
* Cryptic check to ensure chipset not already set for hwif:
*/
if (i > 0 || i <= -11) { /* is parameter a chipset name? */
if (hwif->chipset != ide_unknown)
goto bad_option; /* chipset already specified */
if (i <= -11 && i != -18 && hw != 0)
goto bad_hwif; /* chipset drivers are for "ide0=" only */
if (i <= -11 && i != -18 && ide_hwifs[hw+1].chipset != ide_unknown)
goto bad_option; /* chipset for 2nd port already specified */
printk("\n");
}
switch (i) {
#ifdef CONFIG_BLK_DEV_PDC4030
case -18: /* "dc4030" */
{
extern void init_pdc4030(void);
init_pdc4030();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_ALI14XX
case -17: /* "ali14xx" */
{
extern void init_ali14xx (void);
init_ali14xx();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_UMC8672
case -16: /* "umc8672" */
{
extern void init_umc8672 (void);
init_umc8672();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_DTC2278
case -15: /* "dtc2278" */
{
extern void init_dtc2278 (void);
init_dtc2278();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_CMD640
case -14: /* "cmd640_vlb" */
{
extern int cmd640_vlb; /* flag for cmd640.c */
cmd640_vlb = 1;
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_HT6560B
case -13: /* "ht6560b" */
{
extern void init_ht6560b (void);
init_ht6560b();
goto done;
}
#endif
#if CONFIG_BLK_DEV_QD65XX
case -12: /* "qd65xx" */
{
extern void init_qd65xx (void);
init_qd65xx();
goto done;
}
#endif
case -11: /* minus11 */
case -10: /* minus10 */
case -9: /* minus9 */
case -8: /* minus8 */
goto bad_option;
case -7: /* ata66 */
#ifdef CONFIG_PCI
hwif->udma_four = 1;
goto done;
#else
hwif->udma_four = 0;
goto bad_hwif;
#endif
case -6: /* dma */
hwif->autodma = 1;
goto done;
case -5: /* "reset" */
hwif->reset = 1;
goto done;
case -4: /* "noautotune" */
hwif->drives[0].autotune = 2;
hwif->drives[1].autotune = 2;
goto done;
case -3: /* "autotune" */
hwif->drives[0].autotune = 1;
hwif->drives[1].autotune = 1;
goto done;
case -2: /* "serialize" */
do_serialize:
{
struct ata_channel *mate;
mate = &ide_hwifs[hw ^ 1];
hwif->serialized = 1;
mate->serialized = 1;
}
goto done;
case -1: /* "noprobe" */
hwif->noprobe = 1;
goto done;
case 1: /* base */
vals[1] = vals[0] + 0x206; /* default ctl */
case 2: /* base,ctl */
vals[2] = 0; /* default irq = probe for it */
case 3: /* base,ctl,irq */
hwif->hw.irq = vals[2];
ide_init_hwif_ports(&hwif->hw, (ide_ioreg_t) vals[0], (ide_ioreg_t) vals[1], &hwif->irq);
memcpy(hwif->io_ports, hwif->hw.io_ports, sizeof(hwif->io_ports));
hwif->irq = vals[2];
hwif->noprobe = 0;
hwif->chipset = ide_generic;
goto done;
case 0: goto bad_option;
default:
printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n");
return 1;
}
}
bad_option:
printk(" -- BAD OPTION\n");
return 1;
bad_hwif:
printk("-- NOT SUPPORTED ON ide%d", hw);
done:
printk("\n");
return 1;
}
/****************************************************************************/
/* This is the default end request function as well */
int ide_end_request(struct ata_device *drive, struct request *rq, int uptodate)
{
return __ide_end_request(drive, rq, uptodate, 0);
}
/*
* This is in fact registering a device not a driver.
*/
int ide_register_subdriver(struct ata_device *drive, struct ata_operations *driver)
{
unsigned long flags;
save_flags(flags); /* all CPUs */
cli(); /* all CPUs */
if (!drive->present || drive->driver != NULL || drive->busy || drive->usage) {
restore_flags(flags); /* all CPUs */
return 1;
}
/* FIXME: This will be pushed to the drivers! Thus allowing us to
* save one parameter here separate this out.
*/
drive->driver = driver;
restore_flags(flags); /* all CPUs */
/* FIXME: Check what this magic number is supposed to be about? */
if (drive->autotune != 2) {
if (drive->channel->XXX_udma) {
/*
* Force DMAing for the beginning of the check. Some
* chipsets appear to do interesting things, if not
* checked and cleared.
*
* PARANOIA!!!
*/
udma_enable(drive, 0, 0);
drive->channel->XXX_udma(drive);
#ifdef CONFIG_BLK_DEV_IDE_TCQ_DEFAULT
udma_tcq_enable(drive, 1);
#endif
}
/* Only CD-ROMs and tape drives support DSC overlap. But only
* if they are alone on a channel. */
if (drive->type == ATA_ROM || drive->type == ATA_TAPE) {
int single = 0;
int unit;
for (unit = 0; unit < MAX_DRIVES; ++unit)
if (drive->channel->drives[unit].present)
++single;
drive->dsc_overlap = (single == 1);
} else
drive->dsc_overlap = 0;
}
drive->revalidate = 1;
drive->suspend_reset = 0;
return 0;
}
/*
* This is in fact the default cleanup routine.
*
* FIXME: Check whatever we maybe don't call it twice!.
*/
int ide_unregister_subdriver(struct ata_device *drive)
{
unsigned long flags;
save_flags(flags); /* all CPUs */
cli(); /* all CPUs */
#if 0
if (__MOD_IN_USE(ata_ops(drive)->owner)) {
restore_flags(flags);
return 1;
}
#endif
if (drive->usage || drive->busy || !ata_ops(drive)) {
restore_flags(flags); /* all CPUs */
return 1;
}
#if defined(CONFIG_BLK_DEV_ISAPNP) && defined(CONFIG_ISAPNP) && defined(MODULE)
pnpide_init(0);
#endif
drive->driver = NULL;
restore_flags(flags); /* all CPUs */
return 0;
}
/*
* Register an ATA subdriver for a particular device type.
*/
int register_ata_driver(struct ata_operations *driver)
{
unsigned long flags;
int index;
int count = 0;
spin_lock_irqsave(&ata_drivers_lock, flags);
driver->next = ata_drivers;
ata_drivers = driver;
spin_unlock_irqrestore(&ata_drivers_lock, flags);
for (index = 0; index < MAX_HWIFS; ++index)
count += subdriver_match(&ide_hwifs[index], driver);
return count;
}
EXPORT_SYMBOL(register_ata_driver);
/*
* Unregister an ATA subdriver for a particular device type.
*/
void unregister_ata_driver(struct ata_operations *driver)
{
struct ata_operations **tmp;
unsigned long flags;
int index;
int unit;
spin_lock_irqsave(&ata_drivers_lock, flags);
for (tmp = &ata_drivers; *tmp != NULL; tmp = &(*tmp)->next) {
if (*tmp == driver) {
*tmp = driver->next;
break;
}
}
spin_unlock_irqrestore(&ata_drivers_lock, flags);
for (index = 0; index < MAX_HWIFS; ++index) {
struct ata_channel *ch = &ide_hwifs[index];
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (drive->driver == driver)
(*ata_ops(drive)->cleanup)(drive);
}
}
}
EXPORT_SYMBOL(unregister_ata_driver);
struct block_device_operations ide_fops[] = {{
owner: THIS_MODULE,
open: ide_open,
release: ide_release,
ioctl: ide_ioctl,
ioctl: ata_ioctl,
check_media_change: ide_check_media_change,
revalidate: ide_revalidate_disk
revalidate: ata_revalidate
}};
EXPORT_SYMBOL(ide_fops);
EXPORT_SYMBOL(ide_hwifs);
EXPORT_SYMBOL(ide_spin_wait_hwgroup);
devfs_handle_t ide_devfs_handle;
EXPORT_SYMBOL(ide_lock);
EXPORT_SYMBOL(drive_is_flashcard);
EXPORT_SYMBOL(ide_timer_expiry);
EXPORT_SYMBOL(do_ide_request);
EXPORT_SYMBOL(ide_register_subdriver);
EXPORT_SYMBOL(ide_unregister_subdriver);
EXPORT_SYMBOL(ide_set_handler);
EXPORT_SYMBOL(ide_dump_status);
EXPORT_SYMBOL(ide_error);
......@@ -3182,324 +1669,7 @@ EXPORT_SYMBOL(restart_request);
EXPORT_SYMBOL(ide_end_drive_cmd);
EXPORT_SYMBOL(__ide_end_request);
EXPORT_SYMBOL(ide_end_request);
EXPORT_SYMBOL(ide_revalidate_disk);
EXPORT_SYMBOL(ide_delay_50ms);
EXPORT_SYMBOL(ide_stall_queue);
EXPORT_SYMBOL(ide_register_hw);
EXPORT_SYMBOL(ide_register);
EXPORT_SYMBOL(ide_unregister);
EXPORT_SYMBOL(ide_setup_ports);
EXPORT_SYMBOL(get_info_ptr);
/*
* Handle power handling related events ths system informs us about.
*/
static int ata_sys_notify(struct notifier_block *this, unsigned long event, void *x)
{
int i;
switch (event) {
case SYS_HALT:
case SYS_POWER_OFF:
case SYS_RESTART:
break;
default:
return NOTIFY_DONE;
}
printk("flushing ide devices: ");
for (i = 0; i < MAX_HWIFS; i++) {
int unit;
struct ata_channel *ch = &ide_hwifs[i];
if (!ch->present)
continue;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (!drive->present)
continue;
/* set the drive to standby */
printk("%s ", drive->name);
if (ata_ops(drive)) {
if (event != SYS_RESTART)
if (ata_ops(drive)->standby && ata_ops(drive)->standby(drive))
continue;
if (ata_ops(drive)->cleanup)
ata_ops(drive)->cleanup(drive);
}
}
}
printk("\n");
return NOTIFY_DONE;
}
static struct notifier_block ata_notifier = {
ata_sys_notify,
NULL,
5
};
/*
* This is the global initialization entry point.
*/
static int __init ata_module_init(void)
{
int h;
printk(KERN_INFO "ATA/ATAPI device driver v" VERSION "\n");
ide_devfs_handle = devfs_mk_dir (NULL, "ide", NULL);
/*
* Because most of the ATA adapters represent the timings in unit of
* bus clocks, and there is no known reliable way to detect the bus
* clock frequency, we assume 50 MHz for non-PCI (VLB, EISA) and 33 MHz
* for PCI based systems. Since assuming only hurts performance and not
* stability, this is OK. The user can change this on the command line
* by using the "idebus=XX" parameter. While the system_bus_speed
* variable is in kHz units, we accept both MHz and kHz entry on the
* command line for backward compatibility.
*/
system_bus_speed = 50000;
if (pci_present())
system_bus_speed = 33333;
if (idebus_parameter >= 20 && idebus_parameter <= 80) {
system_bus_speed = idebus_parameter * 1000;
switch (system_bus_speed) {
case 33000: system_bus_speed = 33333; break;
case 37000: system_bus_speed = 37500; break;
case 41000: system_bus_speed = 41666; break;
case 66000: system_bus_speed = 66666; break;
}
}
if (idebus_parameter >= 20000 && idebus_parameter <= 80000)
system_bus_speed = idebus_parameter;
printk(KERN_INFO "ATA: %s bus speed %d.%dMHz\n",
pci_present() ? "PCI" : "System", system_bus_speed / 1000, system_bus_speed / 100 % 10);
init_ide_data();
initializing = 1;
#ifdef CONFIG_PCI
/*
* Register the host chip drivers.
*/
# ifdef CONFIG_BLK_DEV_PIIX
init_piix();
# endif
# ifdef CONFIG_BLK_DEV_VIA82CXXX
init_via82cxxx();
# endif
# ifdef CONFIG_BLK_DEV_PDC202XX
init_pdc202xx();
# endif
# ifdef CONFIG_BLK_DEV_RZ1000
init_rz1000();
# endif
# ifdef CONFIG_BLK_DEV_SIS5513
init_sis5513();
# endif
# ifdef CONFIG_BLK_DEV_CMD64X
init_cmd64x();
# endif
# ifdef CONFIG_BLK_DEV_OPTI621
init_opti621();
# endif
# ifdef CONFIG_BLK_DEV_TRM290
init_trm290();
# endif
# ifdef CONFIG_BLK_DEV_NS87415
init_ns87415();
# endif
# ifdef CONFIG_BLK_DEV_AEC62XX
init_aec62xx();
# endif
# ifdef CONFIG_BLK_DEV_SL82C105
init_sl82c105();
# endif
# ifdef CONFIG_BLK_DEV_HPT34X
init_hpt34x();
# endif
# ifdef CONFIG_BLK_DEV_HPT366
init_hpt366();
# endif
# ifdef CONFIG_BLK_DEV_ALI15X3
init_ali15x3();
# endif
# ifdef CONFIG_BLK_DEV_CY82C693
init_cy82c693();
# endif
# ifdef CONFIG_BLK_DEV_CS5530
init_cs5530();
# endif
# ifdef CONFIG_BLK_DEV_AMD74XX
init_amd74xx();
# endif
# ifdef CONFIG_BLK_DEV_SVWKS
init_svwks();
# endif
# ifdef CONFIG_BLK_DEV_IT8172
init_it8172();
# endif
init_ata_pci_misc();
/*
* Detect and initialize "known" IDE host chip types.
*/
if (pci_present()) {
# ifdef CONFIG_PCI
ide_scan_pcibus(ide_scan_direction);
# else
# ifdef CONFIG_BLK_DEV_RZ1000
ide_probe_for_rz100x();
# endif
# endif
}
#endif
#ifdef CONFIG_ETRAX_IDE
init_e100_ide();
#endif
#ifdef CONFIG_BLK_DEV_CMD640
ide_probe_for_cmd640x();
#endif
#ifdef CONFIG_BLK_DEV_PDC4030
ide_probe_for_pdc4030();
#endif
#ifdef CONFIG_BLK_DEV_IDE_PMAC
pmac_ide_probe();
#endif
#ifdef CONFIG_BLK_DEV_IDE_ICSIDE
icside_init();
#endif
#ifdef CONFIG_BLK_DEV_IDE_RAPIDE
rapide_init();
#endif
#ifdef CONFIG_BLK_DEV_GAYLE
gayle_init();
#endif
#ifdef CONFIG_BLK_DEV_FALCON_IDE
falconide_init();
#endif
#ifdef CONFIG_BLK_DEV_MAC_IDE
macide_init();
#endif
#ifdef CONFIG_BLK_DEV_Q40IDE
q40ide_init();
#endif
#ifdef CONFIG_BLK_DEV_BUDDHA
buddha_init();
#endif
#if defined(CONFIG_BLK_DEV_ISAPNP) && defined(CONFIG_ISAPNP)
pnpide_init(1);
#endif
#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
# if defined(__mc68000__) || defined(CONFIG_APUS)
if (ide_hwifs[0].io_ports[IDE_DATA_OFFSET]) {
// ide_get_lock(&irq_lock, NULL, NULL);/* for atari only */
disable_irq(ide_hwifs[0].irq); /* disable_irq_nosync ?? */
// disable_irq_nosync(ide_hwifs[0].irq);
}
# endif
ideprobe_init();
# if defined(__mc68000__) || defined(CONFIG_APUS)
if (ide_hwifs[0].io_ports[IDE_DATA_OFFSET]) {
enable_irq(ide_hwifs[0].irq);
ide_release_lock(&irq_lock);/* for atari only */
}
# endif
#endif
/*
* Initialize all device type driver modules.
*/
#ifdef CONFIG_BLK_DEV_IDEDISK
idedisk_init();
#endif
#ifdef CONFIG_BLK_DEV_IDECD
ide_cdrom_init();
#endif
#ifdef CONFIG_BLK_DEV_IDETAPE
idetape_init();
#endif
#ifdef CONFIG_BLK_DEV_IDEFLOPPY
idefloppy_init();
#endif
#ifdef CONFIG_BLK_DEV_IDESCSI
# ifdef CONFIG_SCSI
idescsi_init();
# else
#error ATA SCSI emulation selected but no SCSI-subsystem in kernel
# endif
#endif
initializing = 0;
for (h = 0; h < MAX_HWIFS; ++h) {
struct ata_channel *channel = &ide_hwifs[h];
if (channel->present)
ide_geninit(channel);
}
register_reboot_notifier(&ata_notifier);
return 0;
}
static char *options = NULL;
static int __init init_ata(void)
{
if (options != NULL && *options) {
char *next = options;
while ((options = next) != NULL) {
if ((next = strchr(options,' ')) != NULL)
*next++ = 0;
if (!ide_setup(options))
printk(KERN_ERR "Unknown option '%s'\n", options);
}
}
return ata_module_init();
}
static void __exit cleanup_ata(void)
{
int h;
unregister_reboot_notifier(&ata_notifier);
for (h = 0; h < MAX_HWIFS; ++h) {
ide_unregister(&ide_hwifs[h]);
}
devfs_unregister(ide_devfs_handle);
}
module_init(init_ata);
module_exit(cleanup_ata);
#ifndef MODULE
/* command line option parser */
__setup("", ide_setup);
#endif
drivers/ide/ioctl.c 0 → 100644
View file @ 4478f040
/**** vi:set ts=8 sts=8 sw=8:************************************************
*
* Copyright (C) 2002 Marcin Dalecki <martin@dalecki.de>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*/
/*
* Generic ioctl handling for all ATA/ATAPI device drivers.
*/
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/blkpg.h>
#include <linux/pci.h>
#include <linux/cdrom.h>
#include <linux/device.h>
#include <linux/ide.h>
#include <asm/uaccess.h>
#include "ioctl.h"
/*
* NOTE: Due to ridiculous coding habbits in the hdparm utility we have to
* always return unsigned long in case we are returning simple values.
*/
int ata_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
unsigned int major, minor;
struct ata_device *drive;
struct request rq;
kdev_t dev;
dev = inode->i_rdev;
major = major(dev);
minor = minor(dev);
if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
return -ENODEV;
/* Contrary to popular beleve we disallow even the reading of the ioctl
* values for users which don't have permission too. We do this becouse
* such information could be used by an attacker to deply a simple-user
* attack, which triggers bugs present only on a particular
* configuration.
*/
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
ide_init_drive_cmd(&rq);
switch (cmd) {
case HDIO_GET_32BIT: {
unsigned long val = drive->channel->io_32bit;
if (put_user(val, (unsigned long *) arg))
return -EFAULT;
return 0;
}
case HDIO_SET_32BIT:
if (arg < 0 || arg > 1)
return -EINVAL;
if (drive->channel->no_io_32bit)
return -EIO;
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
drive->channel->io_32bit = arg;
spin_unlock_irq(drive->channel->lock);
return 0;
case HDIO_SET_PIO_MODE:
if (arg < 0 || arg > 255)
return -EINVAL;
if (!drive->channel->tuneproc)
return -ENOSYS;
/* FIXME: we can see that tuneproc whould do the
* locking!.
*/
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
drive->channel->tuneproc(drive, (u8) arg);
spin_unlock_irq(drive->channel->lock);
return 0;
case HDIO_GET_UNMASKINTR: {
unsigned long val = drive->channel->unmask;
if (put_user(val, (unsigned long *) arg))
return -EFAULT;
return 0;
}
case HDIO_SET_UNMASKINTR:
if (arg < 0 || arg > 1)
return -EINVAL;
if (drive->channel->no_unmask)
return -EIO;
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
drive->channel->unmask = arg;
spin_unlock_irq(drive->channel->lock);
return 0;
case HDIO_GET_DMA: {
unsigned long val = drive->using_dma;
if (put_user(val, (unsigned long *) arg))
return -EFAULT;
return 0;
}
case HDIO_SET_DMA:
if (arg < 0 || arg > 1)
return -EINVAL;
if (!drive->driver)
return -EPERM;
if (!drive->id || !(drive->id->capability & 1) || !drive->channel->XXX_udma)
return -EPERM;
if (ide_spin_wait_hwgroup(drive))
return -EBUSY;
udma_enable(drive, arg, 1);
spin_unlock_irq(drive->channel->lock);
return 0;
case HDIO_GETGEO: {
struct hd_geometry *loc = (struct hd_geometry *) arg;
unsigned short bios_cyl = drive->bios_cyl; /* truncate */
if (!loc || (drive->type != ATA_DISK && drive->type != ATA_FLOPPY))
return -EINVAL;
if (put_user(drive->bios_head, (byte *) &loc->heads))
return -EFAULT;
if (put_user(drive->bios_sect, (byte *) &loc->sectors))
return -EFAULT;
if (put_user(bios_cyl, (unsigned short *) &loc->cylinders))
return -EFAULT;
if (put_user((unsigned)drive->part[minor(inode->i_rdev)&PARTN_MASK].start_sect,
(unsigned long *) &loc->start))
return -EFAULT;
return 0;
}
case HDIO_GETGEO_BIG_RAW: {
struct hd_big_geometry *loc = (struct hd_big_geometry *) arg;
if (!loc || (drive->type != ATA_DISK && drive->type != ATA_FLOPPY))
return -EINVAL;
if (put_user(drive->head, (u8 *) &loc->heads))
return -EFAULT;
if (put_user(drive->sect, (u8 *) &loc->sectors))
return -EFAULT;
if (put_user(drive->cyl, (unsigned int *) &loc->cylinders))
return -EFAULT;
if (put_user((unsigned)drive->part[minor(inode->i_rdev)&PARTN_MASK].start_sect,
(unsigned long *) &loc->start))
return -EFAULT;
return 0;
}
case BLKRRPART: /* Re-read partition tables */
return ata_revalidate(inode->i_rdev);
case HDIO_GET_IDENTITY:
if (minor(inode->i_rdev) & PARTN_MASK)
return -EINVAL;
if (drive->id == NULL)
return -ENOMSG;
if (copy_to_user((char *)arg, (char *)drive->id, sizeof(*drive->id)))
return -EFAULT;
return 0;
case HDIO_GET_NICE:
return put_user(drive->dsc_overlap << IDE_NICE_DSC_OVERLAP |
drive->atapi_overlap << IDE_NICE_ATAPI_OVERLAP,
(long *) arg);
case HDIO_DRIVE_CMD:
if (!capable(CAP_SYS_RAWIO))
return -EACCES;
return ide_cmd_ioctl(drive, arg);
case HDIO_SET_NICE:
if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP))))
return -EPERM;
drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1;
/* Only CD-ROM's and tapes support DSC overlap. */
if (drive->dsc_overlap && !(drive->type == ATA_ROM || drive->type == ATA_TAPE)) {
drive->dsc_overlap = 0;
return -EPERM;
}
return 0;
case BLKGETSIZE:
case BLKGETSIZE64:
case BLKROSET:
case BLKROGET:
case BLKFLSBUF:
case BLKSSZGET:
case BLKPG:
case BLKELVGET:
case BLKELVSET:
case BLKBSZGET:
case BLKBSZSET:
return blk_ioctl(inode->i_bdev, cmd, arg);
/*
* uniform packet command handling
*/
case CDROMEJECT:
case CDROMCLOSETRAY:
return block_ioctl(inode->i_bdev, cmd, arg);
case HDIO_GET_BUSSTATE:
if (put_user(drive->channel->bus_state, (long *)arg))
return -EFAULT;
return 0;
case HDIO_SET_BUSSTATE:
if (drive->channel->busproc)
drive->channel->busproc(drive, (int)arg);
return 0;
/* Now check whatever this particular ioctl has a device type
* specific implementation.
*/
default:
if (ata_ops(drive) && ata_ops(drive)->ioctl)
return ata_ops(drive)->ioctl(drive, inode, file, cmd, arg);
return -EINVAL;
}
}
drivers/ide/ioctl.h 0 → 100644
View file @ 4478f040
/**** vi:set ts=8 sts=8 sw=8:************************************************
*
* Copyright (C) 2002 Marcin Dalecki <martin@dalecki.de>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*/
extern int ata_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
drivers/ide/main.c 0 → 100644
View file @ 4478f040
/**** vi:set ts=8 sts=8 sw=8:************************************************
*
* Copyright (C) 1994-1998,2002 Linus Torvalds and authors:
*
* Mark Lord <mlord@pobox.com>
* Gadi Oxman <gadio@netvision.net.il>
* Andre Hedrick <andre@linux-ide.org>
* Jens Axboe <axboe@suse.de>
* Marcin Dalecki <martin@dalecki.de>
*
* See linux/MAINTAINERS for address of current maintainer.
*/
/*
* Handle overall infrastructure of the driver
*/
#define VERSION "7.0.0"
#include <linux/config.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/blkpg.h>
#include <linux/slab.h>
#ifndef MODULE
# include <linux/init.h>
#endif
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/reboot.h>
#include <linux/cdrom.h>
#include <linux/device.h>
#include <linux/kmod.h>
#include <asm/byteorder.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/bitops.h>
#include "ata-timing.h"
#include "pcihost.h"
#include "ioctl.h"
MODULE_DESCRIPTION("ATA/ATAPI driver infrastructure");
MODULE_PARM(options,"s");
MODULE_LICENSE("GPL");
/*
* Those will be moved into separate header files eventually.
*/
#ifdef CONFIG_ETRAX_IDE
extern void init_e100_ide(void);
#endif
#ifdef CONFIG_BLK_DEV_CMD640
extern void ide_probe_for_cmd640x(void);
#endif
#ifdef CONFIG_BLK_DEV_PDC4030
extern int ide_probe_for_pdc4030(void);
#endif
#ifdef CONFIG_BLK_DEV_IDE_PMAC
extern void pmac_ide_probe(void);
#endif
#ifdef CONFIG_BLK_DEV_IDE_ICSIDE
extern void icside_init(void);
#endif
#ifdef CONFIG_BLK_DEV_IDE_RAPIDE
extern void rapide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_GAYLE
extern void gayle_init(void);
#endif
#ifdef CONFIG_BLK_DEV_FALCON_IDE
extern void falconide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_MAC_IDE
extern void macide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_Q40IDE
extern void q40ide_init(void);
#endif
#ifdef CONFIG_BLK_DEV_BUDDHA
extern void buddha_init(void);
#endif
#if defined(CONFIG_BLK_DEV_ISAPNP) && defined(CONFIG_ISAPNP)
extern void pnpide_init(int);
#endif
/* default maximum number of failures */
#define IDE_DEFAULT_MAX_FAILURES 1
int system_bus_speed; /* holds what we think is VESA/PCI bus speed */
static int initializing; /* set while initializing built-in drivers */
static int idebus_parameter; /* the "idebus=" parameter */
/*
* Protects access to global structures etc.
*/
spinlock_t ide_lock __cacheline_aligned = SPIN_LOCK_UNLOCKED;
#ifdef CONFIG_PCI
static int ide_scan_direction; /* THIS was formerly 2.2.x pci=reverse */
#endif
#if defined(__mc68000__) || defined(CONFIG_APUS)
/*
* This is used by the Atari code to obtain access to the IDE interrupt,
* which is shared between several drivers.
*/
static int irq_lock;
#endif
int noautodma = 0;
/* Single linked list of sub device type drivers */
static struct ata_operations *ata_drivers; /* = NULL */
static spinlock_t ata_drivers_lock = SPIN_LOCK_UNLOCKED;
/*
* This is declared extern in ide.h, for access by other IDE modules:
*/
struct ata_channel ide_hwifs[MAX_HWIFS]; /* master data repository */
static void init_hwif_data(struct ata_channel *ch, unsigned int index)
{
static const unsigned int majors[] = {
IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR, IDE4_MAJOR,
IDE5_MAJOR, IDE6_MAJOR, IDE7_MAJOR, IDE8_MAJOR, IDE9_MAJOR
};
unsigned int unit;
hw_regs_t hw;
/* bulk initialize channel & drive info with zeros */
memset(ch, 0, sizeof(struct ata_channel));
memset(&hw, 0, sizeof(hw_regs_t));
/* fill in any non-zero initial values */
ch->index = index;
ide_init_hwif_ports(&hw, ide_default_io_base(index), 0, &ch->irq);
memcpy(&ch->hw, &hw, sizeof(hw));
memcpy(ch->io_ports, hw.io_ports, sizeof(hw.io_ports));
ch->noprobe = !ch->io_ports[IDE_DATA_OFFSET];
#ifdef CONFIG_BLK_DEV_HD
if (ch->io_ports[IDE_DATA_OFFSET] == HD_DATA)
ch->noprobe = 1; /* may be overridden by ide_setup() */
#endif
ch->major = majors[index];
sprintf(ch->name, "ide%d", index);
ch->bus_state = BUSSTATE_ON;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
drive->type = ATA_DISK;
drive->select.all = (unit<<4)|0xa0;
drive->channel = ch;
drive->ctl = 0x08;
drive->ready_stat = READY_STAT;
drive->bad_wstat = BAD_W_STAT;
sprintf(drive->name, "hd%c", 'a' + (index * MAX_DRIVES) + unit);
drive->max_failures = IDE_DEFAULT_MAX_FAILURES;
init_waitqueue_head(&drive->wqueue);
}
}
extern struct block_device_operations ide_fops[];
/*
* This is called exactly *once* for each channel.
*/
void ide_geninit(struct ata_channel *ch)
{
unsigned int unit;
struct gendisk *gd = ch->gd;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (!drive->present)
continue;
if (drive->type != ATA_DISK && drive->type != ATA_FLOPPY)
continue;
register_disk(gd,mk_kdev(ch->major,unit<<PARTN_BITS),
#ifdef CONFIG_BLK_DEV_ISAPNP
(drive->forced_geom && drive->noprobe) ? 1 :
#endif
1 << PARTN_BITS, ide_fops, ata_capacity(drive));
}
}
/*
* Returns the (struct ata_device *) for a given device number. Return
* NULL if the given device number does not match any present drives.
*/
struct ata_device *get_info_ptr(kdev_t i_rdev)
{
unsigned int major = major(i_rdev);
int h;
for (h = 0; h < MAX_HWIFS; ++h) {
struct ata_channel *ch = &ide_hwifs[h];
if (ch->present && major == ch->major) {
int unit = DEVICE_NR(i_rdev);
if (unit < MAX_DRIVES) {
struct ata_device *drive = &ch->drives[unit];
if (drive->present)
return drive;
}
break;
}
}
return NULL;
}
/*
* This routine is called to flush all partitions and partition tables
* for a changed disk, and then re-read the new partition table.
* If we are revalidating a disk because of a media change, then we
* enter with usage == 0. If we are using an ioctl, we automatically have
* usage == 1 (we need an open channel to use an ioctl :-), so this
* is our limit.
*/
int ata_revalidate(kdev_t i_rdev)
{
struct ata_device *drive;
unsigned long flags;
int res;
if ((drive = get_info_ptr(i_rdev)) == NULL)
return -ENODEV;
/* FIXME: The locking here doesn't make the slightest sense! */
spin_lock_irqsave(&ide_lock, flags);
if (drive->busy || (drive->usage > 1)) {
spin_unlock_irqrestore(&ide_lock, flags);
return -EBUSY;
}
drive->busy = 1;
MOD_INC_USE_COUNT;
spin_unlock_irqrestore(&ide_lock, flags);
res = wipe_partitions(i_rdev);
if (!res) {
if (ata_ops(drive) && ata_ops(drive)->revalidate) {
ata_get(ata_ops(drive));
/* this is a no-op for tapes and SCSI based access */
ata_ops(drive)->revalidate(drive);
ata_put(ata_ops(drive));
} else
grok_partitions(i_rdev, ata_capacity(drive));
}
drive->busy = 0;
wake_up(&drive->wqueue);
MOD_DEC_USE_COUNT;
return res;
}
/*
* FIXME: this is most propably just totally unnecessary.
*
* Look again for all drives in the system on all interfaces.
*/
static void revalidate_drives(void)
{
int i;
for (i = 0; i < MAX_HWIFS; ++i) {
int unit;
struct ata_channel *ch = &ide_hwifs[i];
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (drive->revalidate) {
drive->revalidate = 0;
if (!initializing)
ata_revalidate(mk_kdev(ch->major, unit<<PARTN_BITS));
}
}
}
}
void ide_driver_module(void)
{
int i;
/* Don't reinit the probe if there is already one channel detected. */
for (i = 0; i < MAX_HWIFS; ++i) {
if (ide_hwifs[i].present)
goto revalidate;
}
ideprobe_init();
revalidate:
revalidate_drives();
}
void ide_unregister(struct ata_channel *ch)
{
struct gendisk *gd;
struct ata_device *d;
spinlock_t *lock;
int unit;
int i;
unsigned long flags;
unsigned int p, minor;
struct ata_channel old;
int n_irq;
int n_ch;
spin_lock_irqsave(&ide_lock, flags);
if (!ch->present)
goto abort;
put_device(&ch->dev);
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device * drive = &ch->drives[unit];
if (!drive->present)
continue;
if (drive->busy || drive->usage)
goto abort;
if (ata_ops(drive)) {
if (ata_ops(drive)->cleanup) {
if (ata_ops(drive)->cleanup(drive))
goto abort;
} else
ide_unregister_subdriver(drive);
}
}
ch->present = 0;
/*
* All clear? Then blow away the buffer cache
*/
spin_unlock_irqrestore(&ide_lock, flags);
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device * drive = &ch->drives[unit];
if (!drive->present)
continue;
minor = drive->select.b.unit << PARTN_BITS;
for (p = 0; p < (1<<PARTN_BITS); ++p) {
if (drive->part[p].nr_sects > 0) {
kdev_t devp = mk_kdev(ch->major, minor+p);
invalidate_device(devp, 0);
}
}
}
spin_lock_irqsave(&ide_lock, flags);
/*
* Note that we only release the standard ports, and do not even try to
* handle any extra ports allocated for weird IDE interface chipsets.
*/
if (ch->straight8) {
release_region(ch->io_ports[IDE_DATA_OFFSET], 8);
} else {
for (i = 0; i < 8; i++)
if (ch->io_ports[i])
release_region(ch->io_ports[i], 1);
}
if (ch->io_ports[IDE_CONTROL_OFFSET])
release_region(ch->io_ports[IDE_CONTROL_OFFSET], 1);
/* FIXME: check if we can remove this ifdef */
#if defined(CONFIG_AMIGA) || defined(CONFIG_MAC)
if (ch->io_ports[IDE_IRQ_OFFSET])
release_region(ch->io_ports[IDE_IRQ_OFFSET], 1);
#endif
/*
* Remove us from the lock group.
*/
lock = ch->lock;
d = ch->drive;
for (i = 0; i < MAX_DRIVES; ++i) {
struct ata_device *drive = &ch->drives[i];
if (drive->de) {
devfs_unregister (drive->de);
drive->de = NULL;
}
if (!drive->present)
continue;
/* FIXME: possibly unneccessary */
if (ch->drive == drive)
ch->drive = NULL;
if (drive->id != NULL) {
kfree(drive->id);
drive->id = NULL;
}
drive->present = 0;
blk_cleanup_queue(&drive->queue);
}
if (d->present)
ch->drive = d;
/*
* Free the irq if we were the only channel using it.
*
* Free the lock group if we were the only member.
*/
n_irq = n_ch = 0;
for (i = 0; i < MAX_HWIFS; ++i) {
struct ata_channel *tmp = &ide_hwifs[i];
if (!tmp->present)
continue;
if (tmp->irq == ch->irq)
++n_irq;
if (tmp->lock == ch->lock)
++n_ch;
}
if (n_irq == 1)
free_irq(ch->irq, ch);
if (n_ch == 1) {
kfree(ch->lock);
kfree(ch->active);
ch->lock = NULL;
ch->active = NULL;
}
#ifdef CONFIG_BLK_DEV_IDEDMA
ide_release_dma(ch);
#endif
/*
* Remove us from the kernel's knowledge.
*/
unregister_blkdev(ch->major, ch->name);
blk_dev[ch->major].data = NULL;
blk_dev[ch->major].queue = NULL;
blk_clear(ch->major);
gd = ch->gd;
if (gd) {
del_gendisk(gd);
kfree(gd->sizes);
kfree(gd->part);
if (gd->de_arr)
kfree (gd->de_arr);
if (gd->flags)
kfree (gd->flags);
kfree(gd);
ch->gd = NULL;
}
/*
* Reinitialize the channel handler, but preserve any special methods for
* it.
*/
old = *ch;
init_hwif_data(ch, ch->index);
ch->lock = old.lock;
ch->tuneproc = old.tuneproc;
ch->speedproc = old.speedproc;
ch->selectproc = old.selectproc;
ch->resetproc = old.resetproc;
ch->intrproc = old.intrproc;
ch->maskproc = old.maskproc;
ch->quirkproc = old.quirkproc;
ch->ata_read = old.ata_read;
ch->ata_write = old.ata_write;
ch->atapi_read = old.atapi_read;
ch->atapi_write = old.atapi_write;
ch->XXX_udma = old.XXX_udma;
ch->udma_enable = old.udma_enable;
ch->udma_start = old.udma_start;
ch->udma_stop = old.udma_stop;
ch->udma_read = old.udma_read;
ch->udma_write = old.udma_write;
ch->udma_irq_status = old.udma_irq_status;
ch->udma_timeout = old.udma_timeout;
ch->udma_irq_lost = old.udma_irq_lost;
ch->busproc = old.busproc;
ch->bus_state = old.bus_state;
ch->dma_base = old.dma_base;
ch->dma_extra = old.dma_extra;
ch->config_data = old.config_data;
ch->select_data = old.select_data;
ch->proc = old.proc;
/* FIXME: most propably this is always right:! */
#ifndef CONFIG_BLK_DEV_IDECS
ch->irq = old.irq;
#endif
ch->major = old.major;
ch->chipset = old.chipset;
ch->autodma = old.autodma;
ch->udma_four = old.udma_four;
#ifdef CONFIG_PCI
ch->pci_dev = old.pci_dev;
#endif
ch->straight8 = old.straight8;
abort:
spin_unlock_irqrestore(&ide_lock, flags);
}
static int subdriver_match(struct ata_channel *channel, struct ata_operations *ops)
{
int count, unit;
if (!channel->present)
return 0;
count = 0;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &channel->drives[unit];
if (drive->present && !drive->driver) {
(*ops->attach)(drive);
if (drive->driver != NULL)
count++;
}
}
return count;
}
static struct ata_operations * subdriver_iterator(struct ata_operations *prev)
{
struct ata_operations *tmp;
unsigned long flags;
spin_lock_irqsave(&ata_drivers_lock, flags);
/* Restart from beginning if current ata_operations was deallocated,
or if prev is NULL. */
for(tmp = ata_drivers; tmp != prev && tmp; tmp = tmp->next);
if (!tmp)
tmp = ata_drivers;
else
tmp = tmp->next;
spin_unlock_irqrestore(&ata_drivers_lock, flags);
return tmp;
}
/*
* Register an IDE interface, specifing exactly the registers etc
* Set init=1 iff calling before probes have taken place.
*/
int ide_register_hw(hw_regs_t *hw, struct ata_channel **hwifp)
{
int h;
int retry = 1;
struct ata_channel *ch;
struct ata_operations *subdriver;
do {
for (h = 0; h < MAX_HWIFS; ++h) {
ch = &ide_hwifs[h];
if (ch->hw.io_ports[IDE_DATA_OFFSET] == hw->io_ports[IDE_DATA_OFFSET])
goto found;
}
for (h = 0; h < MAX_HWIFS; ++h) {
ch = &ide_hwifs[h];
if ((!ch->present && (ch->unit == ATA_PRIMARY) && !initializing) ||
(!ch->hw.io_ports[IDE_DATA_OFFSET] && initializing))
goto found;
}
for (h = 0; h < MAX_HWIFS; ++h)
ide_unregister(&ide_hwifs[h]);
} while (retry--);
return -1;
found:
ide_unregister(ch);
if (ch->present)
return -1;
memcpy(&ch->hw, hw, sizeof(*hw));
memcpy(ch->io_ports, ch->hw.io_ports, sizeof(ch->hw.io_ports));
ch->irq = hw->irq;
ch->noprobe = 0;
ch->chipset = hw->chipset;
if (!initializing) {
ideprobe_init();
revalidate_drives();
/* FIXME: Do we really have to call it second time here?! */
ide_driver_module();
}
/* Look up whatever there is a subdriver, which will serve this
* device.
*/
subdriver = NULL;
while ((subdriver = subdriver_iterator(subdriver))) {
if (subdriver_match(ch, subdriver) > 0)
break;
}
if (hwifp)
*hwifp = ch;
return (initializing || ch->present) ? h : -1;
}
/****************************************************************************
* FIXME: rewrite the following crap:
*/
/*
* stridx() returns the offset of c within s,
* or -1 if c is '\0' or not found within s.
*/
static int __init stridx (const char *s, char c)
{
char *i = strchr(s, c);
return (i && c) ? i - s : -1;
}
/*
* Parsing for ide_setup():
*
* 1. the first char of s must be '='.
* 2. if the remainder matches one of the supplied keywords,
* the index (1 based) of the keyword is negated and returned.
* 3. if the remainder is a series of no more than max_vals numbers
* separated by commas, the numbers are saved in vals[] and a
* count of how many were saved is returned. Base10 is assumed,
* and base16 is allowed when prefixed with "0x".
* 4. otherwise, zero is returned.
*/
static int __init match_parm (char *s, const char *keywords[], int vals[], int max_vals)
{
static const char *decimal = "0123456789";
static const char *hex = "0123456789abcdef";
int i, n;
if (*s++ == '=') {
/*
* Try matching against the supplied keywords,
* and return -(index+1) if we match one
*/
if (keywords != NULL) {
for (i = 0; *keywords != NULL; ++i) {
if (!strcmp(s, *keywords++))
return -(i+1);
}
}
/*
* Look for a series of no more than "max_vals"
* numeric values separated by commas, in base10,
* or base16 when prefixed with "0x".
* Return a count of how many were found.
*/
for (n = 0; (i = stridx(decimal, *s)) >= 0;) {
vals[n] = i;
while ((i = stridx(decimal, *++s)) >= 0)
vals[n] = (vals[n] * 10) + i;
if (*s == 'x' && !vals[n]) {
while ((i = stridx(hex, *++s)) >= 0)
vals[n] = (vals[n] * 0x10) + i;
}
if (++n == max_vals)
break;
if (*s == ',' || *s == ';')
++s;
}
if (!*s)
return n;
}
return 0; /* zero = nothing matched */
}
/*
* This sets reasonable default values into all fields of all instances of the
* channles and drives, but only on the first call. Subsequent calls have no
* effect (they don't wipe out anything).
*
* This routine is normally called at driver initialization time, but may also
* be called MUCH earlier during kernel "command-line" parameter processing.
* As such, we cannot depend on any other parts of the kernel (such as memory
* allocation) to be functioning yet.
*
* This is too bad, as otherwise we could dynamically allocate the ata_device
* structs as needed, rather than always consuming memory for the max possible
* number (MAX_HWIFS * MAX_DRIVES) of them.
*/
#define MAGIC_COOKIE 0x12345678
static void __init init_global_data(void)
{
unsigned int h;
static unsigned long magic_cookie = MAGIC_COOKIE;
if (magic_cookie != MAGIC_COOKIE)
return; /* already initialized */
magic_cookie = 0;
/* Initialize all interface structures */
for (h = 0; h < MAX_HWIFS; ++h)
init_hwif_data(&ide_hwifs[h], h);
/* Add default hw interfaces */
ide_init_default_hwifs();
}
/*
* This gets called VERY EARLY during initialization, to handle kernel "command
* line" strings beginning with "hdx=" or "ide".It gets called even before the
* actual module gets initialized.
*
* Here is the complete set currently supported comand line options:
*
* "hdx=" is recognized for all "x" from "a" to "h", such as "hdc".
* "idex=" is recognized for all "x" from "0" to "3", such as "ide1".
*
* "hdx=noprobe" : drive may be present, but do not probe for it
* "hdx=none" : drive is NOT present, ignore cmos and do not probe
* "hdx=nowerr" : ignore the WRERR_STAT bit on this drive
* "hdx=cdrom" : drive is present, and is a cdrom drive
* "hdx=cyl,head,sect" : disk drive is present, with specified geometry
* "hdx=noremap" : do not remap 0->1 even though EZD was detected
* "hdx=autotune" : driver will attempt to tune interface speed
* to the fastest PIO mode supported,
* if possible for this drive only.
* Not fully supported by all chipset types,
* and quite likely to cause trouble with
* older/odd IDE drives.
*
* "hdx=slow" : insert a huge pause after each access to the data
* port. Should be used only as a last resort.
*
* "hdxlun=xx" : set the drive last logical unit.
* "hdx=flash" : allows for more than one ata_flash disk to be
* registered. In most cases, only one device
* will be present.
* "hdx=ide-scsi" : the return of the ide-scsi flag, this is useful for
* allowwing ide-floppy, ide-tape, and ide-cdrom|writers
* to use ide-scsi emulation on a device specific option.
* "idebus=xx" : inform IDE driver of VESA/PCI bus speed in MHz,
* where "xx" is between 20 and 66 inclusive,
* used when tuning chipset PIO modes.
* For PCI bus, 25 is correct for a P75 system,
* 30 is correct for P90,P120,P180 systems,
* and 33 is used for P100,P133,P166 systems.
* If in doubt, use idebus=33 for PCI.
* As for VLB, it is safest to not specify it.
*
* "idex=noprobe" : do not attempt to access/use this interface
* "idex=base" : probe for an interface at the address specified,
* where "base" is usually 0x1f0 or 0x170
* and "ctl" is assumed to be "base"+0x206
* "idex=base,ctl" : specify both base and ctl
* "idex=base,ctl,irq" : specify base, ctl, and irq number
* "idex=autotune" : driver will attempt to tune interface speed
* to the fastest PIO mode supported,
* for all drives on this interface.
* Not fully supported by all chipset types,
* and quite likely to cause trouble with
* older/odd IDE drives.
* "idex=noautotune" : driver will NOT attempt to tune interface speed
* This is the default for most chipsets,
* except the cmd640.
* "idex=serialize" : do not overlap operations on idex and ide(x^1)
* "idex=four" : four drives on idex and ide(x^1) share same ports
* "idex=reset" : reset interface before first use
* "idex=dma" : enable DMA by default on both drives if possible
* "idex=ata66" : informs the interface that it has an 80c cable
* for chipsets that are ATA-66 capable, but
* the ablity to bit test for detection is
* currently unknown.
* "ide=reverse" : Formerly called to pci sub-system, but now local.
*
* The following are valid ONLY on ide0, (except dc4030)
* and the defaults for the base,ctl ports must not be altered.
*
* "ide0=dtc2278" : probe/support DTC2278 interface
* "ide0=ht6560b" : probe/support HT6560B interface
* "ide0=cmd640_vlb" : *REQUIRED* for VLB cards with the CMD640 chip
* (not for PCI -- automatically detected)
* "ide0=qd65xx" : probe/support qd65xx interface
* "ide0=ali14xx" : probe/support ali14xx chipsets (ALI M1439, M1443, M1445)
* "ide0=umc8672" : probe/support umc8672 chipsets
* "idex=dc4030" : probe/support Promise DC4030VL interface
* "ide=doubler" : probe/support IDE doublers on Amiga
*/
int __init ide_setup(char *s)
{
int i, vals[3];
struct ata_channel *ch;
struct ata_device *drive;
unsigned int hw, unit;
const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1);
const char max_ch = '0' + (MAX_HWIFS - 1);
if (!strncmp(s, "hd=", 3)) /* hd= is for hd.c driver and not us */
return 0;
if (strncmp(s,"ide",3) &&
strncmp(s,"idebus",6) &&
strncmp(s,"hd",2)) /* hdx= & hdxlun= */
return 0;
printk(KERN_INFO "ide_setup: %s", s);
init_global_data();
#ifdef CONFIG_BLK_DEV_IDEDOUBLER
if (!strcmp(s, "ide=doubler")) {
extern int ide_doubler;
printk(KERN_INFO" : Enabled support for IDE doublers\n");
ide_doubler = 1;
return 1;
}
#endif
if (!strcmp(s, "ide=nodma")) {
printk(KERN_INFO "ATA: Prevented DMA\n");
noautodma = 1;
return 1;
}
#ifdef CONFIG_PCI
if (!strcmp(s, "ide=reverse")) {
ide_scan_direction = 1;
printk(" : Enabled support for IDE inverse scan order.\n");
return 1;
}
#endif
/*
* Look for drive options: "hdx="
*/
if (!strncmp(s, "hd", 2) && s[2] >= 'a' && s[2] <= max_drive) {
const char *hd_words[] = {"none", "noprobe", "nowerr", "cdrom",
"serialize", "autotune", "noautotune",
"slow", "flash", "remap", "noremap", "scsi", NULL};
unit = s[2] - 'a';
hw = unit / MAX_DRIVES;
unit = unit % MAX_DRIVES;
ch = &ide_hwifs[hw];
drive = &ch->drives[unit];
if (!strncmp(s + 4, "ide-", 4)) {
strncpy(drive->driver_req, s + 4, 9);
goto done;
}
/*
* Look for last lun option: "hdxlun="
*/
if (!strncmp(&s[3], "lun", 3)) {
if (match_parm(&s[6], NULL, vals, 1) != 1)
goto bad_option;
if (vals[0] >= 0 && vals[0] <= 7) {
drive->last_lun = vals[0];
drive->forced_lun = 1;
} else
printk(" -- BAD LAST LUN! Expected value from 0 to 7");
goto done;
}
switch (match_parm(&s[3], hd_words, vals, 3)) {
case -1: /* "none" */
drive->nobios = 1; /* drop into "noprobe" */
case -2: /* "noprobe" */
drive->noprobe = 1;
goto done;
case -3: /* "nowerr" */
drive->bad_wstat = BAD_R_STAT;
ch->noprobe = 0;
goto done;
case -4: /* "cdrom" */
drive->present = 1;
drive->type = ATA_ROM;
ch->noprobe = 0;
goto done;
case -5: /* "serialize" */
printk(" -- USE \"ide%d=serialize\" INSTEAD", hw);
goto do_serialize;
case -6: /* "autotune" */
drive->autotune = 1;
goto done;
case -7: /* "noautotune" */
drive->autotune = 2;
goto done;
case -8: /* "slow" */
ch->slow = 1;
goto done;
case -9: /* "flash" */
drive->ata_flash = 1;
goto done;
case -10: /* "remap" */
drive->remap_0_to_1 = 1;
goto done;
case -11: /* "noremap" */
drive->remap_0_to_1 = 2;
goto done;
case -12: /* "scsi" */
#if defined(CONFIG_BLK_DEV_IDESCSI) && defined(CONFIG_SCSI)
drive->scsi = 1;
goto done;
#else
drive->scsi = 0;
goto bad_option;
#endif
case 3: /* cyl,head,sect */
drive->type = ATA_DISK;
drive->cyl = drive->bios_cyl = vals[0];
drive->head = drive->bios_head = vals[1];
drive->sect = drive->bios_sect = vals[2];
drive->present = 1;
drive->forced_geom = 1;
ch->noprobe = 0;
goto done;
default:
goto bad_option;
}
}
/*
* Look for bus speed option: "idebus="
*/
if (!strncmp(s, "idebus", 6)) {
if (match_parm(&s[6], NULL, vals, 1) != 1)
goto bad_option;
idebus_parameter = vals[0];
goto done;
}
/*
* Look for interface options: "idex="
*/
if (!strncmp(s, "ide", 3) && s[3] >= '0' && s[3] <= max_ch) {
/*
* Be VERY CAREFUL changing this: note hardcoded indexes below
* -8,-9,-10. -11 : are reserved for future idex calls to ease the hardcoding.
*/
const char *ide_words[] = {
"noprobe", "serialize", "autotune", "noautotune", "reset", "dma", "ata66",
"minus8", "minus9", "minus10", "minus11",
"qd65xx", "ht6560b", "cmd640_vlb", "dtc2278", "umc8672", "ali14xx", "dc4030", NULL };
hw = s[3] - '0';
ch = &ide_hwifs[hw];
i = match_parm(&s[4], ide_words, vals, 3);
/*
* Cryptic check to ensure chipset not already set for a channel:
*/
if (i > 0 || i <= -11) { /* is parameter a chipset name? */
if (ch->chipset != ide_unknown)
goto bad_option; /* chipset already specified */
if (i <= -11 && i != -18 && hw != 0)
goto bad_channel; /* chipset drivers are for "ide0=" only */
if (i <= -11 && i != -18 && ide_hwifs[hw+1].chipset != ide_unknown)
goto bad_option; /* chipset for 2nd port already specified */
printk("\n");
}
switch (i) {
#ifdef CONFIG_BLK_DEV_PDC4030
case -18: /* "dc4030" */
{
extern void init_pdc4030(void);
init_pdc4030();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_ALI14XX
case -17: /* "ali14xx" */
{
extern void init_ali14xx (void);
init_ali14xx();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_UMC8672
case -16: /* "umc8672" */
{
extern void init_umc8672 (void);
init_umc8672();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_DTC2278
case -15: /* "dtc2278" */
{
extern void init_dtc2278 (void);
init_dtc2278();
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_CMD640
case -14: /* "cmd640_vlb" */
{
extern int cmd640_vlb; /* flag for cmd640.c */
cmd640_vlb = 1;
goto done;
}
#endif
#ifdef CONFIG_BLK_DEV_HT6560B
case -13: /* "ht6560b" */
{
extern void init_ht6560b (void);
init_ht6560b();
goto done;
}
#endif
#if CONFIG_BLK_DEV_QD65XX
case -12: /* "qd65xx" */
{
extern void init_qd65xx (void);
init_qd65xx();
goto done;
}
#endif
case -11: /* minus11 */
case -10: /* minus10 */
case -9: /* minus9 */
case -8: /* minus8 */
goto bad_option;
case -7: /* ata66 */
#ifdef CONFIG_PCI
ch->udma_four = 1;
goto done;
#else
ch->udma_four = 0;
goto bad_channel;
#endif
case -6: /* dma */
ch->autodma = 1;
goto done;
case -5: /* "reset" */
ch->reset = 1;
goto done;
case -4: /* "noautotune" */
ch->drives[0].autotune = 2;
ch->drives[1].autotune = 2;
goto done;
case -3: /* "autotune" */
ch->drives[0].autotune = 1;
ch->drives[1].autotune = 1;
goto done;
case -2: /* "serialize" */
do_serialize:
{
struct ata_channel *mate;
mate = &ide_hwifs[hw ^ 1];
ch->serialized = 1;
mate->serialized = 1;
}
goto done;
case -1: /* "noprobe" */
ch->noprobe = 1;
goto done;
case 1: /* base */
vals[1] = vals[0] + 0x206; /* default ctl */
case 2: /* base,ctl */
vals[2] = 0; /* default irq = probe for it */
case 3: /* base,ctl,irq */
ch->hw.irq = vals[2];
ide_init_hwif_ports(&ch->hw, (ide_ioreg_t) vals[0], (ide_ioreg_t) vals[1], &ch->irq);
memcpy(ch->io_ports, ch->hw.io_ports, sizeof(ch->io_ports));
ch->irq = vals[2];
ch->noprobe = 0;
ch->chipset = ide_generic;
goto done;
case 0:
goto bad_option;
default:
printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n");
return 1;
}
}
bad_option:
printk(" -- BAD OPTION\n");
return 1;
bad_channel:
printk("-- NOT SUPPORTED ON ide%d", hw);
done:
printk("\n");
return 1;
}
/****************************************************************************/
/*
* This is in fact registering a device not a driver.
*/
int ide_register_subdriver(struct ata_device *drive, struct ata_operations *driver)
{
unsigned long flags;
save_flags(flags); /* all CPUs */
cli(); /* all CPUs */
if (!drive->present || drive->driver != NULL || drive->busy || drive->usage) {
restore_flags(flags); /* all CPUs */
return 1;
}
/* FIXME: This will be pushed to the drivers! Thus allowing us to
* save one parameter here separate this out.
*/
drive->driver = driver;
restore_flags(flags); /* all CPUs */
/* FIXME: Check what this magic number is supposed to be about? */
if (drive->autotune != 2) {
if (drive->channel->XXX_udma) {
/*
* Force DMAing for the beginning of the check. Some
* chipsets appear to do interesting things, if not
* checked and cleared.
*
* PARANOIA!!!
*/
udma_enable(drive, 0, 0);
drive->channel->XXX_udma(drive);
#ifdef CONFIG_BLK_DEV_IDE_TCQ_DEFAULT
udma_tcq_enable(drive, 1);
#endif
}
/* Only CD-ROMs and tape drives support DSC overlap. But only
* if they are alone on a channel. */
if (drive->type == ATA_ROM || drive->type == ATA_TAPE) {
int single = 0;
int unit;
for (unit = 0; unit < MAX_DRIVES; ++unit)
if (drive->channel->drives[unit].present)
++single;
drive->dsc_overlap = (single == 1);
} else
drive->dsc_overlap = 0;
}
drive->revalidate = 1;
drive->suspend_reset = 0;
return 0;
}
/*
* This is in fact the default cleanup routine.
*
* FIXME: Check whatever we maybe don't call it twice!.
*/
int ide_unregister_subdriver(struct ata_device *drive)
{
unsigned long flags;
save_flags(flags); /* all CPUs */
cli(); /* all CPUs */
#if 0
if (__MOD_IN_USE(ata_ops(drive)->owner)) {
restore_flags(flags);
return 1;
}
#endif
if (drive->usage || drive->busy || !ata_ops(drive)) {
restore_flags(flags); /* all CPUs */
return 1;
}
#if defined(CONFIG_BLK_DEV_ISAPNP) && defined(CONFIG_ISAPNP) && defined(MODULE)
pnpide_init(0);
#endif
drive->driver = NULL;
restore_flags(flags); /* all CPUs */
return 0;
}
/*
* Register an ATA subdriver for a particular device type.
*/
int register_ata_driver(struct ata_operations *driver)
{
unsigned long flags;
int index;
int count = 0;
spin_lock_irqsave(&ata_drivers_lock, flags);
driver->next = ata_drivers;
ata_drivers = driver;
spin_unlock_irqrestore(&ata_drivers_lock, flags);
for (index = 0; index < MAX_HWIFS; ++index)
count += subdriver_match(&ide_hwifs[index], driver);
return count;
}
EXPORT_SYMBOL(register_ata_driver);
/*
* Unregister an ATA subdriver for a particular device type.
*/
void unregister_ata_driver(struct ata_operations *driver)
{
struct ata_operations **tmp;
unsigned long flags;
int index;
int unit;
spin_lock_irqsave(&ata_drivers_lock, flags);
for (tmp = &ata_drivers; *tmp != NULL; tmp = &(*tmp)->next) {
if (*tmp == driver) {
*tmp = driver->next;
break;
}
}
spin_unlock_irqrestore(&ata_drivers_lock, flags);
for (index = 0; index < MAX_HWIFS; ++index) {
struct ata_channel *ch = &ide_hwifs[index];
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (drive->driver == driver)
(*ata_ops(drive)->cleanup)(drive);
}
}
}
EXPORT_SYMBOL(unregister_ata_driver);
EXPORT_SYMBOL(ide_hwifs);
EXPORT_SYMBOL(ide_lock);
devfs_handle_t ide_devfs_handle;
EXPORT_SYMBOL(ide_register_subdriver);
EXPORT_SYMBOL(ide_unregister_subdriver);
EXPORT_SYMBOL(ata_revalidate);
EXPORT_SYMBOL(ide_register_hw);
EXPORT_SYMBOL(ide_unregister);
EXPORT_SYMBOL(get_info_ptr);
/*
* Handle power handling related events ths system informs us about.
*/
static int ata_sys_notify(struct notifier_block *this, unsigned long event, void *x)
{
int i;
switch (event) {
case SYS_HALT:
case SYS_POWER_OFF:
case SYS_RESTART:
break;
default:
return NOTIFY_DONE;
}
printk("flushing ide devices: ");
for (i = 0; i < MAX_HWIFS; i++) {
int unit;
struct ata_channel *ch = &ide_hwifs[i];
if (!ch->present)
continue;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
struct ata_device *drive = &ch->drives[unit];
if (!drive->present)
continue;
/* set the drive to standby */
printk("%s ", drive->name);
if (ata_ops(drive)) {
if (event != SYS_RESTART)
if (ata_ops(drive)->standby && ata_ops(drive)->standby(drive))
continue;
if (ata_ops(drive)->cleanup)
ata_ops(drive)->cleanup(drive);
}
}
}
printk("\n");
return NOTIFY_DONE;
}
static struct notifier_block ata_notifier = {
ata_sys_notify,
NULL,
5
};
/*
* This is the global initialization entry point.
*/
static int __init ata_module_init(void)
{
int h;
printk(KERN_INFO "ATA/ATAPI device driver v" VERSION "\n");
ide_devfs_handle = devfs_mk_dir (NULL, "ide", NULL);
/*
* Because most of the ATA adapters represent the timings in unit of
* bus clocks, and there is no known reliable way to detect the bus
* clock frequency, we assume 50 MHz for non-PCI (VLB, EISA) and 33 MHz
* for PCI based systems. Since assuming only hurts performance and not
* stability, this is OK. The user can change this on the command line
* by using the "idebus=XX" parameter. While the system_bus_speed
* variable is in kHz units, we accept both MHz and kHz entry on the
* command line for backward compatibility.
*/
system_bus_speed = 50000;
if (pci_present())
system_bus_speed = 33333;
if (idebus_parameter >= 20 && idebus_parameter <= 80) {
system_bus_speed = idebus_parameter * 1000;
switch (system_bus_speed) {
case 33000: system_bus_speed = 33333; break;
case 37000: system_bus_speed = 37500; break;
case 41000: system_bus_speed = 41666; break;
case 66000: system_bus_speed = 66666; break;
}
}
if (idebus_parameter >= 20000 && idebus_parameter <= 80000)
system_bus_speed = idebus_parameter;
printk(KERN_INFO "ATA: %s bus speed %d.%dMHz\n",
pci_present() ? "PCI" : "System", system_bus_speed / 1000, system_bus_speed / 100 % 10);
init_global_data();
initializing = 1;
#ifdef CONFIG_PCI
/*
* Register the host chip drivers.
*/
# ifdef CONFIG_BLK_DEV_PIIX
init_piix();
# endif
# ifdef CONFIG_BLK_DEV_VIA82CXXX
init_via82cxxx();
# endif
# ifdef CONFIG_BLK_DEV_PDC202XX
init_pdc202xx();
# endif
# ifdef CONFIG_BLK_DEV_RZ1000
init_rz1000();
# endif
# ifdef CONFIG_BLK_DEV_SIS5513
init_sis5513();
# endif
# ifdef CONFIG_BLK_DEV_CMD64X
init_cmd64x();
# endif
# ifdef CONFIG_BLK_DEV_OPTI621
init_opti621();
# endif
# ifdef CONFIG_BLK_DEV_TRM290
init_trm290();
# endif
# ifdef CONFIG_BLK_DEV_NS87415
init_ns87415();
# endif
# ifdef CONFIG_BLK_DEV_AEC62XX
init_aec62xx();
# endif
# ifdef CONFIG_BLK_DEV_SL82C105
init_sl82c105();
# endif
# ifdef CONFIG_BLK_DEV_HPT34X
init_hpt34x();
# endif
# ifdef CONFIG_BLK_DEV_HPT366
init_hpt366();
# endif
# ifdef CONFIG_BLK_DEV_ALI15X3
init_ali15x3();
# endif
# ifdef CONFIG_BLK_DEV_CY82C693
init_cy82c693();
# endif
# ifdef CONFIG_BLK_DEV_CS5530
init_cs5530();
# endif
# ifdef CONFIG_BLK_DEV_AMD74XX
init_amd74xx();
# endif
# ifdef CONFIG_BLK_DEV_SVWKS
init_svwks();
# endif
# ifdef CONFIG_BLK_DEV_IT8172
init_it8172();
# endif
init_ata_pci_misc();
/*
* Detect and initialize "known" IDE host chip types.
*/
if (pci_present()) {
# ifdef CONFIG_PCI
ide_scan_pcibus(ide_scan_direction);
# else
# ifdef CONFIG_BLK_DEV_RZ1000
ide_probe_for_rz100x();
# endif
# endif
}
#endif
#ifdef CONFIG_ETRAX_IDE
init_e100_ide();
#endif
#ifdef CONFIG_BLK_DEV_CMD640
ide_probe_for_cmd640x();
#endif
#ifdef CONFIG_BLK_DEV_PDC4030
ide_probe_for_pdc4030();
#endif
#ifdef CONFIG_BLK_DEV_IDE_PMAC
pmac_ide_probe();
#endif
#ifdef CONFIG_BLK_DEV_IDE_ICSIDE
icside_init();
#endif
#ifdef CONFIG_BLK_DEV_IDE_RAPIDE
rapide_init();
#endif
#ifdef CONFIG_BLK_DEV_GAYLE
gayle_init();
#endif
#ifdef CONFIG_BLK_DEV_FALCON_IDE
falconide_init();
#endif
#ifdef CONFIG_BLK_DEV_MAC_IDE
macide_init();
#endif
#ifdef CONFIG_BLK_DEV_Q40IDE
q40ide_init();
#endif
#ifdef CONFIG_BLK_DEV_BUDDHA
buddha_init();
#endif
#if defined(CONFIG_BLK_DEV_ISAPNP) && defined(CONFIG_ISAPNP)
pnpide_init(1);
#endif
#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
# if defined(__mc68000__) || defined(CONFIG_APUS)
if (ide_hwifs[0].io_ports[IDE_DATA_OFFSET]) {
// ide_get_lock(&irq_lock, NULL, NULL);/* for atari only */
disable_irq(ide_hwifs[0].irq); /* disable_irq_nosync ?? */
// disable_irq_nosync(ide_hwifs[0].irq);
}
# endif
ideprobe_init();
# if defined(__mc68000__) || defined(CONFIG_APUS)
if (ide_hwifs[0].io_ports[IDE_DATA_OFFSET]) {
enable_irq(ide_hwifs[0].irq);
ide_release_lock(&irq_lock);/* for atari only */
}
# endif
#endif
/*
* Initialize all device type driver modules.
*/
#ifdef CONFIG_BLK_DEV_IDEDISK
idedisk_init();
#endif
#ifdef CONFIG_BLK_DEV_IDECD
ide_cdrom_init();
#endif
#ifdef CONFIG_BLK_DEV_IDETAPE
idetape_init();
#endif
#ifdef CONFIG_BLK_DEV_IDEFLOPPY
idefloppy_init();
#endif
#ifdef CONFIG_BLK_DEV_IDESCSI
# ifdef CONFIG_SCSI
idescsi_init();
# else
#error ATA SCSI emulation selected but no SCSI-subsystem in kernel
# endif
#endif
initializing = 0;
for (h = 0; h < MAX_HWIFS; ++h) {
struct ata_channel *channel = &ide_hwifs[h];
if (channel->present)
ide_geninit(channel);
}
register_reboot_notifier(&ata_notifier);
return 0;
}
static char *options = NULL;
static int __init init_ata(void)
{
if (options != NULL && *options) {
char *next = options;
while ((options = next) != NULL) {
if ((next = strchr(options,' ')) != NULL)
*next++ = 0;
if (!ide_setup(options))
printk(KERN_ERR "Unknown option '%s'\n", options);
}
}
return ata_module_init();
}
static void __exit cleanup_ata(void)
{
int h;
unregister_reboot_notifier(&ata_notifier);
for (h = 0; h < MAX_HWIFS; ++h) {
ide_unregister(&ide_hwifs[h]);
}
devfs_unregister(ide_devfs_handle);
}
module_init(init_ata);
module_exit(cleanup_ata);
#ifndef MODULE
/* command line option parser */
__setup("", ide_setup);
#endif
drivers/ide/qd65xx.c
View file @ 4478f040
......@@ -21,6 +21,7 @@
* Samuel Thibault <samuel.thibault@fnac.net>
*/
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
......@@ -84,7 +85,7 @@
static int timings[4]={-1,-1,-1,-1}; /* stores current timing for each timer */
static void qd_write_reg (byte content, byte reg)
static void qd_write_reg(byte content, byte reg)
{
unsigned long flags;
......@@ -94,7 +95,7 @@ static void qd_write_reg (byte content, byte reg)
restore_flags(flags); /* all CPUs */
}
byte __init qd_read_reg (byte reg)
byte __init qd_read_reg(byte reg)
{
unsigned long flags;
byte read;
......@@ -114,7 +115,7 @@ byte __init qd_read_reg (byte reg)
static void qd_select(struct ata_device *drive)
{
byte index = (( (QD_TIMREG(drive)) & 0x80 ) >> 7) |
byte index = (( (QD_TIMREG(drive)) & 0x80 ) >> 7) |
(QD_TIMREG(drive) & 0x02);
if (timings[index] != QD_TIMING(drive))
......@@ -150,10 +151,10 @@ static byte qd6500_compute_timing(struct ata_channel *hwif, int active_time, int
* idem for qd6580
*/
static byte qd6580_compute_timing (int active_time, int recovery_time)
static byte qd6580_compute_timing(int active_time, int recovery_time)
{
byte active_cycle = 17-IDE_IN(active_time * system_bus_speed / 1000000 + 1, 2, 17);
byte recovery_cycle = 15-IDE_IN(recovery_time * system_bus_speed / 1000000 + 1, 2, 15);
byte active_cycle = 17 - IDE_IN(active_time * system_bus_speed / 1000000 + 1, 2, 17);
byte recovery_cycle = 15 - IDE_IN(recovery_time * system_bus_speed / 1000000 + 1, 2, 15);
return((recovery_cycle<<4) | active_cycle);
}
......@@ -176,8 +177,8 @@ static int qd_find_disk_type(struct ata_device *drive,
ide_fixstring(model,40,1); /* byte-swap */
for (p = qd65xx_timing ; p->offset != -1 ; p++) {
if (!strncmp(p->model, model+p->offset,4)) {
printk(KERN_DEBUG "%s: listed !\n",drive->name);
if (!strncmp(p->model, model+p->offset, 4)) {
printk(KERN_DEBUG "%s: listed !\n", drive->name);
*active_time = p->active;
*recovery_time = p->recovery;
return 1;
......@@ -218,7 +219,7 @@ static void qd_set_timing(struct ata_device *drive, byte timing)
} else
hwif->selectproc = &qd_select;
printk(KERN_DEBUG "%s: %#x\n",drive->name,timing);
printk(KERN_DEBUG "%s: %#x\n", drive->name, timing);
}
/*
......@@ -230,17 +231,16 @@ static void qd6500_tune_drive(struct ata_device *drive, byte pio)
int active_time = 175;
int recovery_time = 415; /* worst case values from the dos driver */
if (drive->id && !qd_find_disk_type(drive,&active_time,&recovery_time)
if (drive->id && !qd_find_disk_type(drive, &active_time, &recovery_time)
&& drive->id->tPIO && (drive->id->field_valid & 0x02)
&& drive->id->eide_pio >= 240) {
printk(KERN_INFO "%s: PIO mode%d\n", drive->name,
drive->id->tPIO);
printk(KERN_INFO "%s: PIO mode%d\n", drive->name, drive->id->tPIO);
active_time = 110;
recovery_time = drive->id->eide_pio - 120;
}
qd_set_timing(drive,qd6500_compute_timing(drive->channel, active_time,recovery_time));
qd_set_timing(drive, qd6500_compute_timing(drive->channel, active_time, recovery_time));
}
/*
......@@ -254,7 +254,7 @@ static void qd6580_tune_drive(struct ata_device *drive, byte pio)
int active_time = 175;
int recovery_time = 415; /* worst case values from the dos driver */
if (drive->id && !qd_find_disk_type(drive,&active_time,&recovery_time)) {
if (drive->id && !qd_find_disk_type(drive, &active_time, &recovery_time)) {
if (pio == 255)
pio = ata_timing_mode(drive, XFER_PIO | XFER_EPIO);
......@@ -268,14 +268,14 @@ static void qd6580_tune_drive(struct ata_device *drive, byte pio)
case 3:
if (t->cycle >= 110) {
active_time = 86;
recovery_time = t->cycle-102;
recovery_time = t->cycle - 102;
} else
printk(KERN_WARNING "%s: Strange recovery time !\n",drive->name);
break;
case 4:
if (t->cycle >= 69) {
active_time = 70;
recovery_time = t->cycle-61;
recovery_time = t->cycle - 61;
} else
printk(KERN_WARNING "%s: Strange recovery time !\n",drive->name);
break;
......@@ -292,11 +292,11 @@ static void qd6580_tune_drive(struct ata_device *drive, byte pio)
}
if (!drive->channel->unit && drive->type != ATA_DISK) {
qd_write_reg(0x5f,QD_CONTROL_PORT);
printk(KERN_WARNING "%s: ATAPI: disabled read-ahead FIFO and post-write buffer on %s.\n",drive->name, drive->channel->name);
qd_write_reg(0x5f, QD_CONTROL_PORT);
printk(KERN_WARNING "%s: ATAPI: disabled read-ahead FIFO and post-write buffer on %s.\n", drive->name, drive->channel->name);
}
qd_set_timing(drive,qd6580_compute_timing(active_time,recovery_time));
qd_set_timing(drive, qd6580_compute_timing(active_time, recovery_time));
}
/*
......@@ -314,9 +314,9 @@ static int __init qd_testreg(int port)
save_flags(flags); /* all CPUs */
cli(); /* all CPUs */
savereg = inb_p(port);
outb_p(QD_TESTVAL,port); /* safe value */
outb_p(QD_TESTVAL, port); /* safe value */
readreg = inb_p(port);
outb(savereg,port);
outb(savereg, port);
restore_flags(flags); /* all CPUs */
if (savereg == QD_TESTVAL) {
......@@ -330,109 +330,121 @@ static int __init qd_testreg(int port)
}
/*
* probe:
* qd_setup:
*
* called to setup an ata channel : adjusts attributes & links for tuning
*/
void __init qd_setup(int unit, int base, int config, unsigned int data0, unsigned int data1, void (*tuneproc) (struct ata_device *, byte pio))
{
struct ata_channel *hwif = &ide_hwifs[unit];
hwif->chipset = ide_qd65xx;
hwif->unit = unit;
hwif->select_data = base;
hwif->config_data = config;
hwif->drives[0].drive_data = data0;
hwif->drives[1].drive_data = data1;
hwif->io_32bit = 1;
hwif->tuneproc = tuneproc;
}
/*
* qd_unsetup:
*
* called to unsetup an ata channel : back to default values, unlinks tuning
*/
void __init qd_unsetup(int unit) {
struct ata_channel *hwif = &ide_hwifs[unit];
byte config = hwif->config_data;
int base = hwif->select_data;
void *tuneproc = (void *) hwif->tuneproc;
if (!(hwif->chipset == ide_qd65xx)) return;
printk(KERN_NOTICE "%s: back to defaults\n", hwif->name);
hwif->selectproc = NULL;
hwif->tuneproc = NULL;
if (tuneproc == (void *) qd6500_tune_drive) {
// will do it for both
qd_write_reg(QD6500_DEF_DATA, QD_TIMREG(&hwif->drives[0]));
} else if (tuneproc == (void *) qd6580_tune_drive) {
if (QD_CONTROL(hwif) & QD_CONTR_SEC_DISABLED) {
qd_write_reg(QD6580_DEF_DATA, QD_TIMREG(&hwif->drives[0]));
qd_write_reg(QD6580_DEF_DATA2, QD_TIMREG(&hwif->drives[1]));
} else {
qd_write_reg(unit?QD6580_DEF_DATA2:QD6580_DEF_DATA, QD_TIMREG(&hwif->drives[0]));
}
} else {
printk(KERN_WARNING "Unknown qd65xx tuning fonction !\n");
printk(KERN_WARNING "keeping settings !\n");
}
}
/*
* qd_probe:
*
* looks at the specified baseport, and if qd found, registers & initialises it
* return 1 if another qd may be probed
*/
int __init probe (int base)
int __init qd_probe(int base)
{
byte config;
byte index;
int unit;
config = qd_read_reg(QD_CONFIG_PORT);
if (! ((config & QD_CONFIG_BASEPORT) >> 1 == (base == 0xb0)) ) return 1;
index = ! (config & QD_CONFIG_IDE_BASEPORT);
unit = ! (config & QD_CONFIG_IDE_BASEPORT);
if ((config & 0xf0) == QD_CONFIG_QD6500) {
struct ata_channel *hwif = &ide_hwifs[index];
if (qd_testreg(base)) return 1; /* bad register */
/* qd6500 found */
/* qd6500 found */
printk(KERN_NOTICE "%s: qd6500 at %#x\n", ide_hwifs[unit].name, base);
printk(KERN_DEBUG "qd6500: config=%#x, ID3=%u\n", config, QD_ID3);
printk(KERN_NOTICE "%s: qd6500 at %#x\n",
ide_hwifs[index].name, base);
printk(KERN_DEBUG "qd6500: config=%#x, ID3=%u\n",
config, QD_ID3);
if (config & QD_CONFIG_DISABLED) {
printk(KERN_WARNING "qd6500 is disabled !\n");
return 1;
}
hwif->chipset = ide_qd65xx;
hwif->select_data = base;
hwif->config_data = config;
hwif->drives[0].drive_data =
hwif->drives[1].drive_data = QD6500_DEF_DATA;
hwif->io_32bit = 1;
hwif->tuneproc = &qd6500_tune_drive;
qd_setup(unit, base, config, QD6500_DEF_DATA, QD6500_DEF_DATA, &qd6500_tune_drive);
return 1;
}
if (((config & 0xf0) == QD_CONFIG_QD6580_A) || ((config & 0xf0) == QD_CONFIG_QD6580_B)) {
byte control;
if (qd_testreg(base) || qd_testreg(base+0x02)) return 1;
/* bad registers */
/* qd6580 found */
/* qd6580 found */
control = qd_read_reg(QD_CONTROL_PORT);
printk(KERN_NOTICE "qd6580 at %#x\n", base);
printk(KERN_DEBUG "qd6580: config=%#x, control=%#x, ID3=%u\n",
config, control, QD_ID3);
printk(KERN_DEBUG "qd6580: config=%#x, control=%#x, ID3=%u\n", config, control, QD_ID3);
if (control & QD_CONTR_SEC_DISABLED) {
struct ata_channel *hwif = &ide_hwifs[index];
/* secondary disabled */
printk(KERN_INFO "%s: qd6580: single IDE board\n",
ide_hwifs[index].name);
hwif->chipset = ide_qd65xx;
hwif->select_data = base;
hwif->config_data = config | (control <<8);
hwif->drives[0].drive_data =
hwif->drives[1].drive_data = QD6580_DEF_DATA;
hwif->io_32bit = 1;
hwif->tuneproc = &qd6580_tune_drive;
qd_write_reg(QD_DEF_CONTR,QD_CONTROL_PORT);
printk(KERN_INFO "%s: qd6580: single IDE board\n", ide_hwifs[unit].name);
qd_setup(unit, base, config | (control << 8), QD6580_DEF_DATA, QD6580_DEF_DATA2, &qd6580_tune_drive);
qd_write_reg(QD_DEF_CONTR, QD_CONTROL_PORT);
return 1;
} else {
int i;
/* secondary enabled */
printk(KERN_INFO "%s&%s: qd6580: dual IDE board\n",
ide_hwifs[0].name,ide_hwifs[1].name);
for (i = 0; i < 2; i++) {
int j;
ide_hwifs[i].chipset = ide_qd65xx;
ide_hwifs[i].unit = i;
ide_hwifs[i].select_data = base;
ide_hwifs[i].config_data = config | (control <<8);
ide_hwifs[i].tuneproc = &qd6580_tune_drive;
ide_hwifs[i].io_32bit = 1;
for (j = 0; j < 2; j++) {
ide_hwifs[i].drives[j].drive_data =
i?QD6580_DEF_DATA2:QD6580_DEF_DATA;
}
}
printk(KERN_INFO "%s&%s: qd6580: dual IDE board\n", ide_hwifs[0].name, ide_hwifs[1].name);
qd_write_reg(QD_DEF_CONTR,QD_CONTROL_PORT);
qd_setup(ATA_PRIMARY, base, config | (control << 8), QD6580_DEF_DATA, QD6580_DEF_DATA, &qd6580_tune_drive);
qd_setup(ATA_SECONDARY, base, config | (control << 8), QD6580_DEF_DATA2, QD6580_DEF_DATA2, &qd6580_tune_drive);
qd_write_reg(QD_DEF_CONTR, QD_CONTROL_PORT);
return 0; /* no other qd65xx possible */
}
......@@ -441,13 +453,36 @@ int __init probe (int base)
return 1;
}
#ifndef MODULE
/*
* init_qd65xx:
*
* called at the very beginning of initialization ; should just probe and link
* called by ide.c when parsing command line
*/
void __init init_qd65xx (void)
void __init init_qd65xx(void)
{
if (qd_probe(0x30)) qd_probe(0xb0);
}
#else
MODULE_AUTHOR("Samuel Thibault");
MODULE_DESCRIPTION("support of qd65xx vlb ide chipset");
MODULE_LICENSE("GPL");
int __init qd65xx_mod_init(void)
{
if (qd_probe(0x30)) qd_probe(0xb0);
if (ide_hwifs[0].chipset != ide_qd65xx && ide_hwifs[1].chipset != ide_qd65xx) return -ENODEV;
return 0;
}
module_init(qd65xx_mod_init);
void __init qd65xx_mod_exit(void)
{
if (probe(0x30)) probe(0xb0);
qd_unsetup(ATA_PRIMARY);
qd_unsetup(ATA_SECONDARY);
}
module_exit(qd65xx_mod_exit);
#endif
drivers/macintosh/mediabay.c
View file @ 4478f040
......@@ -555,17 +555,21 @@ media_bay_step(int i)
break;
case mb_ide_waiting:
if (bay->cd_base == 0) {
if (bay->cd_base == 0) {
bay->timer = 0;
bay->state = mb_up;
MBDBG("mediabay%d: up before IDE init\n", i);
break;
} else if (MB_IDE_READY(i)) {
} else if (MB_IDE_READY(i)) {
bay->timer = 0;
bay->state = mb_up;
if (bay->cd_index < 0) {
hw_regs_t hw;
pmu_suspend();
bay->cd_index = ide_register(bay->cd_base, 0, bay->cd_irq);
ide_init_hwif_ports(&hw, (ide_ioreg_t) bay->cd_base, (ide_ioreg_t) 0, NULL);
hw.irq = bay->cd_irq;
bay->cd_index = ide_register_hw(&hw, NULL);
pmu_resume();
}
if (bay->cd_index == -1) {
......
drivers/scsi/ide-scsi.c
View file @ 4478f040
......@@ -234,12 +234,17 @@ static void hexdump(u8 *x, int len)
printk("]\n");
}
static inline idescsi_scsi_t *idescsi_private(struct Scsi_Host *host)
{
return (idescsi_scsi_t*) &host[1];
}
static int idescsi_end_request(struct ata_device *drive, struct request *rq, int uptodate)
{
idescsi_scsi_t *scsi = drive->driver_data;
struct Scsi_Host *host = drive->driver_data;
idescsi_scsi_t *scsi = idescsi_private(host);
struct atapi_packet_command *pc = (struct atapi_packet_command *) rq->special;
int log = test_bit(IDESCSI_LOG_CMD, &scsi->log);
struct Scsi_Host *host;
u8 *scsi_buf;
unsigned long flags;
......@@ -289,20 +294,21 @@ static inline unsigned long get_timeout(struct atapi_packet_command *pc)
*/
static ide_startstop_t idescsi_pc_intr(struct ata_device *drive, struct request *rq)
{
idescsi_scsi_t *scsi = drive->driver_data;
struct Scsi_Host *host = drive->driver_data;
idescsi_scsi_t *scsi = idescsi_private(host);
byte status, ireason;
int bcount;
struct atapi_packet_command *pc = scsi->pc;
struct atapi_packet_command *pc=scsi->pc;
unsigned int temp;
#if IDESCSI_DEBUG_LOG
printk (KERN_INFO "ide-scsi: Reached idescsi_pc_intr interrupt handler\n");
#endif
#endif /* IDESCSI_DEBUG_LOG */
if (test_and_clear_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {
if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
#if IDESCSI_DEBUG_LOG
printk ("ide-scsi: %s: DMA complete\n", drive->name);
#endif
#endif /* IDESCSI_DEBUG_LOG */
pc->actually_transferred=pc->request_transfer;
udma_stop(drive);
}
......@@ -372,7 +378,8 @@ static ide_startstop_t idescsi_pc_intr(struct ata_device *drive, struct request
static ide_startstop_t idescsi_transfer_pc(struct ata_device *drive, struct request *rq)
{
idescsi_scsi_t *scsi = drive->driver_data;
struct Scsi_Host *host = drive->driver_data;
idescsi_scsi_t *scsi = idescsi_private(host);
struct atapi_packet_command *pc = scsi->pc;
byte ireason;
ide_startstop_t startstop;
......@@ -397,7 +404,8 @@ static ide_startstop_t idescsi_transfer_pc(struct ata_device *drive, struct requ
static ide_startstop_t idescsi_issue_pc(struct ata_device *drive, struct request *rq,
struct atapi_packet_command *pc)
{
idescsi_scsi_t *scsi = drive->driver_data;
struct Scsi_Host *host = drive->driver_data;
idescsi_scsi_t *scsi = idescsi_private(host);
int bcount;
int dma_ok = 0;
......@@ -463,36 +471,14 @@ static void idescsi_ide_release(struct inode *inode, struct file *filp, struct a
MOD_DEC_USE_COUNT;
}
static struct ata_device *idescsi_drives[MAX_HWIFS * MAX_DRIVES];
static int idescsi_initialized = 0;
/*
* Driver initialization.
*/
static void idescsi_setup(struct ata_device *drive, idescsi_scsi_t *scsi, int id)
{
idescsi_drives[id] = drive;
drive->driver_data = scsi;
drive->ready_stat = 0;
memset (scsi, 0, sizeof (idescsi_scsi_t));
scsi->drive = drive;
if (drive->id && (drive->id->config & 0x0060) == 0x20)
set_bit (IDESCSI_DRQ_INTERRUPT, &scsi->flags);
set_bit(IDESCSI_TRANSFORM, &scsi->transform);
clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
#if IDESCSI_DEBUG_LOG
set_bit(IDESCSI_LOG_CMD, &scsi->log);
#endif
}
static int idescsi_cleanup(struct ata_device *drive)
static int idescsi_cleanup (struct ata_device *drive)
{
idescsi_scsi_t *scsi = drive->driver_data;
struct Scsi_Host *host = drive->driver_data;
if (ide_unregister_subdriver (drive))
if (ide_unregister_subdriver (drive)) {
return 1;
drive->driver_data = NULL;
kfree (scsi);
}
scsi_unregister(host);
return 0;
}
......@@ -522,73 +508,9 @@ static struct ata_operations idescsi_driver = {
capacity: NULL,
};
static void idescsi_attach(struct ata_device *drive)
{
idescsi_scsi_t *scsi;
int i, id;
char *req;
struct ata_channel *channel;
int unit;
if (idescsi_initialized)
return;
idescsi_initialized = 1;
for (i = 0; i < MAX_HWIFS * MAX_DRIVES; i++)
idescsi_drives[i] = NULL;
req = drive->driver_req;
if (req[0] != '\0' && strcmp(req, "ide-scsi"))
return;
if ((scsi = (idescsi_scsi_t *) kmalloc (sizeof (idescsi_scsi_t), GFP_KERNEL)) == NULL) {
printk(KERN_ERR "ide-scsi: %s: Can't allocate a scsi structure\n", drive->name);
return;
}
if (ide_register_subdriver (drive, &idescsi_driver)) {
printk(KERN_ERR "ide-scsi: %s: Failed to register the driver with ide.c\n", drive->name);
kfree (scsi);
return;
}
for (id = 0; id < MAX_HWIFS * MAX_DRIVES && idescsi_drives[id]; id++);
idescsi_setup (drive, scsi, id);
channel = drive->channel;
unit = drive - channel->drives;
ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
}
int idescsi_detect (Scsi_Host_Template *host_template)
{
struct Scsi_Host *host;
int id;
int last_lun = 0;
host_template->proc_name = "ide-scsi";
host = scsi_register(host_template, 0);
if(host == NULL)
return 0;
for (id = 0; id < MAX_HWIFS * MAX_DRIVES && idescsi_drives[id]; id++)
last_lun = max(last_lun, idescsi_drives[id]->last_lun);
host->max_id = id;
host->max_lun = last_lun + 1;
host->can_queue = host->cmd_per_lun * id;
return 1;
}
int idescsi_release (struct Scsi_Host *host)
{
struct ata_device *drive;
int id;
for (id = 0; id < MAX_HWIFS * MAX_DRIVES; id++) {
drive = idescsi_drives[id];
if (drive) {
MOD_DEC_USE_COUNT;
}
}
return 0;
return register_ata_driver(&idescsi_driver);
}
const char *idescsi_info (struct Scsi_Host *host)
......@@ -598,8 +520,7 @@ const char *idescsi_info (struct Scsi_Host *host)
int idescsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
{
struct ata_device *drive = idescsi_drives[dev->id];
idescsi_scsi_t *scsi = drive->driver_data;
idescsi_scsi_t *scsi = idescsi_private(dev->host);
if (cmd == SG_SET_TRANSFORM) {
if (arg)
......@@ -693,7 +614,8 @@ static inline struct bio *idescsi_dma_bio(struct ata_device *drive, struct atapi
static inline int should_transform(struct ata_device *drive, Scsi_Cmnd *cmd)
{
idescsi_scsi_t *scsi = drive->driver_data;
struct Scsi_Host *host = drive->driver_data;
idescsi_scsi_t *scsi = idescsi_private(host);
if (major(cmd->request.rq_dev) == SCSI_GENERIC_MAJOR)
return test_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
......@@ -702,16 +624,11 @@ static inline int should_transform(struct ata_device *drive, Scsi_Cmnd *cmd)
int idescsi_queue (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
{
struct ata_device *drive = idescsi_drives[cmd->target];
idescsi_scsi_t *scsi;
idescsi_scsi_t *scsi = idescsi_private(cmd->host);
struct ata_device *drive = scsi->drive;
struct request *rq = NULL;
struct atapi_packet_command *pc = NULL;
if (!drive) {
printk (KERN_ERR "ide-scsi: drive id %d not present\n", cmd->target);
goto abort;
}
scsi = drive->driver_data;
pc = kmalloc(sizeof(*pc), GFP_ATOMIC);
rq = kmalloc(sizeof(*rq), GFP_ATOMIC);
if (rq == NULL || pc == NULL) {
......@@ -774,7 +691,8 @@ int idescsi_device_reset (Scsi_Cmnd *cmd)
int idescsi_bios (Disk *disk, kdev_t dev, int *parm)
{
struct ata_device *drive = idescsi_drives[disk->device->id];
idescsi_scsi_t *scsi = idescsi_private(disk->device->host);
struct ata_device *drive = scsi->drive;
if (drive->bios_cyl && drive->bios_head && drive->bios_sect) {
parm[0] = drive->bios_head;
......@@ -788,7 +706,10 @@ static Scsi_Host_Template idescsi_template = {
module: THIS_MODULE,
name: "idescsi",
detect: idescsi_detect,
release: idescsi_release,
release: NULL, /* unregister_ata_driver is always
called before scsi_unregister_host,
there never controllers left to
release by that point. */
info: idescsi_info,
ioctl: idescsi_ioctl,
queuecommand: idescsi_queue,
......@@ -801,33 +722,65 @@ static Scsi_Host_Template idescsi_template = {
cmd_per_lun: 5,
use_clustering: DISABLE_CLUSTERING,
emulated: 1,
proc_name: "ide-scsi",
};
static int __init idescsi_init(void)
/*
* Driver initialization.
*/
static void idescsi_attach(struct ata_device *drive)
{
int ret;
ret = ata_driver_module(&idescsi_driver);
scsi_register_host(&idescsi_template);
return 0;
}
idescsi_scsi_t *scsi;
struct Scsi_Host *host;
static void __exit exit_idescsi_module(void)
{
scsi_unregister_host(&idescsi_template);
#if 0
/* FIXME: what about this cleanup stuff here? This all should be done
* on close time perhaps? */
if (drive->type == ATA_DISK)
return;
host = scsi_register(&idescsi_template, sizeof(idescsi_scsi_t));
if(host == NULL) {
printk (KERN_ERR
"ide-scsi: %s: Can't allocate a scsi host structure\n",
drive->name);
return;
}
host->max_lun = drive->last_lun + 1;
if (idescsi_cleanup (drive)) {
printk ("%s: exit_idescsi_module() called while still busy\n", drive->name);
if (ide_register_subdriver (drive, &idescsi_driver)) {
printk (KERN_ERR "ide-scsi: %s: Failed to register the driver with ide.c\n", drive->name);
scsi_unregister(host);
return;
}
drive->driver_data = host;
drive->ready_stat = 0;
scsi = idescsi_private(host);
memset (scsi, 0, sizeof (idescsi_scsi_t));
scsi->drive = drive;
if (drive->id && (drive->id->config & 0x0060) == 0x20)
set_bit (IDESCSI_DRQ_INTERRUPT, &scsi->flags);
set_bit(IDESCSI_TRANSFORM, &scsi->transform);
clear_bit(IDESCSI_SG_TRANSFORM, &scsi->transform);
#if IDESCSI_DEBUG_LOG
set_bit(IDESCSI_LOG_CMD, &scsi->log);
#endif
}
static int __init init_idescsi_module(void)
{
return scsi_register_host(&idescsi_template);
}
static void __exit exit_idescsi_module(void)
{
unregister_ata_driver(&idescsi_driver);
scsi_unregister_host(&idescsi_template);
}
module_init(idescsi_init);
module_init(init_idescsi_module);
module_exit(exit_idescsi_module);
MODULE_LICENSE("GPL");
include/linux/atapi.h
View file @ 4478f040
......@@ -58,8 +58,11 @@ struct atapi_packet_command {
} s;
};
extern void atapi_init_pc(struct atapi_packet_command *pc);
extern void atapi_discard_data(struct ata_device *drive, unsigned int bcount);
extern void atapi_write_zeros(struct ata_device *drive, unsigned int bcount);
extern void atapi_discard_data(struct ata_device *, unsigned int);
extern void atapi_write_zeros(struct ata_device *, unsigned int);
extern void atapi_read(struct ata_device *, u8 *, unsigned int);
extern void atapi_write(struct ata_device *, u8 *, unsigned int);
extern void atapi_init_pc(struct atapi_packet_command *pc);
include/linux/ide.h
View file @ 4478f040
......@@ -742,9 +742,6 @@ struct ata_taskfile {
extern void ata_read(struct ata_device *, void *, unsigned int);
extern void ata_write(struct ata_device *, void *, unsigned int);
extern void atapi_read(struct ata_device *, void *, unsigned int);
extern void atapi_write(struct ata_device *, void *, unsigned int);
extern ide_startstop_t ata_taskfile(struct ata_device *,
struct ata_taskfile *, struct request *);
......@@ -811,7 +808,8 @@ extern int idescsi_init (void);
extern int ide_register_subdriver(struct ata_device *, struct ata_operations *);
extern int ide_unregister_subdriver(struct ata_device *drive);
extern int ide_revalidate_disk(kdev_t i_rdev);
extern int ata_revalidate(kdev_t i_rdev);
extern void ide_driver_module(void);
#ifdef CONFIG_PCI
# define ON_BOARD 0
......
include/linux/pci_ids.h
View file @ 4478f040
......@@ -1787,3 +1787,7 @@
#define PCI_DEVICE_ID_MICROGATE_USC 0x0010
#define PCI_DEVICE_ID_MICROGATE_SCC 0x0020
#define PCI_DEVICE_ID_MICROGATE_SCA 0x0030
#define PCI_VENDOR_ID_HINT 0x3388
#define PCI_DEVICE_ID_HINT_VXPROII_IDE 0x8013
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7