home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / libata.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  27.8 KB  |  959 lines
  1. /*
  2.  *  Copyright 2003-2005 Red Hat, Inc.  All rights reserved.
  3.  *  Copyright 2003-2005 Jeff Garzik
  4.  *
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2, or (at your option)
  9.  *  any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; see the file COPYING.  If not, write to
  18.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  *
  21.  *  libata documentation is available via 'make {ps|pdf}docs',
  22.  *  as Documentation/DocBook/libata.*
  23.  *
  24.  */
  25.  
  26. #ifndef __LINUX_LIBATA_H__
  27. #define __LINUX_LIBATA_H__
  28.  
  29. #include <linux/delay.h>
  30. #include <linux/interrupt.h>
  31. #include <linux/pci.h>
  32. #include <linux/dma-mapping.h>
  33. #include <asm/io.h>
  34. #include <linux/ata.h>
  35. #include <linux/workqueue.h>
  36.  
  37. /*
  38.  * compile-time options: to be removed as soon as all the drivers are
  39.  * converted to the new debugging mechanism
  40.  */
  41. #undef ATA_DEBUG        /* debugging output */
  42. #undef ATA_VERBOSE_DEBUG    /* yet more debugging output */
  43. #undef ATA_IRQ_TRAP        /* define to ack screaming irqs */
  44. #undef ATA_NDEBUG        /* define to disable quick runtime checks */
  45. #define ATA_ENABLE_PATA        /* define to enable PATA support in some
  46.                  * low-level drivers */
  47. #undef ATAPI_ENABLE_DMADIR    /* enables ATAPI DMADIR bridge support */
  48.  
  49.  
  50. /* note: prints function name for you */
  51. #ifdef ATA_DEBUG
  52. #define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  53. #ifdef ATA_VERBOSE_DEBUG
  54. #define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  55. #else
  56. #define VPRINTK(fmt, args...)
  57. #endif    /* ATA_VERBOSE_DEBUG */
  58. #else
  59. #define DPRINTK(fmt, args...)
  60. #define VPRINTK(fmt, args...)
  61. #endif    /* ATA_DEBUG */
  62.  
  63. #define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  64.  
  65. /* NEW: debug levels */
  66. #define HAVE_LIBATA_MSG 1
  67.  
  68. enum {
  69.     ATA_MSG_DRV    = 0x0001,
  70.     ATA_MSG_INFO    = 0x0002,
  71.     ATA_MSG_PROBE    = 0x0004,
  72.     ATA_MSG_WARN    = 0x0008,
  73.     ATA_MSG_MALLOC    = 0x0010,
  74.     ATA_MSG_CTL    = 0x0020,
  75.     ATA_MSG_INTR    = 0x0040,
  76.     ATA_MSG_ERR    = 0x0080,
  77. };
  78.  
  79. #define ata_msg_drv(p)    ((p)->msg_enable & ATA_MSG_DRV)
  80. #define ata_msg_info(p)   ((p)->msg_enable & ATA_MSG_INFO)
  81. #define ata_msg_probe(p)  ((p)->msg_enable & ATA_MSG_PROBE)
  82. #define ata_msg_warn(p)   ((p)->msg_enable & ATA_MSG_WARN)
  83. #define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)
  84. #define ata_msg_ctl(p)    ((p)->msg_enable & ATA_MSG_CTL)
  85. #define ata_msg_intr(p)   ((p)->msg_enable & ATA_MSG_INTR)
  86. #define ata_msg_err(p)    ((p)->msg_enable & ATA_MSG_ERR)
  87.  
  88. static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
  89. {
  90.     if (dval < 0 || dval >= (sizeof(u32) * 8))
  91.         return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
  92.     if (!dval)
  93.         return 0;
  94.     return (1 << dval) - 1;
  95. }
  96.  
  97. /* defines only for the constants which don't work well as enums */
  98. #define ATA_TAG_POISON        0xfafbfcfdU
  99.  
  100. /* move to PCI layer? */
  101. static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
  102. {
  103.     return &pdev->dev;
  104. }
  105.  
  106. enum {
  107.     /* various global constants */
  108.     LIBATA_MAX_PRD        = ATA_MAX_PRD / 2,
  109.     ATA_MAX_PORTS        = 8,
  110.     ATA_DEF_QUEUE        = 1,
  111.     ATA_MAX_QUEUE        = 1,
  112.     ATA_MAX_SECTORS        = 200,    /* FIXME */
  113.     ATA_MAX_BUS        = 2,
  114.     ATA_DEF_BUSY_WAIT    = 10000,
  115.     ATA_SHORT_PAUSE        = (HZ >> 6) + 1,
  116.  
  117.     ATA_SHT_EMULATED    = 1,
  118.     ATA_SHT_CMD_PER_LUN    = 1,
  119.     ATA_SHT_THIS_ID        = -1,
  120.     ATA_SHT_USE_CLUSTERING    = 1,
  121.  
  122.     /* struct ata_device stuff */
  123.     ATA_DFLAG_LBA        = (1 << 0), /* device supports LBA */
  124.     ATA_DFLAG_LBA48        = (1 << 1), /* device supports LBA48 */
  125.     ATA_DFLAG_HPA        = (1 << 2), /* device has an HPA */
  126.  
  127.     ATA_DFLAG_CFG_MASK    = (1 << 8) - 1,
  128.  
  129.     ATA_DFLAG_PIO        = (1 << 8), /* device currently in PIO mode */
  130.  
  131.     ATA_DEV_UNKNOWN        = 0,    /* unknown device */
  132.     ATA_DEV_ATA        = 1,    /* ATA device */
  133.     ATA_DEV_ATA_UNSUP    = 2,    /* ATA device (unsupported) */
  134.     ATA_DEV_ATAPI        = 3,    /* ATAPI device */
  135.     ATA_DEV_ATAPI_UNSUP    = 4,    /* ATAPI device (unsupported) */
  136.     ATA_DEV_NONE        = 5,    /* no device */
  137.  
  138.     /* struct ata_port flags */
  139.     ATA_FLAG_SLAVE_POSS    = (1 << 1), /* host supports slave dev */
  140.                         /* (doesn't imply presence) */
  141.     ATA_FLAG_PORT_DISABLED    = (1 << 2), /* port is disabled, ignore it */
  142.     ATA_FLAG_SATA        = (1 << 3),
  143.     ATA_FLAG_NO_LEGACY    = (1 << 4), /* no legacy mode check */
  144.     ATA_FLAG_SRST        = (1 << 5), /* (obsolete) use ATA SRST, not E.D.D. */
  145.     ATA_FLAG_MMIO        = (1 << 6), /* use MMIO, not PIO */
  146.     ATA_FLAG_SATA_RESET    = (1 << 7), /* (obsolete) use COMRESET */
  147.     ATA_FLAG_PIO_DMA    = (1 << 8), /* PIO cmds via DMA */
  148.     ATA_FLAG_NOINTR        = (1 << 9), /* FIXME: Remove this once
  149.                          * proper HSM is in place. */
  150.     ATA_FLAG_DEBUGMSG    = (1 << 10),
  151.     ATA_FLAG_NO_ATAPI    = (1 << 11), /* No ATAPI support */
  152.  
  153.     ATA_FLAG_SUSPENDED    = (1 << 12), /* port is suspended */
  154.  
  155.     ATA_FLAG_PIO_LBA48    = (1 << 13), /* Host DMA engine is LBA28 only */
  156.     ATA_FLAG_IRQ_MASK    = (1 << 14), /* Mask IRQ in PIO xfers */
  157.  
  158.     ATA_FLAG_FLUSH_PORT_TASK = (1 << 15), /* Flush port task */
  159.     ATA_FLAG_IN_EH        = (1 << 16), /* EH in progress */
  160.  
  161.     ATA_QCFLAG_ACTIVE    = (1 << 1), /* cmd not yet ack'd to scsi lyer */
  162.     ATA_QCFLAG_SG        = (1 << 3), /* have s/g table? */
  163.     ATA_QCFLAG_SINGLE    = (1 << 4), /* no s/g, just a single buffer */
  164.     ATA_QCFLAG_DMAMAP    = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
  165.     ATA_QCFLAG_EH_SCHEDULED = (1 << 5), /* EH scheduled */
  166.  
  167.     /* host set flags */
  168.     ATA_HOST_SIMPLEX    = (1 << 0),    /* Host is simplex, one DMA channel per host_set only */
  169.     
  170.     /* various lengths of time */
  171.     ATA_TMOUT_PIO        = 30 * HZ,
  172.     ATA_TMOUT_BOOT        = 30 * HZ,    /* heuristic */
  173.     ATA_TMOUT_BOOT_QUICK    = 7 * HZ,    /* heuristic */
  174.     ATA_TMOUT_CDB        = 30 * HZ,
  175.     ATA_TMOUT_CDB_QUICK    = 5 * HZ,
  176.     ATA_TMOUT_INTERNAL    = 30 * HZ,
  177.     ATA_TMOUT_INTERNAL_QUICK = 5 * HZ,
  178.  
  179.     /* ATA bus states */
  180.     BUS_UNKNOWN        = 0,
  181.     BUS_DMA            = 1,
  182.     BUS_IDLE        = 2,
  183.     BUS_NOINTR        = 3,
  184.     BUS_NODATA        = 4,
  185.     BUS_TIMER        = 5,
  186.     BUS_PIO            = 6,
  187.     BUS_EDD            = 7,
  188.     BUS_IDENTIFY        = 8,
  189.     BUS_PACKET        = 9,
  190.  
  191.     /* SATA port states */
  192.     PORT_UNKNOWN        = 0,
  193.     PORT_ENABLED        = 1,
  194.     PORT_DISABLED        = 2,
  195.  
  196.     /* encoding various smaller bitmaps into a single
  197.      * unsigned int bitmap
  198.      */
  199.     ATA_BITS_PIO        = 5,
  200.     ATA_BITS_MWDMA        = 3,
  201.     ATA_BITS_UDMA        = 8,
  202.  
  203.     ATA_SHIFT_PIO        = 0,
  204.     ATA_SHIFT_MWDMA        = ATA_SHIFT_PIO + ATA_BITS_PIO,
  205.     ATA_SHIFT_UDMA        = ATA_SHIFT_MWDMA + ATA_BITS_MWDMA,
  206.  
  207.     ATA_MASK_PIO        = ((1 << ATA_BITS_PIO) - 1) << ATA_SHIFT_PIO,
  208.     ATA_MASK_MWDMA        = ((1 << ATA_BITS_MWDMA) - 1) << ATA_SHIFT_MWDMA,
  209.     ATA_MASK_UDMA        = ((1 << ATA_BITS_UDMA) - 1) << ATA_SHIFT_UDMA,
  210.  
  211.     /* size of buffer to pad xfers ending on unaligned boundaries */
  212.     ATA_DMA_PAD_SZ        = 4,
  213.     ATA_DMA_PAD_BUF_SZ    = ATA_DMA_PAD_SZ * ATA_MAX_QUEUE,
  214.     
  215.     /* Masks for port functions */
  216.     ATA_PORT_PRIMARY    = (1 << 0),
  217.     ATA_PORT_SECONDARY    = (1 << 1),
  218. };
  219.  
  220. enum hsm_task_states {
  221.     HSM_ST_UNKNOWN,
  222.     HSM_ST_IDLE,
  223.     HSM_ST_POLL,
  224.     HSM_ST_TMOUT,
  225.     HSM_ST,
  226.     HSM_ST_LAST,
  227.     HSM_ST_LAST_POLL,
  228.     HSM_ST_ERR,
  229. };
  230.  
  231. enum ata_completion_errors {
  232.     AC_ERR_DEV        = (1 << 0), /* device reported error */
  233.     AC_ERR_HSM        = (1 << 1), /* host state machine violation */
  234.     AC_ERR_TIMEOUT        = (1 << 2), /* timeout */
  235.     AC_ERR_MEDIA        = (1 << 3), /* media error */
  236.     AC_ERR_ATA_BUS        = (1 << 4), /* ATA bus error */
  237.     AC_ERR_HOST_BUS        = (1 << 5), /* host bus error */
  238.     AC_ERR_SYSTEM        = (1 << 6), /* system error */
  239.     AC_ERR_INVALID        = (1 << 7), /* invalid argument */
  240.     AC_ERR_OTHER        = (1 << 8), /* unknown */
  241. };
  242.  
  243. /* forward declarations */
  244. struct scsi_device;
  245. struct ata_port_operations;
  246. struct ata_port;
  247. struct ata_queued_cmd;
  248.  
  249. /* typedefs */
  250. typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
  251. typedef void (*ata_probeinit_fn_t)(struct ata_port *);
  252. typedef int (*ata_reset_fn_t)(struct ata_port *, int, unsigned int *);
  253. typedef void (*ata_postreset_fn_t)(struct ata_port *ap, unsigned int *);
  254.  
  255. struct ata_ioports {
  256.     unsigned long        cmd_addr;
  257.     unsigned long        data_addr;
  258.     unsigned long        error_addr;
  259.     unsigned long        feature_addr;
  260.     unsigned long        nsect_addr;
  261.     unsigned long        lbal_addr;
  262.     unsigned long        lbam_addr;
  263.     unsigned long        lbah_addr;
  264.     unsigned long        device_addr;
  265.     unsigned long        status_addr;
  266.     unsigned long        command_addr;
  267.     unsigned long        altstatus_addr;
  268.     unsigned long        ctl_addr;
  269.     unsigned long        bmdma_addr;
  270.     unsigned long        scr_addr;
  271. };
  272.  
  273. struct ata_probe_ent {
  274.     struct list_head    node;
  275.     struct device         *dev;
  276.     const struct ata_port_operations *port_ops;
  277.     struct scsi_host_template *sht;
  278.     struct ata_ioports    port[ATA_MAX_PORTS];
  279.     unsigned int        n_ports;
  280.     unsigned int        hard_port_no;
  281.     unsigned int        pio_mask;
  282.     unsigned int        mwdma_mask;
  283.     unsigned int        udma_mask;
  284.     unsigned int        legacy_mode;
  285.     unsigned long        irq;
  286.     unsigned int        irq_flags;
  287.     unsigned long        host_flags;
  288.     unsigned long        port_flags[ATA_MAX_PORTS];
  289.     unsigned long        host_set_flags;
  290.     void __iomem        *mmio_base;
  291.     void            *private_data;
  292. };
  293.  
  294. struct ata_host_set {
  295.     spinlock_t        lock;
  296.     struct device         *dev;
  297.     unsigned long        irq;
  298.     void __iomem        *mmio_base;
  299.     unsigned int        n_ports;
  300.     void            *private_data;
  301.     const struct ata_port_operations *ops;
  302.     unsigned long        flags;
  303.     int            simplex_claimed;    /* Keep seperate in case we
  304.                                ever need to do this locked */
  305.     struct ata_port *    ports[0];
  306. };
  307.  
  308. struct ata_queued_cmd {
  309.     struct ata_port        *ap;
  310.     struct ata_device    *dev;
  311.  
  312.     struct scsi_cmnd    *scsicmd;
  313.     void            (*scsidone)(struct scsi_cmnd *);
  314.  
  315.     struct ata_taskfile    tf;
  316.     u8            cdb[ATAPI_CDB_LEN];
  317.  
  318.     unsigned long        flags;        /* ATA_QCFLAG_xxx */
  319.     unsigned int        tag;
  320.     unsigned int        n_elem;
  321.     unsigned int        orig_n_elem;
  322.  
  323.     int            dma_dir;
  324.  
  325.     unsigned int        pad_len;
  326.  
  327.     unsigned int        nsect;
  328.     unsigned int        cursect;
  329.  
  330.     unsigned int        nbytes;
  331.     unsigned int        curbytes;
  332.  
  333.     unsigned int        cursg;
  334.     unsigned int        cursg_ofs;
  335.  
  336.     struct scatterlist    sgent;
  337.     struct scatterlist    pad_sgent;
  338.     void            *buf_virt;
  339.  
  340.     /* DO NOT iterate over __sg manually, use ata_for_each_sg() */
  341.     struct scatterlist    *__sg;
  342.  
  343.     unsigned int        err_mask;
  344.  
  345.     ata_qc_cb_t        complete_fn;
  346.  
  347.     void            *private_data;
  348. };
  349.  
  350. struct ata_host_stats {
  351.     unsigned long        unhandled_irq;
  352.     unsigned long        idle_irq;
  353.     unsigned long        rw_reqbuf;
  354. };
  355.  
  356. struct ata_device {
  357.     u64            n_sectors;    /* size of device, if ATA */
  358.     unsigned long        flags;        /* ATA_DFLAG_xxx */
  359.     unsigned int        class;        /* ATA_DEV_xxx */
  360.     unsigned int        devno;        /* 0 or 1 */
  361.     u16            *id;        /* IDENTIFY xxx DEVICE data */
  362.     u8            pio_mode;
  363.     u8            dma_mode;
  364.     u8            xfer_mode;
  365.     unsigned int        xfer_shift;    /* ATA_SHIFT_xxx */
  366.  
  367.     unsigned int        multi_count;    /* sectors count for
  368.                            READ/WRITE MULTIPLE */
  369.     unsigned int        max_sectors;    /* per-device max sectors */
  370.     unsigned int        cdb_len;
  371.  
  372.     /* per-dev xfer mask */
  373.     unsigned int        pio_mask;
  374.     unsigned int        mwdma_mask;
  375.     unsigned int        udma_mask;
  376.  
  377.     /* for CHS addressing */
  378.     u16            cylinders;    /* Number of cylinders */
  379.     u16            heads;        /* Number of heads */
  380.     u16            sectors;    /* Number of sectors per track */
  381. };
  382.  
  383. struct ata_port {
  384.     struct Scsi_Host    *host;    /* our co-allocated scsi host */
  385.     const struct ata_port_operations *ops;
  386.     unsigned long        flags;    /* ATA_FLAG_xxx */
  387.     unsigned int        id;    /* unique id req'd by scsi midlyr */
  388.     unsigned int        port_no; /* unique port #; from zero */
  389.     unsigned int        hard_port_no;    /* hardware port #; from zero */
  390.  
  391.     struct ata_prd        *prd;     /* our SG list */
  392.     dma_addr_t        prd_dma; /* and its DMA mapping */
  393.  
  394.     void            *pad;    /* array of DMA pad buffers */
  395.     dma_addr_t        pad_dma;
  396.  
  397.     struct ata_ioports    ioaddr;    /* ATA cmd/ctl/dma register blocks */
  398.  
  399.     u8            ctl;    /* cache of ATA control register */
  400.     u8            last_ctl;    /* Cache last written value */
  401.     unsigned int        pio_mask;
  402.     unsigned int        mwdma_mask;
  403.     unsigned int        udma_mask;
  404.     unsigned int        cbl;    /* cable type; ATA_CBL_xxx */
  405.  
  406.     struct ata_device    device[ATA_MAX_DEVICES];
  407.  
  408.     struct ata_queued_cmd    qcmd[ATA_MAX_QUEUE];
  409.     unsigned long        qactive;
  410.     unsigned int        active_tag;
  411.  
  412.     struct ata_host_stats    stats;
  413.     struct ata_host_set    *host_set;
  414.     struct device         *dev;
  415.  
  416.     struct work_struct    port_task;
  417.  
  418.     unsigned int        hsm_task_state;
  419.     unsigned long        pio_task_timeout;
  420.  
  421.     u32            msg_enable;
  422.     struct list_head    eh_done_q;
  423.  
  424.     void            *private_data;
  425. };
  426.  
  427. struct ata_port_operations {
  428.     void (*port_disable) (struct ata_port *);
  429.  
  430.     void (*dev_config) (struct ata_port *, struct ata_device *);
  431.  
  432.     void (*set_piomode) (struct ata_port *, struct ata_device *);
  433.     void (*set_dmamode) (struct ata_port *, struct ata_device *);
  434.     unsigned long (*mode_filter) (const struct ata_port *, struct ata_device *, unsigned long);
  435.  
  436.     void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
  437.     void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
  438.  
  439.     void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
  440.     u8   (*check_status)(struct ata_port *ap);
  441.     u8   (*check_altstatus)(struct ata_port *ap);
  442.     void (*dev_select)(struct ata_port *ap, unsigned int device);
  443.  
  444.     void (*phy_reset) (struct ata_port *ap); /* obsolete */
  445.     void (*set_mode) (struct ata_port *ap);
  446.     int (*probe_reset) (struct ata_port *ap, unsigned int *classes);
  447.  
  448.     void (*post_set_mode) (struct ata_port *ap);
  449.  
  450.     int (*check_atapi_dma) (struct ata_queued_cmd *qc);
  451.  
  452.     void (*bmdma_setup) (struct ata_queued_cmd *qc);
  453.     void (*bmdma_start) (struct ata_queued_cmd *qc);
  454.  
  455.     void (*data_xfer) (struct ata_port *, struct ata_device *, unsigned char *, unsigned int, int);
  456.  
  457.     void (*qc_prep) (struct ata_queued_cmd *qc);
  458.     unsigned int (*qc_issue) (struct ata_queued_cmd *qc);
  459.  
  460.     void (*eng_timeout) (struct ata_port *ap);
  461.  
  462.     irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
  463.     void (*irq_clear) (struct ata_port *);
  464.  
  465.     u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
  466.     void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
  467.                u32 val);
  468.  
  469.     int (*port_start) (struct ata_port *ap);
  470.     void (*port_stop) (struct ata_port *ap);
  471.  
  472.     void (*host_stop) (struct ata_host_set *host_set);
  473.  
  474.     void (*bmdma_stop) (struct ata_queued_cmd *qc);
  475.     u8   (*bmdma_status) (struct ata_port *ap);
  476. };
  477.  
  478. struct ata_port_info {
  479.     struct scsi_host_template    *sht;
  480.     unsigned long        host_flags;
  481.     unsigned long        pio_mask;
  482.     unsigned long        mwdma_mask;
  483.     unsigned long        udma_mask;
  484.     const struct ata_port_operations *port_ops;
  485.     void             *private_data;
  486. };
  487.  
  488. struct ata_timing {
  489.     unsigned short mode;        /* ATA mode */
  490.     unsigned short setup;        /* t1 */
  491.     unsigned short act8b;        /* t2 for 8-bit I/O */
  492.     unsigned short rec8b;        /* t2i for 8-bit I/O */
  493.     unsigned short cyc8b;        /* t0 for 8-bit I/O */
  494.     unsigned short active;        /* t2 or tD */
  495.     unsigned short recover;        /* t2i or tK */
  496.     unsigned short cycle;        /* t0 */
  497.     unsigned short udma;        /* t2CYCTYP/2 */
  498. };
  499.  
  500. #define FIT(v,vmin,vmax)    max_t(short,min_t(short,v,vmax),vmin)
  501.  
  502. extern void ata_port_probe(struct ata_port *);
  503. extern void __sata_phy_reset(struct ata_port *ap);
  504. extern void sata_phy_reset(struct ata_port *ap);
  505. extern void ata_bus_reset(struct ata_port *ap);
  506. extern int ata_drive_probe_reset(struct ata_port *ap,
  507.             ata_probeinit_fn_t probeinit,
  508.             ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
  509.             ata_postreset_fn_t postreset, unsigned int *classes);
  510. extern void ata_std_probeinit(struct ata_port *ap);
  511. extern int ata_std_softreset(struct ata_port *ap, int verbose,
  512.                  unsigned int *classes);
  513. extern int sata_std_hardreset(struct ata_port *ap, int verbose,
  514.                   unsigned int *class);
  515. extern void ata_std_postreset(struct ata_port *ap, unsigned int *classes);
  516. extern int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
  517.                   int post_reset);
  518. extern void ata_port_disable(struct ata_port *);
  519. extern void ata_std_ports(struct ata_ioports *ioaddr);
  520. #ifdef CONFIG_PCI
  521. extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
  522.                  unsigned int n_ports);
  523. extern void ata_pci_remove_one (struct pci_dev *pdev);
  524. extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state);
  525. extern int ata_pci_device_resume(struct pci_dev *pdev);
  526. extern int ata_pci_clear_simplex(struct pci_dev *pdev);
  527. #endif /* CONFIG_PCI */
  528. extern int ata_device_add(const struct ata_probe_ent *ent);
  529. extern void ata_host_set_remove(struct ata_host_set *host_set);
  530. extern int ata_scsi_detect(struct scsi_host_template *sht);
  531. extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
  532. extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
  533. extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
  534. extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
  535. extern int ata_scsi_release(struct Scsi_Host *host);
  536. extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
  537. extern int ata_scsi_device_resume(struct scsi_device *);
  538. extern int ata_scsi_device_suspend(struct scsi_device *, pm_message_t state);
  539. extern int ata_device_resume(struct ata_port *, struct ata_device *);
  540. extern int ata_device_suspend(struct ata_port *, struct ata_device *, pm_message_t state);
  541. extern int ata_ratelimit(void);
  542. extern unsigned int ata_busy_sleep(struct ata_port *ap,
  543.                    unsigned long timeout_pat,
  544.                    unsigned long timeout);
  545. extern void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *),
  546.                 void *data, unsigned long delay);
  547.  
  548. /*
  549.  * Default driver ops implementations
  550.  */
  551. extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
  552. extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
  553. extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp);
  554. extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
  555. extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
  556. extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
  557. extern u8 ata_check_status(struct ata_port *ap);
  558. extern u8 ata_altstatus(struct ata_port *ap);
  559. extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
  560. extern int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes);
  561. extern int ata_port_start (struct ata_port *ap);
  562. extern void ata_port_stop (struct ata_port *ap);
  563. extern void ata_host_stop (struct ata_host_set *host_set);
  564. extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
  565. extern void ata_qc_prep(struct ata_queued_cmd *qc);
  566. extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
  567. extern unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
  568. extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
  569.         unsigned int buflen);
  570. extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
  571.          unsigned int n_elem);
  572. extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
  573. extern void ata_id_string(const u16 *id, unsigned char *s,
  574.               unsigned int ofs, unsigned int len);
  575. extern void ata_id_c_string(const u16 *id, unsigned char *s,
  576.                 unsigned int ofs, unsigned int len);
  577. extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
  578. extern void ata_bmdma_start (struct ata_queued_cmd *qc);
  579. extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
  580. extern u8   ata_bmdma_status(struct ata_port *ap);
  581. extern void ata_bmdma_irq_clear(struct ata_port *ap);
  582. extern void __ata_qc_complete(struct ata_queued_cmd *qc);
  583. extern void ata_eng_timeout(struct ata_port *ap);
  584. extern void ata_mmio_data_xfer(struct ata_port *ap, struct ata_device *adev, unsigned char *buf,
  585.                    unsigned int buflen, int write_data);
  586. extern void ata_pio_data_xfer(struct ata_port *ap, struct ata_device *adev, unsigned char *buf,
  587.                   unsigned int buflen, int write_data);
  588. extern void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
  589.                   struct scsi_cmnd *cmd,
  590.                   void (*done)(struct scsi_cmnd *));
  591. extern int ata_std_bios_param(struct scsi_device *sdev,
  592.                   struct block_device *bdev,
  593.                   sector_t capacity, int geom[]);
  594. extern int ata_scsi_slave_config(struct scsi_device *sdev);
  595. extern struct ata_device *ata_dev_pair(struct ata_port *ap, 
  596.                        struct ata_device *adev);
  597.  
  598. /*
  599.  * Timing helpers
  600.  */
  601.  
  602. extern unsigned int ata_pio_need_iordy(const struct ata_device *);
  603. extern int ata_timing_compute(struct ata_device *, unsigned short,
  604.                   struct ata_timing *, int, int);
  605. extern void ata_timing_merge(const struct ata_timing *,
  606.                  const struct ata_timing *, struct ata_timing *,
  607.                  unsigned int);
  608.  
  609. enum {
  610.     ATA_TIMING_SETUP    = (1 << 0),
  611.     ATA_TIMING_ACT8B    = (1 << 1),
  612.     ATA_TIMING_REC8B    = (1 << 2),
  613.     ATA_TIMING_CYC8B    = (1 << 3),
  614.     ATA_TIMING_8BIT        = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
  615.                   ATA_TIMING_CYC8B,
  616.     ATA_TIMING_ACTIVE    = (1 << 4),
  617.     ATA_TIMING_RECOVER    = (1 << 5),
  618.     ATA_TIMING_CYCLE    = (1 << 6),
  619.     ATA_TIMING_UDMA        = (1 << 7),
  620.     ATA_TIMING_ALL        = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
  621.                   ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
  622.                   ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
  623.                   ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
  624. };
  625.  
  626.  
  627. #ifdef CONFIG_PCI
  628. struct pci_bits {
  629.     unsigned int        reg;    /* PCI config register to read */
  630.     unsigned int        width;    /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
  631.     unsigned long        mask;
  632.     unsigned long        val;
  633. };
  634.  
  635. extern void ata_pci_host_stop (struct ata_host_set *host_set);
  636. extern struct ata_probe_ent *
  637. ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int portmask);
  638. extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
  639. extern unsigned long ata_pci_default_filter(const struct ata_port *, struct ata_device *, unsigned long);
  640. #endif /* CONFIG_PCI */
  641.  
  642.  
  643. static inline int
  644. ata_sg_is_last(struct scatterlist *sg, struct ata_queued_cmd *qc)
  645. {
  646.     if (sg == &qc->pad_sgent)
  647.         return 1;
  648.     if (qc->pad_len)
  649.         return 0;
  650.     if (((sg - qc->__sg) + 1) == qc->n_elem)
  651.         return 1;
  652.     return 0;
  653. }
  654.  
  655. static inline struct scatterlist *
  656. ata_qc_first_sg(struct ata_queued_cmd *qc)
  657. {
  658.     if (qc->n_elem)
  659.         return qc->__sg;
  660.     if (qc->pad_len)
  661.         return &qc->pad_sgent;
  662.     return NULL;
  663. }
  664.  
  665. static inline struct scatterlist *
  666. ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
  667. {
  668.     if (sg == &qc->pad_sgent)
  669.         return NULL;
  670.     if (++sg - qc->__sg < qc->n_elem)
  671.         return sg;
  672.     if (qc->pad_len)
  673.         return &qc->pad_sgent;
  674.     return NULL;
  675. }
  676.  
  677. #define ata_for_each_sg(sg, qc) \
  678.     for (sg = ata_qc_first_sg(qc); sg; sg = ata_qc_next_sg(sg, qc))
  679.  
  680. static inline unsigned int ata_tag_valid(unsigned int tag)
  681. {
  682.     return (tag < ATA_MAX_QUEUE) ? 1 : 0;
  683. }
  684.  
  685. static inline unsigned int ata_class_present(unsigned int class)
  686. {
  687.     return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI;
  688. }
  689.  
  690. static inline unsigned int ata_dev_present(const struct ata_device *dev)
  691. {
  692.     return ata_class_present(dev->class);
  693. }
  694.  
  695. static inline u8 ata_chk_status(struct ata_port *ap)
  696. {
  697.     return ap->ops->check_status(ap);
  698. }
  699.  
  700.  
  701. /**
  702.  *    ata_pause - Flush writes and pause 400 nanoseconds.
  703.  *    @ap: Port to wait for.
  704.  *
  705.  *    LOCKING:
  706.  *    Inherited from caller.
  707.  */
  708.  
  709. static inline void ata_pause(struct ata_port *ap)
  710. {
  711.     ata_altstatus(ap);
  712.     ndelay(400);
  713. }
  714.  
  715.  
  716. /**
  717.  *    ata_busy_wait - Wait for a port status register
  718.  *    @ap: Port to wait for.
  719.  *
  720.  *    Waits up to max*10 microseconds for the selected bits in the port's
  721.  *    status register to be cleared.
  722.  *    Returns final value of status register.
  723.  *
  724.  *    LOCKING:
  725.  *    Inherited from caller.
  726.  */
  727.  
  728. static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
  729.                    unsigned int max)
  730. {
  731.     u8 status;
  732.  
  733.     do {
  734.         udelay(10);
  735.         status = ata_chk_status(ap);
  736.         max--;
  737.     } while ((status & bits) && (max > 0));
  738.  
  739.     return status;
  740. }
  741.  
  742.  
  743. /**
  744.  *    ata_wait_idle - Wait for a port to be idle.
  745.  *    @ap: Port to wait for.
  746.  *
  747.  *    Waits up to 10ms for port's BUSY and DRQ signals to clear.
  748.  *    Returns final value of status register.
  749.  *
  750.  *    LOCKING:
  751.  *    Inherited from caller.
  752.  */
  753.  
  754. static inline u8 ata_wait_idle(struct ata_port *ap)
  755. {
  756.     u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
  757.  
  758.     if (status & (ATA_BUSY | ATA_DRQ)) {
  759.         unsigned long l = ap->ioaddr.status_addr;
  760.         if (ata_msg_warn(ap))
  761.             printk(KERN_WARNING "ATA: abnormal status 0x%X on port 0x%lX\n",
  762.                 status, l);
  763.     }
  764.  
  765.     return status;
  766. }
  767.  
  768. static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
  769. {
  770.     qc->tf.ctl |= ATA_NIEN;
  771. }
  772.  
  773. static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
  774.                               unsigned int tag)
  775. {
  776.     if (likely(ata_tag_valid(tag)))
  777.         return &ap->qcmd[tag];
  778.     return NULL;
  779. }
  780.  
  781. static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
  782. {
  783.     memset(tf, 0, sizeof(*tf));
  784.  
  785.     tf->ctl = ap->ctl;
  786.     if (device == 0)
  787.         tf->device = ATA_DEVICE_OBS;
  788.     else
  789.         tf->device = ATA_DEVICE_OBS | ATA_DEV1;
  790. }
  791.  
  792. static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
  793. {
  794.     qc->__sg = NULL;
  795.     qc->flags = 0;
  796.     qc->cursect = qc->cursg = qc->cursg_ofs = 0;
  797.     qc->nsect = 0;
  798.     qc->nbytes = qc->curbytes = 0;
  799.     qc->err_mask = 0;
  800.  
  801.     ata_tf_init(qc->ap, &qc->tf, qc->dev->devno);
  802. }
  803.  
  804. /**
  805.  *    ata_qc_complete - Complete an active ATA command
  806.  *    @qc: Command to complete
  807.  *    @err_mask: ATA Status register contents
  808.  *
  809.  *    Indicate to the mid and upper layers that an ATA
  810.  *    command has completed, with either an ok or not-ok status.
  811.  *
  812.  *    LOCKING:
  813.  *    spin_lock_irqsave(host_set lock)
  814.  */
  815. static inline void ata_qc_complete(struct ata_queued_cmd *qc)
  816. {
  817.     if (unlikely(qc->flags & ATA_QCFLAG_EH_SCHEDULED))
  818.         return;
  819.  
  820.     __ata_qc_complete(qc);
  821. }
  822.  
  823. /**
  824.  *    ata_irq_on - Enable interrupts on a port.
  825.  *    @ap: Port on which interrupts are enabled.
  826.  *
  827.  *    Enable interrupts on a legacy IDE device using MMIO or PIO,
  828.  *    wait for idle, clear any pending interrupts.
  829.  *
  830.  *    LOCKING:
  831.  *    Inherited from caller.
  832.  */
  833.  
  834. static inline u8 ata_irq_on(struct ata_port *ap)
  835. {
  836.     struct ata_ioports *ioaddr = &ap->ioaddr;
  837.     u8 tmp;
  838.  
  839.     ap->ctl &= ~ATA_NIEN;
  840.     ap->last_ctl = ap->ctl;
  841.  
  842.     if (ap->flags & ATA_FLAG_MMIO)
  843.         writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
  844.     else
  845.         outb(ap->ctl, ioaddr->ctl_addr);
  846.     tmp = ata_wait_idle(ap);
  847.  
  848.     ap->ops->irq_clear(ap);
  849.  
  850.     return tmp;
  851. }
  852.  
  853.  
  854. /**
  855.  *    ata_irq_ack - Acknowledge a device interrupt.
  856.  *    @ap: Port on which interrupts are enabled.
  857.  *
  858.  *    Wait up to 10 ms for legacy IDE device to become idle (BUSY
  859.  *    or BUSY+DRQ clear).  Obtain dma status and port status from
  860.  *    device.  Clear the interrupt.  Return port status.
  861.  *
  862.  *    LOCKING:
  863.  */
  864.  
  865. static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
  866. {
  867.     unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
  868.     u8 host_stat, post_stat, status;
  869.  
  870.     status = ata_busy_wait(ap, bits, 1000);
  871.     if (status & bits)
  872.         if (ata_msg_err(ap))
  873.             printk(KERN_ERR "abnormal status 0x%X\n", status);
  874.  
  875.     /* get controller status; clear intr, err bits */
  876.     if (ap->flags & ATA_FLAG_MMIO) {
  877.         void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
  878.         host_stat = readb(mmio + ATA_DMA_STATUS);
  879.         writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
  880.                mmio + ATA_DMA_STATUS);
  881.  
  882.         post_stat = readb(mmio + ATA_DMA_STATUS);
  883.     } else {
  884.         host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
  885.         outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
  886.              ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
  887.  
  888.         post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
  889.     }
  890.  
  891.     if (ata_msg_intr(ap))
  892.         printk(KERN_INFO "%s: irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
  893.             __FUNCTION__,
  894.             host_stat, post_stat, status);
  895.  
  896.     return status;
  897. }
  898.  
  899. static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
  900. {
  901.     return ap->ops->scr_read(ap, reg);
  902. }
  903.  
  904. static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
  905. {
  906.     ap->ops->scr_write(ap, reg, val);
  907. }
  908.  
  909. static inline void scr_write_flush(struct ata_port *ap, unsigned int reg,
  910.                    u32 val)
  911. {
  912.     ap->ops->scr_write(ap, reg, val);
  913.     (void) ap->ops->scr_read(ap, reg);
  914. }
  915.  
  916. static inline unsigned int sata_dev_present(struct ata_port *ap)
  917. {
  918.     return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
  919. }
  920.  
  921. static inline int ata_try_flush_cache(const struct ata_device *dev)
  922. {
  923.     return ata_id_wcache_enabled(dev->id) ||
  924.            ata_id_has_flush(dev->id) ||
  925.            ata_id_has_flush_ext(dev->id);
  926. }
  927.  
  928. static inline unsigned int ac_err_mask(u8 status)
  929. {
  930.     if (status & ATA_BUSY)
  931.         return AC_ERR_HSM;
  932.     if (status & (ATA_ERR | ATA_DF))
  933.         return AC_ERR_DEV;
  934.     return 0;
  935. }
  936.  
  937. static inline unsigned int __ac_err_mask(u8 status)
  938. {
  939.     unsigned int mask = ac_err_mask(status);
  940.     if (mask == 0)
  941.         return AC_ERR_OTHER;
  942.     return mask;
  943. }
  944.  
  945. static inline int ata_pad_alloc(struct ata_port *ap, struct device *dev)
  946. {
  947.     ap->pad_dma = 0;
  948.     ap->pad = dma_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ,
  949.                      &ap->pad_dma, GFP_KERNEL);
  950.     return (ap->pad == NULL) ? -ENOMEM : 0;
  951. }
  952.  
  953. static inline void ata_pad_free(struct ata_port *ap, struct device *dev)
  954. {
  955.     dma_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
  956. }
  957.  
  958. #endif /* __LINUX_LIBATA_H__ */
  959.