Lines Matching refs:ap
235 } else if (lba48 && (dev->ap->flags & ATA_FLAG_PIO_LBA48)) {
604 if (ata_msg_drv(dev->ap))
614 * @ap: ATA channel to examine
630 static unsigned int ata_devchk(struct ata_port *ap, unsigned int device)
632 struct ata_ioports *ioaddr = &ap->ioaddr;
635 ap->ops->dev_select(ap, device);
696 * @ap: ATA channel to examine
717 ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
723 ap->ops->dev_select(ap, device);
727 ap->ops->tf_read(ap, &tf);
735 ap->device[device].horkage |= ATA_HORKAGE_DIAGNOSTIC;
748 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
1075 * @ap: ATA channel to manipulate
1085 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
1092 * @ap: ATA channel to manipulate
1105 void ata_std_dev_select (struct ata_port *ap, unsigned int device)
1114 iowrite8(tmp, ap->ioaddr.device_addr);
1115 ata_pause(ap); /* needed; also flushes, for mmio */
1120 * @ap: ATA channel to manipulate
1137 void ata_dev_select(struct ata_port *ap, unsigned int device,
1140 if (ata_msg_probe(ap))
1141 ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, "
1145 ata_wait_idle(ap);
1147 ap->ops->dev_select(ap, device);
1150 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
1152 ata_wait_idle(ap);
1251 * @ap: The ata_port to queue port_task for
1268 void ata_port_queue_task(struct ata_port *ap, work_func_t fn, void *data,
1273 if (ap->pflags & ATA_PFLAG_FLUSH_PORT_TASK)
1276 PREPARE_DELAYED_WORK(&ap->port_task, fn);
1277 ap->port_task_data = data;
1279 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
1287 * @ap: The ata_port to flush port_task for
1295 void ata_port_flush_task(struct ata_port *ap)
1301 spin_lock_irqsave(ap->lock, flags);
1302 ap->pflags |= ATA_PFLAG_FLUSH_PORT_TASK;
1303 spin_unlock_irqrestore(ap->lock, flags);
1306 cancel_work_sync(&ap->port_task.work); /* akpm: seems unneeded */
1313 if (!cancel_delayed_work(&ap->port_task)) {
1314 if (ata_msg_ctl(ap))
1315 ata_port_printk(ap, KERN_DEBUG, "%s: flush #2\n",
1317 cancel_work_sync(&ap->port_task.work);
1320 spin_lock_irqsave(ap->lock, flags);
1321 ap->pflags &= ~ATA_PFLAG_FLUSH_PORT_TASK;
1322 spin_unlock_irqrestore(ap->lock, flags);
1324 if (ata_msg_ctl(ap))
1325 ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __FUNCTION__);
1361 struct ata_port *ap = dev->ap;
1371 spin_lock_irqsave(ap->lock, flags);
1374 if (ap->pflags & ATA_PFLAG_FROZEN) {
1375 spin_unlock_irqrestore(ap->lock, flags);
1381 if (ap->ops->error_handler)
1386 if (test_and_set_bit(tag, &ap->qc_allocated))
1388 qc = __ata_qc_from_tag(ap, tag);
1392 qc->ap = ap;
1396 preempted_tag = ap->active_tag;
1397 preempted_sactive = ap->sactive;
1398 preempted_qc_active = ap->qc_active;
1399 ap->active_tag = ATA_TAG_POISON;
1400 ap->sactive = 0;
1401 ap->qc_active = 0;
1424 spin_unlock_irqrestore(ap->lock, flags);
1428 ata_port_flush_task(ap);
1431 spin_lock_irqsave(ap->lock, flags);
1441 if (ap->ops->error_handler)
1442 ata_port_freeze(ap);
1446 if (ata_msg_warn(ap))
1451 spin_unlock_irqrestore(ap->lock, flags);
1455 if (ap->ops->post_internal_cmd)
1456 ap->ops->post_internal_cmd(qc);
1471 spin_lock_irqsave(ap->lock, flags);
1477 ap->active_tag = preempted_tag;
1478 ap->sactive = preempted_sactive;
1479 ap->qc_active = preempted_qc_active;
1481 if (ap->flags & ATA_FLAG_DISABLED) {
1483 ata_port_probe(ap);
1486 spin_unlock_irqrestore(ap->lock, flags);
1565 if (adev->ap->flags & ATA_FLAG_NO_IORDY)
1621 struct ata_port *ap = dev->ap;
1629 if (ata_msg_ctl(ap))
1632 ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1666 ap->print_id, dev->devno);
1765 if (ata_msg_warn(ap))
1773 return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1779 struct ata_port *ap = dev->ap;
1790 if (ap->flags & ATA_FLAG_NCQ) {
1791 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1);
1816 struct ata_port *ap = dev->ap;
1817 int print_info = ap->eh_context.i.flags & ATA_EHI_PRINTINFO;
1825 if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
1831 if (ata_msg_probe(ap))
1842 ata_acpi_exec_tfs(ap);
1845 if (ata_msg_probe(ap))
1869 if (ata_msg_probe(ap))
1918 if (ata_msg_drv(ap) && print_info) {
1944 if (ata_msg_drv(ap) && print_info) {
1966 if (ata_msg_warn(ap))
1980 if (ata_msg_drv(ap) && print_info)
2007 if (ata_msg_drv(ap) && print_info)
2018 if (ap->ops->dev_config)
2019 ap->ops->dev_config(dev);
2021 if (ata_msg_probe(ap))
2023 __FUNCTION__, ata_chk_status(ap));
2027 if (ata_msg_probe(ap))
2035 * @ap: port
2041 int ata_cable_40wire(struct ata_port *ap)
2048 * @ap: port
2054 int ata_cable_80wire(struct ata_port *ap)
2061 * @ap: port
2066 int ata_cable_unknown(struct ata_port *ap)
2073 * @ap: port
2078 int ata_cable_sata(struct ata_port *ap)
2085 * @ap: Bus to probe
2098 int ata_bus_probe(struct ata_port *ap)
2105 ata_port_probe(ap);
2112 ap->ops->phy_reset(ap);
2115 dev = &ap->device[i];
2117 if (!(ap->flags & ATA_FLAG_DISABLED) &&
2126 ata_port_probe(ap);
2132 ap->device[i].pio_mode = XFER_PIO_0;
2139 dev = &ap->device[i];
2154 if (ap->ops->cable_detect)
2155 ap->cbl = ap->ops->cable_detect(ap);
2161 dev = &ap->device[i];
2165 ap->eh_context.i.flags |= ATA_EHI_PRINTINFO;
2167 ap->eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
2173 rc = ata_set_mode(ap, &dev);
2178 if (ata_dev_enabled(&ap->device[i]))
2182 ata_port_disable(ap);
2183 ap->ops->port_disable(ap);
2203 sata_down_spd_limit(ap);
2216 * @ap: Port for which we indicate enablement
2218 * Modify @ap data structure such that the system
2225 void ata_port_probe(struct ata_port *ap)
2227 ap->flags &= ~ATA_FLAG_DISABLED;
2232 * @ap: SATA port to printk link status about
2239 void sata_print_link_status(struct ata_port *ap)
2243 if (sata_scr_read(ap, SCR_STATUS, &sstatus))
2245 sata_scr_read(ap, SCR_CONTROL, &scontrol);
2247 if (ata_port_online(ap)) {
2249 ata_port_printk(ap, KERN_INFO,
2253 ata_port_printk(ap, KERN_INFO,
2261 * @ap: SATA port associated with target SATA PHY.
2271 void __sata_phy_reset(struct ata_port *ap)
2276 if (ap->flags & ATA_FLAG_SATA_RESET) {
2278 sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
2284 sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
2289 sata_scr_read(ap, SCR_STATUS, &sstatus);
2295 sata_print_link_status(ap);
2298 if (!ata_port_offline(ap))
2299 ata_port_probe(ap);
2301 ata_port_disable(ap);
2303 if (ap->flags & ATA_FLAG_DISABLED)
2306 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
2307 ata_port_disable(ap);
2311 ap->cbl = ATA_CBL_SATA;
2316 * @ap: SATA port associated with target SATA PHY.
2325 void sata_phy_reset(struct ata_port *ap)
2327 __sata_phy_reset(ap);
2328 if (ap->flags & ATA_FLAG_DISABLED)
2330 ata_bus_reset(ap);
2343 struct ata_port *ap = adev->ap;
2344 struct ata_device *pair = &ap->device[1 - adev->devno];
2352 * @ap: Port to be disabled.
2354 * Modify @ap data structure such that the system
2363 void ata_port_disable(struct ata_port *ap)
2365 ap->device[0].class = ATA_DEV_NONE;
2366 ap->device[1].class = ATA_DEV_NONE;
2367 ap->flags |= ATA_FLAG_DISABLED;
2372 * @ap: Port to adjust SATA spd limit for
2374 * Adjust SATA spd limit of @ap downward. Note that this
2384 int sata_down_spd_limit(struct ata_port *ap)
2389 rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
2393 mask = ap->sata_spd_limit;
2407 ap->sata_spd_limit = mask;
2409 ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",
2415 static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
2419 if (ap->sata_spd_limit == UINT_MAX)
2422 limit = fls(ap->sata_spd_limit);
2432 * @ap: Port in question
2435 * @ap->sata_spd_limit. This function is used to determine
2445 int sata_set_spd_needed(struct ata_port *ap)
2449 if (sata_scr_read(ap, SCR_CONTROL, &scontrol))
2452 return __sata_set_spd_needed(ap, &scontrol);
2457 * @ap: Port to set SATA spd for
2459 * Set SATA spd of @ap according to sata_spd_limit.
2468 int sata_set_spd(struct ata_port *ap)
2473 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2476 if (!__sata_set_spd_needed(ap, &scontrol))
2479 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
2734 struct ata_eh_context *ehc = &dev->ap->eh_context;
2769 * @ap: port on which timings will be programmed
2784 int ata_do_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
2794 dev = &ap->device[i];
2815 dev = &ap->device[i];
2827 if (ap->ops->set_piomode)
2828 ap->ops->set_piomode(ap, dev);
2833 dev = &ap->device[i];
2840 if (ap->ops->set_dmamode)
2841 ap->ops->set_dmamode(ap, dev);
2846 dev = &ap->device[i];
2860 if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
2861 ap->host->simplex_claimed = ap;
2871 * @ap: port on which timings will be programmed
2884 int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
2887 if (ap->ops->set_mode)
2888 return ap->ops->set_mode(ap, r_failed_dev);
2889 return ata_do_set_mode(ap, r_failed_dev);
2894 * @ap: port to which command is being issued
2905 static inline void ata_tf_to_host(struct ata_port *ap,
2908 ap->ops->tf_load(ap, tf);
2909 ap->ops->exec_command(ap, tf);
2914 * @ap: port containing status register to be polled
2927 int ata_busy_sleep(struct ata_port *ap,
2933 status = ata_busy_wait(ap, ATA_BUSY, 300);
2939 status = ata_busy_wait(ap, ATA_BUSY, 3);
2943 ata_port_printk(ap, KERN_WARNING,
2951 status = ata_chk_status(ap);
2958 ata_port_printk(ap, KERN_ERR, "port failed to respond "
2969 * @ap: port containing status register to be polled
2981 int ata_wait_ready(struct ata_port *ap, unsigned long deadline)
2987 u8 status = ata_chk_status(ap);
2992 if (!ata_port_online(ap) && status == 0xff)
2999 ata_port_printk(ap, KERN_WARNING,
3009 static int ata_bus_post_reset(struct ata_port *ap, unsigned int devmask,
3012 struct ata_ioports *ioaddr = &ap->ioaddr;
3021 rc = ata_wait_ready(ap, deadline);
3035 ap->ops->dev_select(ap, 1);
3051 rc = ata_wait_ready(ap, deadline);
3060 ap->ops->dev_select(ap, 0);
3062 ap->ops->dev_select(ap, 1);
3064 ap->ops->dev_select(ap, 0);
3069 static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
3072 struct ata_ioports *ioaddr = &ap->ioaddr;
3074 DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
3077 iowrite8(ap->ctl, ioaddr->ctl_addr);
3079 iowrite8(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
3081 iowrite8(ap->ctl, ioaddr->ctl_addr);
3099 if (ata_check_status(ap) == 0xFF)
3102 return ata_bus_post_reset(ap, devmask, deadline);
3107 * @ap: port to reset
3125 void ata_bus_reset(struct ata_port *ap)
3127 struct ata_ioports *ioaddr = &ap->ioaddr;
3128 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
3133 DPRINTK("ENTER, host %u, port %u\n", ap->print_id, ap->port_no);
3136 if (ap->flags & ATA_FLAG_SATA_RESET)
3139 dev0 = ata_devchk(ap, 0);
3141 dev1 = ata_devchk(ap, 1);
3150 ap->ops->dev_select(ap, 0);
3153 if (ap->flags & ATA_FLAG_SRST) {
3154 rc = ata_bus_softreset(ap, devmask, jiffies + 40 * HZ);
3162 ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
3164 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
3167 ap->ops->irq_on(ap);
3170 if (ap->device[1].class != ATA_DEV_NONE)
3171 ap->ops->dev_select(ap, 1);
3172 if (ap->device[0].class != ATA_DEV_NONE)
3173 ap->ops->dev_select(ap, 0);
3176 if ((ap->device[0].class == ATA_DEV_NONE) &&
3177 (ap->device[1].class == ATA_DEV_NONE))
3180 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
3182 iowrite8(ap->ctl, ioaddr->ctl_addr);
3189 ata_port_printk(ap, KERN_ERR, "disabling port\n");
3190 ap->ops->port_disable(ap);
3197 * @ap: ATA port to debounce SATA phy status for
3201 * Make sure SStatus of @ap reaches stable state, determined by
3217 int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
3230 if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
3239 if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
3264 * @ap: ATA port to resume SATA phy for
3268 * Resume SATA phy of @ap and debounce it.
3276 int sata_phy_resume(struct ata_port *ap, const unsigned long *params,
3282 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
3287 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
3295 return sata_phy_debounce(ap, params, deadline);
3300 * @ap: ATA port to be reset
3303 * @ap is about to be reset. Initialize it. Failure from
3315 int ata_std_prereset(struct ata_port *ap, unsigned long deadline)
3317 struct ata_eh_context *ehc = &ap->eh_context;
3323 (ap->flags & ATA_FLAG_HRST_TO_RESUME))
3331 if (ap->cbl == ATA_CBL_SATA) {
3332 rc = sata_phy_resume(ap, timing, deadline);
3335 ata_port_printk(ap, KERN_WARNING, "failed to resume "
3342 if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap)) {
3343 rc = ata_wait_ready(ap, deadline);
3345 ata_port_printk(ap, KERN_WARNING, "device not ready "
3356 * @ap: port to reset
3368 int ata_std_softreset(struct ata_port *ap, unsigned int *classes,
3371 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
3378 if (ata_port_offline(ap)) {
3384 if (ata_devchk(ap, 0))
3386 if (slave_possible && ata_devchk(ap, 1))
3390 ap->ops->dev_select(ap, 0);
3394 rc = ata_bus_softreset(ap, devmask, deadline);
3396 if (rc && (rc != -ENODEV || sata_scr_valid(ap))) {
3397 ata_port_printk(ap, KERN_ERR, "SRST failed (errno=%d)\n", rc);
3402 classes[0] = ata_dev_try_classify(ap, 0, &err);
3404 classes[1] = ata_dev_try_classify(ap, 1, &err);
3413 * @ap: port to reset
3425 int sata_port_hardreset(struct ata_port *ap, const unsigned long *timing,
3433 if (sata_set_spd_needed(ap)) {
3439 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
3444 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
3447 sata_set_spd(ap);
3451 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
3456 if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol)))
3465 rc = sata_phy_resume(ap, timing, deadline);
3473 * @ap: port to reset
3486 int sata_std_hardreset(struct ata_port *ap, unsigned int *class,
3489 const unsigned long *timing = sata_ehc_deb_timing(&ap->eh_context);
3495 rc = sata_port_hardreset(ap, timing, deadline);
3497 ata_port_printk(ap, KERN_ERR,
3503 if (ata_port_offline(ap)) {
3512 rc = ata_wait_ready(ap, deadline);
3515 ata_port_printk(ap, KERN_ERR,
3520 ap->ops->dev_select(ap, 0); /* probably unnecessary */
3522 *class = ata_dev_try_classify(ap, 0, NULL);
3530 * @ap: the target ata_port
3540 void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
3547 sata_print_link_status(ap);
3550 if (sata_scr_read(ap, SCR_ERROR, &serror) == 0)
3551 sata_scr_write(ap, SCR_ERROR, serror);
3554 if (!ap->ops->error_handler)
3555 ap->ops->irq_on(ap);
3559 ap->ops->dev_select(ap, 1);
3561 ap->ops->dev_select(ap, 0);
3570 if (ap->ioaddr.ctl_addr)
3571 iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
3642 u16 *id = (void *)dev->ap->sector_buf;
3806 if ((dev->ap->flags & ATA_FLAG_PIO_POLLING) &&
3826 struct ata_port *ap = dev->ap;
3827 struct ata_host *host = ap->host;
3831 xfer_mask = ata_pack_xfermask(ap->pio_mask,
3832 ap->mwdma_mask, ap->udma_mask);
3857 host->simplex_claimed && host->simplex_claimed != ap) {
3863 if (ap->flags & ATA_FLAG_NO_IORDY)
3866 if (ap->ops->mode_filter)
3867 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
3879 if((ap->cbl == ATA_CBL_PATA40) ||
3881 (ap->cbl == ATA_CBL_PATA_UNK ||
3882 ap->cbl == ATA_CBL_PATA80))) {
3897 * on port @ap.
3979 struct ata_port *ap = qc->ap;
3997 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
4001 dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
4012 dma_unmap_single(ap->dev,
4039 struct ata_port *ap = qc->ap;
4064 ap->prd[idx].addr = cpu_to_le32(addr);
4065 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
4075 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
4094 struct ata_port *ap = qc->ap;
4102 if (ap->ops->check_atapi_dma)
4103 return ap->ops->check_atapi_dma(qc);
4191 struct ata_port *ap = qc->ap;
4200 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
4211 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
4227 dma_address = dma_map_single(ap->dev, qc->buf_virt,
4261 struct ata_port *ap = qc->ap;
4266 VPRINTK("ENTER, ata%u\n", ap->print_id);
4272 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
4294 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
4315 n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
4367 struct ata_port *ap = adev->ap;
4372 iowrite16_rep(ap->ioaddr.data_addr, buf, words);
4374 ioread16_rep(ap->ioaddr.data_addr, buf, words);
4383 iowrite16(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
4385 align_buf[0] = cpu_to_le16(ioread16(ap->ioaddr.data_addr));
4428 struct ata_port *ap = qc->ap;
4434 ap->hsm_task_state = HSM_ST_LAST;
4452 ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write);
4458 ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write);
4499 * @ap: Port to which ATAPI device is attached.
4509 static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
4515 ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
4516 ata_altstatus(ap); /* flush */
4520 ap->hsm_task_state = HSM_ST;
4523 ap->hsm_task_state = HSM_ST_LAST;
4526 ap->hsm_task_state = HSM_ST_LAST;
4528 ap->ops->bmdma_start(qc);
4549 struct ata_port *ap = qc->ap;
4555 ap->hsm_task_state = HSM_ST_LAST;
4575 ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write);
4577 ap->hsm_task_state = HSM_ST_LAST;
4605 ap->ops->data_xfer(qc->dev, buf + offset, count, do_write);
4611 ap->ops->data_xfer(qc->dev, buf + offset, count, do_write);
4639 struct ata_port *ap = qc->ap;
4650 ap->ops->tf_read(ap, &qc->result_tf);
4665 VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
4674 ap->hsm_task_state = HSM_ST_ERR;
4679 * @ap: the target ata_port
4686 static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
4691 if (ap->hsm_task_state == HSM_ST_FIRST) {
4717 struct ata_port *ap = qc->ap;
4720 if (ap->ops->error_handler) {
4722 spin_lock_irqsave(ap->lock, flags);
4727 qc = ata_qc_from_tag(ap, qc->tag);
4730 ap->ops->irq_on(ap);
4733 ata_port_freeze(ap);
4736 spin_unlock_irqrestore(ap->lock, flags);
4741 ata_port_freeze(ap);
4745 spin_lock_irqsave(ap->lock, flags);
4746 ap->ops->irq_on(ap);
4748 spin_unlock_irqrestore(ap->lock, flags);
4756 * @ap: the target ata_port
4764 int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
4776 WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
4780 ap->print_id, qc->tf.protocol, ap->hsm_task_state, status);
4782 switch (ap->hsm_task_state) {
4802 ap->hsm_task_state = HSM_ST_ERR;
4813 ata_port_printk(ap, KERN_WARNING, "DRQ=1 with device "
4816 ap->hsm_task_state = HSM_ST_ERR;
4826 spin_lock_irqsave(ap->lock, flags);
4837 ap->hsm_task_state = HSM_ST;
4839 ata_altstatus(ap); /* flush */
4842 atapi_send_cdb(ap, qc);
4845 spin_unlock_irqrestore(ap->lock, flags);
4860 ap->hsm_task_state = HSM_ST_LAST;
4871 ata_port_printk(ap, KERN_WARNING, "DRQ=1 with "
4875 ap->hsm_task_state = HSM_ST_ERR;
4881 if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
4900 ap->hsm_task_state = HSM_ST_ERR;
4920 ata_altstatus(ap);
4921 status = ata_wait_idle(ap);
4931 ap->hsm_task_state = HSM_ST_ERR;
4937 if (ap->hsm_task_state == HSM_ST_LAST &&
4940 ata_altstatus(ap);
4941 status = ata_wait_idle(ap);
4946 ata_altstatus(ap); /* flush */
4953 ap->hsm_task_state = HSM_ST_ERR;
4959 ap->print_id, qc->dev->devno, status);
4963 ap->hsm_task_state = HSM_ST_IDLE;
4977 ap->hsm_task_state = HSM_ST_IDLE;
4994 struct ata_port *ap =
4996 struct ata_queued_cmd *qc = ap->port_task_data;
5001 WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
5010 status = ata_busy_wait(ap, ATA_BUSY, 5);
5013 status = ata_busy_wait(ap, ATA_BUSY, 10);
5015 ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE);
5021 poll_next = ata_hsm_move(ap, qc, status, 1);
5032 * @ap: Port associated with device @dev
5039 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
5045 if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
5050 if (!test_and_set_bit(i, &ap->qc_allocated)) {
5051 qc = __ata_qc_from_tag(ap, i);
5071 struct ata_port *ap = dev->ap;
5074 qc = ata_qc_new(ap);
5077 qc->ap = ap;
5098 struct ata_port *ap = qc->ap;
5107 clear_bit(tag, &ap->qc_allocated);
5113 struct ata_port *ap = qc->ap;
5123 ap->sactive &= ~(1 << qc->tag);
5125 ap->active_tag = ATA_TAG_POISON;
5132 ap->qc_active &= ~(1 << qc->tag);
5140 struct ata_port *ap = qc->ap;
5143 ap->ops->tf_read(ap, &qc->result_tf);
5159 struct ata_port *ap = qc->ap;
5161 if (ap->ops->error_handler) {
5162 WARN_ON(ap->pflags & ATA_PFLAG_FROZEN);
5195 * @ap: port in question
5201 * requests normally. ap->qc_active and @qc_active is compared
5210 int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
5217 done_mask = ap->qc_active ^ qc_active;
5220 ata_port_printk(ap, KERN_ERR, "illegal qc_active transition "
5221 "(%08x->%08x)\n", ap->qc_active, qc_active);
5231 if ((qc = ata_qc_from_tag(ap, i))) {
5244 struct ata_port *ap = qc->ap;
5254 if (ap->flags & ATA_FLAG_PIO_DMA)
5280 struct ata_port *ap = qc->ap;
5286 WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));
5289 WARN_ON(ap->sactive & (1 << qc->tag));
5290 ap->sactive |= 1 << qc->tag;
5292 WARN_ON(ap->sactive);
5293 ap->active_tag = qc->tag;
5297 ap->qc_active |= 1 << qc->tag;
5311 ap->ops->qc_prep(qc);
5313 qc->err_mask |= ap->ops->qc_issue(qc);
5345 struct ata_port *ap = qc->ap;
5350 if (ap->flags & ATA_FLAG_PIO_POLLING) {
5369 ata_dev_select(ap, qc->dev->devno, 1, 0);
5377 ata_tf_to_host(ap, &qc->tf);
5378 ap->hsm_task_state = HSM_ST_LAST;
5381 ata_port_queue_task(ap, ata_pio_task, qc, 0);
5388 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
5389 ap->ops->bmdma_setup(qc); /* set up bmdma */
5390 ap->ops->bmdma_start(qc); /* initiate bmdma */
5391 ap->hsm_task_state = HSM_ST_LAST;
5398 ata_tf_to_host(ap, &qc->tf);
5402 ap->hsm_task_state = HSM_ST_FIRST;
5403 ata_port_queue_task(ap, ata_pio_task, qc, 0);
5410 ap->hsm_task_state = HSM_ST;
5413 ata_port_queue_task(ap, ata_pio_task, qc, 0);
5427 ata_tf_to_host(ap, &qc->tf);
5429 ap->hsm_task_state = HSM_ST_FIRST;
5434 ata_port_queue_task(ap, ata_pio_task, qc, 0);
5440 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
5441 ap->ops->bmdma_setup(qc); /* set up bmdma */
5442 ap->hsm_task_state = HSM_ST_FIRST;
5446 ata_port_queue_task(ap, ata_pio_task, qc, 0);
5459 * @ap: Port on which interrupt arrived (possibly...)
5473 inline unsigned int ata_host_intr (struct ata_port *ap,
5476 struct ata_eh_info *ehi = &ap->eh_info;
5480 ap->print_id, qc->tf.protocol, ap->hsm_task_state);
5483 switch (ap->hsm_task_state) {
5500 host_stat = ap->ops->bmdma_status(ap);
5502 ap->print_id, host_stat);
5509 ap->ops->bmdma_stop(qc);
5514 ap->hsm_task_state = HSM_ST_ERR;
5525 status = ata_altstatus(ap);
5530 status = ata_chk_status(ap);
5535 ap->ops->irq_clear(ap);
5537 ata_hsm_move(ap, qc, status, 0);
5546 ap->stats.idle_irq++;
5549 if ((ap->stats.idle_irq % 1000) == 0) {
5550 ap->ops->irq_ack(ap, 0); /* debug trap */
5551 ata_port_printk(ap, KERN_WARNING, "irq trap\n");
5584 struct ata_port *ap;
5586 ap = host->ports[i];
5587 if (ap &&
5588 !(ap->flags & ATA_FLAG_DISABLED)) {
5591 qc = ata_qc_from_tag(ap, ap->active_tag);
5594 handled |= ata_host_intr(ap, qc);
5605 * @ap: ATA port to test SCR accessibility for
5607 * Test whether SCRs are accessible for @ap.
5615 int sata_scr_valid(struct ata_port *ap)
5617 return ap->cbl == ATA_CBL_SATA && ap->ops->scr_read;
5622 * @ap: ATA port to read SCR for
5626 * Read SCR register @reg of @ap into *@val. This function is
5636 int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
5638 if (sata_scr_valid(ap)) {
5639 *val = ap->ops->scr_read(ap, reg);
5647 * @ap: ATA port to write SCR for
5651 * Write @val to SCR register @reg of @ap. This function is
5661 int sata_scr_write(struct ata_port *ap, int reg, u32 val)
5663 if (sata_scr_valid(ap)) {
5664 ap->ops->scr_write(ap, reg, val);
5672 * @ap: ATA port to write SCR for
5685 int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
5687 if (sata_scr_valid(ap)) {
5688 ap->ops->scr_write(ap, reg, val);
5689 ap->ops->scr_read(ap, reg);
5697 * @ap: ATA port to test
5699 * Test whether @ap is online. Note that this function returns 0
5700 * if online status of @ap cannot be obtained, so
5701 * ata_port_online(ap) != !ata_port_offline(ap).
5709 int ata_port_online(struct ata_port *ap)
5713 if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3)
5720 * @ap: ATA port to test
5722 * Test whether @ap is offline. Note that this function returns
5723 * 0 if offline status of @ap cannot be obtained, so
5724 * ata_port_online(ap) != !ata_port_offline(ap).
5732 int ata_port_offline(struct ata_port *ap)
5736 if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3)
5772 struct ata_port *ap = host->ports[i];
5777 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
5778 ata_port_wait_eh(ap);
5779 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5783 spin_lock_irqsave(ap->lock, flags);
5785 ap->pm_mesg = mesg;
5788 ap->pm_result = &rc;
5791 ap->pflags |= ATA_PFLAG_PM_PENDING;
5792 ap->eh_info.action |= action;
5793 ap->eh_info.flags |= ehi_flags;
5795 ata_port_schedule_eh(ap);
5797 spin_unlock_irqrestore(ap->lock, flags);
5801 ata_port_wait_eh(ap);
5802 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5857 * @ap: Port to initialize
5867 int ata_port_start(struct ata_port *ap)
5869 struct device *dev = ap->dev;
5872 ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma,
5874 if (!ap->prd)
5877 rc = ata_pad_alloc(ap, dev);
5881 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd,
5882 (unsigned long long)ap->prd_dma);
5897 struct ata_port *ap = dev->ap;
5901 ap->sata_spd_limit = ap->hw_sata_spd_limit;
5907 spin_lock_irqsave(ap->lock, flags);
5909 spin_unlock_irqrestore(ap->lock, flags);
5932 struct ata_port *ap;
5937 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
5938 if (!ap)
5941 ap->pflags |= ATA_PFLAG_INITIALIZING;
5942 ap->lock = &host->lock;
5943 ap->flags = ATA_FLAG_DISABLED;
5944 ap->print_id = -1;
5945 ap->ctl = ATA_DEVCTL_OBS;
5946 ap->host = host;
5947 ap->dev = host->dev;
5949 ap->hw_sata_spd_limit = UINT_MAX;
5950 ap->active_tag = ATA_TAG_POISON;
5951 ap->last_ctl = 0xFF;
5955 ap->msg_enable = 0x00FF;
5957 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
5959 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
5962 INIT_DELAYED_WORK(&ap->port_task, NULL);
5963 INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
5964 INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
5965 INIT_LIST_HEAD(&ap->eh_done_q);
5966 init_waitqueue_head(&ap->eh_wait_q);
5968 ap->cbl = ATA_CBL_NONE;
5971 struct ata_device *dev = &ap->device[i];
5972 dev->ap = ap;
5978 ap->stats.unhandled_irq = 1;
5979 ap->stats.idle_irq = 1;
5981 return ap;
5990 struct ata_port *ap = host->ports[i];
5992 if (!ap)
5995 if ((host->flags & ATA_HOST_STARTED) && ap->ops->port_stop)
5996 ap->ops->port_stop(ap);
6003 struct ata_port *ap = host->ports[i];
6005 if (!ap)
6008 if (ap->scsi_host)
6009 scsi_host_put(ap->scsi_host);
6011 kfree(ap);
6065 struct ata_port *ap;
6067 ap = ata_port_alloc(host);
6068 if (!ap)
6071 ap->port_no = i;
6072 host->ports[i] = ap;
6112 struct ata_port *ap = host->ports[i];
6117 ap->pio_mask = pi->pio_mask;
6118 ap->mwdma_mask = pi->mwdma_mask;
6119 ap->udma_mask = pi->udma_mask;
6120 ap->flags |= pi->flags;
6121 ap->ops = pi->port_ops;
6156 struct ata_port *ap = host->ports[i];
6158 if (!host->ops && !ata_port_is_dummy(ap))
6159 host->ops = ap->ops;
6161 if (ap->ops->port_start) {
6162 rc = ap->ops->port_start(ap);
6164 ata_port_printk(ap, KERN_ERR, "failed to "
6170 ata_eh_freeze_port(ap);
6178 struct ata_port *ap = host->ports[i];
6180 if (ap->ops->port_stop)
6181 ap->ops->port_stop(ap);
6252 struct ata_port *ap = host->ports[i];
6258 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
6259 ap->cbl = ATA_CBL_SATA;
6262 if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
6265 ap->hw_sata_spd_limit &= (1 << spd) - 1;
6267 ap->sata_spd_limit = ap->hw_sata_spd_limit;
6274 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
6275 ap->udma_mask);
6278 if (!ata_port_is_dummy(ap))
6279 ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%p "
6281 ap->cbl == ATA_CBL_SATA ? 'S' : 'P',
6283 ap->ioaddr.cmd_addr,
6284 ap->ioaddr.ctl_addr,
6285 ap->ioaddr.bmdma_addr,
6288 ata_port_printk(ap, KERN_INFO, "DUMMY\n");
6294 struct ata_port *ap = host->ports[i];
6298 if (ap->ops->error_handler) {
6299 struct ata_eh_info *ehi = &ap->eh_info;
6302 ata_port_probe(ap);
6305 spin_lock_irqsave(ap->lock, flags);
6311 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
6312 ap->pflags |= ATA_PFLAG_LOADING;
6313 ata_port_schedule_eh(ap);
6315 spin_unlock_irqrestore(ap->lock, flags);
6318 ata_port_wait_eh(ap);
6320 DPRINTK("ata%u: bus probe begin\n", ap->print_id);
6321 rc = ata_bus_probe(ap);
6322 DPRINTK("ata%u: bus probe end\n", ap->print_id);
6332 struct ata_port *ap = host->ports[i];
6334 ata_scsi_scan_host(ap);
6387 * @ap: ATA port to be detached
6389 * Detach all ATA devices and the associated SCSI devices of @ap;
6390 * then, remove the associated SCSI host. @ap is guaranteed to
6396 void ata_port_detach(struct ata_port *ap)
6401 if (!ap->ops->error_handler)
6405 spin_lock_irqsave(ap->lock, flags);
6406 ap->pflags |= ATA_PFLAG_UNLOADING;
6407 spin_unlock_irqrestore(ap->lock, flags);
6409 ata_port_wait_eh(ap);
6414 spin_lock_irqsave(ap->lock, flags);
6417 ata_dev_disable(&ap->device[i]);
6419 spin_unlock_irqrestore(ap->lock, flags);
6425 spin_lock_irqsave(ap->lock, flags);
6426 ata_port_freeze(ap); /* won't be thawed */
6427 spin_unlock_irqrestore(ap->lock, flags);
6429 ata_port_wait_eh(ap);
6434 cancel_work_sync(&ap->hotplug_task.work); /* akpm: why? */
6435 cancel_delayed_work(&ap->hotplug_task);
6436 cancel_work_sync(&ap->hotplug_task.work);
6440 scsi_remove_host(ap->scsi_host);
6695 static void ata_dummy_noret(struct ata_port *ap) { }
6696 static int ata_dummy_ret0(struct ata_port *ap) { return 0; }
6699 static u8 ata_dummy_check_status(struct ata_port *ap)