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

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



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@xxxxxxxxx>

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@xxxxxxxxxxxx

Attachment: .config.gz
Description: application/gzip


[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Index of Archives]     [SCSI Target Devel]     [Linux SCSI Target Infrastructure]     [Kernel Newbies]     [IDE]     [Security]     [Git]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux RAID]     [Linux ATA RAID]     [Linux IIO]     [Samba]     [Device Mapper]

  Powered by Linux