1#ifndef _IDE_H 2#define _IDE_H 3/* 4 * linux/include/linux/ide.h 5 * 6 * Copyright (C) 1994-2002 Linus Torvalds & authors 7 */ 8 9#include <linux/init.h> 10#include <linux/ioport.h> 11#include <linux/hdreg.h> 12#include <linux/hdsmart.h> 13#include <linux/blkdev.h> 14#include <linux/proc_fs.h> 15#include <linux/interrupt.h> 16#include <linux/bitops.h> 17#include <linux/bio.h> 18#include <linux/device.h> 19#include <linux/pci.h> 20#include <linux/completion.h> 21#ifdef CONFIG_BLK_DEV_IDEACPI 22#include <acpi/acpi.h> 23#endif 24#include <asm/byteorder.h> 25#include <asm/system.h> 26#include <asm/io.h> 27#include <asm/semaphore.h> 28 29/****************************************************************************** 30 * IDE driver configuration options (play with these as desired): 31 * 32 * REALLY_SLOW_IO can be defined in ide.c and ide-cd.c, if necessary 33 */ 34#define INITIAL_MULT_COUNT 0 /* off=0; on=2,4,8,16,32, etc.. */ 35 36#ifndef SUPPORT_SLOW_DATA_PORTS /* 1 to support slow data ports */ 37#define SUPPORT_SLOW_DATA_PORTS 1 /* 0 to reduce kernel size */ 38#endif 39#ifndef SUPPORT_VLB_SYNC /* 1 to support weird 32-bit chips */ 40#define SUPPORT_VLB_SYNC 1 /* 0 to reduce kernel size */ 41#endif 42#ifndef OK_TO_RESET_CONTROLLER /* 1 needed for good error recovery */ 43#define OK_TO_RESET_CONTROLLER 1 /* 0 for use with AH2372A/B interface */ 44#endif 45 46#ifndef DISABLE_IRQ_NOSYNC 47#define DISABLE_IRQ_NOSYNC 0 48#endif 49 50/* 51 * Used to indicate "no IRQ", should be a value that cannot be an IRQ 52 * number. 53 */ 54 55#define IDE_NO_IRQ (-1) 56 57/* 58 * "No user-serviceable parts" beyond this point :) 59 *****************************************************************************/ 60 61typedef unsigned char byte; /* used everywhere */ 62 63/* 64 * Probably not wise to fiddle with these 65 */ 66#define ERROR_MAX 8 /* Max read/write errors per sector */ 67#define ERROR_RESET 3 /* Reset controller every 4th retry */ 68#define ERROR_RECAL 1 /* Recalibrate every 2nd retry */ 69 70/* 71 * Tune flags 72 */ 73#define IDE_TUNE_NOAUTO 2 74#define IDE_TUNE_AUTO 1 75#define IDE_TUNE_DEFAULT 0 76 77/* 78 * state flags 79 */ 80 81#define DMA_PIO_RETRY 1 /* retrying in PIO */ 82 83#define HWIF(drive) ((ide_hwif_t *)((drive)->hwif)) 84#define HWGROUP(drive) ((ide_hwgroup_t *)(HWIF(drive)->hwgroup)) 85 86/* 87 * Definitions for accessing IDE controller registers 88 */ 89#define IDE_NR_PORTS (10) 90 91#define IDE_DATA_OFFSET (0) 92#define IDE_ERROR_OFFSET (1) 93#define IDE_NSECTOR_OFFSET (2) 94#define IDE_SECTOR_OFFSET (3) 95#define IDE_LCYL_OFFSET (4) 96#define IDE_HCYL_OFFSET (5) 97#define IDE_SELECT_OFFSET (6) 98#define IDE_STATUS_OFFSET (7) 99#define IDE_CONTROL_OFFSET (8) 100#define IDE_IRQ_OFFSET (9) 101 102#define IDE_FEATURE_OFFSET IDE_ERROR_OFFSET 103#define IDE_COMMAND_OFFSET IDE_STATUS_OFFSET 104 105#define IDE_CONTROL_OFFSET_HOB (7) 106 107#define IDE_DATA_REG (HWIF(drive)->io_ports[IDE_DATA_OFFSET]) 108#define IDE_ERROR_REG (HWIF(drive)->io_ports[IDE_ERROR_OFFSET]) 109#define IDE_NSECTOR_REG (HWIF(drive)->io_ports[IDE_NSECTOR_OFFSET]) 110#define IDE_SECTOR_REG (HWIF(drive)->io_ports[IDE_SECTOR_OFFSET]) 111#define IDE_LCYL_REG (HWIF(drive)->io_ports[IDE_LCYL_OFFSET]) 112#define IDE_HCYL_REG (HWIF(drive)->io_ports[IDE_HCYL_OFFSET]) 113#define IDE_SELECT_REG (HWIF(drive)->io_ports[IDE_SELECT_OFFSET]) 114#define IDE_STATUS_REG (HWIF(drive)->io_ports[IDE_STATUS_OFFSET]) 115#define IDE_CONTROL_REG (HWIF(drive)->io_ports[IDE_CONTROL_OFFSET]) 116#define IDE_IRQ_REG (HWIF(drive)->io_ports[IDE_IRQ_OFFSET]) 117 118#define IDE_FEATURE_REG IDE_ERROR_REG 119#define IDE_COMMAND_REG IDE_STATUS_REG 120#define IDE_ALTSTATUS_REG IDE_CONTROL_REG 121#define IDE_IREASON_REG IDE_NSECTOR_REG 122#define IDE_BCOUNTL_REG IDE_LCYL_REG 123#define IDE_BCOUNTH_REG IDE_HCYL_REG 124 125#define OK_STAT(stat,good,bad) (((stat)&((good)|(bad)))==(good)) 126#define BAD_R_STAT (BUSY_STAT | ERR_STAT) 127#define BAD_W_STAT (BAD_R_STAT | WRERR_STAT) 128#define BAD_STAT (BAD_R_STAT | DRQ_STAT) 129#define DRIVE_READY (READY_STAT | SEEK_STAT) 130#define DATA_READY (DRQ_STAT) 131 132#define BAD_CRC (ABRT_ERR | ICRC_ERR) 133 134#define SATA_NR_PORTS (3) /* 16 possible ?? */ 135 136#define SATA_STATUS_OFFSET (0) 137#define SATA_STATUS_REG (HWIF(drive)->sata_scr[SATA_STATUS_OFFSET]) 138#define SATA_ERROR_OFFSET (1) 139#define SATA_ERROR_REG (HWIF(drive)->sata_scr[SATA_ERROR_OFFSET]) 140#define SATA_CONTROL_OFFSET (2) 141#define SATA_CONTROL_REG (HWIF(drive)->sata_scr[SATA_CONTROL_OFFSET]) 142 143#define SATA_MISC_OFFSET (0) 144#define SATA_MISC_REG (HWIF(drive)->sata_misc[SATA_MISC_OFFSET]) 145#define SATA_PHY_OFFSET (1) 146#define SATA_PHY_REG (HWIF(drive)->sata_misc[SATA_PHY_OFFSET]) 147#define SATA_IEN_OFFSET (2) 148#define SATA_IEN_REG (HWIF(drive)->sata_misc[SATA_IEN_OFFSET]) 149 150/* 151 * Our Physical Region Descriptor (PRD) table should be large enough 152 * to handle the biggest I/O request we are likely to see. Since requests 153 * can have no more than 256 sectors, and since the typical blocksize is 154 * two or more sectors, we could get by with a limit of 128 entries here for 155 * the usual worst case. Most requests seem to include some contiguous blocks, 156 * further reducing the number of table entries required. 157 * 158 * The driver reverts to PIO mode for individual requests that exceed 159 * this limit (possible with 512 byte blocksizes, eg. MSDOS f/s), so handling 160 * 100% of all crazy scenarios here is not necessary. 161 * 162 * As it turns out though, we must allocate a full 4KB page for this, 163 * so the two PRD tables (ide0 & ide1) will each get half of that, 164 * allowing each to have about 256 entries (8 bytes each) from this. 165 */ 166#define PRD_BYTES 8 167#define PRD_ENTRIES 256 168 169/* 170 * Some more useful definitions 171 */ 172#define PARTN_BITS 6 /* number of minor dev bits for partitions */ 173#define MAX_DRIVES 2 /* per interface; 2 assumed by lots of code */ 174#define SECTOR_SIZE 512 175#define SECTOR_WORDS (SECTOR_SIZE / 4) /* number of 32bit words per sector */ 176#define IDE_LARGE_SEEK(b1,b2,t) (((b1) > (b2) + (t)) || ((b2) > (b1) + (t))) 177 178/* 179 * Timeouts for various operations: 180 */ 181#define WAIT_DRQ (HZ/10) /* 100msec - spec allows up to 20ms */ 182#define WAIT_READY (5*HZ) /* 5sec - some laptops are very slow */ 183#define WAIT_PIDENTIFY (10*HZ) /* 10sec - should be less than 3ms (?), if all ATAPI CD is closed at boot */ 184#define WAIT_WORSTCASE (30*HZ) /* 30sec - worst case when spinning up */ 185#define WAIT_CMD (10*HZ) /* 10sec - maximum wait for an IRQ to happen */ 186#define WAIT_MIN_SLEEP (2*HZ/100) /* 20msec - minimum sleep time */ 187 188/* 189 * Check for an interrupt and acknowledge the interrupt status 190 */ 191struct hwif_s; 192typedef int (ide_ack_intr_t)(struct hwif_s *); 193 194#ifndef NO_DMA 195#define NO_DMA 255 196#endif 197 198/* 199 * hwif_chipset_t is used to keep track of the specific hardware 200 * chipset used by each IDE interface, if known. 201 */ 202typedef enum { ide_unknown, ide_generic, ide_pci, 203 ide_cmd640, ide_dtc2278, ide_ali14xx, 204 ide_qd65xx, ide_umc8672, ide_ht6560b, 205 ide_rz1000, ide_trm290, 206 ide_cmd646, ide_cy82c693, ide_4drives, 207 ide_pmac, ide_etrax100, ide_acorn, 208 ide_au1xxx, ide_forced 209} hwif_chipset_t; 210 211/* 212 * Structure to hold all information about the location of this port 213 */ 214typedef struct hw_regs_s { 215 unsigned long io_ports[IDE_NR_PORTS]; /* task file registers */ 216 int irq; /* our irq number */ 217 int dma; /* our dma entry */ 218 ide_ack_intr_t *ack_intr; /* acknowledge interrupt */ 219 hwif_chipset_t chipset; 220 struct device *dev; 221} hw_regs_t; 222 223/* 224 * Register new hardware with ide 225 */ 226int ide_register_hw(hw_regs_t *, int, struct hwif_s **); 227int ide_register_hw_with_fixup(hw_regs_t *, int, struct hwif_s **, 228 void (*)(struct hwif_s *)); 229 230/* 231 * Set up hw_regs_t structure before calling ide_register_hw (optional) 232 */ 233void ide_setup_ports( hw_regs_t *hw, 234 unsigned long base, 235 int *offsets, 236 unsigned long ctrl, 237 unsigned long intr, 238 ide_ack_intr_t *ack_intr, 239 int irq); 240 241static inline void ide_std_init_ports(hw_regs_t *hw, 242 unsigned long io_addr, 243 unsigned long ctl_addr) 244{ 245 unsigned int i; 246 247 for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) 248 hw->io_ports[i] = io_addr++; 249 250 hw->io_ports[IDE_CONTROL_OFFSET] = ctl_addr; 251} 252 253#include <asm/ide.h> 254 255#if !defined(MAX_HWIFS) || defined(CONFIG_EMBEDDED) 256#undef MAX_HWIFS 257#define MAX_HWIFS CONFIG_IDE_MAX_HWIFS 258#endif 259 260/* needed on alpha, x86/x86_64, ia64, mips, ppc32 and sh */ 261#ifndef IDE_ARCH_OBSOLETE_DEFAULTS 262# define ide_default_io_base(index) (0) 263# define ide_default_irq(base) (0) 264# define ide_init_default_irq(base) (0) 265#endif 266 267/* 268 * ide_init_hwif_ports() is OBSOLETE and will be removed in 2.7 series. 269 * New ports shouldn't define IDE_ARCH_OBSOLETE_INIT in <asm/ide.h>. 270 */ 271#ifdef IDE_ARCH_OBSOLETE_INIT 272static inline void ide_init_hwif_ports(hw_regs_t *hw, 273 unsigned long io_addr, 274 unsigned long ctl_addr, 275 int *irq) 276{ 277 if (!ctl_addr) 278 ide_std_init_ports(hw, io_addr, ide_default_io_ctl(io_addr)); 279 else 280 ide_std_init_ports(hw, io_addr, ctl_addr); 281 282 if (irq) 283 *irq = 0; 284 285 hw->io_ports[IDE_IRQ_OFFSET] = 0; 286 287#ifdef CONFIG_PPC32 288 if (ppc_ide_md.ide_init_hwif) 289 ppc_ide_md.ide_init_hwif(hw, io_addr, ctl_addr, irq); 290#endif 291} 292#else 293static inline void ide_init_hwif_ports(hw_regs_t *hw, 294 unsigned long io_addr, 295 unsigned long ctl_addr, 296 int *irq) 297{ 298 if (io_addr || ctl_addr) 299 printk(KERN_WARNING "%s: must not be called\n", __FUNCTION__); 300} 301#endif /* IDE_ARCH_OBSOLETE_INIT */ 302 303/* Currently only m68k, apus and m8xx need it */ 304#ifndef IDE_ARCH_ACK_INTR 305# define ide_ack_intr(hwif) (1) 306#endif 307 308/* Currently only Atari needs it */ 309#ifndef IDE_ARCH_LOCK 310# define ide_release_lock() do {} while (0) 311# define ide_get_lock(hdlr, data) do {} while (0) 312#endif /* IDE_ARCH_LOCK */ 313 314/* 315 * Now for the data we need to maintain per-drive: ide_drive_t 316 */ 317 318#define ide_scsi 0x21 319#define ide_disk 0x20 320#define ide_optical 0x7 321#define ide_cdrom 0x5 322#define ide_tape 0x1 323#define ide_floppy 0x0 324 325/* 326 * Special Driver Flags 327 * 328 * set_geometry : respecify drive geometry 329 * recalibrate : seek to cyl 0 330 * set_multmode : set multmode count 331 * set_tune : tune interface for drive 332 * serviced : service command 333 * reserved : unused 334 */ 335typedef union { 336 unsigned all : 8; 337 struct { 338#if defined(__LITTLE_ENDIAN_BITFIELD) 339 unsigned set_geometry : 1; 340 unsigned recalibrate : 1; 341 unsigned set_multmode : 1; 342 unsigned set_tune : 1; 343 unsigned serviced : 1; 344 unsigned reserved : 3; 345#elif defined(__BIG_ENDIAN_BITFIELD) 346 unsigned reserved : 3; 347 unsigned serviced : 1; 348 unsigned set_tune : 1; 349 unsigned set_multmode : 1; 350 unsigned recalibrate : 1; 351 unsigned set_geometry : 1; 352#else 353#error "Please fix <asm/byteorder.h>" 354#endif 355 } b; 356} special_t; 357 358/* 359 * ATA DATA Register Special. 360 * ATA NSECTOR Count Register(). 361 * ATAPI Byte Count Register. 362 * Channel index ordering pairs. 363 */ 364typedef union { 365 unsigned all :16; 366 struct { 367#if defined(__LITTLE_ENDIAN_BITFIELD) 368 unsigned low :8; /* LSB */ 369 unsigned high :8; /* MSB */ 370#elif defined(__BIG_ENDIAN_BITFIELD) 371 unsigned high :8; /* MSB */ 372 unsigned low :8; /* LSB */ 373#else 374#error "Please fix <asm/byteorder.h>" 375#endif 376 } b; 377} ata_nsector_t, ata_data_t, atapi_bcount_t, ata_index_t; 378 379/* 380 * ATA-IDE Select Register, aka Device-Head 381 * 382 * head : always zeros here 383 * unit : drive select number: 0/1 384 * bit5 : always 1 385 * lba : using LBA instead of CHS 386 * bit7 : always 1 387 */ 388typedef union { 389 unsigned all : 8; 390 struct { 391#if defined(__LITTLE_ENDIAN_BITFIELD) 392 unsigned head : 4; 393 unsigned unit : 1; 394 unsigned bit5 : 1; 395 unsigned lba : 1; 396 unsigned bit7 : 1; 397#elif defined(__BIG_ENDIAN_BITFIELD) 398 unsigned bit7 : 1; 399 unsigned lba : 1; 400 unsigned bit5 : 1; 401 unsigned unit : 1; 402 unsigned head : 4; 403#else 404#error "Please fix <asm/byteorder.h>" 405#endif 406 } b; 407} select_t, ata_select_t; 408 409/* 410 * The ATA-IDE Status Register. 411 * The ATAPI Status Register. 412 * 413 * check : Error occurred 414 * idx : Index Error 415 * corr : Correctable error occurred 416 * drq : Data is request by the device 417 * dsc : Disk Seek Complete : ata 418 * : Media access command finished : atapi 419 * df : Device Fault : ata 420 * : Reserved : atapi 421 * drdy : Ready, Command Mode Capable : ata 422 * : Ignored for ATAPI commands : atapi 423 * bsy : Disk is Busy 424 * : The device has access to the command block 425 */ 426typedef union { 427 unsigned all :8; 428 struct { 429#if defined(__LITTLE_ENDIAN_BITFIELD) 430 unsigned check :1; 431 unsigned idx :1; 432 unsigned corr :1; 433 unsigned drq :1; 434 unsigned dsc :1; 435 unsigned df :1; 436 unsigned drdy :1; 437 unsigned bsy :1; 438#elif defined(__BIG_ENDIAN_BITFIELD) 439 unsigned bsy :1; 440 unsigned drdy :1; 441 unsigned df :1; 442 unsigned dsc :1; 443 unsigned drq :1; 444 unsigned corr :1; 445 unsigned idx :1; 446 unsigned check :1; 447#else 448#error "Please fix <asm/byteorder.h>" 449#endif 450 } b; 451} ata_status_t, atapi_status_t; 452 453/* 454 * ATAPI Feature Register 455 * 456 * dma : Using DMA or PIO 457 * reserved321 : Reserved 458 * reserved654 : Reserved (Tag Type) 459 * reserved7 : Reserved 460 */ 461typedef union { 462 unsigned all :8; 463 struct { 464#if defined(__LITTLE_ENDIAN_BITFIELD) 465 unsigned dma :1; 466 unsigned reserved321 :3; 467 unsigned reserved654 :3; 468 unsigned reserved7 :1; 469#elif defined(__BIG_ENDIAN_BITFIELD) 470 unsigned reserved7 :1; 471 unsigned reserved654 :3; 472 unsigned reserved321 :3; 473 unsigned dma :1; 474#else 475#error "Please fix <asm/byteorder.h>" 476#endif 477 } b; 478} atapi_feature_t; 479 480/* 481 * ATAPI Interrupt Reason Register. 482 * 483 * cod : Information transferred is command (1) or data (0) 484 * io : The device requests us to read (1) or write (0) 485 * reserved : Reserved 486 */ 487typedef union { 488 unsigned all :8; 489 struct { 490#if defined(__LITTLE_ENDIAN_BITFIELD) 491 unsigned cod :1; 492 unsigned io :1; 493 unsigned reserved :6; 494#elif defined(__BIG_ENDIAN_BITFIELD) 495 unsigned reserved :6; 496 unsigned io :1; 497 unsigned cod :1; 498#else 499#error "Please fix <asm/byteorder.h>" 500#endif 501 } b; 502} atapi_ireason_t; 503 504/* 505 * The ATAPI error register. 506 * 507 * ili : Illegal Length Indication 508 * eom : End Of Media Detected 509 * abrt : Aborted command - As defined by ATA 510 * mcr : Media Change Requested - As defined by ATA 511 * sense_key : Sense key of the last failed packet command 512 */ 513typedef union { 514 unsigned all :8; 515 struct { 516#if defined(__LITTLE_ENDIAN_BITFIELD) 517 unsigned ili :1; 518 unsigned eom :1; 519 unsigned abrt :1; 520 unsigned mcr :1; 521 unsigned sense_key :4; 522#elif defined(__BIG_ENDIAN_BITFIELD) 523 unsigned sense_key :4; 524 unsigned mcr :1; 525 unsigned abrt :1; 526 unsigned eom :1; 527 unsigned ili :1; 528#else 529#error "Please fix <asm/byteorder.h>" 530#endif 531 } b; 532} atapi_error_t; 533 534/* 535 * Status returned from various ide_ functions 536 */ 537typedef enum { 538 ide_stopped, /* no drive operation was started */ 539 ide_started, /* a drive operation was started, handler was set */ 540} ide_startstop_t; 541 542struct ide_driver_s; 543struct ide_settings_s; 544 545#ifdef CONFIG_BLK_DEV_IDEACPI 546struct ide_acpi_drive_link; 547struct ide_acpi_hwif_link; 548#endif 549 550typedef struct ide_drive_s { 551 char name[4]; /* drive name, such as "hda" */ 552 char driver_req[10]; /* requests specific driver */ 553 554 request_queue_t *queue; /* request queue */ 555 556 struct request *rq; /* current request */ 557 struct ide_drive_s *next; /* circular list of hwgroup drives */ 558 void *driver_data; /* extra driver data */ 559 struct hd_driveid *id; /* drive model identification info */ 560#ifdef CONFIG_IDE_PROC_FS 561 struct proc_dir_entry *proc; /* /proc/ide/ directory entry */ 562 struct ide_settings_s *settings;/* /proc/ide/ drive settings */ 563#endif 564 struct hwif_s *hwif; /* actually (ide_hwif_t *) */ 565 566 unsigned long sleep; /* sleep until this time */ 567 unsigned long service_start; /* time we started last request */ 568 unsigned long service_time; /* service time of last request */ 569 unsigned long timeout; /* max time to wait for irq */ 570 571 special_t special; /* special action flags */ 572 select_t select; /* basic drive/head select reg value */ 573 574 u8 keep_settings; /* restore settings after drive reset */ 575 u8 autodma; /* device can safely use dma on host */ 576 u8 using_dma; /* disk is using dma for read/write */ 577 u8 retry_pio; /* retrying dma capable host in pio */ 578 u8 state; /* retry state */ 579 u8 waiting_for_dma; /* dma currently in progress */ 580 u8 unmask; /* okay to unmask other irqs */ 581 u8 bswap; /* byte swap data */ 582 u8 noflush; /* don't attempt flushes */ 583 u8 dsc_overlap; /* DSC overlap */ 584 u8 nice1; /* give potential excess bandwidth */ 585 586 unsigned present : 1; /* drive is physically present */ 587 unsigned dead : 1; /* device ejected hint */ 588 unsigned id_read : 1; /* 1=id read from disk 0 = synthetic */ 589 unsigned noprobe : 1; /* from: hdx=noprobe */ 590 unsigned removable : 1; /* 1 if need to do check_media_change */ 591 unsigned attach : 1; /* needed for removable devices */ 592 unsigned forced_geom : 1; /* 1 if hdx=c,h,s was given at boot */ 593 unsigned no_unmask : 1; /* disallow setting unmask bit */ 594 unsigned no_io_32bit : 1; /* disallow enabling 32bit I/O */ 595 unsigned atapi_overlap : 1; /* ATAPI overlap (not supported) */ 596 unsigned nice0 : 1; /* give obvious excess bandwidth */ 597 unsigned nice2 : 1; /* give a share in our own bandwidth */ 598 unsigned doorlocking : 1; /* for removable only: door lock/unlock works */ 599 unsigned autotune : 2; /* 0=default, 1=autotune, 2=noautotune */ 600 unsigned remap_0_to_1 : 1; /* 0=noremap, 1=remap 0->1 (for EZDrive) */ 601 unsigned blocked : 1; /* 1=powermanagment told us not to do anything, so sleep nicely */ 602 unsigned vdma : 1; /* 1=doing PIO over DMA 0=doing normal DMA */ 603 unsigned scsi : 1; /* 0=default, 1=ide-scsi emulation */ 604 unsigned sleeping : 1; /* 1=sleeping & sleep field valid */ 605 unsigned post_reset : 1; 606 unsigned udma33_warned : 1; 607 608 u8 addressing; /* 0=28-bit, 1=48-bit, 2=48-bit doing 28-bit */ 609 u8 quirk_list; /* considered quirky, set for a specific host */ 610 u8 init_speed; /* transfer rate set at boot */ 611 u8 current_speed; /* current transfer rate set */ 612 u8 desired_speed; /* desired transfer rate set */ 613 u8 dn; /* now wide spread use */ 614 u8 wcache; /* status of write cache */ 615 u8 acoustic; /* acoustic management */ 616 u8 media; /* disk, cdrom, tape, floppy, ... */ 617 u8 ctl; /* "normal" value for IDE_CONTROL_REG */ 618 u8 ready_stat; /* min status value for drive ready */ 619 u8 mult_count; /* current multiple sector setting */ 620 u8 mult_req; /* requested multiple sector setting */ 621 u8 tune_req; /* requested drive tuning setting */ 622 u8 io_32bit; /* 0=16-bit, 1=32-bit, 2/3=32bit+sync */ 623 u8 bad_wstat; /* used for ignoring WRERR_STAT */ 624 u8 nowerr; /* used for ignoring WRERR_STAT */ 625 u8 sect0; /* offset of first sector for DM6:DDO */ 626 u8 head; /* "real" number of heads */ 627 u8 sect; /* "real" sectors per track */ 628 u8 bios_head; /* BIOS/fdisk/LILO number of heads */ 629 u8 bios_sect; /* BIOS/fdisk/LILO sectors per track */ 630 631 unsigned int bios_cyl; /* BIOS/fdisk/LILO number of cyls */ 632 unsigned int cyl; /* "real" number of cyls */ 633 unsigned int drive_data; /* use by tuneproc/selectproc */ 634 unsigned int failures; /* current failure count */ 635 unsigned int max_failures; /* maximum allowed failure count */ 636 u64 probed_capacity;/* initial reported media capacity (ide-cd only currently) */ 637 638 u64 capacity64; /* total number of sectors */ 639 640 int lun; /* logical unit */ 641 int crc_count; /* crc counter to reduce drive speed */ 642#ifdef CONFIG_BLK_DEV_IDEACPI 643 struct ide_acpi_drive_link *acpidata; 644#endif 645 struct list_head list; 646 struct device gendev; 647 struct completion gendev_rel_comp; /* to deal with device release() */ 648} ide_drive_t; 649 650#define to_ide_device(dev)container_of(dev, ide_drive_t, gendev) 651 652#define IDE_CHIPSET_PCI_MASK \ 653 ((1<<ide_pci)|(1<<ide_cmd646)|(1<<ide_ali14xx)) 654#define IDE_CHIPSET_IS_PCI(c) ((IDE_CHIPSET_PCI_MASK >> (c)) & 1) 655 656struct ide_pci_device_s; 657 658typedef struct hwif_s { 659 struct hwif_s *next; /* for linked-list in ide_hwgroup_t */ 660 struct hwif_s *mate; /* other hwif from same PCI chip */ 661 struct hwgroup_s *hwgroup; /* actually (ide_hwgroup_t *) */ 662 struct proc_dir_entry *proc; /* /proc/ide/ directory entry */ 663 664 char name[6]; /* name of interface, eg. "ide0" */ 665 666 /* task file registers for pata and sata */ 667 unsigned long io_ports[IDE_NR_PORTS]; 668 unsigned long sata_scr[SATA_NR_PORTS]; 669 unsigned long sata_misc[SATA_NR_PORTS]; 670 671 hw_regs_t hw; /* Hardware info */ 672 ide_drive_t drives[MAX_DRIVES]; /* drive info */ 673 674 u8 major; /* our major number */ 675 u8 index; /* 0 for ide0; 1 for ide1; ... */ 676 u8 channel; /* for dual-port chips: 0=primary, 1=secondary */ 677 u8 straight8; /* Alan's straight 8 check */ 678 u8 bus_state; /* power state of the IDE bus */ 679 680 u8 atapi_dma; /* host supports atapi_dma */ 681 u8 ultra_mask; 682 u8 mwdma_mask; 683 u8 swdma_mask; 684 685 hwif_chipset_t chipset; /* sub-module for tuning.. */ 686 687 struct pci_dev *pci_dev; /* for pci chipsets */ 688 struct ide_pci_device_s *cds; /* chipset device struct */ 689 690 void (*rw_disk)(ide_drive_t *, struct request *); 691 692 /* routine to tune PIO mode for drives */ 693 void (*tuneproc)(ide_drive_t *, u8); 694 /* routine to retune DMA modes for drives */ 695 int (*speedproc)(ide_drive_t *, u8); 696 /* tweaks hardware to select drive */ 697 void (*selectproc)(ide_drive_t *); 698 /* chipset polling based on hba specifics */ 699 int (*reset_poll)(ide_drive_t *); 700 /* chipset specific changes to default for device-hba resets */ 701 void (*pre_reset)(ide_drive_t *); 702 /* routine to reset controller after a disk reset */ 703 void (*resetproc)(ide_drive_t *); 704 /* special interrupt handling for shared pci interrupts */ 705 void (*intrproc)(ide_drive_t *); 706 /* special host masking for drive selection */ 707 void (*maskproc)(ide_drive_t *, int); 708 /* check host's drive quirk list */ 709 int (*quirkproc)(ide_drive_t *); 710 /* driver soft-power interface */ 711 int (*busproc)(ide_drive_t *, int); 712 u8 (*udma_filter)(ide_drive_t *); 713 714 void (*ata_input_data)(ide_drive_t *, void *, u32); 715 void (*ata_output_data)(ide_drive_t *, void *, u32); 716 717 void (*atapi_input_bytes)(ide_drive_t *, void *, u32); 718 void (*atapi_output_bytes)(ide_drive_t *, void *, u32); 719 720 int (*dma_setup)(ide_drive_t *); 721 void (*dma_exec_cmd)(ide_drive_t *, u8); 722 void (*dma_start)(ide_drive_t *); 723 int (*ide_dma_end)(ide_drive_t *drive); 724 int (*ide_dma_check)(ide_drive_t *drive); 725 int (*ide_dma_on)(ide_drive_t *drive); 726 void (*dma_off_quietly)(ide_drive_t *drive); 727 int (*ide_dma_test_irq)(ide_drive_t *drive); 728 void (*ide_dma_clear_irq)(ide_drive_t *drive); 729 void (*dma_host_on)(ide_drive_t *drive); 730 void (*dma_host_off)(ide_drive_t *drive); 731 int (*ide_dma_lostirq)(ide_drive_t *drive); 732 int (*ide_dma_timeout)(ide_drive_t *drive); 733 734 void (*OUTB)(u8 addr, unsigned long port); 735 void (*OUTBSYNC)(ide_drive_t *drive, u8 addr, unsigned long port); 736 void (*OUTW)(u16 addr, unsigned long port); 737 void (*OUTSW)(unsigned long port, void *addr, u32 count); 738 void (*OUTSL)(unsigned long port, void *addr, u32 count); 739 740 u8 (*INB)(unsigned long port); 741 u16 (*INW)(unsigned long port); 742 void (*INSW)(unsigned long port, void *addr, u32 count); 743 void (*INSL)(unsigned long port, void *addr, u32 count); 744 745 /* dma physical region descriptor table (cpu view) */ 746 unsigned int *dmatable_cpu; 747 /* dma physical region descriptor table (dma view) */ 748 dma_addr_t dmatable_dma; 749 /* Scatter-gather list used to build the above */ 750 struct scatterlist *sg_table; 751 int sg_max_nents; /* Maximum number of entries in it */ 752 int sg_nents; /* Current number of entries in it */ 753 int sg_dma_direction; /* dma transfer direction */ 754 755 /* data phase of the active command (currently only valid for PIO/DMA) */ 756 int data_phase; 757 758 unsigned int nsect; 759 unsigned int nleft; 760 unsigned int cursg; 761 unsigned int cursg_ofs; 762 763 int rqsize; /* max sectors per request */ 764 int irq; /* our irq number */ 765 766 unsigned long dma_master; /* reference base addr dmabase */ 767 unsigned long dma_base; /* base addr for dma ports */ 768 unsigned long dma_command; /* dma command register */ 769 unsigned long dma_vendor1; /* dma vendor 1 register */ 770 unsigned long dma_status; /* dma status register */ 771 unsigned long dma_vendor3; /* dma vendor 3 register */ 772 unsigned long dma_prdtable; /* actual prd table address */ 773 774 unsigned long config_data; /* for use by chipset-specific code */ 775 unsigned long select_data; /* for use by chipset-specific code */ 776 777 unsigned long extra_base; /* extra addr for dma ports */ 778 unsigned extra_ports; /* number of extra dma ports */ 779 780 unsigned noprobe : 1; /* don't probe for this interface */ 781 unsigned present : 1; /* this interface exists */ 782 unsigned hold : 1; /* this interface is always present */ 783 unsigned serialized : 1; /* serialized all channel operation */ 784 unsigned sharing_irq: 1; /* 1 = sharing irq with another hwif */ 785 unsigned reset : 1; /* reset after probe */ 786 unsigned autodma : 1; /* auto-attempt using DMA at boot */ 787 unsigned udma_four : 1; /* 1=ATA-66 capable, 0=default */ 788 unsigned no_lba48 : 1; /* 1 = cannot do LBA48 */ 789 unsigned no_lba48_dma : 1; /* 1 = cannot do LBA48 DMA */ 790 unsigned auto_poll : 1; /* supports nop auto-poll */ 791 unsigned sg_mapped : 1; /* sg_table and sg_nents are ready */ 792 unsigned no_io_32bit : 1; /* 1 = can not do 32-bit IO ops */ 793 unsigned err_stops_fifo : 1; /* 1=data FIFO is cleared by an error */ 794 unsigned mmio : 1; /* host uses MMIO */ 795 796 struct device gendev; 797 struct completion gendev_rel_comp; /* To deal with device release() */ 798 799 void *hwif_data; /* extra hwif data */ 800 801 unsigned dma; 802 803#ifdef CONFIG_BLK_DEV_IDEACPI 804 struct ide_acpi_hwif_link *acpidata; 805#endif 806} ____cacheline_internodealigned_in_smp ide_hwif_t; 807 808/* 809 * internal ide interrupt handler type 810 */ 811typedef ide_startstop_t (ide_pre_handler_t)(ide_drive_t *, struct request *); 812typedef ide_startstop_t (ide_handler_t)(ide_drive_t *); 813typedef int (ide_expiry_t)(ide_drive_t *); 814 815typedef struct hwgroup_s { 816 /* irq handler, if active */ 817 ide_startstop_t (*handler)(ide_drive_t *); 818 /* irq handler, suspended if active */ 819 ide_startstop_t (*handler_save)(ide_drive_t *); 820 /* BOOL: protects all fields below */ 821 volatile int busy; 822 /* BOOL: wake us up on timer expiry */ 823 unsigned int sleeping : 1; 824 /* BOOL: polling active & poll_timeout field valid */ 825 unsigned int polling : 1; 826 /* BOOL: in a polling reset situation. Must not trigger another reset yet */ 827 unsigned int resetting : 1; 828 829 /* current drive */ 830 ide_drive_t *drive; 831 /* ptr to current hwif in linked-list */ 832 ide_hwif_t *hwif; 833 834 /* for pci chipsets */ 835 struct pci_dev *pci_dev; 836 /* chipset device struct */ 837 struct ide_pci_device_s *cds; 838 839 /* current request */ 840 struct request *rq; 841 /* failsafe timer */ 842 struct timer_list timer; 843 /* local copy of current write rq */ 844 struct request wrq; 845 /* timeout value during long polls */ 846 unsigned long poll_timeout; 847 /* queried upon timeouts */ 848 int (*expiry)(ide_drive_t *); 849 /* ide_system_bus_speed */ 850 int pio_clock; 851 int req_gen; 852 int req_gen_timer; 853 854 unsigned char cmd_buf[4]; 855} ide_hwgroup_t; 856 857typedef struct ide_driver_s ide_driver_t; 858 859extern struct semaphore ide_setting_sem; 860 861int set_io_32bit(ide_drive_t *, int); 862int set_pio_mode(ide_drive_t *, int); 863int set_using_dma(ide_drive_t *, int); 864 865#ifdef CONFIG_IDE_PROC_FS 866/* 867 * configurable drive settings 868 */ 869 870#define TYPE_INT 0 871#define TYPE_BYTE 1 872#define TYPE_SHORT 2 873 874#define SETTING_READ (1 << 0) 875#define SETTING_WRITE (1 << 1) 876#define SETTING_RW (SETTING_READ | SETTING_WRITE) 877 878typedef int (ide_procset_t)(ide_drive_t *, int); 879typedef struct ide_settings_s { 880 char *name; 881 int rw; 882 int data_type; 883 int min; 884 int max; 885 int mul_factor; 886 int div_factor; 887 void *data; 888 ide_procset_t *set; 889 int auto_remove; 890 struct ide_settings_s *next; 891} ide_settings_t; 892 893int ide_add_setting(ide_drive_t *, const char *, int, int, int, int, int, int, void *, ide_procset_t *set); 894 895/* 896 * /proc/ide interface 897 */ 898typedef struct { 899 const char *name; 900 mode_t mode; 901 read_proc_t *read_proc; 902 write_proc_t *write_proc; 903} ide_proc_entry_t; 904 905void proc_ide_create(void); 906void proc_ide_destroy(void); 907void ide_proc_register_port(ide_hwif_t *); 908void ide_proc_unregister_port(ide_hwif_t *); 909void ide_proc_register_driver(ide_drive_t *, ide_driver_t *); 910void ide_proc_unregister_driver(ide_drive_t *, ide_driver_t *); 911 912void ide_add_generic_settings(ide_drive_t *); 913 914read_proc_t proc_ide_read_capacity; 915read_proc_t proc_ide_read_geometry; 916 917#ifdef CONFIG_BLK_DEV_IDEPCI 918void ide_pci_create_host_proc(const char *, get_info_t *); 919#endif 920 921/* 922 * Standard exit stuff: 923 */ 924#define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) \ 925{ \ 926 len -= off; \ 927 if (len < count) { \ 928 *eof = 1; \ 929 if (len <= 0) \ 930 return 0; \ 931 } else \ 932 len = count; \ 933 *start = page + off; \ 934 return len; \ 935} 936#else 937static inline void proc_ide_create(void) { ; } 938static inline void proc_ide_destroy(void) { ; } 939static inline void ide_proc_register_port(ide_hwif_t *hwif) { ; } 940static inline void ide_proc_unregister_port(ide_hwif_t *hwif) { ; } 941static inline void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver) { ; } 942static inline void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver) { ; } 943static inline void ide_add_generic_settings(ide_drive_t *drive) { ; } 944#define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) return 0; 945#endif 946 947/* 948 * Power Management step value (rq->pm->pm_step). 949 * 950 * The step value starts at 0 (ide_pm_state_start_suspend) for a 951 * suspend operation or 1000 (ide_pm_state_start_resume) for a 952 * resume operation. 953 * 954 * For each step, the core calls the subdriver start_power_step() first. 955 * This can return: 956 * - ide_stopped : In this case, the core calls us back again unless 957 * step have been set to ide_power_state_completed. 958 * - ide_started : In this case, the channel is left busy until an 959 * async event (interrupt) occurs. 960 * Typically, start_power_step() will issue a taskfile request with 961 * do_rw_taskfile(). 962 * 963 * Upon reception of the interrupt, the core will call complete_power_step() 964 * with the error code if any. This routine should update the step value 965 * and return. It should not start a new request. The core will call 966 * start_power_step for the new step value, unless step have been set to 967 * ide_power_state_completed. 968 * 969 * Subdrivers are expected to define their own additional power 970 * steps from 1..999 for suspend and from 1001..1999 for resume, 971 * other values are reserved for future use. 972 */ 973 974enum { 975 ide_pm_state_completed = -1, 976 ide_pm_state_start_suspend = 0, 977 ide_pm_state_start_resume = 1000, 978}; 979 980/* 981 * Subdrivers support. 982 * 983 * The gendriver.owner field should be set to the module owner of this driver. 984 * The gendriver.name field should be set to the name of this driver 985 */ 986struct ide_driver_s { 987 const char *version; 988 u8 media; 989 unsigned supports_dsc_overlap : 1; 990 ide_startstop_t (*do_request)(ide_drive_t *, struct request *, sector_t); 991 int (*end_request)(ide_drive_t *, int, int); 992 ide_startstop_t (*error)(ide_drive_t *, struct request *rq, u8, u8); 993 ide_startstop_t (*abort)(ide_drive_t *, struct request *rq); 994 struct device_driver gen_driver; 995 int (*probe)(ide_drive_t *); 996 void (*remove)(ide_drive_t *); 997 void (*resume)(ide_drive_t *); 998 void (*shutdown)(ide_drive_t *); 999#ifdef CONFIG_IDE_PROC_FS 1000 ide_proc_entry_t *proc; 1001#endif 1002}; 1003 1004#define to_ide_driver(drv) container_of(drv, ide_driver_t, gen_driver) 1005 1006int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *, unsigned, unsigned long); 1007 1008/* 1009 * ide_hwifs[] is the master data structure used to keep track 1010 * of just about everything in ide.c. Whenever possible, routines 1011 * should be using pointers to a drive (ide_drive_t *) or 1012 * pointers to a hwif (ide_hwif_t *), rather than indexing this 1013 * structure directly (the allocation/layout may change!). 1014 * 1015 */ 1016#ifndef _IDE_C 1017extern ide_hwif_t ide_hwifs[]; /* master data repository */ 1018#endif 1019extern int noautodma; 1020 1021extern int ide_end_request (ide_drive_t *drive, int uptodate, int nrsecs); 1022int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq, 1023 int uptodate, int nr_sectors); 1024 1025/* 1026 * This is used on exit from the driver to designate the next irq handler 1027 * and also to start the safety timer. 1028 */ 1029extern void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry); 1030 1031/* 1032 * This is used on exit from the driver to designate the next irq handler 1033 * and start the safety time safely and atomically from the IRQ handler 1034 * with respect to the command issue (which it also does) 1035 */ 1036extern void ide_execute_command(ide_drive_t *, task_ioreg_t cmd, ide_handler_t *, unsigned int, ide_expiry_t *); 1037 1038ide_startstop_t __ide_error(ide_drive_t *, struct request *, u8, u8); 1039 1040/* 1041 * ide_error() takes action based on the error returned by the controller. 1042 * The caller should return immediately after invoking this. 1043 * 1044 * (drive, msg, status) 1045 */ 1046ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat); 1047 1048ide_startstop_t __ide_abort(ide_drive_t *, struct request *); 1049 1050/* 1051 * Abort a running command on the controller triggering the abort 1052 * from a host side, non error situation 1053 * (drive, msg) 1054 */ 1055extern ide_startstop_t ide_abort(ide_drive_t *, const char *); 1056 1057extern void ide_fix_driveid(struct hd_driveid *); 1058/* 1059 * ide_fixstring() cleans up and (optionally) byte-swaps a text string, 1060 * removing leading/trailing blanks and compressing internal blanks. 1061 * It is primarily used to tidy up the model name/number fields as 1062 * returned by the WIN_[P]IDENTIFY commands. 1063 * 1064 * (s, bytecount, byteswap) 1065 */ 1066extern void ide_fixstring(u8 *, const int, const int); 1067 1068/* 1069 * This routine busy-waits for the drive status to be not "busy". 1070 * It then checks the status for all of the "good" bits and none 1071 * of the "bad" bits, and if all is okay it returns 0. All other 1072 * cases return 1 after doing "*startstop = ide_error()", and the 1073 * caller should return the updated value of "startstop" in this case. 1074 * "startstop" is unchanged when the function returns 0; 1075 * (startstop, drive, good, bad, timeout) 1076 */ 1077extern int ide_wait_stat(ide_startstop_t *, ide_drive_t *, u8, u8, unsigned long); 1078 1079/* 1080 * Start a reset operation for an IDE interface. 1081 * The caller should return immediately after invoking this. 1082 */ 1083extern ide_startstop_t ide_do_reset (ide_drive_t *); 1084 1085/* 1086 * This function is intended to be used prior to invoking ide_do_drive_cmd(). 1087 */ 1088extern void ide_init_drive_cmd (struct request *rq); 1089 1090/* 1091 * this function returns error location sector offset in case of a write error 1092 */ 1093extern u64 ide_get_error_location(ide_drive_t *, char *); 1094 1095/* 1096 * "action" parameter type for ide_do_drive_cmd() below. 1097 */ 1098typedef enum { 1099 ide_wait, /* insert rq at end of list, and wait for it */ 1100 ide_preempt, /* insert rq in front of current request */ 1101 ide_head_wait, /* insert rq in front of current request and wait for it */ 1102 ide_end /* insert rq at end of list, but don't wait for it */ 1103} ide_action_t; 1104 1105extern int ide_do_drive_cmd(ide_drive_t *, struct request *, ide_action_t); 1106 1107/* 1108 * Clean up after success/failure of an explicit drive cmd. 1109 * stat/err are used only when (HWGROUP(drive)->rq->cmd == IDE_DRIVE_CMD). 1110 * stat/err are used only when (HWGROUP(drive)->rq->cmd == IDE_DRIVE_TASK_MASK). 1111 * 1112 * (ide_drive_t *drive, u8 stat, u8 err) 1113 */ 1114extern void ide_end_drive_cmd(ide_drive_t *, u8, u8); 1115 1116/* 1117 * Issue ATA command and wait for completion. 1118 * Use for implementing commands in kernel 1119 * 1120 * (ide_drive_t *drive, u8 cmd, u8 nsect, u8 feature, u8 sectors, u8 *buf) 1121 */ 1122extern int ide_wait_cmd(ide_drive_t *, u8, u8, u8, u8, u8 *); 1123 1124typedef struct ide_task_s { 1125/* 1126 * struct hd_drive_task_hdr tf; 1127 * task_struct_t tf; 1128 * struct hd_drive_hob_hdr hobf; 1129 * hob_struct_t hobf; 1130 */ 1131 task_ioreg_t tfRegister[8]; 1132 task_ioreg_t hobRegister[8]; 1133 ide_reg_valid_t tf_out_flags; 1134 ide_reg_valid_t tf_in_flags; 1135 int data_phase; 1136 int command_type; 1137 ide_pre_handler_t *prehandler; 1138 ide_handler_t *handler; 1139 struct request *rq; /* copy of request */ 1140 void *special; /* valid_t generally */ 1141} ide_task_t; 1142 1143extern u32 ide_read_24(ide_drive_t *); 1144 1145extern void SELECT_DRIVE(ide_drive_t *); 1146extern void SELECT_INTERRUPT(ide_drive_t *); 1147extern void SELECT_MASK(ide_drive_t *, int); 1148extern void QUIRK_LIST(ide_drive_t *); 1149 1150extern int drive_is_ready(ide_drive_t *); 1151extern int wait_for_ready(ide_drive_t *, int /* timeout */); 1152 1153/* 1154 * taskfile io for disks for now...and builds request from ide_ioctl 1155 */ 1156extern ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *); 1157 1158/* 1159 * Special Flagged Register Validation Caller 1160 */ 1161extern ide_startstop_t flagged_taskfile(ide_drive_t *, ide_task_t *); 1162 1163extern ide_startstop_t set_multmode_intr(ide_drive_t *); 1164extern ide_startstop_t set_geometry_intr(ide_drive_t *); 1165extern ide_startstop_t recal_intr(ide_drive_t *); 1166extern ide_startstop_t task_no_data_intr(ide_drive_t *); 1167extern ide_startstop_t task_in_intr(ide_drive_t *); 1168extern ide_startstop_t pre_task_out_intr(ide_drive_t *, struct request *); 1169 1170extern int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *); 1171 1172int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long); 1173int ide_cmd_ioctl(ide_drive_t *, unsigned int, unsigned long); 1174int ide_task_ioctl(ide_drive_t *, unsigned int, unsigned long); 1175 1176extern int system_bus_clock(void); 1177 1178extern int ide_driveid_update(ide_drive_t *); 1179extern int ide_ata66_check(ide_drive_t *, ide_task_t *); 1180extern int ide_config_drive_speed(ide_drive_t *, u8); 1181extern u8 eighty_ninty_three (ide_drive_t *); 1182extern int set_transfer(ide_drive_t *, ide_task_t *); 1183extern int taskfile_lib_get_identify(ide_drive_t *drive, u8 *); 1184 1185extern int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout); 1186 1187/* 1188 * ide_stall_queue() can be used by a drive to give excess bandwidth back 1189 * to the hwgroup by sleeping for timeout jiffies. 1190 */ 1191extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout); 1192 1193extern int ide_spin_wait_hwgroup(ide_drive_t *); 1194extern void ide_timer_expiry(unsigned long); 1195extern irqreturn_t ide_intr(int irq, void *dev_id); 1196extern void do_ide_request(request_queue_t *); 1197 1198void ide_init_disk(struct gendisk *, ide_drive_t *); 1199 1200extern int ideprobe_init(void); 1201 1202#ifdef CONFIG_IDEPCI_PCIBUS_ORDER 1203extern void ide_scan_pcibus(int scan_direction) __init; 1204extern int __ide_pci_register_driver(struct pci_driver *driver, struct module *owner, const char *mod_name); 1205#define ide_pci_register_driver(d) __ide_pci_register_driver(d, THIS_MODULE, KBUILD_MODNAME) 1206#else 1207#define ide_pci_register_driver(d) pci_register_driver(d) 1208#endif 1209 1210void ide_pci_setup_ports(struct pci_dev *, struct ide_pci_device_s *, int, ata_index_t *); 1211extern void ide_setup_pci_noise (struct pci_dev *dev, struct ide_pci_device_s *d); 1212 1213extern void default_hwif_iops(ide_hwif_t *); 1214extern void default_hwif_mmiops(ide_hwif_t *); 1215extern void default_hwif_transport(ide_hwif_t *); 1216 1217#define ON_BOARD 1 1218#define NEVER_BOARD 0 1219 1220#ifdef CONFIG_BLK_DEV_OFFBOARD 1221# define OFF_BOARD ON_BOARD 1222#else /* CONFIG_BLK_DEV_OFFBOARD */ 1223# define OFF_BOARD NEVER_BOARD 1224#endif /* CONFIG_BLK_DEV_OFFBOARD */ 1225 1226#define NODMA 0 1227#define NOAUTODMA 1 1228#define AUTODMA 2 1229 1230typedef struct ide_pci_enablebit_s { 1231 u8 reg; /* byte pci reg holding the enable-bit */ 1232 u8 mask; /* mask to isolate the enable-bit */ 1233 u8 val; /* value of masked reg when "enabled" */ 1234} ide_pci_enablebit_t; 1235 1236enum { 1237 /* Uses ISA control ports not PCI ones. */ 1238 IDEPCI_FLAG_ISA_PORTS = (1 << 0), 1239}; 1240 1241typedef struct ide_pci_device_s { 1242 char *name; 1243 int (*init_setup)(struct pci_dev *, struct ide_pci_device_s *); 1244 void (*init_setup_dma)(struct pci_dev *, struct ide_pci_device_s *, ide_hwif_t *); 1245 unsigned int (*init_chipset)(struct pci_dev *, const char *); 1246 void (*init_iops)(ide_hwif_t *); 1247 void (*init_hwif)(ide_hwif_t *); 1248 void (*init_dma)(ide_hwif_t *, unsigned long); 1249 void (*fixup)(ide_hwif_t *); 1250 u8 channels; 1251 u8 autodma; 1252 ide_pci_enablebit_t enablebits[2]; 1253 u8 bootable; 1254 unsigned int extra; 1255 struct ide_pci_device_s *next; 1256 u8 flags; 1257 u8 udma_mask; 1258} ide_pci_device_t; 1259 1260extern int ide_setup_pci_device(struct pci_dev *, ide_pci_device_t *); 1261extern int ide_setup_pci_devices(struct pci_dev *, struct pci_dev *, ide_pci_device_t *); 1262 1263void ide_map_sg(ide_drive_t *, struct request *); 1264void ide_init_sg_cmd(ide_drive_t *, struct request *); 1265 1266#define BAD_DMA_DRIVE 0 1267#define GOOD_DMA_DRIVE 1 1268 1269#ifdef CONFIG_BLK_DEV_IDEDMA 1270struct drive_list_entry { 1271 const char *id_model; 1272 const char *id_firmware; 1273}; 1274 1275int ide_in_drive_list(struct hd_driveid *, const struct drive_list_entry *); 1276int __ide_dma_bad_drive(ide_drive_t *); 1277int __ide_dma_good_drive(ide_drive_t *); 1278u8 ide_max_dma_mode(ide_drive_t *); 1279int ide_tune_dma(ide_drive_t *); 1280void ide_dma_off(ide_drive_t *); 1281void ide_dma_verbose(ide_drive_t *); 1282int ide_set_dma(ide_drive_t *); 1283ide_startstop_t ide_dma_intr(ide_drive_t *); 1284 1285#ifdef CONFIG_BLK_DEV_IDEDMA_PCI 1286extern int ide_build_sglist(ide_drive_t *, struct request *); 1287extern int ide_build_dmatable(ide_drive_t *, struct request *); 1288extern void ide_destroy_dmatable(ide_drive_t *); 1289extern int ide_release_dma(ide_hwif_t *); 1290extern void ide_setup_dma(ide_hwif_t *, unsigned long, unsigned int); 1291 1292void ide_dma_host_off(ide_drive_t *); 1293void ide_dma_off_quietly(ide_drive_t *); 1294void ide_dma_host_on(ide_drive_t *); 1295extern int __ide_dma_on(ide_drive_t *); 1296extern int __ide_dma_check(ide_drive_t *); 1297extern int ide_dma_setup(ide_drive_t *); 1298extern void ide_dma_start(ide_drive_t *); 1299extern int __ide_dma_end(ide_drive_t *); 1300extern int __ide_dma_lostirq(ide_drive_t *); 1301extern int __ide_dma_timeout(ide_drive_t *); 1302#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */ 1303 1304#else 1305static inline u8 ide_max_dma_mode(ide_drive_t *drive) { return 0; } 1306static inline int ide_tune_dma(ide_drive_t *drive) { return 0; } 1307static inline void ide_dma_off(ide_drive_t *drive) { ; } 1308static inline void ide_dma_verbose(ide_drive_t *drive) { ; } 1309static inline int ide_set_dma(ide_drive_t *drive) { return 1; } 1310#endif /* CONFIG_BLK_DEV_IDEDMA */ 1311 1312#ifndef CONFIG_BLK_DEV_IDEDMA_PCI 1313static inline void ide_release_dma(ide_hwif_t *drive) {;} 1314#endif 1315 1316#ifdef CONFIG_BLK_DEV_IDEACPI 1317extern int ide_acpi_exec_tfs(ide_drive_t *drive); 1318extern void ide_acpi_get_timing(ide_hwif_t *hwif); 1319extern void ide_acpi_push_timing(ide_hwif_t *hwif); 1320extern void ide_acpi_init(ide_hwif_t *hwif); 1321#else 1322static inline int ide_acpi_exec_tfs(ide_drive_t *drive) { return 0; } 1323static inline void ide_acpi_get_timing(ide_hwif_t *hwif) { ; } 1324static inline void ide_acpi_push_timing(ide_hwif_t *hwif) { ; } 1325static inline void ide_acpi_init(ide_hwif_t *hwif) { ; } 1326#endif 1327 1328extern int ide_hwif_request_regions(ide_hwif_t *hwif); 1329extern void ide_hwif_release_regions(ide_hwif_t* hwif); 1330extern void ide_unregister (unsigned int index); 1331 1332void ide_register_region(struct gendisk *); 1333void ide_unregister_region(struct gendisk *); 1334 1335void ide_undecoded_slave(ide_hwif_t *); 1336 1337int probe_hwif_init_with_fixup(ide_hwif_t *, void (*)(ide_hwif_t *)); 1338extern int probe_hwif_init(ide_hwif_t *); 1339 1340static inline void *ide_get_hwifdata (ide_hwif_t * hwif) 1341{ 1342 return hwif->hwif_data; 1343} 1344 1345static inline void ide_set_hwifdata (ide_hwif_t * hwif, void *data) 1346{ 1347 hwif->hwif_data = data; 1348} 1349 1350/* ide-lib.c */ 1351u8 ide_rate_filter(ide_drive_t *, u8); 1352extern char *ide_xfer_verbose(u8 xfer_rate); 1353extern void ide_toggle_bounce(ide_drive_t *drive, int on); 1354extern int ide_set_xfer_rate(ide_drive_t *drive, u8 rate); 1355int ide_use_fast_pio(ide_drive_t *); 1356 1357u8 ide_dump_status(ide_drive_t *, const char *, u8); 1358 1359typedef struct ide_pio_timings_s { 1360 int setup_time; /* Address setup (ns) minimum */ 1361 int active_time; /* Active pulse (ns) minimum */ 1362 int cycle_time; /* Cycle time (ns) minimum = */ 1363 /* active + recovery (+ setup for some chips) */ 1364} ide_pio_timings_t; 1365 1366typedef struct ide_pio_data_s { 1367 u8 pio_mode; 1368 u8 use_iordy; 1369 u8 overridden; 1370 unsigned int cycle_time; 1371} ide_pio_data_t; 1372 1373extern u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_pio_data_t *d); 1374extern const ide_pio_timings_t ide_pio_timings[6]; 1375 1376 1377extern spinlock_t ide_lock; 1378extern struct semaphore ide_cfg_sem; 1379/* 1380 * Structure locking: 1381 * 1382 * ide_cfg_sem and ide_lock together protect changes to 1383 * ide_hwif_t->{next,hwgroup} 1384 * ide_drive_t->next 1385 * 1386 * ide_hwgroup_t->busy: ide_lock 1387 * ide_hwgroup_t->hwif: ide_lock 1388 * ide_hwif_t->mate: constant, no locking 1389 * ide_drive_t->hwif: constant, no locking 1390 */ 1391 1392#define local_irq_set(flags) do { local_save_flags((flags)); local_irq_enable_in_hardirq(); } while (0) 1393 1394extern struct bus_type ide_bus_type; 1395 1396/* check if CACHE FLUSH (EXT) command is supported (bits defined in ATA-6) */ 1397#define ide_id_has_flush_cache(id) ((id)->cfs_enable_2 & 0x3000) 1398 1399/* some Maxtor disks have bit 13 defined incorrectly so check bit 10 too */ 1400#define ide_id_has_flush_cache_ext(id) \ 1401 (((id)->cfs_enable_2 & 0x2400) == 0x2400) 1402 1403static inline int hwif_to_node(ide_hwif_t *hwif) 1404{ 1405 struct pci_dev *dev = hwif->pci_dev; 1406 return dev ? pcibus_to_node(dev->bus) : -1; 1407} 1408 1409#endif /* _IDE_H */ 1410