UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

usb: host: xhci-mtk: omit shared hcd if either root hub has no ports 

There is error log when add a usb3 root hub without ports:
"hub 4-0:1.0: config failed, hub doesn't have any ports! (err -19)"

so omit the shared hcd if either of the root hubs has no ports, but
usually there is no usb3 port.

Signed-off-by: Chunfeng Yun <chunfeng.yun@mediatek.com>
Reviewed-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
Link: https://lore.kernel.org/r/20221118110116.20165-1-chunfeng.yun@mediatek.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Chunfeng Yun 2022-11-18 19:01:16 +08:00 committed by Greg Kroah-Hartman
parent 0384e87e3f
commit e99e1a7d6f
1 changed files with 46 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
drivers/usb/host/xhci-mtk.c
View File

@ -485,6 +485,7 @@ static int xhci_mtk_probe(struct platform_device *pdev)
const struct hc_driver *driver; const struct hc_driver *driver;
struct xhci_hcd *xhci; struct xhci_hcd *xhci;
struct resource *res; struct resource *res;
struct usb_hcd *usb3_hcd;
struct usb_hcd *hcd; struct usb_hcd *hcd;
int ret = -ENODEV; int ret = -ENODEV;
int wakeup_irq; int wakeup_irq;
@ -593,6 +594,7 @@ static int xhci_mtk_probe(struct platform_device *pdev)
xhci = hcd_to_xhci(hcd); xhci = hcd_to_xhci(hcd);
xhci->main_hcd = hcd; xhci->main_hcd = hcd;
xhci->allow_single_roothub = 1;
/* /*
* imod_interval is the interrupt moderation value in nanoseconds. * imod_interval is the interrupt moderation value in nanoseconds.
@ -602,24 +604,29 @@ static int xhci_mtk_probe(struct platform_device *pdev)
xhci->imod_interval = 5000; xhci->imod_interval = 5000;
device_property_read_u32(dev, "imod-interval-ns", &xhci->imod_interval); device_property_read_u32(dev, "imod-interval-ns", &xhci->imod_interval);
xhci->shared_hcd = usb_create_shared_hcd(driver, dev,
dev_name(dev), hcd);
if (!xhci->shared_hcd) {
ret = -ENOMEM;
goto disable_device_wakeup;
}
ret = usb_add_hcd(hcd, irq, IRQF_SHARED); ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
if (ret) if (ret)
goto put_usb3_hcd; goto disable_device_wakeup;
if (HCC_MAX_PSA(xhci->hcc_params) >= 4 && if (!xhci_has_one_roothub(xhci)) {
xhci->shared_hcd = usb_create_shared_hcd(driver, dev,
dev_name(dev), hcd);
if (!xhci->shared_hcd) {
ret = -ENOMEM;
goto dealloc_usb2_hcd;
}
}
usb3_hcd = xhci_get_usb3_hcd(xhci);
if (usb3_hcd && HCC_MAX_PSA(xhci->hcc_params) >= 4 &&
!(xhci->quirks & XHCI_BROKEN_STREAMS)) !(xhci->quirks & XHCI_BROKEN_STREAMS))
xhci->shared_hcd->can_do_streams = 1; usb3_hcd->can_do_streams = 1;
ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED); if (xhci->shared_hcd) {
if (ret) ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
goto dealloc_usb2_hcd; if (ret)
goto put_usb3_hcd;
}
if (wakeup_irq > 0) { if (wakeup_irq > 0) {
ret = dev_pm_set_dedicated_wake_irq_reverse(dev, wakeup_irq); ret = dev_pm_set_dedicated_wake_irq_reverse(dev, wakeup_irq);
@ -641,13 +648,13 @@ dealloc_usb3_hcd:
usb_remove_hcd(xhci->shared_hcd); usb_remove_hcd(xhci->shared_hcd);
xhci->shared_hcd = NULL; xhci->shared_hcd = NULL;
dealloc_usb2_hcd:
usb_remove_hcd(hcd);
put_usb3_hcd: put_usb3_hcd:
xhci_mtk_sch_exit(mtk);
usb_put_hcd(xhci->shared_hcd); usb_put_hcd(xhci->shared_hcd);
dealloc_usb2_hcd:
xhci_mtk_sch_exit(mtk);
usb_remove_hcd(hcd);
disable_device_wakeup: disable_device_wakeup:
device_init_wakeup(dev, false); device_init_wakeup(dev, false);
@ -679,10 +686,15 @@ static int xhci_mtk_remove(struct platform_device *pdev)
dev_pm_clear_wake_irq(dev); dev_pm_clear_wake_irq(dev);
device_init_wakeup(dev, false); device_init_wakeup(dev, false);
usb_remove_hcd(shared_hcd); if (shared_hcd) {
xhci->shared_hcd = NULL; usb_remove_hcd(shared_hcd);
xhci->shared_hcd = NULL;
}
usb_remove_hcd(hcd); usb_remove_hcd(hcd);
usb_put_hcd(shared_hcd);
if (shared_hcd)
usb_put_hcd(shared_hcd);
usb_put_hcd(hcd); usb_put_hcd(hcd);
xhci_mtk_sch_exit(mtk); xhci_mtk_sch_exit(mtk);
clk_bulk_disable_unprepare(BULK_CLKS_NUM, mtk->clks); clk_bulk_disable_unprepare(BULK_CLKS_NUM, mtk->clks);
@ -700,13 +712,16 @@ static int __maybe_unused xhci_mtk_suspend(struct device *dev)
struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev); struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
struct usb_hcd *hcd = mtk->hcd; struct usb_hcd *hcd = mtk->hcd;
struct xhci_hcd *xhci = hcd_to_xhci(hcd); struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct usb_hcd *shared_hcd = xhci->shared_hcd;
int ret; int ret;
xhci_dbg(xhci, "%s: stop port polling\n", __func__); xhci_dbg(xhci, "%s: stop port polling\n", __func__);
clear_bit(HCD_FLAG_POLL_RH, &hcd->flags); clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
del_timer_sync(&hcd->rh_timer); del_timer_sync(&hcd->rh_timer);
clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags); if (shared_hcd) {
del_timer_sync(&xhci->shared_hcd->rh_timer); clear_bit(HCD_FLAG_POLL_RH, &shared_hcd->flags);
del_timer_sync(&shared_hcd->rh_timer);
}
ret = xhci_mtk_host_disable(mtk); ret = xhci_mtk_host_disable(mtk);
if (ret) if (ret)
@ -718,8 +733,10 @@ static int __maybe_unused xhci_mtk_suspend(struct device *dev)
restart_poll_rh: restart_poll_rh:
xhci_dbg(xhci, "%s: restart port polling\n", __func__); xhci_dbg(xhci, "%s: restart port polling\n", __func__);
set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags); if (shared_hcd) {
usb_hcd_poll_rh_status(xhci->shared_hcd); set_bit(HCD_FLAG_POLL_RH, &shared_hcd->flags);
usb_hcd_poll_rh_status(shared_hcd);
}
set_bit(HCD_FLAG_POLL_RH, &hcd->flags); set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
usb_hcd_poll_rh_status(hcd); usb_hcd_poll_rh_status(hcd);
return ret; return ret;
@ -730,6 +747,7 @@ static int __maybe_unused xhci_mtk_resume(struct device *dev)
struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev); struct xhci_hcd_mtk *mtk = dev_get_drvdata(dev);
struct usb_hcd *hcd = mtk->hcd; struct usb_hcd *hcd = mtk->hcd;
struct xhci_hcd *xhci = hcd_to_xhci(hcd); struct xhci_hcd *xhci = hcd_to_xhci(hcd);
struct usb_hcd *shared_hcd = xhci->shared_hcd;
int ret; int ret;
usb_wakeup_set(mtk, false); usb_wakeup_set(mtk, false);
@ -742,8 +760,10 @@ static int __maybe_unused xhci_mtk_resume(struct device *dev)
goto disable_clks; goto disable_clks;
xhci_dbg(xhci, "%s: restart port polling\n", __func__); xhci_dbg(xhci, "%s: restart port polling\n", __func__);
set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags); if (shared_hcd) {
usb_hcd_poll_rh_status(xhci->shared_hcd); set_bit(HCD_FLAG_POLL_RH, &shared_hcd->flags);
usb_hcd_poll_rh_status(shared_hcd);
}
set_bit(HCD_FLAG_POLL_RH, &hcd->flags); set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
usb_hcd_poll_rh_status(hcd); usb_hcd_poll_rh_status(hcd);
return 0; return 0;