drivers/ide/ide-io-std.c

   1
   2 #include <linux/kernel.h>
   3 #include <linux/ide.h>
   4
   5 #if defined(CONFIG_ARM) || defined(CONFIG_M68K) || defined(CONFIG_MIPS) || \
   6     defined(CONFIG_PARISC) || defined(CONFIG_PPC) || defined(CONFIG_SPARC)
   7 #include <asm/ide.h>
   8 #else
   9 #include <asm-generic/ide_iops.h>
  10 #endif
  11
  12 /*
  13  *      Conventional PIO operations for ATA devices
  14  */
  15
  16 static u8 ide_inb(unsigned long port)
  17 {
  18         return (u8) inb(port);
  19 }
  20
  21 static void ide_outb(u8 val, unsigned long port)
  22 {
  23         outb(val, port);
  24 }
  25
  26 /*
  27  *      MMIO operations, typically used for SATA controllers
  28  */
  29
  30 static u8 ide_mm_inb(unsigned long port)
  31 {
  32         return (u8) readb((void __iomem *) port);
  33 }
  34
  35 static void ide_mm_outb(u8 value, unsigned long port)
  36 {
  37         writeb(value, (void __iomem *) port);
  38 }
  39
  40 void ide_exec_command(ide_hwif_t *hwif, u8 cmd)
  41 {
  42         if (hwif->host_flags & IDE_HFLAG_MMIO)
  43                 writeb(cmd, (void __iomem *)hwif->io_ports.command_addr);
  44         else
  45                 outb(cmd, hwif->io_ports.command_addr);
  46 }
  47 EXPORT_SYMBOL_GPL(ide_exec_command);
  48
  49 u8 ide_read_status(ide_hwif_t *hwif)
  50 {
  51         if (hwif->host_flags & IDE_HFLAG_MMIO)
  52                 return readb((void __iomem *)hwif->io_ports.status_addr);
  53         else
  54                 return inb(hwif->io_ports.status_addr);
  55 }
  56 EXPORT_SYMBOL_GPL(ide_read_status);
  57
  58 u8 ide_read_altstatus(ide_hwif_t *hwif)
  59 {
  60         if (hwif->host_flags & IDE_HFLAG_MMIO)
  61                 return readb((void __iomem *)hwif->io_ports.ctl_addr);
  62         else
  63                 return inb(hwif->io_ports.ctl_addr);
  64 }
  65 EXPORT_SYMBOL_GPL(ide_read_altstatus);
  66
  67 void ide_write_devctl(ide_hwif_t *hwif, u8 ctl)
  68 {
  69         if (hwif->host_flags & IDE_HFLAG_MMIO)
  70                 writeb(ctl, (void __iomem *)hwif->io_ports.ctl_addr);
  71         else
  72                 outb(ctl, hwif->io_ports.ctl_addr);
  73 }
  74 EXPORT_SYMBOL_GPL(ide_write_devctl);
  75
  76 void ide_dev_select(ide_drive_t *drive)
  77 {
  78         ide_hwif_t *hwif = drive->hwif;
  79         u8 select = drive->select | ATA_DEVICE_OBS;
  80
  81         if (hwif->host_flags & IDE_HFLAG_MMIO)
  82                 writeb(select, (void __iomem *)hwif->io_ports.device_addr);
  83         else
  84                 outb(select, hwif->io_ports.device_addr);
  85 }
  86 EXPORT_SYMBOL_GPL(ide_dev_select);
  87
  88 void ide_tf_load(ide_drive_t *drive, struct ide_cmd *cmd)
  89 {
  90         ide_hwif_t *hwif = drive->hwif;
  91         struct ide_io_ports *io_ports = &hwif->io_ports;
  92         struct ide_taskfile *tf = &cmd->hob;
  93         void (*tf_outb)(u8 addr, unsigned long port);
  94         u8 valid = cmd->valid.out.hob;
  95         u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
  96
  97         if (mmio)
  98                 tf_outb = ide_mm_outb;
  99         else
 100                 tf_outb = ide_outb;
 101
 102         if (valid & IDE_VALID_FEATURE)
 103                 tf_outb(tf->feature, io_ports->feature_addr);
 104         if (valid & IDE_VALID_NSECT)
 105                 tf_outb(tf->nsect, io_ports->nsect_addr);
 106         if (valid & IDE_VALID_LBAL)
 107                 tf_outb(tf->lbal, io_ports->lbal_addr);
 108         if (valid & IDE_VALID_LBAM)
 109                 tf_outb(tf->lbam, io_ports->lbam_addr);
 110         if (valid & IDE_VALID_LBAH)
 111                 tf_outb(tf->lbah, io_ports->lbah_addr);
 112
 113         tf = &cmd->tf;
 114         valid = cmd->valid.out.tf;
 115
 116         if (valid & IDE_VALID_FEATURE)
 117                 tf_outb(tf->feature, io_ports->feature_addr);
 118         if (valid & IDE_VALID_NSECT)
 119                 tf_outb(tf->nsect, io_ports->nsect_addr);
 120         if (valid & IDE_VALID_LBAL)
 121                 tf_outb(tf->lbal, io_ports->lbal_addr);
 122         if (valid & IDE_VALID_LBAM)
 123                 tf_outb(tf->lbam, io_ports->lbam_addr);
 124         if (valid & IDE_VALID_LBAH)
 125                 tf_outb(tf->lbah, io_ports->lbah_addr);
 126         if (valid & IDE_VALID_DEVICE)
 127                 tf_outb(tf->device, io_ports->device_addr);
 128 }
 129 EXPORT_SYMBOL_GPL(ide_tf_load);
 130
 131 void ide_tf_read(ide_drive_t *drive, struct ide_cmd *cmd)
 132 {
 133         ide_hwif_t *hwif = drive->hwif;
 134         struct ide_io_ports *io_ports = &hwif->io_ports;
 135         struct ide_taskfile *tf = &cmd->tf;
 136         u8 (*tf_inb)(unsigned long port);
 137         u8 valid = cmd->valid.in.tf;
 138         u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
 139
 140         if (mmio)
 141                 tf_inb  = ide_mm_inb;
 142         else
 143                 tf_inb  = ide_inb;
 144
 145         /* be sure we're looking at the low order bits */
 146         hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
 147
 148         if (valid & IDE_VALID_ERROR)
 149                 tf->error  = tf_inb(io_ports->feature_addr);
 150         if (valid & IDE_VALID_NSECT)
 151                 tf->nsect  = tf_inb(io_ports->nsect_addr);
 152         if (valid & IDE_VALID_LBAL)
 153                 tf->lbal   = tf_inb(io_ports->lbal_addr);
 154         if (valid & IDE_VALID_LBAM)
 155                 tf->lbam   = tf_inb(io_ports->lbam_addr);
 156         if (valid & IDE_VALID_LBAH)
 157                 tf->lbah   = tf_inb(io_ports->lbah_addr);
 158         if (valid & IDE_VALID_DEVICE)
 159                 tf->device = tf_inb(io_ports->device_addr);
 160
 161         if (cmd->tf_flags & IDE_TFLAG_LBA48) {
 162                 hwif->tp_ops->write_devctl(hwif, ATA_HOB | ATA_DEVCTL_OBS);
 163
 164                 tf = &cmd->hob;
 165                 valid = cmd->valid.in.hob;
 166
 167                 if (valid & IDE_VALID_ERROR)
 168                         tf->error = tf_inb(io_ports->feature_addr);
 169                 if (valid & IDE_VALID_NSECT)
 170                         tf->nsect = tf_inb(io_ports->nsect_addr);
 171                 if (valid & IDE_VALID_LBAL)
 172                         tf->lbal  = tf_inb(io_ports->lbal_addr);
 173                 if (valid & IDE_VALID_LBAM)
 174                         tf->lbam  = tf_inb(io_ports->lbam_addr);
 175                 if (valid & IDE_VALID_LBAH)
 176                         tf->lbah  = tf_inb(io_ports->lbah_addr);
 177         }
 178 }
 179 EXPORT_SYMBOL_GPL(ide_tf_read);
 180
 181 /*
 182  * Some localbus EIDE interfaces require a special access sequence
 183  * when using 32-bit I/O instructions to transfer data.  We call this
 184  * the "vlb_sync" sequence, which consists of three successive reads
 185  * of the sector count register location, with interrupts disabled
 186  * to ensure that the reads all happen together.
 187  */
 188 static void ata_vlb_sync(unsigned long port)
 189 {
 190         (void)inb(port);
 191         (void)inb(port);
 192         (void)inb(port);
 193 }
 194
 195 /*
 196  * This is used for most PIO data transfers *from* the IDE interface
 197  *
 198  * These routines will round up any request for an odd number of bytes,
 199  * so if an odd len is specified, be sure that there's at least one
 200  * extra byte allocated for the buffer.
 201  */
 202 void ide_input_data(ide_drive_t *drive, struct ide_cmd *cmd, void *buf,
 203                     unsigned int len)
 204 {
 205         ide_hwif_t *hwif = drive->hwif;
 206         struct ide_io_ports *io_ports = &hwif->io_ports;
 207         unsigned long data_addr = io_ports->data_addr;
 208         unsigned int words = (len + 1) >> 1;
 209         u8 io_32bit = drive->io_32bit;
 210         u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
 211
 212         if (io_32bit) {
 213                 unsigned long uninitialized_var(flags);
 214
 215                 if ((io_32bit & 2) && !mmio) {
 216                         local_irq_save(flags);
 217                         ata_vlb_sync(io_ports->nsect_addr);
 218                 }
 219
 220                 words >>= 1;
 221                 if (mmio)
 222                         __ide_mm_insl((void __iomem *)data_addr, buf, words);
 223                 else
 224                         insl(data_addr, buf, words);
 225
 226                 if ((io_32bit & 2) && !mmio)
 227                         local_irq_restore(flags);
 228
 229                 if (((len + 1) & 3) < 2)
 230                         return;
 231
 232                 buf += len & ~3;
 233                 words = 1;
 234         }
 235
 236         if (mmio)
 237                 __ide_mm_insw((void __iomem *)data_addr, buf, words);
 238         else
 239                 insw(data_addr, buf, words);
 240 }
 241 EXPORT_SYMBOL_GPL(ide_input_data);
 242
 243 /*
 244  * This is used for most PIO data transfers *to* the IDE interface
 245  */
 246 void ide_output_data(ide_drive_t *drive, struct ide_cmd *cmd, void *buf,
 247                      unsigned int len)
 248 {
 249         ide_hwif_t *hwif = drive->hwif;
 250         struct ide_io_ports *io_ports = &hwif->io_ports;
 251         unsigned long data_addr = io_ports->data_addr;
 252         unsigned int words = (len + 1) >> 1;
 253         u8 io_32bit = drive->io_32bit;
 254         u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
 255
 256         if (io_32bit) {
 257                 unsigned long uninitialized_var(flags);
 258
 259                 if ((io_32bit & 2) && !mmio) {
 260                         local_irq_save(flags);
 261                         ata_vlb_sync(io_ports->nsect_addr);
 262                 }
 263
 264                 words >>= 1;
 265                 if (mmio)
 266                         __ide_mm_outsl((void __iomem *)data_addr, buf, words);
 267                 else
 268                         outsl(data_addr, buf, words);
 269
 270                 if ((io_32bit & 2) && !mmio)
 271                         local_irq_restore(flags);
 272
 273                 if (((len + 1) & 3) < 2)
 274                         return;
 275
 276                 buf += len & ~3;
 277                 words = 1;
 278         }
 279
 280         if (mmio)
 281                 __ide_mm_outsw((void __iomem *)data_addr, buf, words);
 282         else
 283                 outsw(data_addr, buf, words);
 284 }
 285 EXPORT_SYMBOL_GPL(ide_output_data);
 286
 287 const struct ide_tp_ops default_tp_ops = {
 288         .exec_command           = ide_exec_command,
 289         .read_status            = ide_read_status,
 290         .read_altstatus         = ide_read_altstatus,
 291         .write_devctl           = ide_write_devctl,
 292
 293         .dev_select             = ide_dev_select,
 294         .tf_load                = ide_tf_load,
 295         .tf_read                = ide_tf_read,
 296
 297         .input_data             = ide_input_data,
 298         .output_data            = ide_output_data,
 299 };