drivers/scsi/libata-bmdma.c

   1 /*
   2  *  libata-bmdma.c - helper library for PCI IDE BMDMA
   3  *
   4  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
   5  *                  Please ALWAYS copy linux-ide@vger.kernel.org
   6  *                  on emails.
   7  *
   8  *  Copyright 2003-2006 Red Hat, Inc.  All rights reserved.
   9  *  Copyright 2003-2006 Jeff Garzik
  10  *
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2, or (at your option)
  15  *  any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; see the file COPYING.  If not, write to
  24  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25  *
  26  *
  27  *  libata documentation is available via 'make {ps|pdf}docs',
  28  *  as Documentation/DocBook/libata.*
  29  *
  30  *  Hardware documentation available from http://www.t13.org/ and
  31  *  http://www.sata-io.org/
  32  *
  33  */
  34
  35 #include <linux/config.h>
  36 #include <linux/kernel.h>
  37 #include <linux/pci.h>
  38 #include <linux/libata.h>
  39
  40 #include "libata.h"
  41
  42 /**
  43  *      ata_tf_load_pio - send taskfile registers to host controller
  44  *      @ap: Port to which output is sent
  45  *      @tf: ATA taskfile register set
  46  *
  47  *      Outputs ATA taskfile to standard ATA host controller.
  48  *
  49  *      LOCKING:
  50  *      Inherited from caller.
  51  */
  52
  53 static void ata_tf_load_pio(struct ata_port *ap, const struct ata_taskfile *tf)
  54 {
  55         struct ata_ioports *ioaddr = &ap->ioaddr;
  56         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
  57
  58         if (tf->ctl != ap->last_ctl) {
  59                 outb(tf->ctl, ioaddr->ctl_addr);
  60                 ap->last_ctl = tf->ctl;
  61                 ata_wait_idle(ap);
  62         }
  63
  64         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
  65                 outb(tf->hob_feature, ioaddr->feature_addr);
  66                 outb(tf->hob_nsect, ioaddr->nsect_addr);
  67                 outb(tf->hob_lbal, ioaddr->lbal_addr);
  68                 outb(tf->hob_lbam, ioaddr->lbam_addr);
  69                 outb(tf->hob_lbah, ioaddr->lbah_addr);
  70                 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
  71                         tf->hob_feature,
  72                         tf->hob_nsect,
  73                         tf->hob_lbal,
  74                         tf->hob_lbam,
  75                         tf->hob_lbah);
  76         }
  77
  78         if (is_addr) {
  79                 outb(tf->feature, ioaddr->feature_addr);
  80                 outb(tf->nsect, ioaddr->nsect_addr);
  81                 outb(tf->lbal, ioaddr->lbal_addr);
  82                 outb(tf->lbam, ioaddr->lbam_addr);
  83                 outb(tf->lbah, ioaddr->lbah_addr);
  84                 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
  85                         tf->feature,
  86                         tf->nsect,
  87                         tf->lbal,
  88                         tf->lbam,
  89                         tf->lbah);
  90         }
  91
  92         if (tf->flags & ATA_TFLAG_DEVICE) {
  93                 outb(tf->device, ioaddr->device_addr);
  94                 VPRINTK("device 0x%X\n", tf->device);
  95         }
  96
  97         ata_wait_idle(ap);
  98 }
  99
 100 /**
 101  *      ata_tf_load_mmio - send taskfile registers to host controller
 102  *      @ap: Port to which output is sent
 103  *      @tf: ATA taskfile register set
 104  *
 105  *      Outputs ATA taskfile to standard ATA host controller using MMIO.
 106  *
 107  *      LOCKING:
 108  *      Inherited from caller.
 109  */
 110
 111 static void ata_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 112 {
 113         struct ata_ioports *ioaddr = &ap->ioaddr;
 114         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
 115
 116         if (tf->ctl != ap->last_ctl) {
 117                 writeb(tf->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
 118                 ap->last_ctl = tf->ctl;
 119                 ata_wait_idle(ap);
 120         }
 121
 122         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
 123                 writeb(tf->hob_feature, (void __iomem *) ioaddr->feature_addr);
 124                 writeb(tf->hob_nsect, (void __iomem *) ioaddr->nsect_addr);
 125                 writeb(tf->hob_lbal, (void __iomem *) ioaddr->lbal_addr);
 126                 writeb(tf->hob_lbam, (void __iomem *) ioaddr->lbam_addr);
 127                 writeb(tf->hob_lbah, (void __iomem *) ioaddr->lbah_addr);
 128                 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
 129                         tf->hob_feature,
 130                         tf->hob_nsect,
 131                         tf->hob_lbal,
 132                         tf->hob_lbam,
 133                         tf->hob_lbah);
 134         }
 135
 136         if (is_addr) {
 137                 writeb(tf->feature, (void __iomem *) ioaddr->feature_addr);
 138                 writeb(tf->nsect, (void __iomem *) ioaddr->nsect_addr);
 139                 writeb(tf->lbal, (void __iomem *) ioaddr->lbal_addr);
 140                 writeb(tf->lbam, (void __iomem *) ioaddr->lbam_addr);
 141                 writeb(tf->lbah, (void __iomem *) ioaddr->lbah_addr);
 142                 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
 143                         tf->feature,
 144                         tf->nsect,
 145                         tf->lbal,
 146                         tf->lbam,
 147                         tf->lbah);
 148         }
 149
 150         if (tf->flags & ATA_TFLAG_DEVICE) {
 151                 writeb(tf->device, (void __iomem *) ioaddr->device_addr);
 152                 VPRINTK("device 0x%X\n", tf->device);
 153         }
 154
 155         ata_wait_idle(ap);
 156 }
 157
 158
 159 /**
 160  *      ata_tf_load - send taskfile registers to host controller
 161  *      @ap: Port to which output is sent
 162  *      @tf: ATA taskfile register set
 163  *
 164  *      Outputs ATA taskfile to standard ATA host controller using MMIO
 165  *      or PIO as indicated by the ATA_FLAG_MMIO flag.
 166  *      Writes the control, feature, nsect, lbal, lbam, and lbah registers.
 167  *      Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
 168  *      hob_lbal, hob_lbam, and hob_lbah.
 169  *
 170  *      This function waits for idle (!BUSY and !DRQ) after writing
 171  *      registers.  If the control register has a new value, this
 172  *      function also waits for idle after writing control and before
 173  *      writing the remaining registers.
 174  *
 175  *      May be used as the tf_load() entry in ata_port_operations.
 176  *
 177  *      LOCKING:
 178  *      Inherited from caller.
 179  */
 180 void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
 181 {
 182         if (ap->flags & ATA_FLAG_MMIO)
 183                 ata_tf_load_mmio(ap, tf);
 184         else
 185                 ata_tf_load_pio(ap, tf);
 186 }
 187
 188 /**
 189  *      ata_exec_command_pio - issue ATA command to host controller
 190  *      @ap: port to which command is being issued
 191  *      @tf: ATA taskfile register set
 192  *
 193  *      Issues PIO write to ATA command register, with proper
 194  *      synchronization with interrupt handler / other threads.
 195  *
 196  *      LOCKING:
 197  *      spin_lock_irqsave(host_set lock)
 198  */
 199
 200 static void ata_exec_command_pio(struct ata_port *ap, const struct ata_taskfile *tf)
 201 {
 202         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
 203
 204         outb(tf->command, ap->ioaddr.command_addr);
 205         ata_pause(ap);
 206 }
 207
 208
 209 /**
 210  *      ata_exec_command_mmio - issue ATA command to host controller
 211  *      @ap: port to which command is being issued
 212  *      @tf: ATA taskfile register set
 213  *
 214  *      Issues MMIO write to ATA command register, with proper
 215  *      synchronization with interrupt handler / other threads.
 216  *
 217  *      FIXME: missing write posting for 400nS delay enforcement
 218  *
 219  *      LOCKING:
 220  *      spin_lock_irqsave(host_set lock)
 221  */
 222
 223 static void ata_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
 224 {
 225         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
 226
 227         writeb(tf->command, (void __iomem *) ap->ioaddr.command_addr);
 228         ata_pause(ap);
 229 }
 230
 231
 232 /**
 233  *      ata_exec_command - issue ATA command to host controller
 234  *      @ap: port to which command is being issued
 235  *      @tf: ATA taskfile register set
 236  *
 237  *      Issues PIO/MMIO write to ATA command register, with proper
 238  *      synchronization with interrupt handler / other threads.
 239  *
 240  *      LOCKING:
 241  *      spin_lock_irqsave(host_set lock)
 242  */
 243 void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
 244 {
 245         if (ap->flags & ATA_FLAG_MMIO)
 246                 ata_exec_command_mmio(ap, tf);
 247         else
 248                 ata_exec_command_pio(ap, tf);
 249 }
 250
 251 /**
 252  *      ata_tf_read_pio - input device's ATA taskfile shadow registers
 253  *      @ap: Port from which input is read
 254  *      @tf: ATA taskfile register set for storing input
 255  *
 256  *      Reads ATA taskfile registers for currently-selected device
 257  *      into @tf.
 258  *
 259  *      LOCKING:
 260  *      Inherited from caller.
 261  */
 262
 263 static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
 264 {
 265         struct ata_ioports *ioaddr = &ap->ioaddr;
 266
 267         tf->command = ata_check_status(ap);
 268         tf->feature = inb(ioaddr->error_addr);
 269         tf->nsect = inb(ioaddr->nsect_addr);
 270         tf->lbal = inb(ioaddr->lbal_addr);
 271         tf->lbam = inb(ioaddr->lbam_addr);
 272         tf->lbah = inb(ioaddr->lbah_addr);
 273         tf->device = inb(ioaddr->device_addr);
 274
 275         if (tf->flags & ATA_TFLAG_LBA48) {
 276                 outb(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
 277                 tf->hob_feature = inb(ioaddr->error_addr);
 278                 tf->hob_nsect = inb(ioaddr->nsect_addr);
 279                 tf->hob_lbal = inb(ioaddr->lbal_addr);
 280                 tf->hob_lbam = inb(ioaddr->lbam_addr);
 281                 tf->hob_lbah = inb(ioaddr->lbah_addr);
 282         }
 283 }
 284
 285 /**
 286  *      ata_tf_read_mmio - input device's ATA taskfile shadow registers
 287  *      @ap: Port from which input is read
 288  *      @tf: ATA taskfile register set for storing input
 289  *
 290  *      Reads ATA taskfile registers for currently-selected device
 291  *      into @tf via MMIO.
 292  *
 293  *      LOCKING:
 294  *      Inherited from caller.
 295  */
 296
 297 static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
 298 {
 299         struct ata_ioports *ioaddr = &ap->ioaddr;
 300
 301         tf->command = ata_check_status(ap);
 302         tf->feature = readb((void __iomem *)ioaddr->error_addr);
 303         tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
 304         tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
 305         tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
 306         tf->lbah = readb((void __iomem *)ioaddr->lbah_addr);
 307         tf->device = readb((void __iomem *)ioaddr->device_addr);
 308
 309         if (tf->flags & ATA_TFLAG_LBA48) {
 310                 writeb(tf->ctl | ATA_HOB, (void __iomem *) ap->ioaddr.ctl_addr);
 311                 tf->hob_feature = readb((void __iomem *)ioaddr->error_addr);
 312                 tf->hob_nsect = readb((void __iomem *)ioaddr->nsect_addr);
 313                 tf->hob_lbal = readb((void __iomem *)ioaddr->lbal_addr);
 314                 tf->hob_lbam = readb((void __iomem *)ioaddr->lbam_addr);
 315                 tf->hob_lbah = readb((void __iomem *)ioaddr->lbah_addr);
 316         }
 317 }
 318
 319
 320 /**
 321  *      ata_tf_read - input device's ATA taskfile shadow registers
 322  *      @ap: Port from which input is read
 323  *      @tf: ATA taskfile register set for storing input
 324  *
 325  *      Reads ATA taskfile registers for currently-selected device
 326  *      into @tf.
 327  *
 328  *      Reads nsect, lbal, lbam, lbah, and device.  If ATA_TFLAG_LBA48
 329  *      is set, also reads the hob registers.
 330  *
 331  *      May be used as the tf_read() entry in ata_port_operations.
 332  *
 333  *      LOCKING:
 334  *      Inherited from caller.
 335  */
 336 void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 337 {
 338         if (ap->flags & ATA_FLAG_MMIO)
 339                 ata_tf_read_mmio(ap, tf);
 340         else
 341                 ata_tf_read_pio(ap, tf);
 342 }
 343
 344 /**
 345  *      ata_check_status_pio - Read device status reg & clear interrupt
 346  *      @ap: port where the device is
 347  *
 348  *      Reads ATA taskfile status register for currently-selected device
 349  *      and return its value. This also clears pending interrupts
 350  *      from this device
 351  *
 352  *      LOCKING:
 353  *      Inherited from caller.
 354  */
 355 static u8 ata_check_status_pio(struct ata_port *ap)
 356 {
 357         return inb(ap->ioaddr.status_addr);
 358 }
 359
 360 /**
 361  *      ata_check_status_mmio - Read device status reg & clear interrupt
 362  *      @ap: port where the device is
 363  *
 364  *      Reads ATA taskfile status register for currently-selected device
 365  *      via MMIO and return its value. This also clears pending interrupts
 366  *      from this device
 367  *
 368  *      LOCKING:
 369  *      Inherited from caller.
 370  */
 371 static u8 ata_check_status_mmio(struct ata_port *ap)
 372 {
 373         return readb((void __iomem *) ap->ioaddr.status_addr);
 374 }
 375
 376
 377 /**
 378  *      ata_check_status - Read device status reg & clear interrupt
 379  *      @ap: port where the device is
 380  *
 381  *      Reads ATA taskfile status register for currently-selected device
 382  *      and return its value. This also clears pending interrupts
 383  *      from this device
 384  *
 385  *      May be used as the check_status() entry in ata_port_operations.
 386  *
 387  *      LOCKING:
 388  *      Inherited from caller.
 389  */
 390 u8 ata_check_status(struct ata_port *ap)
 391 {
 392         if (ap->flags & ATA_FLAG_MMIO)
 393                 return ata_check_status_mmio(ap);
 394         return ata_check_status_pio(ap);
 395 }
 396
 397
 398 /**
 399  *      ata_altstatus - Read device alternate status reg
 400  *      @ap: port where the device is
 401  *
 402  *      Reads ATA taskfile alternate status register for
 403  *      currently-selected device and return its value.
 404  *
 405  *      Note: may NOT be used as the check_altstatus() entry in
 406  *      ata_port_operations.
 407  *
 408  *      LOCKING:
 409  *      Inherited from caller.
 410  */
 411 u8 ata_altstatus(struct ata_port *ap)
 412 {
 413         if (ap->ops->check_altstatus)
 414                 return ap->ops->check_altstatus(ap);
 415
 416         if (ap->flags & ATA_FLAG_MMIO)
 417                 return readb((void __iomem *)ap->ioaddr.altstatus_addr);
 418         return inb(ap->ioaddr.altstatus_addr);
 419 }
 420
 421 /**
 422  *      ata_bmdma_setup_mmio - Set up PCI IDE BMDMA transaction
 423  *      @qc: Info associated with this ATA transaction.
 424  *
 425  *      LOCKING:
 426  *      spin_lock_irqsave(host_set lock)
 427  */
 428
 429 static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
 430 {
 431         struct ata_port *ap = qc->ap;
 432         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
 433         u8 dmactl;
 434         void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
 435
 436         /* load PRD table addr. */
 437         mb();   /* make sure PRD table writes are visible to controller */
 438         writel(ap->prd_dma, mmio + ATA_DMA_TABLE_OFS);
 439
 440         /* specify data direction, triple-check start bit is clear */
 441         dmactl = readb(mmio + ATA_DMA_CMD);
 442         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
 443         if (!rw)
 444                 dmactl |= ATA_DMA_WR;
 445         writeb(dmactl, mmio + ATA_DMA_CMD);
 446
 447         /* issue r/w command */
 448         ap->ops->exec_command(ap, &qc->tf);
 449 }
 450
 451 /**
 452  *      ata_bmdma_start_mmio - Start a PCI IDE BMDMA transaction
 453  *      @qc: Info associated with this ATA transaction.
 454  *
 455  *      LOCKING:
 456  *      spin_lock_irqsave(host_set lock)
 457  */
 458
 459 static void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
 460 {
 461         struct ata_port *ap = qc->ap;
 462         void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
 463         u8 dmactl;
 464
 465         /* start host DMA transaction */
 466         dmactl = readb(mmio + ATA_DMA_CMD);
 467         writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
 468
 469         /* Strictly, one may wish to issue a readb() here, to
 470          * flush the mmio write.  However, control also passes
 471          * to the hardware at this point, and it will interrupt
 472          * us when we are to resume control.  So, in effect,
 473          * we don't care when the mmio write flushes.
 474          * Further, a read of the DMA status register _immediately_
 475          * following the write may not be what certain flaky hardware
 476          * is expected, so I think it is best to not add a readb()
 477          * without first all the MMIO ATA cards/mobos.
 478          * Or maybe I'm just being paranoid.
 479          */
 480 }
 481
 482 /**
 483  *      ata_bmdma_setup_pio - Set up PCI IDE BMDMA transaction (PIO)
 484  *      @qc: Info associated with this ATA transaction.
 485  *
 486  *      LOCKING:
 487  *      spin_lock_irqsave(host_set lock)
 488  */
 489
 490 static void ata_bmdma_setup_pio (struct ata_queued_cmd *qc)
 491 {
 492         struct ata_port *ap = qc->ap;
 493         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
 494         u8 dmactl;
 495
 496         /* load PRD table addr. */
 497         outl(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
 498
 499         /* specify data direction, triple-check start bit is clear */
 500         dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 501         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
 502         if (!rw)
 503                 dmactl |= ATA_DMA_WR;
 504         outb(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 505
 506         /* issue r/w command */
 507         ap->ops->exec_command(ap, &qc->tf);
 508 }
 509
 510 /**
 511  *      ata_bmdma_start_pio - Start a PCI IDE BMDMA transaction (PIO)
 512  *      @qc: Info associated with this ATA transaction.
 513  *
 514  *      LOCKING:
 515  *      spin_lock_irqsave(host_set lock)
 516  */
 517
 518 static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
 519 {
 520         struct ata_port *ap = qc->ap;
 521         u8 dmactl;
 522
 523         /* start host DMA transaction */
 524         dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 525         outb(dmactl | ATA_DMA_START,
 526              ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 527 }
 528
 529
 530 /**
 531  *      ata_bmdma_start - Start a PCI IDE BMDMA transaction
 532  *      @qc: Info associated with this ATA transaction.
 533  *
 534  *      Writes the ATA_DMA_START flag to the DMA command register.
 535  *
 536  *      May be used as the bmdma_start() entry in ata_port_operations.
 537  *
 538  *      LOCKING:
 539  *      spin_lock_irqsave(host_set lock)
 540  */
 541 void ata_bmdma_start(struct ata_queued_cmd *qc)
 542 {
 543         if (qc->ap->flags & ATA_FLAG_MMIO)
 544                 ata_bmdma_start_mmio(qc);
 545         else
 546                 ata_bmdma_start_pio(qc);
 547 }
 548
 549
 550 /**
 551  *      ata_bmdma_setup - Set up PCI IDE BMDMA transaction
 552  *      @qc: Info associated with this ATA transaction.
 553  *
 554  *      Writes address of PRD table to device's PRD Table Address
 555  *      register, sets the DMA control register, and calls
 556  *      ops->exec_command() to start the transfer.
 557  *
 558  *      May be used as the bmdma_setup() entry in ata_port_operations.
 559  *
 560  *      LOCKING:
 561  *      spin_lock_irqsave(host_set lock)
 562  */
 563 void ata_bmdma_setup(struct ata_queued_cmd *qc)
 564 {
 565         if (qc->ap->flags & ATA_FLAG_MMIO)
 566                 ata_bmdma_setup_mmio(qc);
 567         else
 568                 ata_bmdma_setup_pio(qc);
 569 }
 570
 571
 572 /**
 573  *      ata_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
 574  *      @ap: Port associated with this ATA transaction.
 575  *
 576  *      Clear interrupt and error flags in DMA status register.
 577  *
 578  *      May be used as the irq_clear() entry in ata_port_operations.
 579  *
 580  *      LOCKING:
 581  *      spin_lock_irqsave(host_set lock)
 582  */
 583
 584 void ata_bmdma_irq_clear(struct ata_port *ap)
 585 {
 586         if (!ap->ioaddr.bmdma_addr)
 587                 return;
 588
 589         if (ap->flags & ATA_FLAG_MMIO) {
 590                 void __iomem *mmio =
 591                       ((void __iomem *) ap->ioaddr.bmdma_addr) + ATA_DMA_STATUS;
 592                 writeb(readb(mmio), mmio);
 593         } else {
 594                 unsigned long addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
 595                 outb(inb(addr), addr);
 596         }
 597 }
 598
 599
 600 /**
 601  *      ata_bmdma_status - Read PCI IDE BMDMA status
 602  *      @ap: Port associated with this ATA transaction.
 603  *
 604  *      Read and return BMDMA status register.
 605  *
 606  *      May be used as the bmdma_status() entry in ata_port_operations.
 607  *
 608  *      LOCKING:
 609  *      spin_lock_irqsave(host_set lock)
 610  */
 611
 612 u8 ata_bmdma_status(struct ata_port *ap)
 613 {
 614         u8 host_stat;
 615         if (ap->flags & ATA_FLAG_MMIO) {
 616                 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
 617                 host_stat = readb(mmio + ATA_DMA_STATUS);
 618         } else
 619                 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 620         return host_stat;
 621 }
 622
 623
 624 /**
 625  *      ata_bmdma_stop - Stop PCI IDE BMDMA transfer
 626  *      @qc: Command we are ending DMA for
 627  *
 628  *      Clears the ATA_DMA_START flag in the dma control register
 629  *
 630  *      May be used as the bmdma_stop() entry in ata_port_operations.
 631  *
 632  *      LOCKING:
 633  *      spin_lock_irqsave(host_set lock)
 634  */
 635
 636 void ata_bmdma_stop(struct ata_queued_cmd *qc)
 637 {
 638         struct ata_port *ap = qc->ap;
 639         if (ap->flags & ATA_FLAG_MMIO) {
 640                 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
 641
 642                 /* clear start/stop bit */
 643                 writeb(readb(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
 644                         mmio + ATA_DMA_CMD);
 645         } else {
 646                 /* clear start/stop bit */
 647                 outb(inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD) & ~ATA_DMA_START,
 648                         ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 649         }
 650
 651         /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
 652         ata_altstatus(ap);        /* dummy read */
 653 }
 654
 655 #ifdef CONFIG_PCI
 656 static struct ata_probe_ent *
 657 ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port)
 658 {
 659         struct ata_probe_ent *probe_ent;
 660
 661         probe_ent = kzalloc(sizeof(*probe_ent), GFP_KERNEL);
 662         if (!probe_ent) {
 663                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
 664                        kobject_name(&(dev->kobj)));
 665                 return NULL;
 666         }
 667
 668         INIT_LIST_HEAD(&probe_ent->node);
 669         probe_ent->dev = dev;
 670
 671         probe_ent->sht = port->sht;
 672         probe_ent->host_flags = port->host_flags;
 673         probe_ent->pio_mask = port->pio_mask;
 674         probe_ent->mwdma_mask = port->mwdma_mask;
 675         probe_ent->udma_mask = port->udma_mask;
 676         probe_ent->port_ops = port->port_ops;
 677
 678         return probe_ent;
 679 }
 680
 681
 682 /**
 683  *      ata_pci_init_native_mode - Initialize native-mode driver
 684  *      @pdev:  pci device to be initialized
 685  *      @port:  array[2] of pointers to port info structures.
 686  *      @ports: bitmap of ports present
 687  *
 688  *      Utility function which allocates and initializes an
 689  *      ata_probe_ent structure for a standard dual-port
 690  *      PIO-based IDE controller.  The returned ata_probe_ent
 691  *      structure can be passed to ata_device_add().  The returned
 692  *      ata_probe_ent structure should then be freed with kfree().
 693  *
 694  *      The caller need only pass the address of the primary port, the
 695  *      secondary will be deduced automatically. If the device has non
 696  *      standard secondary port mappings this function can be called twice,
 697  *      once for each interface.
 698  */
 699
 700 struct ata_probe_ent *
 701 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int ports)
 702 {
 703         struct ata_probe_ent *probe_ent =
 704                 ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
 705         int p = 0;
 706         unsigned long bmdma;
 707
 708         if (!probe_ent)
 709                 return NULL;
 710
 711         probe_ent->irq = pdev->irq;
 712         probe_ent->irq_flags = SA_SHIRQ;
 713         probe_ent->private_data = port[0]->private_data;
 714
 715         if (ports & ATA_PORT_PRIMARY) {
 716                 probe_ent->port[p].cmd_addr = pci_resource_start(pdev, 0);
 717                 probe_ent->port[p].altstatus_addr =
 718                 probe_ent->port[p].ctl_addr =
 719                         pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
 720                 bmdma = pci_resource_start(pdev, 4);
 721                 if (bmdma) {
 722                         if (inb(bmdma + 2) & 0x80)
 723                                 probe_ent->host_set_flags |= ATA_HOST_SIMPLEX;
 724                         probe_ent->port[p].bmdma_addr = bmdma;
 725                 }
 726                 ata_std_ports(&probe_ent->port[p]);
 727                 p++;
 728         }
 729
 730         if (ports & ATA_PORT_SECONDARY) {
 731                 probe_ent->port[p].cmd_addr = pci_resource_start(pdev, 2);
 732                 probe_ent->port[p].altstatus_addr =
 733                 probe_ent->port[p].ctl_addr =
 734                         pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
 735                 bmdma = pci_resource_start(pdev, 4);
 736                 if (bmdma) {
 737                         bmdma += 8;
 738                         if(inb(bmdma + 2) & 0x80)
 739                         probe_ent->host_set_flags |= ATA_HOST_SIMPLEX;
 740                         probe_ent->port[p].bmdma_addr = bmdma;
 741                 }
 742                 ata_std_ports(&probe_ent->port[p]);
 743                 p++;
 744         }
 745
 746         probe_ent->n_ports = p;
 747         return probe_ent;
 748 }
 749
 750
 751 static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev,
 752                                 struct ata_port_info *port, int port_num)
 753 {
 754         struct ata_probe_ent *probe_ent;
 755         unsigned long bmdma;
 756
 757         probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port);
 758         if (!probe_ent)
 759                 return NULL;
 760
 761         probe_ent->legacy_mode = 1;
 762         probe_ent->n_ports = 1;
 763         probe_ent->hard_port_no = port_num;
 764         probe_ent->private_data = port->private_data;
 765
 766         switch(port_num)
 767         {
 768                 case 0:
 769                         probe_ent->irq = 14;
 770                         probe_ent->port[0].cmd_addr = 0x1f0;
 771                         probe_ent->port[0].altstatus_addr =
 772                         probe_ent->port[0].ctl_addr = 0x3f6;
 773                         break;
 774                 case 1:
 775                         probe_ent->irq = 15;
 776                         probe_ent->port[0].cmd_addr = 0x170;
 777                         probe_ent->port[0].altstatus_addr =
 778                         probe_ent->port[0].ctl_addr = 0x376;
 779                         break;
 780         }
 781
 782         bmdma = pci_resource_start(pdev, 4);
 783         if (bmdma != 0) {
 784                 bmdma += 8 * port_num;
 785                 probe_ent->port[0].bmdma_addr = bmdma;
 786                 if (inb(bmdma + 2) & 0x80)
 787                         probe_ent->host_set_flags |= ATA_HOST_SIMPLEX;
 788         }
 789         ata_std_ports(&probe_ent->port[0]);
 790
 791         return probe_ent;
 792 }
 793
 794
 795 /**
 796  *      ata_pci_init_one - Initialize/register PCI IDE host controller
 797  *      @pdev: Controller to be initialized
 798  *      @port_info: Information from low-level host driver
 799  *      @n_ports: Number of ports attached to host controller
 800  *
 801  *      This is a helper function which can be called from a driver's
 802  *      xxx_init_one() probe function if the hardware uses traditional
 803  *      IDE taskfile registers.
 804  *
 805  *      This function calls pci_enable_device(), reserves its register
 806  *      regions, sets the dma mask, enables bus master mode, and calls
 807  *      ata_device_add()
 808  *
 809  *      LOCKING:
 810  *      Inherited from PCI layer (may sleep).
 811  *
 812  *      RETURNS:
 813  *      Zero on success, negative on errno-based value on error.
 814  */
 815
 816 int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 817                       unsigned int n_ports)
 818 {
 819         struct ata_probe_ent *probe_ent = NULL, *probe_ent2 = NULL;
 820         struct ata_port_info *port[2];
 821         u8 tmp8, mask;
 822         unsigned int legacy_mode = 0;
 823         int disable_dev_on_err = 1;
 824         int rc;
 825
 826         DPRINTK("ENTER\n");
 827
 828         port[0] = port_info[0];
 829         if (n_ports > 1)
 830                 port[1] = port_info[1];
 831         else
 832                 port[1] = port[0];
 833
 834         if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0
 835             && (pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
 836                 /* TODO: What if one channel is in native mode ... */
 837                 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
 838                 mask = (1 << 2) | (1 << 0);
 839                 if ((tmp8 & mask) != mask)
 840                         legacy_mode = (1 << 3);
 841         }
 842
 843         /* FIXME... */
 844         if ((!legacy_mode) && (n_ports > 2)) {
 845                 printk(KERN_ERR "ata: BUG: native mode, n_ports > 2\n");
 846                 n_ports = 2;
 847                 /* For now */
 848         }
 849
 850         /* FIXME: Really for ATA it isn't safe because the device may be
 851            multi-purpose and we want to leave it alone if it was already
 852            enabled. Secondly for shared use as Arjan says we want refcounting
 853
 854            Checking dev->is_enabled is insufficient as this is not set at
 855            boot for the primary video which is BIOS enabled
 856          */
 857
 858         rc = pci_enable_device(pdev);
 859         if (rc)
 860                 return rc;
 861
 862         rc = pci_request_regions(pdev, DRV_NAME);
 863         if (rc) {
 864                 disable_dev_on_err = 0;
 865                 goto err_out;
 866         }
 867
 868         /* FIXME: Should use platform specific mappers for legacy port ranges */
 869         if (legacy_mode) {
 870                 if (!request_region(0x1f0, 8, "libata")) {
 871                         struct resource *conflict, res;
 872                         res.start = 0x1f0;
 873                         res.end = 0x1f0 + 8 - 1;
 874                         conflict = ____request_resource(&ioport_resource, &res);
 875                         if (!strcmp(conflict->name, "libata"))
 876                                 legacy_mode |= (1 << 0);
 877                         else {
 878                                 disable_dev_on_err = 0;
 879                                 printk(KERN_WARNING "ata: 0x1f0 IDE port busy\n");
 880                         }
 881                 } else
 882                         legacy_mode |= (1 << 0);
 883
 884                 if (!request_region(0x170, 8, "libata")) {
 885                         struct resource *conflict, res;
 886                         res.start = 0x170;
 887                         res.end = 0x170 + 8 - 1;
 888                         conflict = ____request_resource(&ioport_resource, &res);
 889                         if (!strcmp(conflict->name, "libata"))
 890                                 legacy_mode |= (1 << 1);
 891                         else {
 892                                 disable_dev_on_err = 0;
 893                                 printk(KERN_WARNING "ata: 0x170 IDE port busy\n");
 894                         }
 895                 } else
 896                         legacy_mode |= (1 << 1);
 897         }
 898
 899         /* we have legacy mode, but all ports are unavailable */
 900         if (legacy_mode == (1 << 3)) {
 901                 rc = -EBUSY;
 902                 goto err_out_regions;
 903         }
 904
 905         /* FIXME: If we get no DMA mask we should fall back to PIO */
 906         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
 907         if (rc)
 908                 goto err_out_regions;
 909         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
 910         if (rc)
 911                 goto err_out_regions;
 912
 913         if (legacy_mode) {
 914                 if (legacy_mode & (1 << 0))
 915                         probe_ent = ata_pci_init_legacy_port(pdev, port[0], 0);
 916                 if (legacy_mode & (1 << 1))
 917                         probe_ent2 = ata_pci_init_legacy_port(pdev, port[1], 1);
 918         } else {
 919                 if (n_ports == 2)
 920                         probe_ent = ata_pci_init_native_mode(pdev, port, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
 921                 else
 922                         probe_ent = ata_pci_init_native_mode(pdev, port, ATA_PORT_PRIMARY);
 923         }
 924         if (!probe_ent && !probe_ent2) {
 925                 rc = -ENOMEM;
 926                 goto err_out_regions;
 927         }
 928
 929         pci_set_master(pdev);
 930
 931         /* FIXME: check ata_device_add return */
 932         if (legacy_mode) {
 933                 if (legacy_mode & (1 << 0))
 934                         ata_device_add(probe_ent);
 935                 if (legacy_mode & (1 << 1))
 936                         ata_device_add(probe_ent2);
 937         } else
 938                 ata_device_add(probe_ent);
 939
 940         kfree(probe_ent);
 941         kfree(probe_ent2);
 942
 943         return 0;
 944
 945 err_out_regions:
 946         if (legacy_mode & (1 << 0))
 947                 release_region(0x1f0, 8);
 948         if (legacy_mode & (1 << 1))
 949                 release_region(0x170, 8);
 950         pci_release_regions(pdev);
 951 err_out:
 952         if (disable_dev_on_err)
 953                 pci_disable_device(pdev);
 954         return rc;
 955 }
 956
 957 /**
 958  *      ata_pci_clear_simplex   -       attempt to kick device out of simplex
 959  *      @pdev: PCI device
 960  *
 961  *      Some PCI ATA devices report simplex mode but in fact can be told to
 962  *      enter non simplex mode. This implements the neccessary logic to
 963  *      perform the task on such devices. Calling it on other devices will
 964  *      have -undefined- behaviour.
 965  */
 966
 967 int ata_pci_clear_simplex(struct pci_dev *pdev)
 968 {
 969         unsigned long bmdma = pci_resource_start(pdev, 4);
 970         u8 simplex;
 971
 972         if (bmdma == 0)
 973                 return -ENOENT;
 974
 975         simplex = inb(bmdma + 0x02);
 976         outb(simplex & 0x60, bmdma + 0x02);
 977         simplex = inb(bmdma + 0x02);
 978         if (simplex & 0x80)
 979                 return -EOPNOTSUPP;
 980         return 0;
 981 }
 982
 983 unsigned long ata_pci_default_filter(const struct ata_port *ap, struct ata_device *adev, unsigned long xfer_mask)
 984 {
 985         /* Filter out DMA modes if the device has been configured by
 986            the BIOS as PIO only */
 987
 988         if (ap->ioaddr.bmdma_addr == 0)
 989                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
 990         return xfer_mask;
 991 }
 992
 993 #endif /* CONFIG_PCI */
 994