Re: [PATCH v1 1/2] scsi: ufs: Put hba into LPM during clk gating

kernel test robot
2020-10-27T04:42:47Z

[-- Attachment #1: Type: text/plain, Size: 10731 bytes --]

Hi Asutosh,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on mkp-scsi/for-next]
[also build test ERROR on scsi/for-next v5.10-rc1 next-20201026]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url: https://github.com/0day-ci/linux/commits/Asutosh-Das/scsi-ufs-Put-hba-into-LPM-during-clk-gating/20201027-073142
base: https://git.kernel.org/pub/scm/linux/kernel/git/mkp/scsi.git for-next
config: arm-randconfig-r031-20201026 (attached as .config)
compiler: arm-linux-gnueabi-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/9e2e3ce8b0bf533614823400cdb43ea92cc6b1c0
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Asutosh-Das/scsi-ufs-Put-hba-into-LPM-during-clk-gating/20201027-073142
git checkout 9e2e3ce8b0bf533614823400cdb43ea92cc6b1c0
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=arm

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All error/warnings (new ones prefixed by >>):

drivers/scsi/ufs/ufshcd.c: In function 'ufshcd_ungate_work':
>> drivers/scsi/ufs/ufshcd.c:1551:2: error: implicit declaration of function 'ufshcd_hba_vreg_set_hpm' [-Werror=implicit-function-declaration]
1551 | ufshcd_hba_vreg_set_hpm(hba);
| ^~~~~~~~~~~~~~~~~~~~~~~
drivers/scsi/ufs/ufshcd.c: In function 'ufshcd_gate_work':
>> drivers/scsi/ufs/ufshcd.c:1718:2: error: implicit declaration of function 'ufshcd_hba_vreg_set_lpm' [-Werror=implicit-function-declaration]
1718 | ufshcd_hba_vreg_set_lpm(hba);
| ^~~~~~~~~~~~~~~~~~~~~~~
drivers/scsi/ufs/ufshcd.c: At top level:
>> drivers/scsi/ufs/ufshcd.c:8409:13: warning: conflicting types for 'ufshcd_hba_vreg_set_lpm'
8409 | static void ufshcd_hba_vreg_set_lpm(struct ufs_hba *hba)
| ^~~~~~~~~~~~~~~~~~~~~~~
drivers/scsi/ufs/ufshcd.c:8409:13: error: static declaration of 'ufshcd_hba_vreg_set_lpm' follows non-static declaration
drivers/scsi/ufs/ufshcd.c:1718:2: note: previous implicit declaration of 'ufshcd_hba_vreg_set_lpm' was here
1718 | ufshcd_hba_vreg_set_lpm(hba);
| ^~~~~~~~~~~~~~~~~~~~~~~
>> drivers/scsi/ufs/ufshcd.c:8415:13: warning: conflicting types for 'ufshcd_hba_vreg_set_hpm'
8415 | static void ufshcd_hba_vreg_set_hpm(struct ufs_hba *hba)
| ^~~~~~~~~~~~~~~~~~~~~~~
drivers/scsi/ufs/ufshcd.c:8415:13: error: static declaration of 'ufshcd_hba_vreg_set_hpm' follows non-static declaration
drivers/scsi/ufs/ufshcd.c:1551:2: note: previous implicit declaration of 'ufshcd_hba_vreg_set_hpm' was here
1551 | ufshcd_hba_vreg_set_hpm(hba);
| ^~~~~~~~~~~~~~~~~~~~~~~
cc1: some warnings being treated as errors

vim +/ufshcd_hba_vreg_set_hpm +1551 drivers/scsi/ufs/ufshcd.c

