Lines Matching refs:ap
168 * @ap: ATA port containing links to iterate
177 struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
188 if (sata_pmp_attached(ap))
189 return ap->pmp_link;
192 return &ap->link;
196 if (link == &ap->link)
199 if (sata_pmp_attached(ap))
200 return ap->pmp_link;
203 if (unlikely(ap->slave_link))
204 return ap->slave_link;
211 if (unlikely(link == ap->slave_link))
215 if (++link < ap->pmp_link + ap->nr_pmp_links)
219 return &ap->link;
295 struct ata_port *ap = dev->link->ap;
297 if (!ap->slave_link)
300 return &ap->link;
301 return ap->slave_link;
307 * @ap: ATA port of interest
318 void ata_force_cbl(struct ata_port *ap)
325 if (fe->port != -1 && fe->port != ap->print_id)
331 ap->cbl = fe->param.cbl;
332 ata_port_notice(ap, "FORCE: cable set to %s\n", fe->param.name);
339 * @ap: ATA port of interest
346 static void ata_force_pflags(struct ata_port *ap)
353 if (fe->port != -1 && fe->port != ap->print_id)
358 ap->pflags |= fe->param.pflags_on;
359 ata_port_notice(ap,
361 fe->param.pflags_on, ap->pflags);
394 if (fe->port != -1 && fe->port != link->ap->print_id)
449 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
492 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
533 static inline void ata_force_pflags(struct ata_port *ap) { }
633 } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
1542 struct ata_port *ap = link->ap;
1543 const bool owns_eh_mutex = ap->host->eh_owner == current;
1560 spin_lock_irqsave(ap->lock, flags);
1563 if (ata_port_is_frozen(ap)) {
1564 spin_unlock_irqrestore(ap->lock, flags);
1569 qc = __ata_qc_from_tag(ap, ATA_TAG_INTERNAL);
1574 qc->ap = ap;
1580 preempted_qc_active = ap->qc_active;
1581 preempted_nr_active_links = ap->nr_active_links;
1584 ap->qc_active = 0;
1585 ap->nr_active_links = 0;
1608 ata_qc_issue(ap, qc);
1610 spin_unlock_irqrestore(ap->lock, flags);
1626 __acquire(&ap->host->eh_mutex);
1627 ata_eh_release(ap);
1633 ata_eh_acquire(ap);
1638 __release(&ap->host->eh_mutex);
1641 ata_sff_flush_pio_task(ap);
1649 spin_lock_irqsave(ap->lock, flags);
1652 ata_port_freeze(ap);
1656 spin_unlock_irqrestore(ap->lock, flags);
1659 if (ap->ops->post_internal_cmd)
1660 ap->ops->post_internal_cmd(qc);
1677 spin_lock_irqsave(ap->lock, flags);
1685 ap->qc_active = preempted_qc_active;
1686 ap->nr_active_links = preempted_nr_active_links;
1688 spin_unlock_irqrestore(ap->lock, flags);
1709 if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
1714 if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1795 struct ata_port *ap = dev->link->ap;
1836 if (ap->ops->read_id)
1837 err_mask = ap->ops->read_id(dev, &tf, (__le16 *)id);
1907 if (ap->host->flags & ATA_HOST_IGNORE_ATA &&
2046 unsigned long ap_flags = dev->link->ap->flags;
2137 unsigned long ap_flags = dev->link->ap->flags;
2175 if (!ata_port_is_frozen(dev->link->ap))
2297 struct ata_port *ap = dev->link->ap;
2302 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
2390 bool ata_adapter_is_online(struct ata_port *ap)
2394 if (!ap || !ap->host)
2397 dev = ap->host->dev;
2411 struct ata_port *ap = dev->link->ap;
2433 if (ap->flags & ATA_FLAG_NCQ) {
2434 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE);
2439 (ap->flags & ATA_FLAG_FPDMA_AA) &&
2461 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
2957 struct ata_port *ap = dev->link->ap;
2960 if (ap->flags & ATA_FLAG_NO_LPM) {
2983 ap->target_lpm_policy != ATA_LPM_MAX_POWER) {
2985 ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2995 if (ap->flags & ATA_FLAG_NO_DIPM && ata_id_has_dipm(dev->id)) {
3042 struct ata_port *ap = dev->link->ap;
3070 if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
3215 (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
3216 (!sata_pmp_attached(ap) ||
3217 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
3290 if (ap->ops->dev_config)
3291 ap->ops->dev_config(dev);
3321 * @ap: port
3327 int ata_cable_40wire(struct ata_port *ap)
3335 * @ap: port
3341 int ata_cable_80wire(struct ata_port *ap)
3349 * @ap: port
3354 int ata_cable_unknown(struct ata_port *ap)
3362 * @ap: port
3367 int ata_cable_ignore(struct ata_port *ap)
3375 * @ap: port
3380 int ata_cable_sata(struct ata_port *ap)
3576 struct ata_port *ap = dev->link->ap;
3588 if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
3676 struct ata_port *ap = link->ap;
3722 if (ap->ops->set_piomode)
3723 ap->ops->set_piomode(ap, dev);
3733 if (ap->ops->set_dmamode)
3734 ap->ops->set_dmamode(ap, dev);
3747 if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
3748 ap->host->simplex_claimed = ap;
3785 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3794 WARN_ON(link == link->ap->slave_link);
3821 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3840 ata_msleep(link->ap, 50);
3861 ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
3886 struct ata_port *ap = link->ap;
3896 if (ap->flags & ATA_FLAG_SATA) {
4586 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4609 * @ap: port to consider
4613 * there is a good case for setting ap->cbl to the result when
4620 static int cable_is_40wire(struct ata_port *ap)
4626 if (ap->cbl == ATA_CBL_PATA40)
4630 if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA)
4637 if (ap->cbl == ATA_CBL_PATA40_SHORT)
4649 ata_for_each_link(link, ap, EDGE) {
4672 struct ata_port *ap = link->ap;
4673 struct ata_host *host = ap->host;
4677 xfer_mask = ata_pack_xfermask(ap->pio_mask,
4678 ap->mwdma_mask, ap->udma_mask);
4703 host->simplex_claimed && host->simplex_claimed != ap) {
4709 if (ap->flags & ATA_FLAG_NO_IORDY)
4712 if (ap->ops->mode_filter)
4713 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
4725 if (cable_is_40wire(ap)) {
4740 * on port @ap.
4786 * Issue SET FEATURES command to device @dev on port @ap with sector count
4875 struct ata_port *ap = qc->ap;
4884 if (ap->ops->check_atapi_dma)
4885 return ap->ops->check_atapi_dma(qc);
4955 struct ata_port *ap = qc->ap;
4962 dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
4983 struct ata_port *ap = qc->ap;
4986 n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
5045 struct ata_port *ap;
5051 ap = qc->ap;
5061 ap->nr_active_links--;
5064 ap->nr_active_links--;
5069 ap->excl_link == link))
5070 ap->excl_link = NULL;
5078 ap->qc_active &= ~(1ULL << qc->tag);
5086 struct ata_port *ap = qc->ap;
5096 ap->ops->qc_fill_rtf(qc);
5130 struct ata_port *ap = qc->ap;
5167 WARN_ON_ONCE(ata_port_is_frozen(ap));
5195 ap->pflags |= ATA_PFLAG_EH_PENDING;
5213 ata_port_schedule_eh(ap);
5230 * @ap: port in question
5238 u64 ata_qc_get_active(struct ata_port *ap)
5240 u64 qc_active = ap->qc_active;
5254 * @ap: ATA port of interest
5265 void ata_qc_issue(struct ata_port *ap, struct ata_queued_cmd *qc)
5266 __must_hold(ap->lock)
5283 ap->nr_active_links++;
5288 ap->nr_active_links++;
5293 ap->qc_active |= 1ULL << qc->tag;
5296 if (!ata_adapter_is_online(ap)) {
5309 (ap->flags & ATA_FLAG_PIO_DMA)))
5321 if (ap->ops->qc_prep) {
5323 qc->err_mask |= ap->ops->qc_prep(qc);
5329 qc->err_mask |= ap->ops->qc_issue(qc);
5406 struct ata_link *slave = link->ap->slave_link;
5433 struct ata_link *slave = link->ap->slave_link;
5443 static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
5450 spin_lock_irqsave(ap->lock, flags);
5456 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
5457 spin_unlock_irqrestore(ap->lock, flags);
5458 ata_port_wait_eh(ap);
5459 spin_lock_irqsave(ap->lock, flags);
5463 ap->pm_mesg = mesg;
5464 ap->pflags |= ATA_PFLAG_PM_PENDING;
5465 ata_for_each_link(link, ap, HOST_FIRST) {
5470 ata_port_schedule_eh(ap);
5472 spin_unlock_irqrestore(ap->lock, flags);
5475 ata_port_wait_eh(ap);
5478 static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg,
5487 cancel_delayed_work_sync(&ap->scsi_rescan_task);
5497 ata_port_request_pm(ap, mesg, 0,
5505 struct ata_port *ap = to_ata_port(dev);
5510 ata_port_suspend(ap, PMSG_SUSPEND, false);
5516 struct ata_port *ap = to_ata_port(dev);
5521 ata_port_suspend(ap, PMSG_FREEZE, false);
5532 static void ata_port_resume(struct ata_port *ap, pm_message_t mesg,
5535 ata_port_request_pm(ap, mesg, ATA_EH_RESET,
5557 struct ata_port *ap = to_ata_port(dev);
5561 ata_for_each_link(link, ap, HOST_FIRST) {
5601 void ata_sas_port_suspend(struct ata_port *ap)
5603 ata_port_suspend(ap, PMSG_SUSPEND, true);
5607 void ata_sas_port_resume(struct ata_port *ap)
5609 ata_port_resume(ap, PMSG_RESUME, true);
5658 struct ata_port *ap = link->ap;
5669 spin_lock_irqsave(ap->lock, flags);
5672 spin_unlock_irqrestore(ap->lock, flags);
5683 * @ap: ATA port link is attached to
5692 void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
5700 link->ap = ap;
5706 /* can't use iterator, ap isn't initialized yet */
5766 struct ata_port *ap;
5769 ap = kzalloc_obj(*ap);
5770 if (!ap)
5773 ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
5774 ap->lock = &host->lock;
5777 kfree(ap);
5780 ap->print_id = id;
5781 ap->host = host;
5782 ap->dev = host->dev;
5784 mutex_init(&ap->scsi_scan_mutex);
5785 INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
5786 INIT_DELAYED_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
5787 INIT_LIST_HEAD(&ap->eh_done_q);
5788 init_waitqueue_head(&ap->eh_wait_q);
5789 init_completion(&ap->park_req_pending);
5790 timer_setup(&ap->fastdrain_timer, ata_eh_fastdrain_timerfn,
5793 ap->cbl = ATA_CBL_NONE;
5795 ata_link_init(ap, &ap->link, 0);
5798 ap->stats.unhandled_irq = 1;
5799 ap->stats.idle_irq = 1;
5801 ata_sff_port_init(ap);
5803 ata_force_pflags(ap);
5805 return ap;
5809 void ata_port_free(struct ata_port *ap)
5811 if (!ap)
5814 kfree(ap->pmp_link);
5815 kfree(ap->slave_link);
5816 ida_free(&ata_ida, ap->print_id);
5817 kfree(ap);
5827 struct ata_port *ap = host->ports[i];
5829 if (!ap)
5832 if (ap->scsi_host)
5833 scsi_host_put(ap->scsi_host);
5914 struct ata_port *ap;
5916 ap = ata_port_alloc(host);
5917 if (!ap)
5920 ap->port_no = i;
5921 host->ports[i] = ap;
5962 struct ata_port *ap = host->ports[i];
5967 ap->pio_mask = pi->pio_mask;
5968 ap->mwdma_mask = pi->mwdma_mask;
5969 ap->udma_mask = pi->udma_mask;
5970 ap->flags |= pi->flags;
5971 ap->link.flags |= pi->link_flags;
5972 ap->ops = pi->port_ops;
5990 struct ata_port *ap = host->ports[i];
5992 if (ap->ops->port_stop)
5993 ap->ops->port_stop(ap);
6078 struct ata_port *ap = host->ports[i];
6080 ata_finalize_port_ops(ap->ops);
6082 if (!host->ops && !ata_port_is_dummy(ap))
6083 host->ops = ap->ops;
6085 if (ap->ops->port_stop)
6099 struct ata_port *ap = host->ports[i];
6101 if (ap->ops->port_start) {
6102 rc = ap->ops->port_start(ap);
6111 ata_eh_freeze_port(ap);
6121 struct ata_port *ap = host->ports[i];
6123 if (ap->ops->port_stop)
6124 ap->ops->port_stop(ap);
6150 void ata_port_probe(struct ata_port *ap)
6152 struct ata_eh_info *ehi = &ap->link.eh_info;
6155 ata_acpi_port_power_on(ap);
6158 spin_lock_irqsave(ap->lock, flags);
6164 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
6165 ap->pflags |= ATA_PFLAG_LOADING;
6166 ata_port_schedule_eh(ap);
6168 spin_unlock_irqrestore(ap->lock, flags);
6174 struct ata_port *ap = data;
6183 if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
6186 ata_port_probe(ap);
6187 ata_port_wait_eh(ap);
6192 ata_scsi_scan_host(ap, 1);
6238 struct ata_port *ap = host->ports[i];
6242 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
6243 ap->cbl = ATA_CBL_SATA;
6246 sata_link_init_spd(&ap->link);
6247 if (ap->slave_link)
6248 sata_link_init_spd(ap->slave_link);
6251 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
6252 ap->udma_mask);
6254 if (!ata_port_is_dummy(ap)) {
6255 ata_port_info(ap, "%cATA max %s %s\n",
6256 (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
6258 ap->link.eh_info.desc);
6259 ata_ehi_clear_desc(&ap->link.eh_info);
6261 ata_port_info(ap, "DUMMY\n");
6266 struct ata_port *ap = host->ports[i];
6267 ap->cookie = async_schedule(async_port_probe, ap);
6363 * @ap: ATA port to be detached
6365 * Detach all ATA devices and the associated SCSI devices of @ap;
6366 * then, remove the associated SCSI host. @ap is guaranteed to
6372 static void ata_port_detach(struct ata_port *ap)
6379 async_synchronize_cookie(ap->cookie + 1);
6382 ata_port_wait_eh(ap);
6384 mutex_lock(&ap->scsi_scan_mutex);
6385 spin_lock_irqsave(ap->lock, flags);
6388 ata_for_each_link(link, ap, HOST_FIRST) {
6391 spin_unlock_irqrestore(ap->lock, flags);
6393 spin_lock_irqsave(ap->lock, flags);
6400 ap->pflags |= ATA_PFLAG_UNLOADING;
6401 ata_port_schedule_eh(ap);
6403 spin_unlock_irqrestore(ap->lock, flags);
6404 mutex_unlock(&ap->scsi_scan_mutex);
6407 ata_port_wait_eh(ap);
6410 WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
6412 cancel_delayed_work_sync(&ap->hotplug_task);
6413 cancel_delayed_work_sync(&ap->scsi_rescan_task);
6415 ata_for_each_link(link, ap, PMP_FIRST) {
6421 if (ap->pmp_link) {
6425 ata_tlink_delete(&ap->pmp_link[i]);
6429 scsi_remove_host(ap->scsi_host);
6430 ata_tport_delete(ap);
6481 struct ata_port *ap = host->ports[i];
6483 ap->pflags |= ATA_PFLAG_FROZEN;
6486 if (ap->ops->freeze)
6487 ap->ops->freeze(ap);
6490 if (ap->ops->port_stop)
6491 ap->ops->port_stop(ap);
6927 * @ap: ATA port to attribute the sleep to
6930 * Sleeps @msecs. If the current task is owner of @ap's EH, the
6933 * @ap->host will be allowed to own the EH while this task is
6939 void ata_msleep(struct ata_port *ap, unsigned int msecs)
6942 bool owns_eh = ap && ap->host->eh_owner == current;
6945 ata_eh_release(ap);
6955 ata_eh_acquire(ap);
6961 * @ap: ATA port to wait register for, can be NULL
6983 u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
6998 ata_msleep(ap, interval);
7014 static void ata_dummy_error_handler(struct ata_port *ap)
7015 __must_hold(&ap->host->eh_mutex)