Lines Matching defs:link
115 MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/admin-guide/kernel-parameters.rst for details)");
165 struct ata_eh_context *ehc = &dev->link->eh_context;
176 * ata_link_next - link iteration helper
177 * @link: the previous link, NULL to start
185 * Pointer to the next link.
187 struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
193 /* NULL link indicates start of iteration */
194 if (!link)
202 return &ap->link;
205 /* we just iterated over the host link, what's next? */
206 if (link == &ap->link)
221 if (unlikely(link == ap->slave_link))
224 /* we were over a PMP link */
225 if (++link < ap->pmp_link + ap->nr_pmp_links)
226 return link;
229 return &ap->link;
238 * @link: ATA link containing devices to iterate
247 struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link,
258 dev = link->device;
262 dev = link->device + ata_link_max_devices(link) - 1;
271 if (++dev < link->device + ata_link_max_devices(link))
276 if (--dev >= link->device)
290 * ata_dev_phys_link - find physical link for a device
291 * @dev: ATA device to look up physical link for
293 * Look up physical link which @dev is attached to. Note that
294 * this is different from @dev->link only when @dev is on slave
295 * link. For all other cases, it's the same as @dev->link.
301 * Pointer to the found physical link.
305 struct ata_port *ap = dev->link->ap;
308 return dev->link;
310 return &ap->link;
348 * ata_force_link_limits - force link limits according to libata.force
349 * @link: ATA link of interest
351 * Force link flags and SATA spd limit according to libata.force
354 * the host link and all fan-out ports connected via PMP. If the
356 * first fan-out link not the host link. Device number 15 always
357 * points to the host link whether PMP is attached or not. If the
358 * controller has slave link, device number 16 points to it.
363 static void ata_force_link_limits(struct ata_link *link)
366 int linkno = link->pmp;
369 if (ata_is_host_link(link))
375 if (fe->port != -1 && fe->port != link->ap->print_id)
383 link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
384 ata_link_notice(link, "FORCE: PHY spd limit set to %s\n",
391 link->flags |= fe->param.lflags_on;
392 ata_link_notice(link,
393 "FORCE: link flag 0x%x forced -> 0x%x\n",
394 fe->param.lflags_on, link->flags);
397 link->flags &= ~fe->param.lflags_off;
398 ata_link_notice(link,
399 "FORCE: link flag 0x%x cleared -> 0x%x\n",
400 fe->param.lflags_off, link->flags);
410 * For consistency with link selection, device number 15 selects
411 * the first device connected to the host link.
418 int devno = dev->link->pmp + dev->devno;
423 if (ata_is_host_link(dev->link))
430 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
464 * For consistency with link selection, device number 15 selects
465 * the first device connected to the host link.
472 int devno = dev->link->pmp + dev->devno;
477 if (ata_is_host_link(dev->link))
483 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
502 static inline void ata_force_link_limits(struct ata_link *link) { }
601 } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
1509 struct ata_link *link = dev->link;
1510 struct ata_port *ap = link->ap;
1541 preempted_tag = link->active_tag;
1542 preempted_sactive = link->sactive;
1545 link->active_tag = ATA_TAG_POISON;
1546 link->sactive = 0;
1642 link->active_tag = preempted_tag;
1643 link->sactive = preempted_sactive;
1706 if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
1711 if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1792 struct ata_port *ap = dev->link->ap;
1987 unsigned long ap_flags = dev->link->ap->flags;
2088 unsigned long ap_flags = dev->link->ap->flags;
2126 if (!ata_port_is_frozen(dev->link->ap))
2139 struct ata_port *ap = dev->link->ap;
2151 struct ata_port *ap = dev->link->ap;
2208 /* Request another EH round by returning -EAGAIN if link is
2213 ata_dev_info(dev, "applying link speed limit horkage to %s\n",
2222 struct ata_port *ap = dev->link->ap;
2232 struct ata_port *ap = dev->link->ap;
2257 struct ata_port *ap = dev->link->ap;
2276 struct ata_port *ap = dev->link->ap;
2324 struct ata_port *ap = dev->link->ap;
2406 struct ata_port *ap = dev->link->ap;
2460 struct ata_port *ap = dev->link->ap;
2491 struct ata_port *ap = dev->link->ap;
2703 u8 *sata_setting = dev->link->ap->sector_buf;
2815 struct ata_port *ap = dev->link->ap;
2863 dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2988 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
3155 * sata_print_link_status - Print SATA link status
3156 * @link: SATA link to printk link status about
3158 * This function prints link speed and status of a SATA link.
3163 static void sata_print_link_status(struct ata_link *link)
3167 if (sata_scr_read(link, SCR_STATUS, &sstatus))
3169 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
3172 if (ata_phys_link_online(link)) {
3174 ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
3177 ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
3192 struct ata_link *link = adev->link;
3193 struct ata_device *pair = &link->device[1 - adev->devno];
3202 * @link: Link to adjust SATA spd limit for
3205 * Adjust SATA spd limit of @link downward. Note that this
3220 int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
3225 if (!sata_scr_valid(link))
3229 * If not, use cached value in link->sata_spd.
3231 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
3235 spd = link->sata_spd;
3237 mask = link->sata_spd_limit;
3248 * recorded the link speed from SStatus, the driver has already
3250 * Otherwise, we should not force 1.5Gbps on a link where we have
3256 else if (link->sata_spd)
3272 link->sata_spd_limit = mask;
3274 ata_link_warn(link, "limiting SATA link speed to %s\n",
3424 struct ata_port *ap = dev->link->ap;
3425 struct ata_eh_context *ehc = &dev->link->eh_context;
3507 * @link: link on which timings will be programmed
3522 int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3524 struct ata_port *ap = link->ap;
3529 ata_for_each_dev(dev, link, ENABLED) {
3561 ata_for_each_dev(dev, link, ENABLED) {
3575 ata_for_each_dev(dev, link, ENABLED) {
3586 ata_for_each_dev(dev, link, ENABLED) {
3606 * ata_wait_ready - wait for link to become ready
3607 * @link: link to be waited on
3609 * @check_ready: callback to check link readiness
3611 * Wait for @link to become ready. @check_ready should return
3612 * positive number if @link is ready, 0 if it isn't, -ENODEV if
3613 * link doesn't seem to be occupied, other errno for other error
3623 * 0 if @link is ready before @deadline; otherwise, -errno.
3625 int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3626 int (*check_ready)(struct ata_link *link))
3633 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3642 WARN_ON(link == link->ap->slave_link);
3651 ready = tmp = check_ready(link);
3656 * -ENODEV could be transient. Ignore -ENODEV if link
3659 * ATA_TMOUT_FF_WAIT[_LONG] on -ENODEV if link isn't
3667 if (ata_link_online(link))
3669 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3670 !ata_link_offline(link) &&
3682 ata_link_warn(link,
3683 "link is slow to respond, please be patient "
3688 ata_msleep(link->ap, 50);
3693 * ata_wait_after_reset - wait for link to become ready after reset
3694 * @link: link to be waited on
3696 * @check_ready: callback to check link readiness
3698 * Wait for @link to become ready after reset.
3704 * 0 if @link is ready before @deadline; otherwise, -errno.
3706 int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
3707 int (*check_ready)(struct ata_link *link))
3709 ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
3711 return ata_wait_ready(link, deadline, check_ready);
3717 * @link: ATA link to be reset
3720 * @link is about to be reset. Initialize it. Failure from
3732 int ata_std_prereset(struct ata_link *link, unsigned long deadline)
3734 struct ata_port *ap = link->ap;
3735 struct ata_eh_context *ehc = &link->eh_context;
3743 /* if SATA, resume link */
3745 rc = sata_link_resume(link, timing, deadline);
3748 ata_link_warn(link,
3749 "failed to resume link for reset (errno=%d)\n",
3753 /* no point in trying softreset on offline link */
3754 if (ata_phys_link_offline(link))
3763 * @link: link to reset
3773 * 0 if link offline, -EAGAIN if link online, -errno on errors.
3775 int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3778 const unsigned int *timing = sata_ehc_deb_timing(&link->eh_context);
3783 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
3790 * @link: the target ata_link
3800 void ata_std_postreset(struct ata_link *link, unsigned int *classes)
3805 if (!sata_scr_read(link, SCR_ERROR, &serror))
3806 sata_scr_write(link, SCR_ERROR, serror);
3808 /* print link status */
3809 sata_print_link_status(link);
3879 u16 *id = (void *)dev->link->ap->sector_buf;
4119 /* Devices which aren't very happy with higher link speeds */
4228 * Some WD SATA-I drives spin up and down erratically when the link
4288 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4324 struct ata_link *link;
4351 ata_for_each_link(link, ap, EDGE) {
4352 ata_for_each_dev(dev, link, ENABLED) {
4374 struct ata_link *link = dev->link;
4375 struct ata_port *ap = link->ap;
4610 struct ata_link *link = qc->dev->link;
4613 if (!ata_tag_valid(link->active_tag))
4616 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4755 struct ata_link *link;
4760 link = qc->dev->link;
4767 link->sactive &= ~(1 << qc->hw_tag);
4768 if (!link->sactive)
4771 link->active_tag = ATA_TAG_POISON;
4777 ap->excl_link == link))
4831 struct ata_eh_info *ehi = &dev->link->eh_info;
4966 struct ata_link *link = qc->dev->link;
4970 WARN_ON_ONCE(ata_tag_valid(link->active_tag));
4973 WARN_ON_ONCE(link->sactive & (1 << qc->hw_tag));
4975 if (!link->sactive)
4977 link->sactive |= 1 << qc->hw_tag;
4979 WARN_ON_ONCE(link->sactive);
4982 link->active_tag = qc->tag;
5000 /* if device is sleeping, schedule reset and abort the link */
5002 link->eh_info.action |= ATA_EH_RESET;
5003 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
5004 ata_link_abort(link);
5025 * ata_phys_link_online - test whether the given link is online
5026 * @link: ATA link to test
5028 * Test whether @link is online. Note that this function returns
5029 * 0 if online status of @link cannot be obtained, so
5030 * ata_link_online(link) != !ata_link_offline(link).
5038 bool ata_phys_link_online(struct ata_link *link)
5042 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
5049 * ata_phys_link_offline - test whether the given link is offline
5050 * @link: ATA link to test
5052 * Test whether @link is offline. Note that this function
5053 * returns 0 if offline status of @link cannot be obtained, so
5054 * ata_link_online(link) != !ata_link_offline(link).
5062 bool ata_phys_link_offline(struct ata_link *link)
5066 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
5073 * ata_link_online - test whether the given link is online
5074 * @link: ATA link to test
5076 * Test whether @link is online. This is identical to
5077 * ata_phys_link_online() when there's no slave link. When
5078 * there's a slave link, this function should only be called on
5079 * the master link and will return true if any of M/S links is
5088 bool ata_link_online(struct ata_link *link)
5090 struct ata_link *slave = link->ap->slave_link;
5092 WARN_ON(link == slave); /* shouldn't be called on slave link */
5094 return ata_phys_link_online(link) ||
5100 * ata_link_offline - test whether the given link is offline
5101 * @link: ATA link to test
5103 * Test whether @link is offline. This is identical to
5104 * ata_phys_link_offline() when there's no slave link. When
5105 * there's a slave link, this function should only be called on
5106 * the master link and will return true if both M/S links are
5115 bool ata_link_offline(struct ata_link *link)
5117 struct ata_link *slave = link->ap->slave_link;
5119 WARN_ON(link == slave); /* shouldn't be called on slave link */
5121 return ata_phys_link_offline(link) &&
5131 struct ata_link *link;
5149 ata_for_each_link(link, ap, HOST_FIRST) {
5150 link->eh_info.action |= action;
5151 link->eh_info.flags |= ehi_flags;
5260 struct ata_link *link;
5263 ata_for_each_link(link, ap, HOST_FIRST) {
5264 ata_for_each_dev(adev, link, ENABLED)
5359 struct ata_link *link = ata_dev_phys_link(dev);
5360 struct ata_port *ap = link->ap;
5364 link->sata_spd_limit = link->hw_sata_spd_limit;
5365 link->sata_spd = 0;
5385 * @ap: ATA port link is attached to
5386 * @link: Link structure to initialize
5389 * Initialize @link.
5394 void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
5399 memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
5402 link->ap = ap;
5403 link->pmp = pmp;
5404 link->active_tag = ATA_TAG_POISON;
5405 link->hw_sata_spd_limit = UINT_MAX;
5409 struct ata_device *dev = &link->device[i];
5411 dev->link = link;
5412 dev->devno = dev - link->device;
5421 * sata_link_init_spd - Initialize link->sata_spd_limit
5422 * @link: Link to configure sata_spd_limit for
5424 * Initialize ``link->[hw_]sata_spd_limit`` to the currently
5433 int sata_link_init_spd(struct ata_link *link)
5438 rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol);
5442 spd = (link->saved_scontrol >> 4) & 0xf;
5444 link->hw_sata_spd_limit &= (1 << spd) - 1;
5446 ata_force_link_limits(link);
5448 link->sata_spd_limit = link->hw_sata_spd_limit;
5491 ata_link_init(ap, &ap->link, 0);
5660 ap->link.flags |= pi->link_flags;
5841 struct ata_eh_info *ehi = &ap->link.eh_info;
5946 sata_link_init_spd(&ap->link);
5958 ap->link.eh_info.desc);
5959 ata_ehi_clear_desc(&ap->link.eh_info);
6058 struct ata_link *link;
6068 ata_for_each_link(link, ap, HOST_FIRST) {
6069 ata_for_each_dev(dev, link, ALL) {
6096 ata_for_each_link(link, ap, HOST_FIRST) {
6097 ata_for_each_dev(dev, link, ALL) {
6437 *reason = "invalid port/link";