1534
1535 static void ufshcd_ungate_work(struct work_struct *work)
1536 {
1537 int ret;
1538 unsigned long flags;
1539 struct ufs_hba *hba = container_of(work, struct ufs_hba,
1540 clk_gating.ungate_work);
1541
1542 cancel_delayed_work_sync(&hba->clk_gating.gate_work);
1543
1544 spin_lock_irqsave(hba->host->host_lock, flags);
1545 if (hba->clk_gating.state == CLKS_ON) {
1546 spin_unlock_irqrestore(hba->host->host_lock, flags);
1547 goto unblock_reqs;
1548 }
1549
1550 spin_unlock_irqrestore(hba->host->host_lock, flags);
> 1551 ufshcd_hba_vreg_set_hpm(hba);
1552 ufshcd_setup_clocks(hba, true);
1553
1554 ufshcd_enable_irq(hba);
1555
1556 /* Exit from hibern8 */
1557 if (ufshcd_can_hibern8_during_gating(hba)) {
1558 /* Prevent gating in this path */
1559 hba->clk_gating.is_suspended = true;
1560 if (ufshcd_is_link_hibern8(hba)) {
1561 ret = ufshcd_uic_hibern8_exit(hba);
1562 if (ret)
1563 dev_err(hba->dev, "%s: hibern8 exit failed %d\n",
1564 __func__, ret);
1565 else
1566 ufshcd_set_link_active(hba);
1567 }
1568 hba->clk_gating.is_suspended = false;
1569 }
1570 unblock_reqs:
1571 ufshcd_scsi_unblock_requests(hba);
1572 }
1573
1574 /**
1575 * ufshcd_hold - Enable clocks that were gated earlier due to ufshcd_release.
1576 * Also, exit from hibern8 mode and set the link as active.
1577 * @hba: per adapter instance
1578 * @async: This indicates whether caller should ungate clocks asynchronously.
1579 */
1580 int ufshcd_hold(struct ufs_hba *hba, bool async)
1581 {
1582 int rc = 0;
1583 bool flush_result;
1584 unsigned long flags;
1585
1586 if (!ufshcd_is_clkgating_allowed(hba))
1587 goto out;
1588 spin_lock_irqsave(hba->host->host_lock, flags);
1589 hba->clk_gating.active_reqs++;
1590
1591 start:
1592 switch (hba->clk_gating.state) {
1593 case CLKS_ON:
1594 /*
1595 * Wait for the ungate work to complete if in progress.
1596 * Though the clocks may be in ON state, the link could
1597 * still be in hibner8 state if hibern8 is allowed
1598 * during clock gating.
1599 * Make sure we exit hibern8 state also in addition to
1600 * clocks being ON.
1601 */
1602 if (ufshcd_can_hibern8_during_gating(hba) &&
1603 ufshcd_is_link_hibern8(hba)) {
1604 if (async) {
1605 rc = -EAGAIN;
1606 hba->clk_gating.active_reqs--;
1607 break;
1608 }
1609 spin_unlock_irqrestore(hba->host->host_lock, flags);
1610 flush_result = flush_work(&hba->clk_gating.ungate_work);
1611 if (hba->clk_gating.is_suspended && !flush_result)
1612 goto out;
1613 spin_lock_irqsave(hba->host->host_lock, flags);
1614 goto start;
1615 }
1616 break;
1617 case REQ_CLKS_OFF:
1618 if (cancel_delayed_work(&hba->clk_gating.gate_work)) {
1619 hba->clk_gating.state = CLKS_ON;
1620 trace_ufshcd_clk_gating(dev_name(hba->dev),
1621 hba->clk_gating.state);
1622 break;
1623 }
1624 /*
1625 * If we are here, it means gating work is either done or
1626 * currently running. Hence, fall through to cancel gating
1627 * work and to enable clocks.
1628 */
1629 /* fallthrough */
1630 case CLKS_OFF:
1631 ufshcd_scsi_block_requests(hba);
1632 hba->clk_gating.state = REQ_CLKS_ON;
1633 trace_ufshcd_clk_gating(dev_name(hba->dev),
1634 hba->clk_gating.state);
1635 queue_work(hba->clk_gating.clk_gating_workq,
1636 &hba->clk_gating.ungate_work);
1637 /*
1638 * fall through to check if we should wait for this
1639 * work to be done or not.
1640 */
1641 /* fallthrough */
1642 case REQ_CLKS_ON:
1643 if (async) {
1644 rc = -EAGAIN;
1645 hba->clk_gating.active_reqs--;
1646 break;
1647 }
1648
1649 spin_unlock_irqrestore(hba->host->host_lock, flags);
1650 flush_work(&hba->clk_gating.ungate_work);
1651 /* Make sure state is CLKS_ON before returning */
1652 spin_lock_irqsave(hba->host->host_lock, flags);
1653 goto start;
1654 default:
1655 dev_err(hba->dev, "%s: clk gating is in invalid state %d\n",
1656 __func__, hba->clk_gating.state);
1657 break;
1658 }
1659 spin_unlock_irqrestore(hba->host->host_lock, flags);
1660 out:
1661 return rc;
1662 }
1663 EXPORT_SYMBOL_GPL(ufshcd_hold);
1664
1665 static void ufshcd_gate_work(struct work_struct *work)
1666 {
1667 struct ufs_hba *hba = container_of(work, struct ufs_hba,
1668 clk_gating.gate_work.work);
1669 unsigned long flags;
1670 int ret;
1671
1672 spin_lock_irqsave(hba->host->host_lock, flags);
1673 /*
1674 * In case you are here to cancel this work the gating state
1675 * would be marked as REQ_CLKS_ON. In this case save time by
1676 * skipping the gating work and exit after changing the clock
1677 * state to CLKS_ON.
1678 */
1679 if (hba->clk_gating.is_suspended ||
1680 (hba->clk_gating.state != REQ_CLKS_OFF)) {
1681 hba->clk_gating.state = CLKS_ON;
1682 trace_ufshcd_clk_gating(dev_name(hba->dev),
1683 hba->clk_gating.state);
1684 goto rel_lock;
1685 }
1686
1687 if (hba->clk_gating.active_reqs
1688 || hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL
1689 || ufshcd_any_tag_in_use(hba) || hba->outstanding_tasks
1690 || hba->active_uic_cmd || hba->uic_async_done)
1691 goto rel_lock;
1692
1693 spin_unlock_irqrestore(hba->host->host_lock, flags);
1694
1695 /* put the link into hibern8 mode before turning off clocks */
1696 if (ufshcd_can_hibern8_during_gating(hba)) {
1697 ret = ufshcd_uic_hibern8_enter(hba);
1698 if (ret) {
1699 hba->clk_gating.state = CLKS_ON;
1700 dev_err(hba->dev, "%s: hibern8 enter failed %d\n",
1701 __func__, ret);
1702 trace_ufshcd_clk_gating(dev_name(hba->dev),
1703 hba->clk_gating.state);
1704 goto out;
1705 }
1706 ufshcd_set_link_hibern8(hba);
1707 }
1708
1709 ufshcd_disable_irq(hba);
1710
1711 if (!ufshcd_is_link_active(hba))
1712 ufshcd_setup_clocks(hba, false);
1713 else
1714 /* If link is active, device ref_clk can't be switched off */
1715 __ufshcd_setup_clocks(hba, false, true);
1716
1717 /* Put the host controller in low power mode if possible */
> 1718 ufshcd_hba_vreg_set_lpm(hba);
1719 /*
1720 * In case you are here to cancel this work the gating state
1721 * would be marked as REQ_CLKS_ON. In this case keep the state
1722 * as REQ_CLKS_ON which would anyway imply that clocks are off
1723 * and a request to turn them on is pending. By doing this way,
1724 * we keep the state machine in tact and this would ultimately
1725 * prevent from doing cancel work multiple times when there are
1726 * new requests arriving before the current cancel work is done.
1727 */
1728 spin_lock_irqsave(hba->host->host_lock, flags);
1729 if (hba->clk_gating.state == REQ_CLKS_OFF) {
1730 hba->clk_gating.state = CLKS_OFF;
1731 trace_ufshcd_clk_gating(dev_name(hba->dev),
1732 hba->clk_gating.state);
1733 }
1734 rel_lock:
1735 spin_unlock_irqrestore(hba->host->host_lock, flags);
1736 out:
1737 return;
1738 }
1739

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 27293 bytes --]