Lines Matching defs:link
123 MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/kernel-parameters.txt for details)");
177 * ata_link_next - link iteration helper
178 * @link: the previous link, NULL to start
186 * Pointer to the next link.
188 struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
194 /* NULL link indicates start of iteration */
195 if (!link)
203 return &ap->link;
206 /* we just iterated over the host link, what's next? */
207 if (link == &ap->link)
222 if (unlikely(link == ap->slave_link))
225 /* we were over a PMP link */
226 if (++link < ap->pmp_link + ap->nr_pmp_links)
227 return link;
230 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)
289 * ata_dev_phys_link - find physical link for a device
290 * @dev: ATA device to look up physical link for
292 * Look up physical link which @dev is attached to. Note that
293 * this is different from @dev->link only when @dev is on slave
294 * link. For all other cases, it's the same as @dev->link.
300 * Pointer to the found physical link.
304 struct ata_port *ap = dev->link->ap;
307 return dev->link;
309 return &ap->link;
347 * ata_force_link_limits - force link limits according to libata.force
348 * @link: ATA link of interest
350 * Force link flags and SATA spd limit according to libata.force
353 * the host link and all fan-out ports connected via PMP. If the
355 * first fan-out link not the host link. Device number 15 always
356 * points to the host link whether PMP is attached or not. If the
357 * controller has slave link, device number 16 points to it.
362 static void ata_force_link_limits(struct ata_link *link)
365 int linkno = link->pmp;
368 if (ata_is_host_link(link))
374 if (fe->port != -1 && fe->port != link->ap->print_id)
382 link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
383 ata_link_printk(link, KERN_NOTICE,
391 link->flags |= fe->param.lflags;
392 ata_link_printk(link, KERN_NOTICE,
393 "FORCE: link flag 0x%x forced -> 0x%x\n",
394 fe->param.lflags, link->flags);
404 * For consistency with link selection, device number 15 selects
405 * the first device connected to the host link.
412 int devno = dev->link->pmp + dev->devno;
417 if (ata_is_host_link(dev->link))
424 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
458 * For consistency with link selection, device number 15 selects
459 * the first device connected to the host link.
466 int devno = dev->link->pmp + dev->devno;
471 if (ata_is_host_link(dev->link))
477 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
661 } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
1035 struct ata_link *link = dev->link;
1036 struct ata_port *ap = link->ap;
1064 rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
1072 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
1085 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
1099 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
1119 * @policy: the link power management policy
1132 struct ata_port *ap = dev->link->ap;
1164 struct ata_port *ap = dev->link->ap;
1175 ap->link.eh_info.action |= ATA_EH_LPM;
1176 ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY;
1183 struct ata_link *link;
1190 ata_for_each_link(link, ap, EDGE) {
1191 ata_for_each_dev(dev, link, ALL)
1496 struct ata_eh_context *ehc = &dev->link->eh_context;
1708 struct ata_link *link = dev->link;
1709 struct ata_port *ap = link->ap;
1746 preempted_tag = link->active_tag;
1747 preempted_sactive = link->sactive;
1750 link->active_tag = ATA_TAG_POISON;
1751 link->sactive = 0;
1839 link->active_tag = preempted_tag;
1840 link->sactive = preempted_sactive;
1930 if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
1935 if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1993 struct ata_port *ap = dev->link->ap;
2193 /* Request another EH round by returning -EAGAIN if link is
2199 "applying link speed limit horkage to %s\n",
2208 struct ata_port *ap = dev->link->ap;
2219 struct ata_port *ap = dev->link->ap;
2276 struct ata_port *ap = dev->link->ap;
2277 struct ata_eh_context *ehc = &dev->link->eh_context;
2484 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
2555 /* reset link pm_policy for this port to no pm */
2677 ata_for_each_dev(dev, &ap->link, ALL)
2681 ata_for_each_dev(dev, &ap->link, ALL) {
2703 ata_for_each_dev(dev, &ap->link, ALL) {
2716 ata_for_each_dev(dev, &ap->link, ALL_REVERSE) {
2736 * of the link the bridge is which is a problem.
2738 ata_for_each_dev(dev, &ap->link, ENABLED)
2745 ata_for_each_dev(dev, &ap->link, ENABLED) {
2746 ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
2748 ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
2754 rc = ata_set_mode(&ap->link, &dev);
2758 ata_for_each_dev(dev, &ap->link, ENABLED)
2780 sata_down_spd_limit(&ap->link, 0);
2792 * sata_print_link_status - Print SATA link status
2793 * @link: SATA link to printk link status about
2795 * This function prints link speed and status of a SATA link.
2800 static void sata_print_link_status(struct ata_link *link)
2804 if (sata_scr_read(link, SCR_STATUS, &sstatus))
2806 sata_scr_read(link, SCR_CONTROL, &scontrol);
2808 if (ata_phys_link_online(link)) {
2810 ata_link_printk(link, KERN_INFO,
2811 "SATA link up %s (SStatus %X SControl %X)\n",
2814 ata_link_printk(link, KERN_INFO,
2815 "SATA link down (SStatus %X SControl %X)\n",
2830 struct ata_link *link = adev->link;
2831 struct ata_device *pair = &link->device[1 - adev->devno];
2839 * @link: Link to adjust SATA spd limit for
2842 * Adjust SATA spd limit of @link downward. Note that this
2857 int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
2862 if (!sata_scr_valid(link))
2866 * If not, use cached value in link->sata_spd.
2868 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
2872 spd = link->sata_spd;
2874 mask = link->sata_spd_limit;
2903 link->sata_spd_limit = mask;
2905 ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n",
2911 static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
2913 struct ata_link *host_link = &link->ap->link;
2916 limit = link->sata_spd_limit;
2918 /* Don't configure downstream link faster than upstream link.
2922 if (!ata_is_host_link(link) && host_link->sata_spd)
2938 * @link: Link in question
2941 * @link->sata_spd_limit. This function is used to determine
2951 static int sata_set_spd_needed(struct ata_link *link)
2955 if (sata_scr_read(link, SCR_CONTROL, &scontrol))
2958 return __sata_set_spd_needed(link, &scontrol);
2963 * @link: Link to set SATA spd for
2965 * Set SATA spd of @link according to sata_spd_limit.
2974 int sata_set_spd(struct ata_link *link)
2979 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
2982 if (!__sata_set_spd_needed(link, &scontrol))
2985 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3295 struct ata_port *ap = dev->link->ap;
3296 struct ata_eh_context *ehc = &dev->link->eh_context;
3377 * @link: link on which timings will be programmed
3392 int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3394 struct ata_port *ap = link->ap;
3399 ata_for_each_dev(dev, link, ENABLED) {
3431 ata_for_each_dev(dev, link, ENABLED) {
3445 ata_for_each_dev(dev, link, ENABLED) {
3456 ata_for_each_dev(dev, link, ENABLED) {
3475 * ata_wait_ready - wait for link to become ready
3476 * @link: link to be waited on
3478 * @check_ready: callback to check link readiness
3480 * Wait for @link to become ready. @check_ready should return
3481 * positive number if @link is ready, 0 if it isn't, -ENODEV if
3482 * link doesn't seem to be occupied, other errno for other error
3494 int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3495 int (*check_ready)(struct ata_link *link))
3502 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3511 WARN_ON(link == link->ap->slave_link);
3520 ready = tmp = check_ready(link);
3525 * -ENODEV could be transient. Ignore -ENODEV if link
3528 * ATA_TMOUT_FF_WAIT[_LONG] on -ENODEV if link isn't
3536 if (ata_link_online(link))
3538 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3539 !ata_link_offline(link) &&
3551 ata_link_printk(link, KERN_WARNING,
3552 "link is slow to respond, please be patient "
3562 * ata_wait_after_reset - wait for link to become ready after reset
3563 * @link: link to be waited on
3565 * @check_ready: callback to check link readiness
3567 * Wait for @link to become ready after reset.
3575 int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
3576 int (*check_ready)(struct ata_link *link))
3580 return ata_wait_ready(link, deadline, check_ready);
3585 * @link: ATA link to debounce SATA phy status for
3589 * Make sure SStatus of @link reaches stable state, determined by
3605 int sata_link_debounce(struct ata_link *link, const unsigned long *params,
3618 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
3627 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
3646 * -EPIPE to tell upper layer to lower link speed.
3654 * sata_link_resume - resume SATA link
3655 * @link: ATA link to resume SATA
3659 * Resume SATA phy @link and debounce it.
3667 int sata_link_resume(struct ata_link *link, const unsigned long *params,
3674 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3684 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3694 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3699 ata_link_printk(link, KERN_ERR,
3700 "failed to resume link (SControl %X)\n",
3706 ata_link_printk(link, KERN_WARNING,
3707 "link resume succeeded after %d retries\n",
3710 if ((rc = sata_link_debounce(link, params, deadline)))
3714 if (!(rc = sata_scr_read(link, SCR_ERROR, &serror)))
3715 rc = sata_scr_write(link, SCR_ERROR, serror);
3722 * @link: ATA link to be reset
3725 * @link is about to be reset. Initialize it. Failure from
3737 int ata_std_prereset(struct ata_link *link, unsigned long deadline)
3739 struct ata_port *ap = link->ap;
3740 struct ata_eh_context *ehc = &link->eh_context;
3748 /* if SATA, resume link */
3750 rc = sata_link_resume(link, timing, deadline);
3753 ata_link_printk(link, KERN_WARNING, "failed to resume "
3754 "link for reset (errno=%d)\n", rc);
3757 /* no point in trying softreset on offline link */
3758 if (ata_phys_link_offline(link))
3765 * sata_link_hardreset - reset link via SATA phy reset
3766 * @link: link to reset
3769 * @online: optional out parameter indicating link onlineness
3770 * @check_ready: optional callback to check link readiness
3772 * SATA phy-reset @link using DET bits of SControl register.
3773 * After hardreset, link readiness is waited upon using
3779 * *@online is set to one iff reset succeeded and @link is online
3788 int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
3800 if (sata_set_spd_needed(link)) {
3806 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3811 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3814 sata_set_spd(link);
3818 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3823 if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
3831 /* bring link back */
3832 rc = sata_link_resume(link, timing, deadline);
3835 /* if link is offline nothing more to do */
3836 if (ata_phys_link_offline(link))
3843 if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) {
3856 ata_wait_ready(link, pmp_deadline, check_ready);
3864 rc = ata_wait_ready(link, deadline, check_ready);
3867 /* online is set iff link is online && reset succeeded */
3870 ata_link_printk(link, KERN_ERR,
3879 * @link: link to reset
3889 * 0 if link offline, -EAGAIN if link online, -errno on errors.
3891 int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3894 const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
3899 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
3905 * @link: the target ata_link
3915 void ata_std_postreset(struct ata_link *link, unsigned int *classes)
3922 if (!sata_scr_read(link, SCR_ERROR, &serror))
3923 sata_scr_write(link, SCR_ERROR, serror);
3925 /* print link status */
3926 sata_print_link_status(link);
3997 u16 *id = (void *)dev->link->ap->sector_buf;
4211 /* Devices which aren't very happy with higher link speeds */
4318 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4354 struct ata_link *link;
4381 ata_for_each_link(link, ap, EDGE) {
4382 ata_for_each_dev(dev, link, ENABLED) {
4404 struct ata_link *link = dev->link;
4405 struct ata_port *ap = link->ap;
4666 struct ata_link *link = qc->dev->link;
4669 if (!ata_tag_valid(link->active_tag))
4672 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4796 struct ata_port *ap = dev->link->ap;
4840 struct ata_link *link;
4845 link = qc->dev->link;
4852 link->sactive &= ~(1 << qc->tag);
4853 if (!link->sactive)
4856 link->active_tag = ATA_TAG_POISON;
4862 ap->excl_link == link))
4916 struct ata_eh_info *ehi = &dev->link->eh_info;
5034 struct ata_link *link = qc->dev->link;
5041 WARN_ON_ONCE(ap->ops->error_handler && ata_tag_valid(link->active_tag));
5044 WARN_ON_ONCE(link->sactive & (1 << qc->tag));
5046 if (!link->sactive)
5048 link->sactive |= 1 << qc->tag;
5050 WARN_ON_ONCE(link->sactive);
5053 link->active_tag = qc->tag;
5072 /* if device is sleeping, schedule reset and abort the link */
5074 link->eh_info.action |= ATA_EH_RESET;
5075 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
5076 ata_link_abort(link);
5095 * @link: ATA link to test SCR accessibility for
5097 * Test whether SCRs are accessible for @link.
5105 int sata_scr_valid(struct ata_link *link)
5107 struct ata_port *ap = link->ap;
5114 * @link: ATA link to read SCR for
5118 * Read SCR register @reg of @link into *@val. This function is
5119 * guaranteed to succeed if @link is ap->link, the cable type of
5123 * None if @link is ap->link. Kernel thread context otherwise.
5128 int sata_scr_read(struct ata_link *link, int reg, u32 *val)
5130 if (ata_is_host_link(link)) {
5131 if (sata_scr_valid(link))
5132 return link->ap->ops->scr_read(link, reg, val);
5136 return sata_pmp_scr_read(link, reg, val);
5141 * @link: ATA link to write SCR for
5145 * Write @val to SCR register @reg of @link. This function is
5146 * guaranteed to succeed if @link is ap->link, the cable type of
5150 * None if @link is ap->link. Kernel thread context otherwise.
5155 int sata_scr_write(struct ata_link *link, int reg, u32 val)
5157 if (ata_is_host_link(link)) {
5158 if (sata_scr_valid(link))
5159 return link->ap->ops->scr_write(link, reg, val);
5163 return sata_pmp_scr_write(link, reg, val);
5168 * @link: ATA link to write SCR for
5176 * None if @link is ap->link. Kernel thread context otherwise.
5181 int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
5183 if (ata_is_host_link(link)) {
5186 if (sata_scr_valid(link)) {
5187 rc = link->ap->ops->scr_write(link, reg, val);
5189 rc = link->ap->ops->scr_read(link, reg, &val);
5195 return sata_pmp_scr_write(link, reg, val);
5199 * ata_phys_link_online - test whether the given link is online
5200 * @link: ATA link to test
5202 * Test whether @link is online. Note that this function returns
5203 * 0 if online status of @link cannot be obtained, so
5204 * ata_link_online(link) != !ata_link_offline(link).
5212 bool ata_phys_link_online(struct ata_link *link)
5216 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
5223 * ata_phys_link_offline - test whether the given link is offline
5224 * @link: ATA link to test
5226 * Test whether @link is offline. Note that this function
5227 * returns 0 if offline status of @link cannot be obtained, so
5228 * ata_link_online(link) != !ata_link_offline(link).
5236 bool ata_phys_link_offline(struct ata_link *link)
5240 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
5247 * ata_link_online - test whether the given link is online
5248 * @link: ATA link to test
5250 * Test whether @link is online. This is identical to
5251 * ata_phys_link_online() when there's no slave link. When
5252 * there's a slave link, this function should only be called on
5253 * the master link and will return true if any of M/S links is
5262 bool ata_link_online(struct ata_link *link)
5264 struct ata_link *slave = link->ap->slave_link;
5266 WARN_ON(link == slave); /* shouldn't be called on slave link */
5268 return ata_phys_link_online(link) ||
5273 * ata_link_offline - test whether the given link is offline
5274 * @link: ATA link to test
5276 * Test whether @link is offline. This is identical to
5277 * ata_phys_link_offline() when there's no slave link. When
5278 * there's a slave link, this function should only be called on
5279 * the master link and will return true if both M/S links are
5288 bool ata_link_offline(struct ata_link *link)
5290 struct ata_link *slave = link->ap->slave_link;
5292 WARN_ON(link == slave); /* shouldn't be called on slave link */
5294 return ata_phys_link_offline(link) &&
5308 struct ata_link *link;
5328 ata_for_each_link(link, ap, HOST_FIRST) {
5329 link->eh_info.action |= action;
5330 link->eh_info.flags |= ehi_flags;
5370 * disable link pm on all ports before requesting
5409 /* reenable link pm */
5425 struct ata_link *link = ata_dev_phys_link(dev);
5426 struct ata_port *ap = link->ap;
5430 link->sata_spd_limit = link->hw_sata_spd_limit;
5431 link->sata_spd = 0;
5451 * @ap: ATA port link is attached to
5452 * @link: Link structure to initialize
5455 * Initialize @link.
5460 void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
5465 memset(link, 0, offsetof(struct ata_link, device[0]));
5467 link->ap = ap;
5468 link->pmp = pmp;
5469 link->active_tag = ATA_TAG_POISON;
5470 link->hw_sata_spd_limit = UINT_MAX;
5474 struct ata_device *dev = &link->device[i];
5476 dev->link = link;
5477 dev->devno = dev - link->device;
5486 * sata_link_init_spd - Initialize link->sata_spd_limit
5487 * @link: Link to configure sata_spd_limit for
5489 * Initialize @link->[hw_]sata_spd_limit to the currently
5498 int sata_link_init_spd(struct ata_link *link)
5503 rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol);
5507 spd = (link->saved_scontrol >> 4) & 0xf;
5509 link->hw_sata_spd_limit &= (1 << spd) - 1;
5511 ata_force_link_limits(link);
5513 link->sata_spd_limit = link->hw_sata_spd_limit;
5567 ata_link_init(ap, &ap->link, 0);
5704 ap->link.flags |= pi->link_flags;
5715 * ata_slave_link_init - initialize slave link
5716 * @ap: port to initialize slave link for
5718 * Create and initialize slave link for @ap. This enables slave
5719 * link handling on the port.
5721 * In libata, a port contains links and a link contains devices.
5722 * There is single host link but if a PMP is attached to it,
5724 * a single device connected to a link but PATA and SATA
5732 * need separate links for physical link handling
5733 * (e.g. onlineness, link speed) but should be treated like a
5739 * anything other than physical link handling, the default host
5740 * link is used for both master and slave. For physical link
5744 * called once more for the slave link, so the reset sequence
5762 struct ata_link *link;
5767 link = kzalloc(sizeof(*link), GFP_KERNEL);
5768 if (!link)
5771 ata_link_init(ap, link, 1);
5772 ap->slave_link = link;
5963 struct ata_eh_info *ehi = &ap->link.eh_info;
6052 sata_link_init_spd(&ap->link);
6065 ap->link.eh_info.desc);
6066 ata_ehi_clear_desc(&ap->link.eh_info);
6397 *reason = "invalid port/link";