Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 7c7e92a9268965e08bba853ecdb94fa55e886741

Authored by Anton Salnikov 2008-02-06 09:57:48 +0800

Committed by Bartlomiej Zolnierkiewicz 2008-02-06 09:57:48 +0800

Exists in master and in 7 other branches

Palmchip BK3710 IDE driver

This is Palmchip BK3710 IDE controller support.

The IDE controller logic supports PIO, MultiWord-DMA and Ultra-DMA modes.
Supports interface to Compact Flash (CF) configured in True-IDE mode.

Bart:
- remove dead code
- fix ide_hwif_setup_dma() build problem

Signed-off-by: Anton Salnikov <asalnikov@ru.mvista.com>
Reviewed-by: Alan Cox <alan@lxorguk.ukuu.org.uk>
Reviewed-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>

Showing 5 changed files with 409 additions and 2 deletions Inline Diff

drivers/ide/Kconfig
drivers/ide/arm/Makefile
drivers/ide/arm/palm_bk3710.c
drivers/ide/ide-proc.c
include/linux/ide.h

drivers/ide/Kconfig

Diff comments View file @ 7c7e92a

 #
 # IDE ATA ATAPI Block device driver configuration
 #
 # Andre Hedrick <andre@linux-ide.org>
 #
 menuconfig IDE
 	tristate "ATA/ATAPI/MFM/RLL support"
 	depends on BLOCK
 	depends on HAS_IOMEM
 	---help---
 	  If you say Y here, your kernel will be able to manage low cost mass
 	  storage units such as ATA/(E)IDE and ATAPI units. The most common
 	  cases are IDE hard drives and ATAPI CD-ROM drives.
 	  If your system is pure SCSI and doesn't use these interfaces, you
 	  can say N here.
 	  Integrated Disk Electronics (IDE aka ATA-1) is a connecting standard
 	  for mass storage units such as hard disks. It was designed by
 	  Western Digital and Compaq Computer in 1984. It was then named
 	  ST506. Quite a number of disks use the IDE interface.
 	  AT Attachment (ATA) is the superset of the IDE specifications.
 	  ST506 was also called ATA-1.
 	  Fast-IDE is ATA-2 (also named Fast ATA), Enhanced IDE (EIDE) is
 	  ATA-3. It provides support for larger disks (up to 8.4GB by means of
 	  the LBA standard), more disks (4 instead of 2) and for other mass
 	  storage units such as tapes and cdrom. UDMA/33 (aka UltraDMA/33) is
 	  ATA-4 and provides faster (and more CPU friendly) transfer modes
 	  than previous PIO (Programmed processor Input/Output) from previous
 	  ATA/IDE standards by means of fast DMA controllers.
 	  ATA Packet Interface (ATAPI) is a protocol used by EIDE tape and
 	  CD-ROM drives, similar in many respects to the SCSI protocol.
 	  SMART IDE (Self Monitoring, Analysis and Reporting Technology) was
 	  designed in order to prevent data corruption and disk crash by
 	  detecting pre hardware failure conditions (heat, access time, and
 	  the like...). Disks built since June 1995 may follow this standard.
 	  The kernel itself doesn't manage this; however there are quite a
 	  number of user programs such as smart that can query the status of
 	  SMART parameters from disk drives.
 	  To compile this driver as a module, choose M here: the
 	  module will be called ide.
 	  For further information, please read <file:Documentation/ide.txt>.
 	  If unsure, say Y.
 if IDE
 config IDE_MAX_HWIFS
 	int "Max IDE interfaces"
 	depends on ALPHA || SUPERH || IA64 || EMBEDDED
 	range 1 10
 	default 4
 	help
 	  This is the maximum number of IDE hardware interfaces that will
 	  be supported by the driver. Make sure it is at least as high as
 	  the number of IDE interfaces in your system.
 config BLK_DEV_IDE
 	tristate "Enhanced IDE/MFM/RLL disk/cdrom/tape/floppy support"
 	---help---
 	  If you say Y here, you will use the full-featured IDE driver to
 	  control up to ten ATA/IDE interfaces, each being able to serve a
 	  "master" and a "slave" device, for a total of up to twenty ATA/IDE
 	  disk/cdrom/tape/floppy drives.
 	  Useful information about large (>540 MB) IDE disks, multiple
 	  interfaces, what to do if ATA/IDE devices are not automatically
 	  detected, sound card ATA/IDE ports, module support, and other
 	  topics, is contained in <file:Documentation/ide.txt>. For detailed
 	  information about hard drives, consult the Disk-HOWTO and the
 	  Multi-Disk-HOWTO, available from
 	  <http://www.tldp.org/docs.html#howto>.
 	  To fine-tune ATA/IDE drive/interface parameters for improved
 	  performance, look for the hdparm package at
 	  <ftp://ibiblio.org/pub/Linux/system/hardware/>.
 	  To compile this driver as a module, choose M here and read
 	  <file:Documentation/ide.txt>. The module will be called ide-mod.
 	  Do not compile this driver as a module if your root file system (the
 	  one containing the directory /) is located on an IDE device.
 	  If you have one or more IDE drives, say Y or M here. If your system
 	  has no IDE drives, or if memory requirements are really tight, you
 	  could say N here, and select the "Old hard disk driver" below
 	  instead to save about 13 KB of memory in the kernel.
 if BLK_DEV_IDE
 comment "Please see Documentation/ide.txt for help/info on IDE drives"
 config BLK_DEV_IDE_SATA
 	bool "Support for SATA (deprecated; conflicts with libata SATA driver)"
 	default n
 	---help---
 	  There are two drivers for Serial ATA controllers.
 	  The main driver, "libata", uses the SCSI subsystem
 	  and supports most modern SATA controllers. In order to use it
 	  you may take a look at "Serial ATA (prod) and Parallel ATA
 	  (experimental) drivers".
 	  The IDE driver (which you are currently configuring) supports
 	  a few first-generation SATA controllers.
 	  In order to eliminate conflicts between the two subsystems,
 	  this config option enables the IDE driver's SATA support.
 	  Normally this is disabled, as it is preferred that libata
 	  supports SATA controllers, and this (IDE) driver supports
 	  PATA controllers.
 	  If unsure, say N.
 config BLK_DEV_HD_IDE
 	bool "Use old disk-only driver on primary interface"
 	depends on (X86 || SH_MPC1211)
 	---help---
 	  There are two drivers for MFM/RLL/IDE disks.  Most people use just
 	  the new enhanced driver by itself.  This option however installs the
 	  old hard disk driver to control the primary IDE/disk interface in
 	  the system, leaving the new enhanced IDE driver to take care of only
 	  the 2nd/3rd/4th IDE interfaces.  Doing this will prevent you from
 	  having an IDE/ATAPI CD-ROM or tape drive connected to the primary
 	  IDE interface.  Choosing this option may be useful for older systems
 	  which have MFM/RLL/ESDI controller+drives at the primary port
 	  address (0x1f0), along with IDE drives at the secondary/3rd/4th port
 	  addresses.
 	  Normally, just say N here; you will then use the new driver for all
 	  4 interfaces.
 config BLK_DEV_IDEDISK
 	tristate "Include IDE/ATA-2 DISK support"
 	---help---
 	  This will include enhanced support for MFM/RLL/IDE hard disks.  If
 	  you have a MFM/RLL/IDE disk, and there is no special reason to use
 	  the old hard disk driver instead, say Y.  If you have an SCSI-only
 	  system, you can say N here.
 	  To compile this driver as a module, choose M here: the
 	  module will be called ide-disk.
 	  Do not compile this driver as a module if your root file system
 	  (the one containing the directory /) is located on the IDE disk.
 	  If unsure, say Y.
 config IDEDISK_MULTI_MODE
 	bool "Use multiple sector mode for Programmed Input/Output by default"
 	help
 	  This setting is irrelevant for most IDE disks, with direct memory
 	  access, to which multiple sector mode does not apply. Multiple sector
 	  mode is a feature of most modern IDE hard drives, permitting the
 	  transfer of multiple sectors per Programmed Input/Output interrupt,
 	  rather than the usual one sector per interrupt. When this feature is
 	  enabled, it can reduce operating system overhead for disk Programmed
 	  Input/Output. On some systems, it also can increase the data
 	  throughput of Programmed Input/Output. Some drives, however, seemed
 	  to run slower with multiple sector mode enabled. Some drives claimed
 	  to support multiple sector mode, but lost data at some settings.
 	  Under rare circumstances, such failures could result in massive
 	  filesystem corruption.
 	  If you get the following error, try to say Y here:
 	  hda: set_multmode: status=0x51 { DriveReady SeekComplete Error }
 	  hda: set_multmode: error=0x04 { DriveStatusError }
 	  If in doubt, say N.
 config BLK_DEV_IDECS
 	tristate "PCMCIA IDE support"
 	depends on PCMCIA
 	help
 	  Support for Compact Flash cards, outboard IDE disks, tape drives,
 	  and CD-ROM drives connected through a PCMCIA card.
 config BLK_DEV_DELKIN
 	tristate "Cardbus IDE support (Delkin/ASKA/Workbit)"
 	depends on CARDBUS && PCI
 	help
 	  Support for Delkin, ASKA, and Workbit Cardbus CompactFlash
 	  Adapters.  This may also work for similar SD and XD adapters.
 config BLK_DEV_IDECD
 	tristate "Include IDE/ATAPI CDROM support"
 	---help---
 	  If you have a CD-ROM drive using the ATAPI protocol, say Y. ATAPI is
 	  a newer protocol used by IDE CD-ROM and TAPE drives, similar to the
 	  SCSI protocol. Most new CD-ROM drives use ATAPI, including the
 	  NEC-260, Mitsumi FX400, Sony 55E, and just about all non-SCSI
 	  double(2X) or better speed drives.
 	  If you say Y here, the CD-ROM drive will be identified at boot time
 	  along with other IDE devices, as "hdb" or "hdc", or something
 	  similar (check the boot messages with dmesg). If this is your only
 	  CD-ROM drive, you can say N to all other CD-ROM options, but be sure
 	  to say Y or M to "ISO 9660 CD-ROM file system support".
 	  To compile this driver as a module, choose M here: the
 	  module will be called ide-cd.
 config BLK_DEV_IDECD_VERBOSE_ERRORS
 	bool "Verbose error logging for IDE/ATAPI CDROM driver" if EMBEDDED
 	depends on BLK_DEV_IDECD
 	default y
 	help
 	  Turn this on to have the driver print out the meanings of the
 	  ATAPI error codes.  This will use up additional 8kB of kernel-space
 	  memory, though.
 config BLK_DEV_IDETAPE
 	tristate "Include IDE/ATAPI TAPE support"
 	help
 	  If you have an IDE tape drive using the ATAPI protocol, say Y.
 	  ATAPI is a newer protocol used by IDE tape and CD-ROM drives,
 	  similar to the SCSI protocol.  If you have an SCSI tape drive
 	  however, you can say N here.
 	  You should also say Y if you have an OnStream DI-30 tape drive; this
 	  will not work with the SCSI protocol, until there is support for the
 	  SC-30 and SC-50 versions.
 	  If you say Y here, the tape drive will be identified at boot time
 	  along with other IDE devices, as "hdb" or "hdc", or something
 	  similar, and will be mapped to a character device such as "ht0"
 	  (check the boot messages with dmesg).  Be sure to consult the
 	  <file:drivers/ide/ide-tape.c> and <file:Documentation/ide.txt> files
 	  for usage information.
 	  To compile this driver as a module, choose M here: the
 	  module will be called ide-tape.
 config BLK_DEV_IDEFLOPPY
 	tristate "Include IDE/ATAPI FLOPPY support"
 	---help---
 	  If you have an IDE floppy drive which uses the ATAPI protocol,
 	  answer Y.  ATAPI is a newer protocol used by IDE CD-ROM/tape/floppy
 	  drives, similar to the SCSI protocol.
 	  The LS-120 and the IDE/ATAPI Iomega ZIP drive are also supported by
 	  this driver. For information about jumper settings and the question
 	  of when a ZIP drive uses a partition table, see
 	  <http://www.win.tue.nl/~aeb/linux/zip/zip-1.html>.
 	  (ATAPI PD-CD/CDR drives are not supported by this driver; support
 	  for PD-CD/CDR drives is available if you answer Y to
 	  "SCSI emulation support", below).
 	  If you say Y here, the FLOPPY drive will be identified along with
 	  other IDE devices, as "hdb" or "hdc", or something similar (check
 	  the boot messages with dmesg).
 	  To compile this driver as a module, choose M here: the
 	  module will be called ide-floppy.
 config BLK_DEV_IDESCSI
 	tristate "SCSI emulation support"
 	depends on SCSI
 	---help---
 	  WARNING: ide-scsi is no longer needed for cd writing applications!
 	  The 2.6 kernel supports direct writing to ide-cd, which eliminates
 	  the need for ide-scsi + the entire scsi stack just for writing a
 	  cd. The new method is more efficient in every way.
 	  This will provide SCSI host adapter emulation for IDE ATAPI devices,
 	  and will allow you to use a SCSI device driver instead of a native
 	  ATAPI driver.
 	  This is useful if you have an ATAPI device for which no native
 	  driver has been written (for example, an ATAPI PD-CD drive);
 	  you can then use this emulation together with an appropriate SCSI
 	  device driver. In order to do this, say Y here and to "SCSI support"
 	  and "SCSI generic support", below. You must then provide the kernel
 	  command line "hdx=ide-scsi" (try "man bootparam" or see the
 	  documentation of your boot loader (lilo or loadlin) about how to
 	  pass options to the kernel at boot time) for devices if you want the
 	  native EIDE sub-drivers to skip over the native support, so that
 	  this SCSI emulation can be used instead.
 	  Note that this option does NOT allow you to attach SCSI devices to a
 	  box that doesn't have a SCSI host adapter installed.
 	  If both this SCSI emulation and native ATAPI support are compiled
 	  into the kernel, the native support will be used.
 config BLK_DEV_IDEACPI
 	bool "IDE ACPI support"
 	depends on ACPI
 	---help---
 	  Implement ACPI support for generic IDE devices. On modern
 	  machines ACPI support is required to properly handle ACPI S3 states.
 config IDE_TASK_IOCTL
 	bool "IDE Taskfile Access"
 	help
 	  This is a direct raw access to the media.  It is a complex but
 	  elegant solution to test and validate the domain of the hardware and
 	  perform below the driver data recovery if needed.  This is the most
 	  basic form of media-forensics.
 	  If you are unsure, say N here.
 config IDE_PROC_FS
 	bool "legacy /proc/ide/ support"
 	depends on IDE && PROC_FS
 	default y
 	help
 	  This option enables support for the various files in
 	  /proc/ide.  In Linux 2.6 this has been superseded by
 	  files in sysfs but many legacy applications rely on this.
 	  If unsure say Y.
 comment "IDE chipset support/bugfixes"
 config IDE_GENERIC
 	tristate "generic/default IDE chipset support"
 	help
 	  If unsure, say N.
 config BLK_DEV_PLATFORM
 	tristate "Platform driver for IDE interfaces"
 	help
 	  This is the platform IDE driver, used mostly for Memory Mapped
 	  IDE devices, like Compact Flashes running in True IDE mode.
 	  If unsure, say N.
 config BLK_DEV_CMD640
 	tristate "CMD640 chipset bugfix/support"
 	depends on X86
 	---help---
 	  The CMD-Technologies CMD640 IDE chip is used on many common 486 and
 	  Pentium motherboards, usually in combination with a "Neptune" or
 	  "SiS" chipset. Unfortunately, it has a number of rather nasty
 	  design flaws that can cause severe data corruption under many common
 	  conditions. Say Y here to include code which tries to automatically
 	  detect and correct the problems under Linux. This option also
 	  enables access to the secondary IDE ports in some CMD640 based
 	  systems.
 	  This driver will work automatically in PCI based systems (most new
 	  systems have PCI slots). But if your system uses VESA local bus
 	  (VLB) instead of PCI, you must also supply a kernel boot parameter
 	  to enable the CMD640 bugfix/support: "ide0=cmd640_vlb". (Try "man
 	  bootparam" or see the documentation of your boot loader about how to
 	  pass options to the kernel.)
 	  The CMD640 chip is also used on add-in cards by Acculogic, and on
 	  the "CSA-6400E PCI to IDE controller" that some people have. For
 	  details, read <file:Documentation/ide.txt>.
 config BLK_DEV_CMD640_ENHANCED
 	bool "CMD640 enhanced support"
 	depends on BLK_DEV_CMD640
 	help
 	  This option includes support for setting/autotuning PIO modes and
 	  prefetch on CMD640 IDE interfaces.  For details, read
 	  <file:Documentation/ide.txt>. If you have a CMD640 IDE interface
 	  and your BIOS does not already do this for you, then say Y here.
 	  Otherwise say N.
 config BLK_DEV_IDEPNP
 	tristate "PNP EIDE support"
 	depends on PNP
 	help
 	  If you have a PnP (Plug and Play) compatible EIDE card and
 	  would like the kernel to automatically detect and activate
 	  it, say Y here.
 if PCI
 comment "PCI IDE chipsets support"
 config BLK_DEV_IDEPCI
 	bool
 config IDEPCI_PCIBUS_ORDER
 	bool "Probe IDE PCI devices in the PCI bus order (DEPRECATED)"
 	depends on BLK_DEV_IDE=y && BLK_DEV_IDEPCI
 	default y
 	help
 	  Probe IDE PCI devices in the order in which they appear on the
 	  PCI bus (i.e. 00:1f.1 PCI device before 02:01.0 PCI device)
 	  instead of the order in which IDE PCI host drivers are loaded.
 	  Please note that this method of assuring stable naming of
 	  IDE devices is unreliable and use other means for achieving
 	  it (i.e. udev).
 	  If in doubt, say N.
 # TODO: split it on per host driver config options (or module parameters)
 config BLK_DEV_OFFBOARD
 	bool "Boot off-board chipsets first support (DEPRECATED)"
 	depends on BLK_DEV_IDEPCI && (BLK_DEV_AEC62XX || BLK_DEV_GENERIC || BLK_DEV_HPT34X || BLK_DEV_HPT366 || BLK_DEV_PDC202XX_NEW || BLK_DEV_PDC202XX_OLD || BLK_DEV_TC86C001)
 	help
 	  Normally, IDE controllers built into the motherboard (on-board
 	  controllers) are assigned to ide0 and ide1 while those on add-in PCI
 	  cards (off-board controllers) are relegated to ide2 and ide3.
 	  Answering Y here will allow you to reverse the situation, with
 	  off-board controllers on ide0/1 and on-board controllers on ide2/3.
 	  This can improve the usability of some boot managers such as lilo
 	  when booting from a drive on an off-board controller.
 	  If you say Y here, and you actually want to reverse the device scan
 	  order as explained above, you also need to issue the kernel command
 	  line option "ide=reverse". (Try "man bootparam" or see the
 	  documentation of your boot loader (lilo or loadlin) about how to
 	  pass options to the kernel at boot time.)
 	  Note that, if you do this, the order of the hd* devices will be
 	  rearranged which may require modification of fstab and other files.
 	  Please also note that this method of assuring stable naming of
 	  IDE devices is unreliable and use other means for achieving it
 	  (i.e. udev).
 	  If in doubt, say N.
 config BLK_DEV_GENERIC
 	tristate "Generic PCI IDE Chipset Support"
 	select BLK_DEV_IDEPCI
         help
           This option provides generic support for various PCI IDE Chipsets
           which otherwise might not be supported.
 config BLK_DEV_OPTI621
 	tristate "OPTi 82C621 chipset enhanced support (EXPERIMENTAL)"
 	depends on EXPERIMENTAL
 	select BLK_DEV_IDEPCI
 	help
 	  This is a driver for the OPTi 82C621 EIDE controller.
 	  Please read the comments at the top of <file:drivers/ide/pci/opti621.c>.
 config BLK_DEV_RZ1000
 	tristate "RZ1000 chipset bugfix/support"
 	depends on X86
 	select BLK_DEV_IDEPCI
 	help
 	  The PC-Technologies RZ1000 IDE chip is used on many common 486 and
 	  Pentium motherboards, usually along with the "Neptune" chipset.
 	  Unfortunately, it has a rather nasty design flaw that can cause
 	  severe data corruption under many conditions. Say Y here to include
 	  code which automatically detects and corrects the problem under
 	  Linux. This may slow disk throughput by a few percent, but at least
 	  things will operate 100% reliably.
 config BLK_DEV_IDEDMA_PCI
 	bool
 	select BLK_DEV_IDEPCI
 config BLK_DEV_AEC62XX
 	tristate "AEC62XX chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  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 BLK_DEV_ALI15X3
 	tristate "ALI M15x3 chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver ensures (U)DMA support for ALI 1533, 1543 and 1543C
 	  onboard chipsets.  It also tests for Simplex mode and enables
 	  normal dual channel support.
 	  If you say Y here, you also need to say Y to "Use DMA by default
 	  when available", above.  Please read the comments at the top of
 	  <file:drivers/ide/pci/alim15x3.c>.
 	  If unsure, say N.
 config WDC_ALI15X3
 	bool "ALI M15x3 WDC support (DANGEROUS)"
 	depends on BLK_DEV_ALI15X3
 	---help---
 	  This allows for UltraDMA support for WDC drives that ignore CRC
 	  checking. You are a fool for enabling this option, but there have
 	  been requests. DO NOT COMPLAIN IF YOUR DRIVE HAS FS CORRUPTION, IF
 	  YOU ENABLE THIS! No one will listen, just laugh for ignoring this
 	  SERIOUS WARNING.
 	  Using this option can allow WDC drives to run at ATA-4/5 transfer
 	  rates with only an ATA-2 support structure.
 	  SAY N!
 config BLK_DEV_AMD74XX
 	tristate "AMD and nVidia IDE support"
 	depends on !ARM
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds explicit support for AMD-7xx and AMD-8111 chips
 	  and also for the nVidia nForce chip.  This allows the kernel to
 	  change PIO, DMA and UDMA speeds and to configure the chip to
 	  optimum performance.
 config BLK_DEV_ATIIXP
 	tristate "ATI IXP chipset IDE support"
 	depends on X86
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds explicit support for ATI IXP chipset.
 	  This allows the kernel to change PIO, DMA and UDMA speeds
 	  and to configure the chip to optimum performance.
 	  Say Y here if you have an ATI IXP chipset IDE controller.
 config BLK_DEV_CMD64X
 	tristate "CMD64{3|6|8|9} chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  Say Y here if you have an IDE controller which uses any of these
 	  chipsets: CMD643, CMD646, or CMD648.
 config BLK_DEV_TRIFLEX
 	tristate "Compaq Triflex IDE support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  Say Y here if you have a Compaq Triflex IDE controller, such
 	  as those commonly found on Compaq Pentium-Pro systems
 config BLK_DEV_CY82C693
 	tristate "CY82C693 chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds detection and support for the CY82C693 chipset
 	  used on Digital's PC-Alpha 164SX boards.
 	  If you say Y here, you need to say Y to "Use DMA by default
 	  when available" as well.
 config BLK_DEV_CS5520
 	tristate "Cyrix CS5510/20 MediaGX chipset support (VERY EXPERIMENTAL)"
 	depends on EXPERIMENTAL
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  Include support for PIO tuning and virtual DMA on the Cyrix MediaGX
 	  5510/5520 chipset. This will automatically be detected and
 	  configured if found.
 	  It is safe to say Y to this question.
 config BLK_DEV_CS5530
 	tristate "Cyrix/National Semiconductor CS5530 MediaGX chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  Include support for UDMA on the Cyrix MediaGX 5530 chipset. This
 	  will automatically be detected and configured if found.
 	  It is safe to say Y to this question.
 config BLK_DEV_CS5535
 	tristate "AMD CS5535 chipset support"
 	depends on X86 && !X86_64
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  Include support for UDMA on the NSC/AMD CS5535 companion chipset.
 	  This will automatically be detected and configured if found.
 	  It is safe to say Y to this question.
 config BLK_DEV_HPT34X
 	tristate "HPT34X chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds up to 4 more EIDE devices sharing a single
 	  interrupt. The HPT343 chipset in its current form is a non-bootable
 	  controller; the HPT345/HPT363 chipset is a bootable (needs BIOS FIX)
 	  PCI UDMA controllers. This driver requires dynamic tuning of the
 	  chipset during the ide-probe at boot time. It is reported to support
 	  DVD II drives, by the manufacturer.
 config HPT34X_AUTODMA
 	bool "HPT34X AUTODMA support (EXPERIMENTAL)"
 	depends on BLK_DEV_HPT34X && EXPERIMENTAL
 	help
 	  This is a dangerous thing to attempt currently! Please read the
 	  comments at the top of <file:drivers/ide/pci/hpt34x.c>.  If you say Y
 	  here, then say Y to "Use DMA by default when available" as well.
 	  If unsure, say N.
 config BLK_DEV_HPT366
 	tristate "HPT36X/37X chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  HPT366 is an Ultra DMA chipset for ATA-66.
 	  HPT368 is an Ultra DMA chipset for ATA-66 RAID Based.
 	  HPT370 is an Ultra DMA chipset for ATA-100.
 	  HPT372 is an Ultra DMA chipset for ATA-100.
 	  HPT374 is an Ultra DMA chipset for ATA-100.
 	  This driver adds up to 4 more EIDE devices sharing a single
 	  interrupt.
 	  The HPT366 chipset in its current form is bootable. One solution
 	  for this problem are special LILO commands for redirecting the
 	  reference to device 0x80. The other solution is to say Y to "Boot
 	  off-board chipsets first support" (CONFIG_BLK_DEV_OFFBOARD) unless
 	  your mother board has the chipset natively mounted. Regardless one
 	  should use the fore mentioned option and call at LILO or include
 	  "ide=reverse" in LILO's append-line.
 	  This driver requires dynamic tuning of the chipset during the
 	  ide-probe at boot. It is reported to support DVD II drives, by the
 	  manufacturer.
 config BLK_DEV_JMICRON
 	tristate "JMicron JMB36x support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  Basic support for the JMicron ATA controllers. For full support
 	  use the libata drivers.
 config BLK_DEV_SC1200
 	tristate "National SCx200 chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds support for the on-board IDE controller on the
 	  National SCx200 series of embedded x86 "Geode" systems.
 config BLK_DEV_PIIX
 	tristate "Intel PIIXn chipsets support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds explicit support for Intel PIIX and ICH chips
 	  and also for the Efar Victory66 (slc90e66) chip.  This allows
 	  the kernel to change PIO, DMA and UDMA speeds and to configure
 	  the chip to optimum performance.
 config BLK_DEV_IT8213
 	tristate "IT8213 IDE support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	 This driver adds support for the ITE 8213 IDE controller.
 config BLK_DEV_IT821X
 	tristate "IT821X IDE support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds support for the ITE 8211 IDE controller and the
 	  IT 8212 IDE RAID controller in both RAID and pass-through mode.
 config BLK_DEV_NS87415
 	tristate "NS87415 chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds detection and support for the NS87415 chip
 	  (used mainly on SPARC64 and PA-RISC machines).
 	  Please read the comments at the top of <file:drivers/ide/pci/ns87415.c>.
 config BLK_DEV_PDC202XX_OLD
 	tristate "PROMISE PDC202{46|62|65|67} support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  Promise Ultra33 or PDC20246
 	  Promise Ultra66 or PDC20262
 	  Promise Ultra100 or PDC20265/PDC20267/PDC20268
 	  This driver adds up to 4 more EIDE devices sharing a single
 	  interrupt. This add-on card is a bootable PCI UDMA controller. Since
 	  multiple cards can be installed and there are BIOS ROM problems that
 	  happen if the BIOS revisions of all installed cards (three-max) do
 	  not match, the driver attempts to do dynamic tuning of the chipset
 	  at boot-time for max-speed.  Ultra33 BIOS 1.25 or newer is required
 	  for more than one card. This card may require that you say Y to
 	  "Special UDMA Feature".
 	  If you say Y here, you need to say Y to "Use DMA by default when
 	  available" as well.
 	  Please read the comments at the top of
 	  <file:drivers/ide/pci/pdc202xx_old.c>.
 	  If unsure, say N.
 config PDC202XX_BURST
 	bool "Special UDMA Feature"
 	depends on BLK_DEV_PDC202XX_OLD
 	help
 	  This option causes the pdc202xx driver to enable UDMA modes on the
 	  PDC202xx even when the PDC202xx BIOS has not done so.
 	  It was originally designed for the PDC20246/Ultra33, whose BIOS will
 	  only setup UDMA on the first two PDC20246 cards.  It has also been
 	  used successfully on a PDC20265/Ultra100, allowing use of UDMA modes
 	  when the PDC20265 BIOS has been disabled (for faster boot up).
 	  Please read the comments at the top of
 	  <file:drivers/ide/pci/pdc202xx_old.c>.
 	  If unsure, say N.
 config BLK_DEV_PDC202XX_NEW
 	tristate "PROMISE PDC202{68|69|70|71|75|76|77} support"
 	select BLK_DEV_IDEDMA_PCI
 config BLK_DEV_SVWKS
 	tristate "ServerWorks OSB4/CSB5/CSB6 chipsets support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds PIO/(U)DMA support for the ServerWorks OSB4/CSB5
 	  chipsets.
 config BLK_DEV_SGIIOC4
 	tristate "Silicon Graphics IOC4 chipset ATA/ATAPI support"
 	depends on (IA64_SGI_SN2 || IA64_GENERIC) && SGI_IOC4
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds PIO & MultiMode DMA-2 support for the SGI IOC4
 	  chipset, which has one channel and can support two devices.
 	  Please say Y here if you have an Altix System from SGI.
 config BLK_DEV_SIIMAGE
 	tristate "Silicon Image chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds PIO/(U)DMA support for the SI CMD680 and SII
 	  3112 (Serial ATA) chips.
 config BLK_DEV_SIS5513
 	tristate "SiS5513 chipset support"
 	depends on X86
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver ensures (U)DMA support for SIS5513 chipset family based
 	  mainboards.
 	  The following chipsets are supported:
 	  ATA16:  SiS5511, SiS5513
 	  ATA33:  SiS5591, SiS5597, SiS5598, SiS5600
 	  ATA66:  SiS530, SiS540, SiS620, SiS630, SiS640
 	  ATA100: SiS635, SiS645, SiS650, SiS730, SiS735, SiS740,
 	  SiS745, SiS750
 	  If you say Y here, you need to say Y to "Use DMA by default when
 	  available" as well.
 	  Please read the comments at the top of <file:drivers/ide/pci/sis5513.c>.
 config BLK_DEV_SL82C105
 	tristate "Winbond SL82c105 support"
 	depends on (PPC || ARM)
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  If you have a Winbond SL82c105 IDE controller, say Y here to enable
 	  special configuration for this chip. This is common on various CHRP
 	  motherboards, but could be used elsewhere. If in doubt, say Y.
 config BLK_DEV_SLC90E66
 	tristate "SLC90E66 chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver ensures (U)DMA support for Victory66 SouthBridges for
 	  SMsC with Intel NorthBridges.  This is an Ultra66 based chipset.
 	  The nice thing about it is that you can mix Ultra/DMA/PIO devices
 	  and it will handle timing cycles.  Since this is an improved
 	  look-a-like to the PIIX4 it should be a nice addition.
 	  If you say Y here, you need to say Y to "Use DMA by default when
 	  available" as well.
 	  Please read the comments at the top of
 	  <file:drivers/ide/pci/slc90e66.c>.
 config BLK_DEV_TRM290
 	tristate "Tekram TRM290 chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds support for bus master DMA transfers
 	  using the Tekram TRM290 PCI IDE chip. Volunteers are
 	  needed for further tweaking and development.
 	  Please read the comments at the top of <file:drivers/ide/pci/trm290.c>.
 config BLK_DEV_VIA82CXXX
 	tristate "VIA82CXXX chipset support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver adds explicit support for VIA BusMastering IDE chips.
 	  This allows the kernel to change PIO, DMA and UDMA speeds and to
 	  configure the chip to optimum performance.
 config BLK_DEV_TC86C001
 	tristate "Toshiba TC86C001 support"
 	select BLK_DEV_IDEDMA_PCI
 	help
 	This driver adds support for Toshiba TC86C001 GOKU-S chip.
 config BLK_DEV_CELLEB
 	tristate "Toshiba's Cell Reference Set IDE support"
 	depends on PPC_CELLEB
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This driver provides support for the on-board IDE controller on
 	  Toshiba Cell Reference Board.
 	  If unsure, say Y.
 endif
 config BLK_DEV_IDE_PMAC
 	tristate "PowerMac on-board IDE support"
 	depends on PPC_PMAC && IDE=y && BLK_DEV_IDE=y
 	help
 	  This driver provides support for the on-board IDE controller on
 	  most of the recent Apple Power Macintoshes and PowerBooks.
 	  If unsure, say Y.
 config BLK_DEV_IDE_PMAC_ATA100FIRST
 	bool "Probe on-board ATA/100 (Kauai) first"
 	depends on BLK_DEV_IDE_PMAC
 	help
 	  This option will cause the ATA/100 controller found in UniNorth2
 	  based machines (Windtunnel PowerMac, Aluminium PowerBooks, ...)
 	  to be probed before the ATA/66 and ATA/33 controllers. Without
 	  these, those machine used to have the hard disk on hdc and the
 	  CD-ROM on hda. This option changes this to more natural hda for
 	  hard disk and hdc for CD-ROM.
 config BLK_DEV_IDEDMA_PMAC
 	bool "PowerMac IDE DMA support"
 	depends on BLK_DEV_IDE_PMAC
 	select BLK_DEV_IDEDMA_PCI
 	help
 	  This option allows the driver for the on-board IDE controller on
 	  Power Macintoshes and PowerBooks to use DMA (direct memory access)
 	  to transfer data to and from memory.  Saying Y is safe and improves
 	  performance.
 config BLK_DEV_IDE_SWARM
 	tristate "IDE for Sibyte evaluation boards"
 	depends on SIBYTE_SB1xxx_SOC
 config BLK_DEV_IDE_AU1XXX
        bool "IDE for AMD Alchemy Au1200"
        depends on SOC_AU1200
 choice
        prompt "IDE Mode for AMD Alchemy Au1200"
        default CONFIG_BLK_DEV_IDE_AU1XXX_PIO_DBDMA
        depends on SOC_AU1200 && BLK_DEV_IDE_AU1XXX
 config BLK_DEV_IDE_AU1XXX_PIO_DBDMA
        bool "PIO+DbDMA IDE for AMD Alchemy Au1200"
 config BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
        bool "MDMA2+DbDMA IDE for AMD Alchemy Au1200"
        depends on SOC_AU1200 && BLK_DEV_IDE_AU1XXX
 endchoice
 config BLK_DEV_IDE_AU1XXX_SEQTS_PER_RQ
        int "Maximum transfer size (KB) per request (up to 128)"
        default "128"
        depends on BLK_DEV_IDE_AU1XXX
 config IDE_ARM
 	tristate "ARM IDE support"
 	depends on ARM && (ARCH_CLPS7500 || ARCH_RPC || ARCH_SHARK)
 	default y
 config BLK_DEV_IDE_ICSIDE
 	tristate "ICS IDE interface support"
 	depends on ARM && ARCH_ACORN
 	help
 	  On Acorn systems, say Y here if you wish to use the ICS IDE
 	  interface card.  This is not required for ICS partition support.
 	  If you are unsure, say N to this.
 config BLK_DEV_IDEDMA_ICS
 	bool "ICS DMA support"
 	depends on BLK_DEV_IDE_ICSIDE
 	help
 	  Say Y here if you want to add DMA (Direct Memory Access) support to
 	  the ICS IDE driver.
 config BLK_DEV_IDE_RAPIDE
 	tristate "RapIDE interface support"
 	depends on ARM && ARCH_ACORN
 	help
 	  Say Y here if you want to support the Yellowstone RapIDE controller
 	  manufactured for use with Acorn computers.
 config BLK_DEV_IDE_BAST
 	tristate "Simtec BAST / Thorcom VR1000 IDE support"
 	depends on ARM && (ARCH_BAST || MACH_VR1000)
 	help
 	  Say Y here if you want to support the onboard IDE channels on the
 	  Simtec BAST or the Thorcom VR1000
 config ETRAX_IDE
 	tristate "ETRAX IDE support"
 	depends on CRIS && BROKEN
 	select BLK_DEV_IDEDMA
 	help
 	  Enables the ETRAX IDE driver.
 	  You can't use parallel ports or SCSI ports at the same time.
 config ETRAX_IDE_DELAY
 	int "Delay for drives to regain consciousness"
 	depends on ETRAX_IDE && ETRAX_ARCH_V10
 	default 15
 	help
 	  Number of seconds to wait for IDE drives to spin up after an IDE
 	  reset.
 choice
 	prompt "IDE reset pin"
 	depends on ETRAX_IDE && ETRAX_ARCH_V10
 	default ETRAX_IDE_PB7_RESET
 config ETRAX_IDE_PB7_RESET
 	bool "Port_PB_Bit_7"
 	help
 	  IDE reset on pin 7 on port B
 config ETRAX_IDE_G27_RESET
 	bool "Port_G_Bit_27"
 	help
 	  IDE reset on pin 27 on port G
 endchoice
 config IDE_H8300
 	tristate "H8300 IDE support"
 	depends on H8300
 	default y
 	help
 	  Enables the H8300 IDE driver.
 config BLK_DEV_GAYLE
 	tristate "Amiga Gayle IDE interface support"
 	depends on AMIGA
 	help
 	  This is the IDE driver for the Amiga Gayle IDE interface. It supports
 	  both the `A1200 style' and `A4000 style' of the Gayle IDE interface,
 	  This includes on-board IDE interfaces on some Amiga models (A600,
 	  A1200, A4000, and A4000T), and IDE interfaces on the Zorro expansion
 	  bus (M-Tech E-Matrix 530 expansion card).
 	  Say Y if you have an Amiga with a Gayle IDE interface and want to use
 	  IDE devices (hard disks, CD-ROM drives, etc.) that are connected to
 	  it.
 	  Note that you also have to enable Zorro bus support if you want to
 	  use Gayle IDE interfaces on the Zorro expansion bus.
 config BLK_DEV_IDEDOUBLER
 	bool "Amiga IDE Doubler support (EXPERIMENTAL)"
 	depends on BLK_DEV_GAYLE && EXPERIMENTAL
 	---help---
 	  This driver provides support for the so-called `IDE doublers' (made
 	  by various manufacturers, e.g. Eyetech) that can be connected to
 	  the on-board IDE interface of some Amiga models. Using such an IDE
 	  doubler, you can connect up to four instead of two IDE devices to
 	  the Amiga's on-board IDE interface.
 	  Note that the normal Amiga Gayle IDE driver may not work correctly
 	  if you have an IDE doubler and don't enable this driver!
 	  Say Y if you have an IDE doubler.  The driver is enabled at kernel
 	  runtime using the "ide=doubler" kernel boot parameter.
 config BLK_DEV_BUDDHA
 	tristate "Buddha/Catweasel/X-Surf IDE interface support (EXPERIMENTAL)"
 	depends on ZORRO && EXPERIMENTAL
 	help
 	  This is the IDE driver for the IDE interfaces on the Buddha, Catweasel
 	  and X-Surf expansion boards.  It supports up to two interfaces on the
 	  Buddha, three on the Catweasel and two on the X-Surf.
 	  Say Y if you have a Buddha or Catweasel expansion board and want to
 	  use IDE devices (hard disks, CD-ROM drives, etc.) that are connected
 	  to one of its IDE interfaces.
 config BLK_DEV_FALCON_IDE
 	tristate "Falcon IDE interface support"
 	depends on ATARI
 	help
 	  This is the IDE driver for the on-board IDE interface on the Atari
 	  Falcon. Say Y if you have a Falcon and want to use IDE devices (hard
 	  disks, CD-ROM drives, etc.) that are connected to the on-board IDE
 	  interface.
 config BLK_DEV_MAC_IDE
 	tristate "Macintosh Quadra/Powerbook IDE interface support"
 	depends on MAC
 	help
 	  This is the IDE driver for the on-board IDE interface on some m68k
 	  Macintosh models. It supports both the `Quadra style' (used in
 	  Quadra/ Centris 630 and Performa 588 models) and `Powerbook style'
 	  (used in the Powerbook 150 and 190 models) IDE interface.
 	  Say Y if you have such an Macintosh model and want to use IDE
 	  devices (hard disks, CD-ROM drives, etc.) that are connected to the
 	  on-board IDE interface.
 config BLK_DEV_Q40IDE
 	tristate "Q40/Q60 IDE interface support"
 	depends on Q40
 	help
 	  Enable the on-board IDE controller in the Q40/Q60.  This should
 	  normally be on; disable it only if you are running a custom hard
 	  drive subsystem through an expansion card.
+config BLK_DEV_PALMCHIP_BK3710
+	tristate "Palmchip bk3710 IDE controller support"
+	depends on ARCH_DAVINCI
+	select BLK_DEV_IDEDMA_PCI
+	help
+	  Say Y here if you want to support the onchip IDE controller on the
+	  TI DaVinci SoC
 config BLK_DEV_MPC8xx_IDE
 	tristate "MPC8xx IDE support"
 	depends on 8xx && (LWMON || IVMS8 || IVML24 || TQM8xxL) && IDE=y && BLK_DEV_IDE=y && !PPC_MERGE
 	help
 	  This option provides support for IDE on Motorola MPC8xx Systems.
 	  Please see 'Type of MPC8xx IDE interface' for details.
 	  If unsure, say N.
 choice
 	prompt "Type of MPC8xx IDE interface"
 	depends on BLK_DEV_MPC8xx_IDE
 	default IDE_8xx_PCCARD
 config IDE_8xx_PCCARD
 	bool "8xx_PCCARD"
 	---help---
 	  Select how the IDE devices are connected to the MPC8xx system:
 	  8xx_PCCARD uses the 8xx internal PCMCIA interface in combination
 	  with a PC Card (e.g. ARGOSY portable Hard Disk Adapter),
 	  ATA PC Card HDDs or ATA PC Flash Cards (example: TQM8xxL
 	  systems)
 	  8xx_DIRECT is used for directly connected IDE devices using the 8xx
 	  internal PCMCIA interface (example: IVMS8 systems)
 	  EXT_DIRECT is used for IDE devices directly connected to the 8xx
 	  bus using some glue logic, but _not_ the 8xx internal
 	  PCMCIA interface (example: IDIF860 systems)
 config IDE_8xx_DIRECT
 	bool "8xx_DIRECT"
 config IDE_EXT_DIRECT
 	bool "EXT_DIRECT"
 endchoice
 # no isa -> no vlb
 if ISA
 comment "Other IDE chipsets support"
 comment "Note: most of these also require special kernel boot parameters"
 config BLK_DEV_4DRIVES
 	bool "Generic 4 drives/port support"
 	help
 	  Certain older chipsets, including the Tekram 690CD, use a single set
 	  of I/O ports at 0x1f0 to control up to four drives, instead of the
 	  customary two drives per port. Support for this can be enabled at
 	  runtime using the "ide0=four" kernel boot parameter if you say Y
 	  here.
 config BLK_DEV_ALI14XX
 	tristate "ALI M14xx support"
 	help
 	  This driver is enabled at runtime using the "ali14xx.probe" kernel
 	  boot parameter.  It enables support for the secondary IDE interface
 	  of the ALI M1439/1443/1445/1487/1489 chipsets, and permits faster
 	  I/O speeds to be set as well.  See the files
 	  <file:Documentation/ide.txt> and <file:drivers/ide/legacy/ali14xx.c>
 	  for more info.
 config BLK_DEV_DTC2278
 	tristate "DTC-2278 support"
 	help
 	  This driver is enabled at runtime using the "dtc2278.probe" kernel
 	  boot parameter. It enables support for the secondary IDE interface
 	  of the DTC-2278 card, and permits faster I/O speeds to be set as
 	  well. See the <file:Documentation/ide.txt> and
 	  <file:drivers/ide/legacy/dtc2278.c> files for more info.
 config BLK_DEV_HT6560B
 	tristate "Holtek HT6560B support"
 	help
 	  This driver is enabled at runtime using the "ht6560b.probe" kernel
 	  boot parameter. It enables support for the secondary IDE interface
 	  of the Holtek card, and permits faster I/O speeds to be set as well.
 	  See the <file:Documentation/ide.txt> and
 	  <file:drivers/ide/legacy/ht6560b.c> files for more info.
 config BLK_DEV_QD65XX
 	tristate "QDI QD65xx support"
 	help
 	  This driver is enabled at runtime using the "qd65xx.probe" kernel
 	  boot parameter.  It permits faster I/O speeds to be set.  See the
 	  <file:Documentation/ide.txt> and <file:drivers/ide/legacy/qd65xx.c>
 	  for more info.
 config BLK_DEV_UMC8672
 	tristate "UMC-8672 support"
 	help
 	  This driver is enabled at runtime using the "umc8672.probe" kernel
 	  boot parameter. It enables support for the secondary IDE interface
 	  of the UMC-8672, and permits faster I/O speeds to be set as well.
 	  See the files <file:Documentation/ide.txt> and
 	  <file:drivers/ide/legacy/umc8672.c> for more info.
 endif
 config BLK_DEV_IDEDMA
 	def_bool BLK_DEV_IDEDMA_PCI || BLK_DEV_IDEDMA_PMAC || BLK_DEV_IDEDMA_ICS || BLK_DEV_IDE_AU1XXX_MDMA2_DBDMA
 config IDE_ARCH_OBSOLETE_INIT
 	def_bool ALPHA || (ARM && !ARCH_L7200) || BLACKFIN || X86 || IA64 || M32R || MIPS || PARISC || PPC || (SUPERH64 && BLK_DEV_IDEPCI) || SPARC
 endif
 config BLK_DEV_HD_ONLY
 	bool "Old hard disk (MFM/RLL/IDE) driver"
 	depends on BLK_DEV_IDE=n
 	help
 	  There are two drivers for MFM/RLL/IDE hard disks. Most people use
 	  the newer enhanced driver, but this old one is still around for two
 	  reasons. Some older systems have strange timing problems and seem to
 	  work only with the old driver (which itself does not work with some
 	  newer systems). The other reason is that the old driver is smaller,
 	  since it lacks the enhanced functionality of the new one. This makes
 	  it a good choice for systems with very tight memory restrictions, or
 	  for systems with only older MFM/RLL/ESDI drives. Choosing the old
 	  driver can save 13 KB or so of kernel memory.
 	  If you are unsure, then just choose the Enhanced IDE/MFM/RLL driver
 	  instead of this one. For more detailed information, read the
 	  Disk-HOWTO, available from
 	  <http://www.tldp.org/docs.html#howto>.
 config BLK_DEV_HD
 	def_bool BLK_DEV_HD_IDE || BLK_DEV_HD_ONLY
 endif # IDE

drivers/ide/arm/Makefile

Diff comments View file @ 7c7e92a

 obj-$(CONFIG_BLK_DEV_IDE_ICSIDE)	+= icside.o
 obj-$(CONFIG_BLK_DEV_IDE_RAPIDE)	+= rapide.o
 obj-$(CONFIG_BLK_DEV_IDE_BAST)		+= bast-ide.o
+obj-$(CONFIG_BLK_DEV_PALMCHIP_BK3710)	+= palm_bk3710.o
 ifeq ($(CONFIG_IDE_ARM), m)
 	obj-m += ide_arm.o
 endif
 EXTRA_CFLAGS	:= -Idrivers/ide

drivers/ide/arm/palm_bk3710.c

Diff comments View file @ 7c7e92a

File was created	1	/*
	2	* Palmchip bk3710 IDE controller
	3	*
	4	* Copyright (C) 2006 Texas Instruments.
	5	* Copyright (C) 2007 MontaVista Software, Inc., <source@mvista.com>
	6	*
	7	* ----------------------------------------------------------------------------
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	22	* ----------------------------------------------------------------------------
	23	*
	24	*/
	25
	26	#include <linux/types.h>
	27	#include <linux/module.h>
	28	#include <linux/kernel.h>
	29	#include <linux/ioport.h>
	30	#include <linux/hdreg.h>
	31	#include <linux/ide.h>
	32	#include <linux/delay.h>
	33	#include <linux/init.h>
	34	#include <linux/clk.h>
	35	#include <linux/platform_device.h>
	36
	37	/* Offset of the primary interface registers */
	38	#define IDE_PALM_ATA_PRI_REG_OFFSET 0x1F0
	39
	40	/* Primary Control Offset */
	41	#define IDE_PALM_ATA_PRI_CTL_OFFSET 0x3F6
	42
	43	/*
	44	* PalmChip 3710 IDE Controller UDMA timing structure Definition
	45	*/
	46	struct palm_bk3710_udmatiming {
	47	unsigned int rptime; /* Ready to pause time */
	48	unsigned int cycletime; /* Cycle Time */
	49	};
	50
	51	#define BK3710_BMICP 0x00
	52	#define BK3710_BMISP 0x02
	53	#define BK3710_BMIDTP 0x04
	54	#define BK3710_BMICS 0x08
	55	#define BK3710_BMISS 0x0A
	56	#define BK3710_BMIDTS 0x0C
	57	#define BK3710_IDETIMP 0x40
	58	#define BK3710_IDETIMS 0x42
	59	#define BK3710_SIDETIM 0x44
	60	#define BK3710_SLEWCTL 0x45
	61	#define BK3710_IDESTATUS 0x47
	62	#define BK3710_UDMACTL 0x48
	63	#define BK3710_UDMATIM 0x4A
	64	#define BK3710_MISCCTL 0x50
	65	#define BK3710_REGSTB 0x54
	66	#define BK3710_REGRCVR 0x58
	67	#define BK3710_DATSTB 0x5C
	68	#define BK3710_DATRCVR 0x60
	69	#define BK3710_DMASTB 0x64
	70	#define BK3710_DMARCVR 0x68
	71	#define BK3710_UDMASTB 0x6C
	72	#define BK3710_UDMATRP 0x70
	73	#define BK3710_UDMAENV 0x74
	74	#define BK3710_IORDYTMP 0x78
	75	#define BK3710_IORDYTMS 0x7C
	76
	77	#include "../ide-timing.h"
	78
	79	static long ide_palm_clk;
	80
	81	static const struct palm_bk3710_udmatiming palm_bk3710_udmatimings[6] = {
	82	{160, 240}, /* UDMA Mode 0 */
	83	{125, 160}, /* UDMA Mode 1 */
	84	{100, 120}, /* UDMA Mode 2 */
	85	{100, 90}, /* UDMA Mode 3 */
	86	{85, 60}, /* UDMA Mode 4 */
	87	};
	88
	89	static struct clk *ideclkp;
	90
	91	static void palm_bk3710_setudmamode(void __iomem *base, unsigned int dev,
	92	unsigned int mode)
	93	{
	94	u8 tenv, trp, t0;
	95	u32 val32;
	96	u16 val16;
	97
	98	/* DMA Data Setup */
	99	t0 = (palm_bk3710_udmatimings[mode].cycletime + ide_palm_clk - 1)
	100	/ ide_palm_clk - 1;
	101	tenv = (20 + ide_palm_clk - 1) / ide_palm_clk - 1;
	102	trp = (palm_bk3710_udmatimings[mode].rptime + ide_palm_clk - 1)
	103	/ ide_palm_clk - 1;
	104
	105	/* udmatim Register */
	106	val16 = readw(base + BK3710_UDMATIM) & (dev ? 0xFF0F : 0xFFF0);
	107	val16 \|= (mode << (dev ? 4 : 0));
	108	writew(val16, base + BK3710_UDMATIM);
	109
	110	/* udmastb Ultra DMA Access Strobe Width */
	111	val32 = readl(base + BK3710_UDMASTB) & (0xFF << (dev ? 0 : 8));
	112	val32 \|= (t0 << (dev ? 8 : 0));
	113	writel(val32, base + BK3710_UDMASTB);
	114
	115	/* udmatrp Ultra DMA Ready to Pause Time */
	116	val32 = readl(base + BK3710_UDMATRP) & (0xFF << (dev ? 0 : 8));
	117	val32 \|= (trp << (dev ? 8 : 0));
	118	writel(val32, base + BK3710_UDMATRP);
	119
	120	/* udmaenv Ultra DMA envelop Time */
	121	val32 = readl(base + BK3710_UDMAENV) & (0xFF << (dev ? 0 : 8));
	122	val32 \|= (tenv << (dev ? 8 : 0));
	123	writel(val32, base + BK3710_UDMAENV);
	124
	125	/* Enable UDMA for Device */
	126	val16 = readw(base + BK3710_UDMACTL) \| (1 << dev);
	127	writew(val16, base + BK3710_UDMACTL);
	128	}
	129
	130	static void palm_bk3710_setdmamode(void __iomem *base, unsigned int dev,
	131	unsigned short min_cycle,
	132	unsigned int mode)
	133	{
	134	u8 td, tkw, t0;
	135	u32 val32;
	136	u16 val16;
	137	struct ide_timing *t;
	138	int cycletime;
	139
	140	t = ide_timing_find_mode(mode);
	141	cycletime = max_t(int, t->cycle, min_cycle);
	142
	143	/* DMA Data Setup */
	144	t0 = (cycletime + ide_palm_clk - 1) / ide_palm_clk;
	145	td = (t->active + ide_palm_clk - 1) / ide_palm_clk;
	146	tkw = t0 - td - 1;
	147	td -= 1;
	148
	149	val32 = readl(base + BK3710_DMASTB) & (0xFF << (dev ? 0 : 8));
	150	val32 \|= (td << (dev ? 8 : 0));
	151	writel(val32, base + BK3710_DMASTB);
	152
	153	val32 = readl(base + BK3710_DMARCVR) & (0xFF << (dev ? 0 : 8));
	154	val32 \|= (tkw << (dev ? 8 : 0));
	155	writel(val32, base + BK3710_DMARCVR);
	156
	157	/* Disable UDMA for Device */
	158	val16 = readw(base + BK3710_UDMACTL) & ~(1 << dev);
	159	writew(val16, base + BK3710_UDMACTL);
	160	}
	161
	162	static void palm_bk3710_setpiomode(void __iomem base, ide_drive_t mate,
	163	unsigned int dev, unsigned int cycletime,
	164	unsigned int mode)
	165	{
	166	u8 t2, t2i, t0;
	167	u32 val32;
	168	struct ide_timing *t;
	169
	170	/* PIO Data Setup */
	171	t0 = (cycletime + ide_palm_clk - 1) / ide_palm_clk;
	172	t2 = (ide_timing_find_mode(XFER_PIO_0 + mode)->active +
	173	ide_palm_clk - 1) / ide_palm_clk;
	174
	175	t2i = t0 - t2 - 1;
	176	t2 -= 1;
	177
	178	val32 = readl(base + BK3710_DATSTB) & (0xFF << (dev ? 0 : 8));
	179	val32 \|= (t2 << (dev ? 8 : 0));
	180	writel(val32, base + BK3710_DATSTB);
	181
	182	val32 = readl(base + BK3710_DATRCVR) & (0xFF << (dev ? 0 : 8));
	183	val32 \|= (t2i << (dev ? 8 : 0));
	184	writel(val32, base + BK3710_DATRCVR);
	185
	186	if (mate && mate->present) {
	187	u8 mode2 = ide_get_best_pio_mode(mate, 255, 4);
	188
	189	if (mode2 < mode)
	190	mode = mode2;
	191	}
	192
	193	/* TASKFILE Setup */
	194	t = ide_timing_find_mode(XFER_PIO_0 + mode);
	195	t0 = (t->cyc8b + ide_palm_clk - 1) / ide_palm_clk;
	196	t2 = (t->act8b + ide_palm_clk - 1) / ide_palm_clk;
	197
	198	t2i = t0 - t2 - 1;
	199	t2 -= 1;
	200
	201	val32 = readl(base + BK3710_REGSTB) & (0xFF << (dev ? 0 : 8));
	202	val32 \|= (t2 << (dev ? 8 : 0));
	203	writel(val32, base + BK3710_REGSTB);
	204
	205	val32 = readl(base + BK3710_REGRCVR) & (0xFF << (dev ? 0 : 8));
	206	val32 \|= (t2i << (dev ? 8 : 0));
	207	writel(val32, base + BK3710_REGRCVR);
	208	}
	209
	210	static void palm_bk3710_set_dma_mode(ide_drive_t *drive, u8 xferspeed)
	211	{
	212	int is_slave = drive->dn & 1;
	213	void __iomem base = (void )drive->hwif->dma_base;
	214
	215	if (xferspeed >= XFER_UDMA_0) {
	216	palm_bk3710_setudmamode(base, is_slave,
	217	xferspeed - XFER_UDMA_0);
	218	} else {
	219	palm_bk3710_setdmamode(base, is_slave, drive->id->eide_dma_min,
	220	xferspeed);
	221	}
	222	}
	223
	224	static void palm_bk3710_set_pio_mode(ide_drive_t *drive, u8 pio)
	225	{
	226	unsigned int cycle_time;
	227	int is_slave = drive->dn & 1;
	228	ide_drive_t *mate;
	229	void __iomem base = (void )drive->hwif->dma_base;
	230
	231	/*
	232	* Obtain the drive PIO data for tuning the Palm Chip registers
	233	*/
	234	cycle_time = ide_pio_cycle_time(drive, pio);
	235	mate = ide_get_paired_drive(drive);
	236	palm_bk3710_setpiomode(base, mate, is_slave, cycle_time, pio);
	237	}
	238
	239	static void __devinit palm_bk3710_chipinit(void __iomem *base)
	240	{
	241	/*
	242	* enable the reset_en of ATA controller so that when ata signals
	243	* are brought out, by writing into device config. at that
	244	* time por_n signal should not be 'Z' and have a stable value.
	245	*/
	246	writel(0x0300, base + BK3710_MISCCTL);
	247
	248	/* wait for some time and deassert the reset of ATA Device. */
	249	mdelay(100);
	250
	251	/* Deassert the Reset */
	252	writel(0x0200, base + BK3710_MISCCTL);
	253
	254	/*
	255	* Program the IDETIMP Register Value based on the following assumptions
	256	*
	257	* (ATA_IDETIMP_IDEEN , ENABLE ) \|
	258	* (ATA_IDETIMP_SLVTIMEN , DISABLE) \|
	259	* (ATA_IDETIMP_RDYSMPL , 70NS) \|
	260	* (ATA_IDETIMP_RDYRCVRY , 50NS) \|
	261	* (ATA_IDETIMP_DMAFTIM1 , PIOCOMP) \|
	262	* (ATA_IDETIMP_PREPOST1 , DISABLE) \|
	263	* (ATA_IDETIMP_RDYSEN1 , DISABLE) \|
	264	* (ATA_IDETIMP_PIOFTIM1 , DISABLE) \|
	265	* (ATA_IDETIMP_DMAFTIM0 , PIOCOMP) \|
	266	* (ATA_IDETIMP_PREPOST0 , DISABLE) \|
	267	* (ATA_IDETIMP_RDYSEN0 , DISABLE) \|
	268	* (ATA_IDETIMP_PIOFTIM0 , DISABLE)
	269	*/
	270	writew(0xB388, base + BK3710_IDETIMP);
	271
	272	/*
	273	* Configure SIDETIM Register
	274	* (ATA_SIDETIM_RDYSMPS1 ,120NS ) \|
	275	* (ATA_SIDETIM_RDYRCYS1 ,120NS )
	276	*/
	277	writeb(0, base + BK3710_SIDETIM);
	278
	279	/*
	280	* UDMACTL Ultra-ATA DMA Control
	281	* (ATA_UDMACTL_UDMAP1 , 0 ) \|
	282	* (ATA_UDMACTL_UDMAP0 , 0 )
	283	*
	284	*/
	285	writew(0, base + BK3710_UDMACTL);
	286
	287	/*
	288	* MISCCTL Miscellaneous Conrol Register
	289	* (ATA_MISCCTL_RSTMODEP , 1) \|
	290	* (ATA_MISCCTL_RESETP , 0) \|
	291	* (ATA_MISCCTL_TIMORIDE , 1)
	292	*/
	293	writel(0x201, base + BK3710_MISCCTL);
	294
	295	/*
	296	* IORDYTMP IORDY Timer for Primary Register
	297	* (ATA_IORDYTMP_IORDYTMP , 0xffff )
	298	*/
	299	writel(0xFFFF, base + BK3710_IORDYTMP);
	300
	301	/*
	302	* Configure BMISP Register
	303	* (ATA_BMISP_DMAEN1 , DISABLE ) \|
	304	* (ATA_BMISP_DMAEN0 , DISABLE ) \|
	305	* (ATA_BMISP_IORDYINT , CLEAR) \|
	306	* (ATA_BMISP_INTRSTAT , CLEAR) \|
	307	* (ATA_BMISP_DMAERROR , CLEAR)
	308	*/
	309	writew(0, base + BK3710_BMISP);
	310
	311	palm_bk3710_setpiomode(base, NULL, 0, 600, 0);
	312	palm_bk3710_setpiomode(base, NULL, 1, 600, 0);
	313	}
	314	static int __devinit palm_bk3710_probe(struct platform_device *pdev)
	315	{
	316	hw_regs_t ide_ctlr_info;
	317	int index = 0;
	318	int pribase;
	319	struct clk *clkp;
	320	struct resource mem, irq;
	321	ide_hwif_t *hwif;
	322	void __iomem *base;
	323
	324	clkp = clk_get(NULL, "IDECLK");
	325	if (IS_ERR(clkp))
	326	return -ENODEV;
	327
	328	ideclkp = clkp;
	329	clk_enable(ideclkp);
	330	ide_palm_clk = clk_get_rate(ideclkp)/100000;
	331	ide_palm_clk = (10000/ide_palm_clk) + 1;
	332	/* Register the IDE interface with Linux ATA Interface */
	333	memset(&ide_ctlr_info, 0, sizeof(ide_ctlr_info));
	334
	335	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	336	if (mem == NULL) {
	337	printk(KERN_ERR "failed to get memory region resource\n");
	338	return -ENODEV;
	339	}
	340	irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	341	if (irq == NULL) {
	342	printk(KERN_ERR "failed to get IRQ resource\n");
	343	return -ENODEV;
	344	}
	345
	346	base = (void *)mem->start;
	347
	348	/* Configure the Palm Chip controller */
	349	palm_bk3710_chipinit(base);
	350
	351	pribase = mem->start + IDE_PALM_ATA_PRI_REG_OFFSET;
	352	for (index = 0; index < IDE_NR_PORTS - 2; index++)
	353	ide_ctlr_info.io_ports[index] = pribase + index;
	354	ide_ctlr_info.io_ports[IDE_CONTROL_OFFSET] = mem->start +
	355	IDE_PALM_ATA_PRI_CTL_OFFSET;
	356	ide_ctlr_info.irq = irq->start;
	357	ide_ctlr_info.chipset = ide_palm3710;
	358
	359	if (ide_register_hw(&ide_ctlr_info, NULL, &hwif) < 0) {
	360	printk(KERN_WARNING "Palm Chip BK3710 IDE Register Fail\n");
	361	return -ENODEV;
	362	}
	363
	364	hwif->set_pio_mode = &palm_bk3710_set_pio_mode;
	365	hwif->set_dma_mode = &palm_bk3710_set_dma_mode;
	366	hwif->mmio = 1;
	367	default_hwif_mmiops(hwif);
	368	hwif->cbl = ATA_CBL_PATA80;
	369	hwif->ultra_mask = 0x1f; /* Ultra DMA Mode 4 Max
	370	(input clk 99MHz) */
	371	hwif->mwdma_mask = 0x7;
	372	hwif->drives[0].autotune = 1;
	373	hwif->drives[1].autotune = 1;
	374
	375	ide_setup_dma(hwif, mem->start);
	376
	377	return 0;
	378	}
	379
	380	static struct platform_driver platform_bk_driver = {
	381	.driver = {
	382	.name = "palm_bk3710",
	383	},
	384	.probe = palm_bk3710_probe,
	385	.remove = NULL,
	386	};
	387
	388	static int __init palm_bk3710_init(void)
	389	{
	390	return platform_driver_register(&platform_bk_driver);
	391	}
	392
	393	module_init(palm_bk3710_init);
	394	MODULE_LICENSE("GPL");
	395
	396

drivers/ide/ide-proc.c

Diff comments View file @ 7c7e92a

 /*
  *  Copyright (C) 1997-1998	Mark Lord
  *  Copyright (C) 2003		Red Hat <alan@redhat.com>
  *
  *  Some code was moved here from ide.c, see it for original copyrights.
  */
 /*
  * This is the /proc/ide/ filesystem implementation.
  *
  * Drive/Driver settings can be retrieved by reading the drive's
  * "settings" files.  e.g.    "cat /proc/ide0/hda/settings"
  * To write a new value "val" into a specific setting "name", use:
  *   echo "name:val" >/proc/ide/ide0/hda/settings
  *
  * Also useful, "cat /proc/ide0/hda/[identify, smart_values,
  * smart_thresholds, capabilities]" will issue an IDENTIFY /
  * PACKET_IDENTIFY / SMART_READ_VALUES / SMART_READ_THRESHOLDS /
  * SENSE CAPABILITIES command to /dev/hda, and then dump out the
  * returned data as 256 16-bit words.  The "hdparm" utility will
  * be updated someday soon to use this mechanism.
  *
  */
 #include <linux/module.h>
 #include <asm/uaccess.h>
 #include <linux/errno.h>
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
 #include <linux/mm.h>
 #include <linux/pci.h>
 #include <linux/ctype.h>
 #include <linux/hdreg.h>
 #include <linux/ide.h>
 #include <linux/seq_file.h>
 #include <asm/io.h>
 static struct proc_dir_entry *proc_ide_root;
 static int proc_ide_read_imodel
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_hwif_t	*hwif = (ide_hwif_t *) data;
 	int		len;
 	const char	*name;
 	/*
 	 * Neither ide_unknown nor ide_forced should be set at this point.
 	 */
 	switch (hwif->chipset) {
 		case ide_generic:	name = "generic";	break;
 		case ide_pci:		name = "pci";		break;
 		case ide_cmd640:	name = "cmd640";	break;
 		case ide_dtc2278:	name = "dtc2278";	break;
 		case ide_ali14xx:	name = "ali14xx";	break;
 		case ide_qd65xx:	name = "qd65xx";	break;
 		case ide_umc8672:	name = "umc8672";	break;
 		case ide_ht6560b:	name = "ht6560b";	break;
 		case ide_rz1000:	name = "rz1000";	break;
 		case ide_trm290:	name = "trm290";	break;
 		case ide_cmd646:	name = "cmd646";	break;
 		case ide_cy82c693:	name = "cy82c693";	break;
 		case ide_4drives:	name = "4drives";	break;
 		case ide_pmac:		name = "mac-io";	break;
 		case ide_au1xxx:	name = "au1xxx";	break;
+		case ide_palm3710:      name = "palm3710";      break;
 		case ide_etrax100:	name = "etrax100";	break;
 		case ide_acorn:		name = "acorn";		break;
 		default:		name = "(unknown)";	break;
 	}
 	len = sprintf(page, "%s\n", name);
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 static int proc_ide_read_mate
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_hwif_t	*hwif = (ide_hwif_t *) data;
 	int		len;
 	if (hwif && hwif->mate && hwif->mate->present)
 		len = sprintf(page, "%s\n", hwif->mate->name);
 	else
 		len = sprintf(page, "(none)\n");
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 static int proc_ide_read_channel
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_hwif_t	*hwif = (ide_hwif_t *) data;
 	int		len;
 	page[0] = hwif->channel ? '1' : '0';
 	page[1] = '\n';
 	len = 2;
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 static int proc_ide_read_identify
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *)data;
 	int		len = 0, i = 0;
 	int		err = 0;
 	len = sprintf(page, "\n");
 	if (drive) {
 		unsigned short *val = (unsigned short *) page;
 		err = taskfile_lib_get_identify(drive, page);
 		if (!err) {
 			char *out = ((char *)page) + (SECTOR_WORDS * 4);
 			page = out;
 			do {
 				out += sprintf(out, "%04x%c",
 					le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
 				val += 1;
 			} while (i < (SECTOR_WORDS * 2));
 			len = out - page;
 		}
 	}
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 /**
  *	__ide_add_setting	-	add an ide setting option
  *	@drive: drive to use
  *	@name: setting name
  *	@rw: true if the function is read write
  *	@data_type: type of data
  *	@min: range minimum
  *	@max: range maximum
  *	@mul_factor: multiplication scale
  *	@div_factor: divison scale
  *	@data: private data field
  *	@set: setting
  *	@auto_remove: setting auto removal flag
  *
  *	Removes the setting named from the device if it is present.
  *	The function takes the settings_lock to protect against
  *	parallel changes. This function must not be called from IRQ
  *	context. Returns 0 on success or -1 on failure.
  *
  *	BUGS: This code is seriously over-engineered. There is also
  *	magic about how the driver specific features are setup. If
  *	a driver is attached we assume the driver settings are auto
  *	remove.
  */
 static int __ide_add_setting(ide_drive_t *drive, const char *name, int rw, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set, int auto_remove)
 {
 	ide_settings_t **p = (ide_settings_t **) &drive->settings, *setting = NULL;
 	mutex_lock(&ide_setting_mtx);
 	while ((*p) && strcmp((*p)->name, name) < 0)
 		p = &((*p)->next);
 	if ((setting = kzalloc(sizeof(*setting), GFP_KERNEL)) == NULL)
 		goto abort;
 	if ((setting->name = kmalloc(strlen(name) + 1, GFP_KERNEL)) == NULL)
 		goto abort;
 	strcpy(setting->name, name);
 	setting->rw = rw;
 	setting->data_type = data_type;
 	setting->min = min;
 	setting->max = max;
 	setting->mul_factor = mul_factor;
 	setting->div_factor = div_factor;
 	setting->data = data;
 	setting->set = set;
 	setting->next = *p;
 	if (auto_remove)
 		setting->auto_remove = 1;
 	*p = setting;
 	mutex_unlock(&ide_setting_mtx);
 	return 0;
 abort:
 	mutex_unlock(&ide_setting_mtx);
 	kfree(setting);
 	return -1;
 }
 int ide_add_setting(ide_drive_t *drive, const char *name, int rw, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set)
 {
 	return __ide_add_setting(drive, name, rw, data_type, min, max, mul_factor, div_factor, data, set, 1);
 }
 EXPORT_SYMBOL(ide_add_setting);
 /**
  *	__ide_remove_setting	-	remove an ide setting option
  *	@drive: drive to use
  *	@name: setting name
  *
  *	Removes the setting named from the device if it is present.
  *	The caller must hold the setting semaphore.
  */
 static void __ide_remove_setting (ide_drive_t *drive, char *name)
 {
 	ide_settings_t **p, *setting;
 	p = (ide_settings_t **) &drive->settings;
 	while ((*p) && strcmp((*p)->name, name))
 		p = &((*p)->next);
 	if ((setting = (*p)) == NULL)
 		return;
 	(*p) = setting->next;
 	kfree(setting->name);
 	kfree(setting);
 }
 /**
  *	auto_remove_settings	-	remove driver specific settings
  *	@drive: drive
  *
  *	Automatically remove all the driver specific settings for this
  *	drive. This function may not be called from IRQ context. The
  *	caller must hold ide_setting_mtx.
  */
 static void auto_remove_settings (ide_drive_t *drive)
 {
 	ide_settings_t *setting;
 repeat:
 	setting = drive->settings;
 	while (setting) {
 		if (setting->auto_remove) {
 			__ide_remove_setting(drive, setting->name);
 			goto repeat;
 		}
 		setting = setting->next;
 	}
 }
 /**
  *	ide_find_setting_by_name	-	find a drive specific setting
  *	@drive: drive to scan
  *	@name: setting name
  *
  *	Scan's the device setting table for a matching entry and returns
  *	this or NULL if no entry is found. The caller must hold the
  *	setting semaphore
  */
 static ide_settings_t *ide_find_setting_by_name(ide_drive_t *drive, char *name)
 {
 	ide_settings_t *setting = drive->settings;
 	while (setting) {
 		if (strcmp(setting->name, name) == 0)
 			break;
 		setting = setting->next;
 	}
 	return setting;
 }
 /**
  *	ide_read_setting	-	read an IDE setting
  *	@drive: drive to read from
  *	@setting: drive setting
  *
  *	Read a drive setting and return the value. The caller
  *	must hold the ide_setting_mtx when making this call.
  *
  *	BUGS: the data return and error are the same return value
  *	so an error -EINVAL and true return of the same value cannot
  *	be told apart
  */
 static int ide_read_setting(ide_drive_t *drive, ide_settings_t *setting)
 {
 	int		val = -EINVAL;
 	unsigned long	flags;
 	if ((setting->rw & SETTING_READ)) {
 		spin_lock_irqsave(&ide_lock, flags);
 		switch(setting->data_type) {
 			case TYPE_BYTE:
 				val = *((u8 *) setting->data);
 				break;
 			case TYPE_SHORT:
 				val = *((u16 *) setting->data);
 				break;
 			case TYPE_INT:
 				val = *((u32 *) setting->data);
 				break;
 		}
 		spin_unlock_irqrestore(&ide_lock, flags);
 	}
 	return val;
 }
 /**
  *	ide_write_setting	-	read an IDE setting
  *	@drive: drive to read from
  *	@setting: drive setting
  *	@val: value
  *
  *	Write a drive setting if it is possible. The caller
  *	must hold the ide_setting_mtx when making this call.
  *
  *	BUGS: the data return and error are the same return value
  *	so an error -EINVAL and true return of the same value cannot
  *	be told apart
  *
  *	FIXME:  This should be changed to enqueue a special request
  *	to the driver to change settings, and then wait on a sema for completion.
  *	The current scheme of polling is kludgy, though safe enough.
  */
 static int ide_write_setting(ide_drive_t *drive, ide_settings_t *setting, int val)
 {
 	if (!capable(CAP_SYS_ADMIN))
 		return -EACCES;
 	if (setting->set)
 		return setting->set(drive, val);
 	if (!(setting->rw & SETTING_WRITE))
 		return -EPERM;
 	if (val < setting->min || val > setting->max)
 		return -EINVAL;
 	if (ide_spin_wait_hwgroup(drive))
 		return -EBUSY;
 	switch (setting->data_type) {
 		case TYPE_BYTE:
 			*((u8 *) setting->data) = val;
 			break;
 		case TYPE_SHORT:
 			*((u16 *) setting->data) = val;
 			break;
 		case TYPE_INT:
 			*((u32 *) setting->data) = val;
 			break;
 	}
 	spin_unlock_irq(&ide_lock);
 	return 0;
 }
 static int set_xfer_rate (ide_drive_t *drive, int arg)
 {
 	ide_task_t task;
 	int err;
 	if (arg < 0 || arg > 70)
 		return -EINVAL;
 	memset(&task, 0, sizeof(task));
 	task.tf.command = WIN_SETFEATURES;
 	task.tf.feature = SETFEATURES_XFER;
 	task.tf.nsect   = (u8)arg;
 	task.tf_flags = IDE_TFLAG_OUT_FEATURE | IDE_TFLAG_OUT_NSECT |
 			IDE_TFLAG_IN_NSECT;
 	err = ide_no_data_taskfile(drive, &task);
 	if (!err && arg) {
 		ide_set_xfer_rate(drive, (u8) arg);
 		ide_driveid_update(drive);
 	}
 	return err;
 }
 /**
  *	ide_add_generic_settings	-	generic ide settings
  *	@drive: drive being configured
  *
  *	Add the generic parts of the system settings to the /proc files.
  *	The caller must not be holding the ide_setting_mtx.
  */
 void ide_add_generic_settings (ide_drive_t *drive)
 {
 /*
  *			  drive		setting name		read/write access				data type	min	max				mul_factor	div_factor	data pointer			set function
  */
 	__ide_add_setting(drive,	"io_32bit",		drive->no_io_32bit ? SETTING_READ : SETTING_RW,	TYPE_BYTE,	0,	1 + (SUPPORT_VLB_SYNC << 1),	1,		1,		&drive->io_32bit,		set_io_32bit,	0);
 	__ide_add_setting(drive,	"keepsettings",		SETTING_RW,					TYPE_BYTE,	0,	1,				1,		1,		&drive->keep_settings,		NULL,		0);
 	__ide_add_setting(drive,	"nice1",		SETTING_RW,					TYPE_BYTE,	0,	1,				1,		1,		&drive->nice1,			NULL,		0);
 	__ide_add_setting(drive,	"pio_mode",		SETTING_WRITE,					TYPE_BYTE,	0,	255,				1,		1,		NULL,				set_pio_mode,	0);
 	__ide_add_setting(drive,	"unmaskirq",		drive->no_unmask ? SETTING_READ : SETTING_RW,	TYPE_BYTE,	0,	1,				1,		1,		&drive->unmask,			NULL,		0);
 	__ide_add_setting(drive,	"using_dma",		SETTING_RW,					TYPE_BYTE,	0,	1,				1,		1,		&drive->using_dma,		set_using_dma,	0);
 	__ide_add_setting(drive,	"init_speed",		SETTING_RW,					TYPE_BYTE,	0,	70,				1,		1,		&drive->init_speed,		NULL,		0);
 	__ide_add_setting(drive,	"current_speed",	SETTING_RW,					TYPE_BYTE,	0,	70,				1,		1,		&drive->current_speed,		set_xfer_rate,	0);
 	__ide_add_setting(drive,	"number",		SETTING_RW,					TYPE_BYTE,	0,	3,				1,		1,		&drive->dn,			NULL,		0);
 }
 static void proc_ide_settings_warn(void)
 {
 	static int warned = 0;
 	if (warned)
 		return;
 	printk(KERN_WARNING "Warning: /proc/ide/hd?/settings interface is "
 			    "obsolete, and will be removed soon!\n");
 	warned = 1;
 }
 static int proc_ide_read_settings
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *) data;
 	ide_settings_t	*setting = (ide_settings_t *) drive->settings;
 	char		*out = page;
 	int		len, rc, mul_factor, div_factor;
 	proc_ide_settings_warn();
 	mutex_lock(&ide_setting_mtx);
 	out += sprintf(out, "name\t\t\tvalue\t\tmin\t\tmax\t\tmode\n");
 	out += sprintf(out, "----\t\t\t-----\t\t---\t\t---\t\t----\n");
 	while(setting) {
 		mul_factor = setting->mul_factor;
 		div_factor = setting->div_factor;
 		out += sprintf(out, "%-24s", setting->name);
 		if ((rc = ide_read_setting(drive, setting)) >= 0)
 			out += sprintf(out, "%-16d", rc * mul_factor / div_factor);
 		else
 			out += sprintf(out, "%-16s", "write-only");
 		out += sprintf(out, "%-16d%-16d", (setting->min * mul_factor + div_factor - 1) / div_factor, setting->max * mul_factor / div_factor);
 		if (setting->rw & SETTING_READ)
 			out += sprintf(out, "r");
 		if (setting->rw & SETTING_WRITE)
 			out += sprintf(out, "w");
 		out += sprintf(out, "\n");
 		setting = setting->next;
 	}
 	len = out - page;
 	mutex_unlock(&ide_setting_mtx);
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 #define MAX_LEN	30
 static int proc_ide_write_settings(struct file *file, const char __user *buffer,
 				   unsigned long count, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *) data;
 	char		name[MAX_LEN + 1];
 	int		for_real = 0;
 	unsigned long	n;
 	ide_settings_t	*setting;
 	char *buf, *s;
 	if (!capable(CAP_SYS_ADMIN))
 		return -EACCES;
 	proc_ide_settings_warn();
 	if (count >= PAGE_SIZE)
 		return -EINVAL;
 	s = buf = (char *)__get_free_page(GFP_USER);
 	if (!buf)
 		return -ENOMEM;
 	if (copy_from_user(buf, buffer, count)) {
 		free_page((unsigned long)buf);
 		return -EFAULT;
 	}
 	buf[count] = '\0';
 	/*
 	 * Skip over leading whitespace
 	 */
 	while (count && isspace(*s)) {
 		--count;
 		++s;
 	}
 	/*
 	 * Do one full pass to verify all parameters,
 	 * then do another to actually write the new settings.
 	 */
 	do {
 		char *p = s;
 		n = count;
 		while (n > 0) {
 			unsigned val;
 			char *q = p;
 			while (n > 0 && *p != ':') {
 				--n;
 				p++;
 			}
 			if (*p != ':')
 				goto parse_error;
 			if (p - q > MAX_LEN)
 				goto parse_error;
 			memcpy(name, q, p - q);
 			name[p - q] = 0;
 			if (n > 0) {
 				--n;
 				p++;
 			} else
 				goto parse_error;
 			val = simple_strtoul(p, &q, 10);
 			n -= q - p;
 			p = q;
 			if (n > 0 && !isspace(*p))
 				goto parse_error;
 			while (n > 0 && isspace(*p)) {
 				--n;
 				++p;
 			}
 			mutex_lock(&ide_setting_mtx);
 			setting = ide_find_setting_by_name(drive, name);
 			if (!setting)
 			{
 				mutex_unlock(&ide_setting_mtx);
 				goto parse_error;
 			}
 			if (for_real)
 				ide_write_setting(drive, setting, val * setting->div_factor / setting->mul_factor);
 			mutex_unlock(&ide_setting_mtx);
 		}
 	} while (!for_real++);
 	free_page((unsigned long)buf);
 	return count;
 parse_error:
 	free_page((unsigned long)buf);
 	printk("proc_ide_write_settings(): parse error\n");
 	return -EINVAL;
 }
 int proc_ide_read_capacity
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	int len = sprintf(page,"%llu\n", (long long)0x7fffffff);
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 EXPORT_SYMBOL_GPL(proc_ide_read_capacity);
 int proc_ide_read_geometry
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *) data;
 	char		*out = page;
 	int		len;
 	out += sprintf(out,"physical     %d/%d/%d\n",
 			drive->cyl, drive->head, drive->sect);
 	out += sprintf(out,"logical      %d/%d/%d\n",
 			drive->bios_cyl, drive->bios_head, drive->bios_sect);
 	len = out - page;
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 EXPORT_SYMBOL(proc_ide_read_geometry);
 static int proc_ide_read_dmodel
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *) data;
 	struct hd_driveid *id = drive->id;
 	int		len;
 	len = sprintf(page, "%.40s\n",
 		(id && id->model[0]) ? (char *)id->model : "(none)");
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 static int proc_ide_read_driver
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *) data;
 	struct device	*dev = &drive->gendev;
 	ide_driver_t	*ide_drv;
 	int		len;
 	if (dev->driver) {
 		ide_drv = container_of(dev->driver, ide_driver_t, gen_driver);
 		len = sprintf(page, "%s version %s\n",
 				dev->driver->name, ide_drv->version);
 	} else
 		len = sprintf(page, "ide-default version 0.9.newide\n");
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 static int ide_replace_subdriver(ide_drive_t *drive, const char *driver)
 {
 	struct device *dev = &drive->gendev;
 	int ret = 1;
 	int err;
 	device_release_driver(dev);
 	/* FIXME: device can still be in use by previous driver */
 	strlcpy(drive->driver_req, driver, sizeof(drive->driver_req));
 	err = device_attach(dev);
 	if (err < 0)
 		printk(KERN_WARNING "IDE: %s: device_attach error: %d\n",
 			__FUNCTION__, err);
 	drive->driver_req[0] = 0;
 	if (dev->driver == NULL) {
 		err = device_attach(dev);
 		if (err < 0)
 			printk(KERN_WARNING
 				"IDE: %s: device_attach(2) error: %d\n",
 				__FUNCTION__, err);
 	}
 	if (dev->driver && !strcmp(dev->driver->name, driver))
 		ret = 0;
 	return ret;
 }
 static int proc_ide_write_driver
 	(struct file *file, const char __user *buffer, unsigned long count, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *) data;
 	char name[32];
 	if (!capable(CAP_SYS_ADMIN))
 		return -EACCES;
 	if (count > 31)
 		count = 31;
 	if (copy_from_user(name, buffer, count))
 		return -EFAULT;
 	name[count] = '\0';
 	if (ide_replace_subdriver(drive, name))
 		return -EINVAL;
 	return count;
 }
 static int proc_ide_read_media
 	(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
 	ide_drive_t	*drive = (ide_drive_t *) data;
 	const char	*media;
 	int		len;
 	switch (drive->media) {
 		case ide_disk:	media = "disk\n";
 				break;
 		case ide_cdrom:	media = "cdrom\n";
 				break;
 		case ide_tape:	media = "tape\n";
 				break;
 		case ide_floppy:media = "floppy\n";
 				break;
 		case ide_optical:media = "optical\n";
 				break;
 		default:	media = "UNKNOWN\n";
 				break;
 	}
 	strcpy(page,media);
 	len = strlen(media);
 	PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
 }
 static ide_proc_entry_t generic_drive_entries[] = {
 	{ "driver",	S_IFREG|S_IRUGO,	proc_ide_read_driver,	proc_ide_write_driver },
 	{ "identify",	S_IFREG|S_IRUSR,	proc_ide_read_identify,	NULL },
 	{ "media",	S_IFREG|S_IRUGO,	proc_ide_read_media,	NULL },
 	{ "model",	S_IFREG|S_IRUGO,	proc_ide_read_dmodel,	NULL },
 	{ "settings",	S_IFREG|S_IRUSR|S_IWUSR,proc_ide_read_settings,	proc_ide_write_settings },
 	{ NULL,	0, NULL, NULL }
 };
 static void ide_add_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p, void *data)
 {
 	struct proc_dir_entry *ent;
 	if (!dir || !p)
 		return;
 	while (p->name != NULL) {
 		ent = create_proc_entry(p->name, p->mode, dir);
 		if (!ent) return;
 		ent->data = data;
 		ent->read_proc = p->read_proc;
 		ent->write_proc = p->write_proc;
 		p++;
 	}
 }
 static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p)
 {
 	if (!dir || !p)
 		return;
 	while (p->name != NULL) {
 		remove_proc_entry(p->name, dir);
 		p++;
 	}
 }
 void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver)
 {
 	ide_add_proc_entries(drive->proc, driver->proc, drive);
 }
 EXPORT_SYMBOL(ide_proc_register_driver);
 /**
  *	ide_proc_unregister_driver	-	remove driver specific data
  *	@drive: drive
  *	@driver: driver
  *
  *	Clean up the driver specific /proc files and IDE settings
  *	for a given drive.
  *
  *	Takes ide_setting_mtx and ide_lock.
  *	Caller must hold none of the locks.
  */
 void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver)
 {
 	unsigned long flags;
 	ide_remove_proc_entries(drive->proc, driver->proc);
 	mutex_lock(&ide_setting_mtx);
 	spin_lock_irqsave(&ide_lock, flags);
 	/*
 	 * ide_setting_mtx protects the settings list
 	 * ide_lock protects the use of settings
 	 *
 	 * so we need to hold both, ide_settings_sem because we want to
 	 * modify the settings list, and ide_lock because we cannot take
 	 * a setting out that is being used.
 	 *
 	 * OTOH both ide_{read,write}_setting are only ever used under
 	 * ide_setting_mtx.
 	 */
 	auto_remove_settings(drive);
 	spin_unlock_irqrestore(&ide_lock, flags);
 	mutex_unlock(&ide_setting_mtx);
 }
 EXPORT_SYMBOL(ide_proc_unregister_driver);
 void ide_proc_port_register_devices(ide_hwif_t *hwif)
 {
 	int	d;
 	struct proc_dir_entry *ent;
 	struct proc_dir_entry *parent = hwif->proc;
 	char name[64];
 	for (d = 0; d < MAX_DRIVES; d++) {
 		ide_drive_t *drive = &hwif->drives[d];
 		if (!drive->present)
 			continue;
 		if (drive->proc)
 			continue;
 		drive->proc = proc_mkdir(drive->name, parent);
 		if (drive->proc)
 			ide_add_proc_entries(drive->proc, generic_drive_entries, drive);
 		sprintf(name,"ide%d/%s", (drive->name[2]-'a')/2, drive->name);
 		ent = proc_symlink(drive->name, proc_ide_root, name);
 		if (!ent) return;
 	}
 }
 static void destroy_proc_ide_device(ide_hwif_t *hwif, ide_drive_t *drive)
 {
 	if (drive->proc) {
 		ide_remove_proc_entries(drive->proc, generic_drive_entries);
 		remove_proc_entry(drive->name, proc_ide_root);
 		remove_proc_entry(drive->name, hwif->proc);
 		drive->proc = NULL;
 	}
 }
 static void destroy_proc_ide_drives(ide_hwif_t *hwif)
 {
 	int	d;
 	for (d = 0; d < MAX_DRIVES; d++) {
 		ide_drive_t *drive = &hwif->drives[d];
 		if (drive->proc)
 			destroy_proc_ide_device(hwif, drive);
 	}
 }
 static ide_proc_entry_t hwif_entries[] = {
 	{ "channel",	S_IFREG|S_IRUGO,	proc_ide_read_channel,	NULL },
 	{ "mate",	S_IFREG|S_IRUGO,	proc_ide_read_mate,	NULL },
 	{ "model",	S_IFREG|S_IRUGO,	proc_ide_read_imodel,	NULL },
 	{ NULL,	0, NULL, NULL }
 };
 void ide_proc_register_port(ide_hwif_t *hwif)
 {
 	if (!hwif->proc) {
 		hwif->proc = proc_mkdir(hwif->name, proc_ide_root);
 		if (!hwif->proc)
 			return;
 		ide_add_proc_entries(hwif->proc, hwif_entries, hwif);
 	}
 }
 #ifdef CONFIG_BLK_DEV_IDEPCI
 void ide_pci_create_host_proc(const char *name, get_info_t *get_info)
 {
 	create_proc_info_entry(name, 0, proc_ide_root, get_info);
 }
 EXPORT_SYMBOL_GPL(ide_pci_create_host_proc);
 #endif
 void ide_proc_unregister_port(ide_hwif_t *hwif)
 {
 	if (hwif->proc) {
 		destroy_proc_ide_drives(hwif);
 		ide_remove_proc_entries(hwif->proc, hwif_entries);
 		remove_proc_entry(hwif->name, proc_ide_root);
 		hwif->proc = NULL;
 	}
 }
 static int proc_print_driver(struct device_driver *drv, void *data)
 {
 	ide_driver_t *ide_drv = container_of(drv, ide_driver_t, gen_driver);
 	struct seq_file *s = data;
 	seq_printf(s, "%s version %s\n", drv->name, ide_drv->version);
 	return 0;
 }
 static int ide_drivers_show(struct seq_file *s, void *p)
 {
 	int err;
 	err = bus_for_each_drv(&ide_bus_type, NULL, s, proc_print_driver);
 	if (err < 0)
 		printk(KERN_WARNING "IDE: %s: bus_for_each_drv error: %d\n",
 			__FUNCTION__, err);
 	return 0;
 }
 static int ide_drivers_open(struct inode *inode, struct file *file)
 {
 	return single_open(file, &ide_drivers_show, NULL);
 }
 static const struct file_operations ide_drivers_operations = {
 	.open		= ide_drivers_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= single_release,
 };
 void proc_ide_create(void)
 {
 	struct proc_dir_entry *entry;
 	proc_ide_root = proc_mkdir("ide", NULL);
 	if (!proc_ide_root)
 		return;
 	entry = create_proc_entry("drivers", 0, proc_ide_root);
 	if (entry)
 		entry->proc_fops = &ide_drivers_operations;
 }
 void proc_ide_destroy(void)
 {
 	remove_proc_entry("drivers", proc_ide_root);
 	remove_proc_entry("ide", NULL);
 }

include/linux/ide.h

Diff comments View file @ 7c7e92a

 #ifndef _IDE_H
 #define _IDE_H
 /*
  *  linux/include/linux/ide.h
  *
  *  Copyright (C) 1994-2002  Linus Torvalds & authors
  */
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/hdreg.h>
 #include <linux/blkdev.h>
 #include <linux/proc_fs.h>
 #include <linux/interrupt.h>
 #include <linux/bitops.h>
 #include <linux/bio.h>
 #include <linux/device.h>
 #include <linux/pci.h>
 #include <linux/completion.h>
 #ifdef CONFIG_BLK_DEV_IDEACPI
 #include <acpi/acpi.h>
 #endif
 #include <asm/byteorder.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/semaphore.h>
 #include <asm/mutex.h>
 #if defined(CRIS) || defined(FRV)
 # define SUPPORT_VLB_SYNC 0
 #else
 # define SUPPORT_VLB_SYNC 1
 #endif
 /*
  * Used to indicate "no IRQ", should be a value that cannot be an IRQ
  * number.
  */
 #define IDE_NO_IRQ		(-1)
 typedef unsigned char	byte;	/* used everywhere */
 /*
  * Probably not wise to fiddle with these
  */
 #define ERROR_MAX	8	/* Max read/write errors per sector */
 #define ERROR_RESET	3	/* Reset controller every 4th retry */
 #define ERROR_RECAL	1	/* Recalibrate every 2nd retry */
 /*
  * Tune flags
  */
 #define IDE_TUNE_NOAUTO		2
 #define IDE_TUNE_AUTO		1
 #define IDE_TUNE_DEFAULT	0
 /*
  * state flags
  */
 #define DMA_PIO_RETRY	1	/* retrying in PIO */
 #define HWIF(drive)		((ide_hwif_t *)((drive)->hwif))
 #define HWGROUP(drive)		((ide_hwgroup_t *)(HWIF(drive)->hwgroup))
 /*
  * Definitions for accessing IDE controller registers
  */
 #define IDE_NR_PORTS		(10)
 #define IDE_DATA_OFFSET		(0)
 #define IDE_ERROR_OFFSET	(1)
 #define IDE_NSECTOR_OFFSET	(2)
 #define IDE_SECTOR_OFFSET	(3)
 #define IDE_LCYL_OFFSET		(4)
 #define IDE_HCYL_OFFSET		(5)
 #define IDE_SELECT_OFFSET	(6)
 #define IDE_STATUS_OFFSET	(7)
 #define IDE_CONTROL_OFFSET	(8)
 #define IDE_IRQ_OFFSET		(9)
 #define IDE_FEATURE_OFFSET	IDE_ERROR_OFFSET
 #define IDE_COMMAND_OFFSET	IDE_STATUS_OFFSET
 #define IDE_DATA_REG		(HWIF(drive)->io_ports[IDE_DATA_OFFSET])
 #define IDE_ERROR_REG		(HWIF(drive)->io_ports[IDE_ERROR_OFFSET])
 #define IDE_NSECTOR_REG		(HWIF(drive)->io_ports[IDE_NSECTOR_OFFSET])
 #define IDE_SECTOR_REG		(HWIF(drive)->io_ports[IDE_SECTOR_OFFSET])
 #define IDE_LCYL_REG		(HWIF(drive)->io_ports[IDE_LCYL_OFFSET])
 #define IDE_HCYL_REG		(HWIF(drive)->io_ports[IDE_HCYL_OFFSET])
 #define IDE_SELECT_REG		(HWIF(drive)->io_ports[IDE_SELECT_OFFSET])
 #define IDE_STATUS_REG		(HWIF(drive)->io_ports[IDE_STATUS_OFFSET])
 #define IDE_CONTROL_REG		(HWIF(drive)->io_ports[IDE_CONTROL_OFFSET])
 #define IDE_IRQ_REG		(HWIF(drive)->io_ports[IDE_IRQ_OFFSET])
 #define IDE_FEATURE_REG		IDE_ERROR_REG
 #define IDE_COMMAND_REG		IDE_STATUS_REG
 #define IDE_ALTSTATUS_REG	IDE_CONTROL_REG
 #define IDE_IREASON_REG		IDE_NSECTOR_REG
 #define IDE_BCOUNTL_REG		IDE_LCYL_REG
 #define IDE_BCOUNTH_REG		IDE_HCYL_REG
 #define OK_STAT(stat,good,bad)	(((stat)&((good)|(bad)))==(good))
 #define BAD_R_STAT		(BUSY_STAT   | ERR_STAT)
 #define BAD_W_STAT		(BAD_R_STAT  | WRERR_STAT)
 #define BAD_STAT		(BAD_R_STAT  | DRQ_STAT)
 #define DRIVE_READY		(READY_STAT  | SEEK_STAT)
 #define BAD_CRC			(ABRT_ERR    | ICRC_ERR)
 #define SATA_NR_PORTS		(3)	/* 16 possible ?? */
 #define SATA_STATUS_OFFSET	(0)
 #define SATA_ERROR_OFFSET	(1)
 #define SATA_CONTROL_OFFSET	(2)
 #define SATA_MISC_OFFSET	(0)
 #define SATA_PHY_OFFSET		(1)
 #define SATA_IEN_OFFSET		(2)
 /*
  * Our Physical Region Descriptor (PRD) table should be large enough
  * to handle the biggest I/O request we are likely to see.  Since requests
  * can have no more than 256 sectors, and since the typical blocksize is
  * two or more sectors, we could get by with a limit of 128 entries here for
  * the usual worst case.  Most requests seem to include some contiguous blocks,
  * further reducing the number of table entries required.
  *
  * The driver reverts to PIO mode for individual requests that exceed
  * this limit (possible with 512 byte blocksizes, eg. MSDOS f/s), so handling
  * 100% of all crazy scenarios here is not necessary.
  *
  * As it turns out though, we must allocate a full 4KB page for this,
  * so the two PRD tables (ide0 & ide1) will each get half of that,
  * allowing each to have about 256 entries (8 bytes each) from this.
  */
 #define PRD_BYTES       8
 #define PRD_ENTRIES	256
 /*
  * Some more useful definitions
  */
 #define PARTN_BITS	6	/* number of minor dev bits for partitions */
 #define MAX_DRIVES	2	/* per interface; 2 assumed by lots of code */
 #define SECTOR_SIZE	512
 #define SECTOR_WORDS	(SECTOR_SIZE / 4)	/* number of 32bit words per sector */
 #define IDE_LARGE_SEEK(b1,b2,t)	(((b1) > (b2) + (t)) || ((b2) > (b1) + (t)))
 /*
  * Timeouts for various operations:
  */
 #define WAIT_DRQ	(HZ/10)		/* 100msec - spec allows up to 20ms */
 #define WAIT_READY	(5*HZ)		/* 5sec - some laptops are very slow */
 #define WAIT_PIDENTIFY	(10*HZ)	/* 10sec  - should be less than 3ms (?), if all ATAPI CD is closed at boot */
 #define WAIT_WORSTCASE	(30*HZ)	/* 30sec  - worst case when spinning up */
 #define WAIT_CMD	(10*HZ)	/* 10sec  - maximum wait for an IRQ to happen */
 #define WAIT_MIN_SLEEP	(2*HZ/100)	/* 20msec - minimum sleep time */
 /*
  * Check for an interrupt and acknowledge the interrupt status
  */
 struct hwif_s;
 typedef int (ide_ack_intr_t)(struct hwif_s *);
 /*
  * hwif_chipset_t is used to keep track of the specific hardware
  * chipset used by each IDE interface, if known.
  */
 enum {		ide_unknown,	ide_generic,	ide_pci,
 		ide_cmd640,	ide_dtc2278,	ide_ali14xx,
 		ide_qd65xx,	ide_umc8672,	ide_ht6560b,
 		ide_rz1000,	ide_trm290,
 		ide_cmd646,	ide_cy82c693,	ide_4drives,
 		ide_pmac,	ide_etrax100,	ide_acorn,
-		ide_au1xxx, ide_forced
+		ide_au1xxx,	ide_palm3710,	ide_forced
 };
 typedef u8 hwif_chipset_t;
 /*
  * Structure to hold all information about the location of this port
  */
 typedef struct hw_regs_s {
 	unsigned long	io_ports[IDE_NR_PORTS];	/* task file registers */
 	int		irq;			/* our irq number */
 	ide_ack_intr_t	*ack_intr;		/* acknowledge interrupt */
 	hwif_chipset_t  chipset;
 	struct device	*dev;
 } hw_regs_t;
 struct hwif_s * ide_find_port(unsigned long);
 struct hwif_s *ide_deprecated_find_port(unsigned long);
 void ide_init_port_data(struct hwif_s *, unsigned int);
 void ide_init_port_hw(struct hwif_s *, hw_regs_t *);
 struct ide_drive_s;
 int ide_register_hw(hw_regs_t *, void (*)(struct ide_drive_s *),
 		    struct hwif_s **);
 void ide_setup_ports(	hw_regs_t *hw,
 			unsigned long base,
 			int *offsets,
 			unsigned long ctrl,
 			unsigned long intr,
 			ide_ack_intr_t *ack_intr,
 #if 0
 			ide_io_ops_t *iops,
 #endif
 			int irq);
 static inline void ide_std_init_ports(hw_regs_t *hw,
 				      unsigned long io_addr,
 				      unsigned long ctl_addr)
 {
 	unsigned int i;
 	for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
 		hw->io_ports[i] = io_addr++;
 	hw->io_ports[IDE_CONTROL_OFFSET] = ctl_addr;
 }
 #include <asm/ide.h>
 #if !defined(MAX_HWIFS) || defined(CONFIG_EMBEDDED)
 #undef MAX_HWIFS
 #define MAX_HWIFS	CONFIG_IDE_MAX_HWIFS
 #endif
 /* needed on alpha, x86/x86_64, ia64, mips, ppc32 and sh */
 #ifndef IDE_ARCH_OBSOLETE_DEFAULTS
 # define ide_default_io_base(index)	(0)
 # define ide_default_irq(base)		(0)
 # define ide_init_default_irq(base)	(0)
 #endif
 #ifdef CONFIG_IDE_ARCH_OBSOLETE_INIT
 static inline void ide_init_hwif_ports(hw_regs_t *hw,
 				       unsigned long io_addr,
 				       unsigned long ctl_addr,
 				       int *irq)
 {
 	if (!ctl_addr)
 		ide_std_init_ports(hw, io_addr, ide_default_io_ctl(io_addr));
 	else
 		ide_std_init_ports(hw, io_addr, ctl_addr);
 	if (irq)
 		*irq = 0;
 	hw->io_ports[IDE_IRQ_OFFSET] = 0;
 #ifdef CONFIG_PPC32
 	if (ppc_ide_md.ide_init_hwif)
 		ppc_ide_md.ide_init_hwif(hw, io_addr, ctl_addr, irq);
 #endif
 }
 #else
 static inline void ide_init_hwif_ports(hw_regs_t *hw,
 				       unsigned long io_addr,
 				       unsigned long ctl_addr,
 				       int *irq)
 {
 	if (io_addr || ctl_addr)
 		printk(KERN_WARNING "%s: must not be called\n", __FUNCTION__);
 }
 #endif /* CONFIG_IDE_ARCH_OBSOLETE_INIT */
 /* Currently only m68k, apus and m8xx need it */
 #ifndef IDE_ARCH_ACK_INTR
 # define ide_ack_intr(hwif) (1)
 #endif
 /* Currently only Atari needs it */
 #ifndef IDE_ARCH_LOCK
 # define ide_release_lock()			do {} while (0)
 # define ide_get_lock(hdlr, data)		do {} while (0)
 #endif /* IDE_ARCH_LOCK */
 /*
  * Now for the data we need to maintain per-drive:  ide_drive_t
  */
 #define ide_scsi	0x21
 #define ide_disk	0x20
 #define ide_optical	0x7
 #define ide_cdrom	0x5
 #define ide_tape	0x1
 #define ide_floppy	0x0
 /*
  * Special Driver Flags
  *
  * set_geometry	: respecify drive geometry
  * recalibrate	: seek to cyl 0
  * set_multmode	: set multmode count
  * set_tune	: tune interface for drive
  * serviced	: service command
  * reserved	: unused
  */
 typedef union {
 	unsigned all			: 8;
 	struct {
 		unsigned set_geometry	: 1;
 		unsigned recalibrate	: 1;
 		unsigned set_multmode	: 1;
 		unsigned set_tune	: 1;
 		unsigned serviced	: 1;
 		unsigned reserved	: 3;
 	} b;
 } special_t;
 /*
  * ATA-IDE Select Register, aka Device-Head
  *
  * head		: always zeros here
  * unit		: drive select number: 0/1
  * bit5		: always 1
  * lba		: using LBA instead of CHS
  * bit7		: always 1
  */
 typedef union {
 	unsigned all			: 8;
 	struct {
 #if defined(__LITTLE_ENDIAN_BITFIELD)
 		unsigned head		: 4;
 		unsigned unit		: 1;
 		unsigned bit5		: 1;
 		unsigned lba		: 1;
 		unsigned bit7		: 1;
 #elif defined(__BIG_ENDIAN_BITFIELD)
 		unsigned bit7		: 1;
 		unsigned lba		: 1;
 		unsigned bit5		: 1;
 		unsigned unit		: 1;
 		unsigned head		: 4;
 #else
 #error "Please fix <asm/byteorder.h>"
 #endif
 	} b;
 } select_t, ata_select_t;
 /*
  * Status returned from various ide_ functions
  */
 typedef enum {
 	ide_stopped,	/* no drive operation was started */
 	ide_started,	/* a drive operation was started, handler was set */
 } ide_startstop_t;
 struct ide_driver_s;
 struct ide_settings_s;
 #ifdef CONFIG_BLK_DEV_IDEACPI
 struct ide_acpi_drive_link;
 struct ide_acpi_hwif_link;
 #endif
 typedef struct ide_drive_s {
 	char		name[4];	/* drive name, such as "hda" */
         char            driver_req[10];	/* requests specific driver */
 	struct request_queue	*queue;	/* request queue */
 	struct request		*rq;	/* current request */
 	struct ide_drive_s 	*next;	/* circular list of hwgroup drives */
 	void		*driver_data;	/* extra driver data */
 	struct hd_driveid	*id;	/* drive model identification info */
 #ifdef CONFIG_IDE_PROC_FS
 	struct proc_dir_entry *proc;	/* /proc/ide/ directory entry */
 	struct ide_settings_s *settings;/* /proc/ide/ drive settings */
 #endif
 	struct hwif_s		*hwif;	/* actually (ide_hwif_t *) */
 	unsigned long sleep;		/* sleep until this time */
 	unsigned long service_start;	/* time we started last request */
 	unsigned long service_time;	/* service time of last request */
 	unsigned long timeout;		/* max time to wait for irq */
 	special_t	special;	/* special action flags */
 	select_t	select;		/* basic drive/head select reg value */
 	u8	keep_settings;		/* restore settings after drive reset */
 	u8	using_dma;		/* disk is using dma for read/write */
 	u8	retry_pio;		/* retrying dma capable host in pio */
 	u8	state;			/* retry state */
 	u8	waiting_for_dma;	/* dma currently in progress */
 	u8	unmask;			/* okay to unmask other irqs */
 	u8	noflush;		/* don't attempt flushes */
 	u8	dsc_overlap;		/* DSC overlap */
 	u8	nice1;			/* give potential excess bandwidth */
 	unsigned present	: 1;	/* drive is physically present */
 	unsigned dead		: 1;	/* device ejected hint */
 	unsigned id_read	: 1;	/* 1=id read from disk 0 = synthetic */
 	unsigned noprobe 	: 1;	/* from:  hdx=noprobe */
 	unsigned removable	: 1;	/* 1 if need to do check_media_change */
 	unsigned attach		: 1;	/* needed for removable devices */
 	unsigned forced_geom	: 1;	/* 1 if hdx=c,h,s was given at boot */
 	unsigned no_unmask	: 1;	/* disallow setting unmask bit */
 	unsigned no_io_32bit	: 1;	/* disallow enabling 32bit I/O */
 	unsigned atapi_overlap	: 1;	/* ATAPI overlap (not supported) */
 	unsigned doorlocking	: 1;	/* for removable only: door lock/unlock works */
 	unsigned nodma		: 1;	/* disallow DMA */
 	unsigned autotune	: 2;	/* 0=default, 1=autotune, 2=noautotune */
 	unsigned remap_0_to_1	: 1;	/* 0=noremap, 1=remap 0->1 (for EZDrive) */
 	unsigned blocked        : 1;	/* 1=powermanagment told us not to do anything, so sleep nicely */
 	unsigned vdma		: 1;	/* 1=doing PIO over DMA 0=doing normal DMA */
 	unsigned scsi		: 1;	/* 0=default, 1=ide-scsi emulation */
 	unsigned sleeping	: 1;	/* 1=sleeping & sleep field valid */
 	unsigned post_reset	: 1;
 	unsigned udma33_warned	: 1;
 	u8	addressing;	/* 0=28-bit, 1=48-bit, 2=48-bit doing 28-bit */
         u8	quirk_list;	/* considered quirky, set for a specific host */
         u8	init_speed;	/* transfer rate set at boot */
         u8	current_speed;	/* current transfer rate set */
 	u8	desired_speed;	/* desired transfer rate set */
         u8	dn;		/* now wide spread use */
         u8	wcache;		/* status of write cache */
 	u8	acoustic;	/* acoustic management */
 	u8	media;		/* disk, cdrom, tape, floppy, ... */
 	u8	ctl;		/* "normal" value for IDE_CONTROL_REG */
 	u8	ready_stat;	/* min status value for drive ready */
 	u8	mult_count;	/* current multiple sector setting */
 	u8	mult_req;	/* requested multiple sector setting */
 	u8	tune_req;	/* requested drive tuning setting */
 	u8	io_32bit;	/* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
 	u8	bad_wstat;	/* used for ignoring WRERR_STAT */
 	u8	nowerr;		/* used for ignoring WRERR_STAT */
 	u8	sect0;		/* offset of first sector for DM6:DDO */
 	u8	head;		/* "real" number of heads */
 	u8	sect;		/* "real" sectors per track */
 	u8	bios_head;	/* BIOS/fdisk/LILO number of heads */
 	u8	bios_sect;	/* BIOS/fdisk/LILO sectors per track */
 	unsigned int	bios_cyl;	/* BIOS/fdisk/LILO number of cyls */
 	unsigned int	cyl;		/* "real" number of cyls */
 	unsigned int	drive_data;	/* used by set_pio_mode/selectproc */
 	unsigned int	failures;	/* current failure count */
 	unsigned int	max_failures;	/* maximum allowed failure count */
 	u64		probed_capacity;/* initial reported media capacity (ide-cd only currently) */
 	u64		capacity64;	/* total number of sectors */
 	int		lun;		/* logical unit */
 	int		crc_count;	/* crc counter to reduce drive speed */
 #ifdef CONFIG_BLK_DEV_IDEACPI
 	struct ide_acpi_drive_link *acpidata;
 #endif
 	struct list_head list;
 	struct device	gendev;
 	struct completion gendev_rel_comp;	/* to deal with device release() */
 } ide_drive_t;
 #define to_ide_device(dev)container_of(dev, ide_drive_t, gendev)
 #define IDE_CHIPSET_PCI_MASK	\
     ((1<<ide_pci)|(1<<ide_cmd646)|(1<<ide_ali14xx))
 #define IDE_CHIPSET_IS_PCI(c)	((IDE_CHIPSET_PCI_MASK >> (c)) & 1)
 struct ide_port_info;
 typedef struct hwif_s {
 	struct hwif_s *next;		/* for linked-list in ide_hwgroup_t */
 	struct hwif_s *mate;		/* other hwif from same PCI chip */
 	struct hwgroup_s *hwgroup;	/* actually (ide_hwgroup_t *) */
 	struct proc_dir_entry *proc;	/* /proc/ide/ directory entry */
 	char name[6];			/* name of interface, eg. "ide0" */
 		/* task file registers for pata and sata */
 	unsigned long	io_ports[IDE_NR_PORTS];
 	unsigned long	sata_scr[SATA_NR_PORTS];
 	unsigned long	sata_misc[SATA_NR_PORTS];
 	ide_drive_t	drives[MAX_DRIVES];	/* drive info */
 	u8 major;	/* our major number */
 	u8 index;	/* 0 for ide0; 1 for ide1; ... */
 	u8 channel;	/* for dual-port chips: 0=primary, 1=secondary */
 	u8 bus_state;	/* power state of the IDE bus */
 	u32 host_flags;
 	u8 pio_mask;
 	u8 ultra_mask;
 	u8 mwdma_mask;
 	u8 swdma_mask;
 	u8 cbl;		/* cable type */
 	hwif_chipset_t chipset;	/* sub-module for tuning.. */
 	struct device *dev;
 	const struct ide_port_info *cds;	/* chipset device struct */
 	ide_ack_intr_t *ack_intr;
 	void (*rw_disk)(ide_drive_t *, struct request *);
 #if 0
 	ide_hwif_ops_t	*hwifops;
 #else
 	/* host specific initialization of devices on a port */
 	void	(*port_init_devs)(struct hwif_s *);
 	/* routine to program host for PIO mode */
 	void	(*set_pio_mode)(ide_drive_t *, const u8);
 	/* routine to program host for DMA mode */
 	void	(*set_dma_mode)(ide_drive_t *, const u8);
 	/* tweaks hardware to select drive */
 	void	(*selectproc)(ide_drive_t *);
 	/* chipset polling based on hba specifics */
 	int	(*reset_poll)(ide_drive_t *);
 	/* chipset specific changes to default for device-hba resets */
 	void	(*pre_reset)(ide_drive_t *);
 	/* routine to reset controller after a disk reset */
 	void	(*resetproc)(ide_drive_t *);
 	/* special host masking for drive selection */
 	void	(*maskproc)(ide_drive_t *, int);
 	/* check host's drive quirk list */
 	void	(*quirkproc)(ide_drive_t *);
 	/* driver soft-power interface */
 	int	(*busproc)(ide_drive_t *, int);
 #endif
 	u8 (*mdma_filter)(ide_drive_t *);
 	u8 (*udma_filter)(ide_drive_t *);
 	u8 (*cable_detect)(struct hwif_s *);
 	void (*ata_input_data)(ide_drive_t *, void *, u32);
 	void (*ata_output_data)(ide_drive_t *, void *, u32);
 	void (*atapi_input_bytes)(ide_drive_t *, void *, u32);
 	void (*atapi_output_bytes)(ide_drive_t *, void *, u32);
 	void (*dma_host_set)(ide_drive_t *, int);
 	int (*dma_setup)(ide_drive_t *);
 	void (*dma_exec_cmd)(ide_drive_t *, u8);
 	void (*dma_start)(ide_drive_t *);
 	int (*ide_dma_end)(ide_drive_t *drive);
 	int (*ide_dma_test_irq)(ide_drive_t *drive);
 	void (*ide_dma_clear_irq)(ide_drive_t *drive);
 	void (*dma_lost_irq)(ide_drive_t *drive);
 	void (*dma_timeout)(ide_drive_t *drive);
 	void (*OUTB)(u8 addr, unsigned long port);
 	void (*OUTBSYNC)(ide_drive_t *drive, u8 addr, unsigned long port);
 	void (*OUTW)(u16 addr, unsigned long port);
 	void (*OUTSW)(unsigned long port, void *addr, u32 count);
 	void (*OUTSL)(unsigned long port, void *addr, u32 count);
 	u8  (*INB)(unsigned long port);
 	u16 (*INW)(unsigned long port);
 	void (*INSW)(unsigned long port, void *addr, u32 count);
 	void (*INSL)(unsigned long port, void *addr, u32 count);
 	/* dma physical region descriptor table (cpu view) */
 	unsigned int	*dmatable_cpu;
 	/* dma physical region descriptor table (dma view) */
 	dma_addr_t	dmatable_dma;
 	/* Scatter-gather list used to build the above */
 	struct scatterlist *sg_table;
 	int sg_max_nents;		/* Maximum number of entries in it */
 	int sg_nents;			/* Current number of entries in it */
 	int sg_dma_direction;		/* dma transfer direction */
 	/* data phase of the active command (currently only valid for PIO/DMA) */
 	int		data_phase;
 	unsigned int nsect;
 	unsigned int nleft;
 	struct scatterlist *cursg;
 	unsigned int cursg_ofs;
 	int		rqsize;		/* max sectors per request */
 	int		irq;		/* our irq number */
 	unsigned long	dma_base;	/* base addr for dma ports */
 	unsigned long	dma_command;	/* dma command register */
 	unsigned long	dma_vendor1;	/* dma vendor 1 register */
 	unsigned long	dma_status;	/* dma status register */
 	unsigned long	dma_vendor3;	/* dma vendor 3 register */
 	unsigned long	dma_prdtable;	/* actual prd table address */
 	unsigned long	config_data;	/* for use by chipset-specific code */
 	unsigned long	select_data;	/* for use by chipset-specific code */
 	unsigned long	extra_base;	/* extra addr for dma ports */
 	unsigned	extra_ports;	/* number of extra dma ports */
 	unsigned	noprobe    : 1;	/* don't probe for this interface */
 	unsigned	present    : 1;	/* this interface exists */
 	unsigned	hold       : 1; /* this interface is always present */
 	unsigned	serialized : 1;	/* serialized all channel operation */
 	unsigned	sharing_irq: 1;	/* 1 = sharing irq with another hwif */
 	unsigned	reset      : 1;	/* reset after probe */
 	unsigned	sg_mapped  : 1;	/* sg_table and sg_nents are ready */
 	unsigned	mmio       : 1; /* host uses MMIO */
 	unsigned	straight8  : 1;	/* Alan's straight 8 check */
 	struct device	gendev;
 	struct completion gendev_rel_comp; /* To deal with device release() */
 	void		*hwif_data;	/* extra hwif data */
 	unsigned dma;
 #ifdef CONFIG_BLK_DEV_IDEACPI
 	struct ide_acpi_hwif_link *acpidata;
 #endif
 } ____cacheline_internodealigned_in_smp ide_hwif_t;
 /*
  *  internal ide interrupt handler type
  */
 typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
 typedef int (ide_expiry_t)(ide_drive_t *);
 /* used by ide-cd, ide-floppy, etc. */
 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
 typedef struct hwgroup_s {
 		/* irq handler, if active */
 	ide_startstop_t	(*handler)(ide_drive_t *);
 		/* BOOL: protects all fields below */
 	volatile int busy;
 		/* BOOL: wake us up on timer expiry */
 	unsigned int sleeping	: 1;
 		/* BOOL: polling active & poll_timeout field valid */
 	unsigned int polling	: 1;
 	 	/* BOOL: in a polling reset situation. Must not trigger another reset yet */
 	unsigned int resetting  : 1;
 		/* current drive */
 	ide_drive_t *drive;
 		/* ptr to current hwif in linked-list */
 	ide_hwif_t *hwif;
 		/* current request */
 	struct request *rq;
 		/* failsafe timer */
 	struct timer_list timer;
 		/* timeout value during long polls */
 	unsigned long poll_timeout;
 		/* queried upon timeouts */
 	int (*expiry)(ide_drive_t *);
 	int req_gen;
 	int req_gen_timer;
 } ide_hwgroup_t;
 typedef struct ide_driver_s ide_driver_t;
 extern struct mutex ide_setting_mtx;
 int set_io_32bit(ide_drive_t *, int);
 int set_pio_mode(ide_drive_t *, int);
 int set_using_dma(ide_drive_t *, int);
 #ifdef CONFIG_IDE_PROC_FS
 /*
  * configurable drive settings
  */
 #define TYPE_INT	0
 #define TYPE_BYTE	1
 #define TYPE_SHORT	2
 #define SETTING_READ	(1 << 0)
 #define SETTING_WRITE	(1 << 1)
 #define SETTING_RW	(SETTING_READ | SETTING_WRITE)
 typedef int (ide_procset_t)(ide_drive_t *, int);
 typedef struct ide_settings_s {
 	char			*name;
 	int			rw;
 	int			data_type;
 	int			min;
 	int			max;
 	int			mul_factor;
 	int			div_factor;
 	void			*data;
 	ide_procset_t		*set;
 	int			auto_remove;
 	struct ide_settings_s	*next;
 } ide_settings_t;
 int ide_add_setting(ide_drive_t *, const char *, int, int, int, int, int, int, void *, ide_procset_t *set);
 /*
  * /proc/ide interface
  */
 typedef struct {
 	const char	*name;
 	mode_t		mode;
 	read_proc_t	*read_proc;
 	write_proc_t	*write_proc;
 } ide_proc_entry_t;
 void proc_ide_create(void);
 void proc_ide_destroy(void);
 void ide_proc_register_port(ide_hwif_t *);
 void ide_proc_port_register_devices(ide_hwif_t *);
 void ide_proc_unregister_port(ide_hwif_t *);
 void ide_proc_register_driver(ide_drive_t *, ide_driver_t *);
 void ide_proc_unregister_driver(ide_drive_t *, ide_driver_t *);
 void ide_add_generic_settings(ide_drive_t *);
 read_proc_t proc_ide_read_capacity;
 read_proc_t proc_ide_read_geometry;
 #ifdef CONFIG_BLK_DEV_IDEPCI
 void ide_pci_create_host_proc(const char *, get_info_t *);
 #endif
 /*
  * Standard exit stuff:
  */
 #define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) \
 {					\
 	len -= off;			\
 	if (len < count) {		\
 		*eof = 1;		\
 		if (len <= 0)		\
 			return 0;	\
 	} else				\
 		len = count;		\
 	*start = page + off;		\
 	return len;			\
 }
 #else
 static inline void proc_ide_create(void) { ; }
 static inline void proc_ide_destroy(void) { ; }
 static inline void ide_proc_register_port(ide_hwif_t *hwif) { ; }
 static inline void ide_proc_port_register_devices(ide_hwif_t *hwif) { ; }
 static inline void ide_proc_unregister_port(ide_hwif_t *hwif) { ; }
 static inline void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver) { ; }
 static inline void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver) { ; }
 static inline void ide_add_generic_settings(ide_drive_t *drive) { ; }
 #define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) return 0;
 #endif
 /*
  * Power Management step value (rq->pm->pm_step).
  *
  * The step value starts at 0 (ide_pm_state_start_suspend) for a
  * suspend operation or 1000 (ide_pm_state_start_resume) for a
  * resume operation.
  *
  * For each step, the core calls the subdriver start_power_step() first.
  * This can return:
  *	- ide_stopped :	In this case, the core calls us back again unless
  *			step have been set to ide_power_state_completed.
  *	- ide_started :	In this case, the channel is left busy until an
  *			async event (interrupt) occurs.
  * Typically, start_power_step() will issue a taskfile request with
  * do_rw_taskfile().
  *
  * Upon reception of the interrupt, the core will call complete_power_step()
  * with the error code if any. This routine should update the step value
  * and return. It should not start a new request. The core will call
  * start_power_step for the new step value, unless step have been set to
  * ide_power_state_completed.
  *
  * Subdrivers are expected to define their own additional power
  * steps from 1..999 for suspend and from 1001..1999 for resume,
  * other values are reserved for future use.
  */
 enum {
 	ide_pm_state_completed		= -1,
 	ide_pm_state_start_suspend	= 0,
 	ide_pm_state_start_resume	= 1000,
 };
 /*
  * Subdrivers support.
  *
  * The gendriver.owner field should be set to the module owner of this driver.
  * The gendriver.name field should be set to the name of this driver
  */
 struct ide_driver_s {
 	const char			*version;
 	u8				media;
 	unsigned supports_dsc_overlap	: 1;
 	ide_startstop_t	(*do_request)(ide_drive_t *, struct request *, sector_t);
 	int		(*end_request)(ide_drive_t *, int, int);
 	ide_startstop_t	(*error)(ide_drive_t *, struct request *rq, u8, u8);
 	ide_startstop_t	(*abort)(ide_drive_t *, struct request *rq);
 	struct device_driver	gen_driver;
 	int		(*probe)(ide_drive_t *);
 	void		(*remove)(ide_drive_t *);
 	void		(*resume)(ide_drive_t *);
 	void		(*shutdown)(ide_drive_t *);
 #ifdef CONFIG_IDE_PROC_FS
 	ide_proc_entry_t	*proc;
 #endif
 };
 #define to_ide_driver(drv) container_of(drv, ide_driver_t, gen_driver)
 int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *, unsigned, unsigned long);
 /*
  * ide_hwifs[] is the master data structure used to keep track
  * of just about everything in ide.c.  Whenever possible, routines
  * should be using pointers to a drive (ide_drive_t *) or
  * pointers to a hwif (ide_hwif_t *), rather than indexing this
  * structure directly (the allocation/layout may change!).
  *
  */
 #ifndef _IDE_C
 extern	ide_hwif_t	ide_hwifs[];		/* master data repository */
 #endif
 extern int noautodma;
 extern int ide_end_request (ide_drive_t *drive, int uptodate, int nrsecs);
 int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
 			     int uptodate, int nr_sectors);
 extern void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry);
 void ide_execute_command(ide_drive_t *, u8, ide_handler_t *, unsigned int,
 			 ide_expiry_t *);
 ide_startstop_t __ide_error(ide_drive_t *, struct request *, u8, u8);
 ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat);
 ide_startstop_t __ide_abort(ide_drive_t *, struct request *);
 extern ide_startstop_t ide_abort(ide_drive_t *, const char *);
 extern void ide_fix_driveid(struct hd_driveid *);
 extern void ide_fixstring(u8 *, const int, const int);
 int ide_wait_stat(ide_startstop_t *, ide_drive_t *, u8, u8, unsigned long);
 extern ide_startstop_t ide_do_reset (ide_drive_t *);
 extern void ide_init_drive_cmd (struct request *rq);
 /*
  * "action" parameter type for ide_do_drive_cmd() below.
  */
 typedef enum {
 	ide_wait,	/* insert rq at end of list, and wait for it */
 	ide_preempt,	/* insert rq in front of current request */
 	ide_head_wait,	/* insert rq in front of current request and wait for it */
 	ide_end		/* insert rq at end of list, but don't wait for it */
 } ide_action_t;
 extern int ide_do_drive_cmd(ide_drive_t *, struct request *, ide_action_t);
 extern void ide_end_drive_cmd(ide_drive_t *, u8, u8);
 enum {
 	IDE_TFLAG_LBA48			= (1 << 0),
 	IDE_TFLAG_NO_SELECT_MASK	= (1 << 1),
 	IDE_TFLAG_FLAGGED		= (1 << 2),
 	IDE_TFLAG_OUT_DATA		= (1 << 3),
 	IDE_TFLAG_OUT_HOB_FEATURE	= (1 << 4),
 	IDE_TFLAG_OUT_HOB_NSECT		= (1 << 5),
 	IDE_TFLAG_OUT_HOB_LBAL		= (1 << 6),
 	IDE_TFLAG_OUT_HOB_LBAM		= (1 << 7),
 	IDE_TFLAG_OUT_HOB_LBAH		= (1 << 8),
 	IDE_TFLAG_OUT_HOB		= IDE_TFLAG_OUT_HOB_FEATURE |
 					  IDE_TFLAG_OUT_HOB_NSECT |
 					  IDE_TFLAG_OUT_HOB_LBAL |
 					  IDE_TFLAG_OUT_HOB_LBAM |
 					  IDE_TFLAG_OUT_HOB_LBAH,
 	IDE_TFLAG_OUT_FEATURE		= (1 << 9),
 	IDE_TFLAG_OUT_NSECT		= (1 << 10),
 	IDE_TFLAG_OUT_LBAL		= (1 << 11),
 	IDE_TFLAG_OUT_LBAM		= (1 << 12),
 	IDE_TFLAG_OUT_LBAH		= (1 << 13),
 	IDE_TFLAG_OUT_TF		= IDE_TFLAG_OUT_FEATURE |
 					  IDE_TFLAG_OUT_NSECT |
 					  IDE_TFLAG_OUT_LBAL |
 					  IDE_TFLAG_OUT_LBAM |
 					  IDE_TFLAG_OUT_LBAH,
 	IDE_TFLAG_OUT_DEVICE		= (1 << 14),
 	IDE_TFLAG_WRITE			= (1 << 15),
 	IDE_TFLAG_FLAGGED_SET_IN_FLAGS	= (1 << 16),
 	IDE_TFLAG_IN_DATA		= (1 << 17),
 	IDE_TFLAG_CUSTOM_HANDLER	= (1 << 18),
 	IDE_TFLAG_DMA_PIO_FALLBACK	= (1 << 19),
 	IDE_TFLAG_IN_HOB_FEATURE	= (1 << 20),
 	IDE_TFLAG_IN_HOB_NSECT		= (1 << 21),
 	IDE_TFLAG_IN_HOB_LBAL		= (1 << 22),
 	IDE_TFLAG_IN_HOB_LBAM		= (1 << 23),
 	IDE_TFLAG_IN_HOB_LBAH		= (1 << 24),
 	IDE_TFLAG_IN_HOB_LBA		= IDE_TFLAG_IN_HOB_LBAL |
 					  IDE_TFLAG_IN_HOB_LBAM |
 					  IDE_TFLAG_IN_HOB_LBAH,
 	IDE_TFLAG_IN_HOB		= IDE_TFLAG_IN_HOB_FEATURE |
 					  IDE_TFLAG_IN_HOB_NSECT |
 					  IDE_TFLAG_IN_HOB_LBA,
 	IDE_TFLAG_IN_NSECT		= (1 << 25),
 	IDE_TFLAG_IN_LBAL		= (1 << 26),
 	IDE_TFLAG_IN_LBAM		= (1 << 27),
 	IDE_TFLAG_IN_LBAH		= (1 << 28),
 	IDE_TFLAG_IN_LBA		= IDE_TFLAG_IN_LBAL |
 					  IDE_TFLAG_IN_LBAM |
 					  IDE_TFLAG_IN_LBAH,
 	IDE_TFLAG_IN_TF			= IDE_TFLAG_IN_NSECT |
 					  IDE_TFLAG_IN_LBA,
 	IDE_TFLAG_IN_DEVICE		= (1 << 29),
 	IDE_TFLAG_HOB			= IDE_TFLAG_OUT_HOB |
 					  IDE_TFLAG_IN_HOB,
 	IDE_TFLAG_TF			= IDE_TFLAG_OUT_TF |
 					  IDE_TFLAG_IN_TF,
 	IDE_TFLAG_DEVICE		= IDE_TFLAG_OUT_DEVICE |
 					  IDE_TFLAG_IN_DEVICE,
 	/* force 16-bit I/O operations */
 	IDE_TFLAG_IO_16BIT		= (1 << 30),
 };
 struct ide_taskfile {
 	u8	hob_data;	/*  0: high data byte (for TASKFILE IOCTL) */
 	u8	hob_feature;	/*  1-5: additional data to support LBA48 */
 	u8	hob_nsect;
 	u8	hob_lbal;
 	u8	hob_lbam;
 	u8	hob_lbah;
 	u8	data;		/*  6: low data byte (for TASKFILE IOCTL) */
 	union {			/*  7: */
 		u8 error;	/*   read:  error */
 		u8 feature;	/*  write: feature */
 	};
 	u8	nsect;		/*  8: number of sectors */
 	u8	lbal;		/*  9: LBA low */
 	u8	lbam;		/* 10: LBA mid */
 	u8	lbah;		/* 11: LBA high */
 	u8	device;		/* 12: device select */
 	union {			/* 13: */
 		u8 status;	/*  read: status  */
 		u8 command;	/* write: command */
 	};
 };
 typedef struct ide_task_s {
 	union {
 		struct ide_taskfile	tf;
 		u8			tf_array[14];
 	};
 	u32			tf_flags;
 	int			data_phase;
 	struct request		*rq;		/* copy of request */
 	void			*special;	/* valid_t generally */
 } ide_task_t;
 void ide_tf_load(ide_drive_t *, ide_task_t *);
 void ide_tf_read(ide_drive_t *, ide_task_t *);
 extern void SELECT_DRIVE(ide_drive_t *);
 extern void SELECT_MASK(ide_drive_t *, int);
 extern int drive_is_ready(ide_drive_t *);
 void ide_pktcmd_tf_load(ide_drive_t *, u32, u16, u8);
 ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
 void task_end_request(ide_drive_t *, struct request *, u8);
 int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *, u16);
 int ide_no_data_taskfile(ide_drive_t *, ide_task_t *);
 int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long);
 int ide_cmd_ioctl(ide_drive_t *, unsigned int, unsigned long);
 int ide_task_ioctl(ide_drive_t *, unsigned int, unsigned long);
 extern int system_bus_clock(void);
 extern int ide_driveid_update(ide_drive_t *);
 extern int ide_config_drive_speed(ide_drive_t *, u8);
 extern u8 eighty_ninty_three (ide_drive_t *);
 extern int taskfile_lib_get_identify(ide_drive_t *drive, u8 *);
 extern int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout);
 extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout);
 extern int ide_spin_wait_hwgroup(ide_drive_t *);
 extern void ide_timer_expiry(unsigned long);
 extern irqreturn_t ide_intr(int irq, void *dev_id);
 extern void do_ide_request(struct request_queue *);
 void ide_init_disk(struct gendisk *, ide_drive_t *);
 #ifdef CONFIG_IDEPCI_PCIBUS_ORDER
 extern int ide_scan_direction;
 extern int __ide_pci_register_driver(struct pci_driver *driver, struct module *owner, const char *mod_name);
 #define ide_pci_register_driver(d) __ide_pci_register_driver(d, THIS_MODULE, KBUILD_MODNAME)
 #else
 #define ide_pci_register_driver(d) pci_register_driver(d)
 #endif
 void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *, int, u8 *);
 void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *);
-#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
+/* FIXME: palm_bk3710 uses BLK_DEV_IDEDMA_PCI without BLK_DEV_IDEPCI! */
+#if defined(CONFIG_BLK_DEV_IDEPCI) && defined(CONFIG_BLK_DEV_IDEDMA_PCI)
 void ide_hwif_setup_dma(ide_hwif_t *, const struct ide_port_info *);
 #else
 static inline void ide_hwif_setup_dma(ide_hwif_t *hwif,
 				      const struct ide_port_info *d) { }
 #endif
 extern void default_hwif_iops(ide_hwif_t *);
 extern void default_hwif_mmiops(ide_hwif_t *);
 extern void default_hwif_transport(ide_hwif_t *);
 typedef struct ide_pci_enablebit_s {
 	u8	reg;	/* byte pci reg holding the enable-bit */
 	u8	mask;	/* mask to isolate the enable-bit */
 	u8	val;	/* value of masked reg when "enabled" */
 } ide_pci_enablebit_t;
 enum {
 	/* Uses ISA control ports not PCI ones. */
 	IDE_HFLAG_ISA_PORTS		= (1 << 0),
 	/* single port device */
 	IDE_HFLAG_SINGLE		= (1 << 1),
 	/* don't use legacy PIO blacklist */
 	IDE_HFLAG_PIO_NO_BLACKLIST	= (1 << 2),
 	/* don't use conservative PIO "downgrade" */
 	IDE_HFLAG_PIO_NO_DOWNGRADE	= (1 << 3),
 	/* use PIO8/9 for prefetch off/on */
 	IDE_HFLAG_ABUSE_PREFETCH	= (1 << 4),
 	/* use PIO6/7 for fast-devsel off/on */
 	IDE_HFLAG_ABUSE_FAST_DEVSEL	= (1 << 5),
 	/* use 100-102 and 200-202 PIO values to set DMA modes */
 	IDE_HFLAG_ABUSE_DMA_MODES	= (1 << 6),
 	/*
 	 * keep DMA setting when programming PIO mode, may be used only
 	 * for hosts which have separate PIO and DMA timings (ie. PMAC)
 	 */
 	IDE_HFLAG_SET_PIO_MODE_KEEP_DMA	= (1 << 7),
 	/* program host for the transfer mode after programming device */
 	IDE_HFLAG_POST_SET_MODE		= (1 << 8),
 	/* don't program host/device for the transfer mode ("smart" hosts) */
 	IDE_HFLAG_NO_SET_MODE		= (1 << 9),
 	/* trust BIOS for programming chipset/device for DMA */
 	IDE_HFLAG_TRUST_BIOS_FOR_DMA	= (1 << 10),
 	/* host uses VDMA (tied with IDE_HFLAG_CS5520 for now) */
 	IDE_HFLAG_VDMA			= (1 << 11),
 	/* ATAPI DMA is unsupported */
 	IDE_HFLAG_NO_ATAPI_DMA		= (1 << 12),
 	/* set if host is a "bootable" controller */
 	IDE_HFLAG_BOOTABLE		= (1 << 13),
 	/* host doesn't support DMA */
 	IDE_HFLAG_NO_DMA		= (1 << 14),
 	/* check if host is PCI IDE device before allowing DMA */
 	IDE_HFLAG_NO_AUTODMA		= (1 << 15),
 	/* don't autotune PIO */
 	IDE_HFLAG_NO_AUTOTUNE		= (1 << 16),
 	/* host is CS5510/CS5520 */
 	IDE_HFLAG_CS5520		= IDE_HFLAG_VDMA,
 	/* no LBA48 */
 	IDE_HFLAG_NO_LBA48		= (1 << 17),
 	/* no LBA48 DMA */
 	IDE_HFLAG_NO_LBA48_DMA		= (1 << 18),
 	/* data FIFO is cleared by an error */
 	IDE_HFLAG_ERROR_STOPS_FIFO	= (1 << 19),
 	/* serialize ports */
 	IDE_HFLAG_SERIALIZE		= (1 << 20),
 	/* use legacy IRQs */
 	IDE_HFLAG_LEGACY_IRQS		= (1 << 21),
 	/* force use of legacy IRQs */
 	IDE_HFLAG_FORCE_LEGACY_IRQS	= (1 << 22),
 	/* limit LBA48 requests to 256 sectors */
 	IDE_HFLAG_RQSIZE_256		= (1 << 23),
 	/* use 32-bit I/O ops */
 	IDE_HFLAG_IO_32BIT		= (1 << 24),
 	/* unmask IRQs */
 	IDE_HFLAG_UNMASK_IRQS		= (1 << 25),
 	IDE_HFLAG_ABUSE_SET_DMA_MODE	= (1 << 26),
 	/* host is CY82C693 */
 	IDE_HFLAG_CY82C693		= (1 << 27),
 	/* force host out of "simplex" mode */
 	IDE_HFLAG_CLEAR_SIMPLEX		= (1 << 28),
 	/* DSC overlap is unsupported */
 	IDE_HFLAG_NO_DSC		= (1 << 29),
 	/* never use 32-bit I/O ops */
 	IDE_HFLAG_NO_IO_32BIT		= (1 << 30),
 	/* never unmask IRQs */
 	IDE_HFLAG_NO_UNMASK_IRQS	= (1 << 31),
 };
 #ifdef CONFIG_BLK_DEV_OFFBOARD
 # define IDE_HFLAG_OFF_BOARD	IDE_HFLAG_BOOTABLE
 #else
 # define IDE_HFLAG_OFF_BOARD	0
 #endif
 struct ide_port_info {
 	char			*name;
 	unsigned int		(*init_chipset)(struct pci_dev *, const char *);
 	void			(*init_iops)(ide_hwif_t *);
 	void                    (*init_hwif)(ide_hwif_t *);
 	void			(*init_dma)(ide_hwif_t *, unsigned long);
 	ide_pci_enablebit_t	enablebits[2];
 	hwif_chipset_t		chipset;
 	u8			extra;
 	u32			host_flags;
 	u8			pio_mask;
 	u8			swdma_mask;
 	u8			mwdma_mask;
 	u8			udma_mask;
 };
 int ide_setup_pci_device(struct pci_dev *, const struct ide_port_info *);
 int ide_setup_pci_devices(struct pci_dev *, struct pci_dev *, const struct ide_port_info *);
 void ide_map_sg(ide_drive_t *, struct request *);
 void ide_init_sg_cmd(ide_drive_t *, struct request *);
 #define BAD_DMA_DRIVE		0
 #define GOOD_DMA_DRIVE		1
 struct drive_list_entry {
 	const char *id_model;
 	const char *id_firmware;
 };
 int ide_in_drive_list(struct hd_driveid *, const struct drive_list_entry *);
 #ifdef CONFIG_BLK_DEV_IDEDMA
 int __ide_dma_bad_drive(ide_drive_t *);
 int ide_id_dma_bug(ide_drive_t *);
 u8 ide_find_dma_mode(ide_drive_t *, u8);
 static inline u8 ide_max_dma_mode(ide_drive_t *drive)
 {
 	return ide_find_dma_mode(drive, XFER_UDMA_6);
 }
 void ide_dma_off_quietly(ide_drive_t *);
 void ide_dma_off(ide_drive_t *);
 void ide_dma_on(ide_drive_t *);
 int ide_set_dma(ide_drive_t *);
 void ide_check_dma_crc(ide_drive_t *);
 ide_startstop_t ide_dma_intr(ide_drive_t *);
 int ide_build_sglist(ide_drive_t *, struct request *);
 void ide_destroy_dmatable(ide_drive_t *);
 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
 extern int ide_build_dmatable(ide_drive_t *, struct request *);
 extern int ide_release_dma(ide_hwif_t *);
 extern void ide_setup_dma(ide_hwif_t *, unsigned long);
 void ide_dma_host_set(ide_drive_t *, int);
 extern int ide_dma_setup(ide_drive_t *);
 extern void ide_dma_start(ide_drive_t *);
 extern int __ide_dma_end(ide_drive_t *);
 extern void ide_dma_lost_irq(ide_drive_t *);
 extern void ide_dma_timeout(ide_drive_t *);
 #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
 #else
 static inline int ide_id_dma_bug(ide_drive_t *drive) { return 0; }
 static inline u8 ide_find_dma_mode(ide_drive_t *drive, u8 speed) { return 0; }
 static inline u8 ide_max_dma_mode(ide_drive_t *drive) { return 0; }
 static inline void ide_dma_off_quietly(ide_drive_t *drive) { ; }
 static inline void ide_dma_off(ide_drive_t *drive) { ; }
 static inline void ide_dma_on(ide_drive_t *drive) { ; }
 static inline void ide_dma_verbose(ide_drive_t *drive) { ; }
 static inline int ide_set_dma(ide_drive_t *drive) { return 1; }
 static inline void ide_check_dma_crc(ide_drive_t *drive) { ; }
 #endif /* CONFIG_BLK_DEV_IDEDMA */
 #ifndef CONFIG_BLK_DEV_IDEDMA_PCI
 static inline void ide_release_dma(ide_hwif_t *drive) {;}
 #endif
 #ifdef CONFIG_BLK_DEV_IDEACPI
 extern int ide_acpi_exec_tfs(ide_drive_t *drive);
 extern void ide_acpi_get_timing(ide_hwif_t *hwif);
 extern void ide_acpi_push_timing(ide_hwif_t *hwif);
 extern void ide_acpi_init(ide_hwif_t *hwif);
 void ide_acpi_port_init_devices(ide_hwif_t *);
 extern void ide_acpi_set_state(ide_hwif_t *hwif, int on);
 #else
 static inline int ide_acpi_exec_tfs(ide_drive_t *drive) { return 0; }
 static inline void ide_acpi_get_timing(ide_hwif_t *hwif) { ; }
 static inline void ide_acpi_push_timing(ide_hwif_t *hwif) { ; }
 static inline void ide_acpi_init(ide_hwif_t *hwif) { ; }
 static inline void ide_acpi_port_init_devices(ide_hwif_t *hwif) { ; }
 static inline void ide_acpi_set_state(ide_hwif_t *hwif, int on) {}
 #endif
 void ide_remove_port_from_hwgroup(ide_hwif_t *);
 extern int ide_hwif_request_regions(ide_hwif_t *hwif);
 extern void ide_hwif_release_regions(ide_hwif_t* hwif);
 void ide_unregister(unsigned int, int, int);
 void ide_register_region(struct gendisk *);
 void ide_unregister_region(struct gendisk *);
 void ide_undecoded_slave(ide_drive_t *);
 int ide_device_add_all(u8 *idx, const struct ide_port_info *);
 int ide_device_add(u8 idx[4], const struct ide_port_info *);
 static inline void *ide_get_hwifdata (ide_hwif_t * hwif)
 {
 	return hwif->hwif_data;
 }
 static inline void ide_set_hwifdata (ide_hwif_t * hwif, void *data)
 {
 	hwif->hwif_data = data;
 }
 const char *ide_xfer_verbose(u8 mode);
 extern void ide_toggle_bounce(ide_drive_t *drive, int on);
 extern int ide_set_xfer_rate(ide_drive_t *drive, u8 rate);
 static inline int ide_dev_has_iordy(struct hd_driveid *id)
 {
 	return ((id->field_valid & 2) && (id->capability & 8)) ? 1 : 0;
 }
 static inline int ide_dev_is_sata(struct hd_driveid *id)
 {
 	/*
 	 * See if word 93 is 0 AND drive is at least ATA-5 compatible
 	 * verifying that word 80 by casting it to a signed type --
 	 * this trick allows us to filter out the reserved values of
 	 * 0x0000 and 0xffff along with the earlier ATA revisions...
 	 */
 	if (id->hw_config == 0 && (short)id->major_rev_num >= 0x0020)
 		return 1;
 	return 0;
 }
 u64 ide_get_lba_addr(struct ide_taskfile *, int);
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 typedef struct ide_pio_timings_s {
 	int	setup_time;	/* Address setup (ns) minimum */
 	int	active_time;	/* Active pulse (ns) minimum */
 	int	cycle_time;	/* Cycle time (ns) minimum = */
 				/* active + recovery (+ setup for some chips) */
 } ide_pio_timings_t;
 unsigned int ide_pio_cycle_time(ide_drive_t *, u8);
 u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8);
 extern const ide_pio_timings_t ide_pio_timings[6];
 int ide_set_pio_mode(ide_drive_t *, u8);
 int ide_set_dma_mode(ide_drive_t *, u8);
 void ide_set_pio(ide_drive_t *, u8);
 static inline void ide_set_max_pio(ide_drive_t *drive)
 {
 	ide_set_pio(drive, 255);
 }
 extern spinlock_t ide_lock;
 extern struct mutex ide_cfg_mtx;
 /*
  * Structure locking:
  *
  * ide_cfg_mtx and ide_lock together protect changes to
  * ide_hwif_t->{next,hwgroup}
  * ide_drive_t->next
  *
  * ide_hwgroup_t->busy: ide_lock
  * ide_hwgroup_t->hwif: ide_lock
  * ide_hwif_t->mate: constant, no locking
  * ide_drive_t->hwif: constant, no locking
  */
 #define local_irq_set(flags)	do { local_save_flags((flags)); local_irq_enable_in_hardirq(); } while (0)
 extern struct bus_type ide_bus_type;
 /* check if CACHE FLUSH (EXT) command is supported (bits defined in ATA-6) */
 #define ide_id_has_flush_cache(id)	((id)->cfs_enable_2 & 0x3000)
 /* some Maxtor disks have bit 13 defined incorrectly so check bit 10 too */
 #define ide_id_has_flush_cache_ext(id)	\
 	(((id)->cfs_enable_2 & 0x2400) == 0x2400)
 static inline void ide_dump_identify(u8 *id)
 {
 	print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 2, id, 512, 0);
 }
 static inline int hwif_to_node(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	return dev ? pcibus_to_node(dev->bus) : -1;
 }
 static inline ide_drive_t *ide_get_paired_drive(ide_drive_t *drive)
 {
 	ide_hwif_t *hwif	= HWIF(drive);
 	return &hwif->drives[(drive->dn ^ 1) & 1];
 }
 static inline void ide_set_irq(ide_drive_t *drive, int on)
 {
 	drive->hwif->OUTB(drive->ctl | (on ? 0 : 2), IDE_CONTROL_REG);
 }
 #endif /* _IDE_H */