static int dwc3_omap_extcon_register(struct dwc3_omap *omap)
{
int ret;
struct device_node *node = omap->dev->of_node;
struct extcon_dev *edev;
if (of_property_read_bool(node, "extcon")) {
edev = extcon_get_edev_by_phandle(omap->dev, 0);
if (IS_ERR(edev)) {
dev_vdbg(omap->dev, "couldn't get extcon device\n");
return -EPROBE_DEFER;
}
omap->vbus_nb.notifier_call = dwc3_omap_vbus_notifier;
ret = extcon_register_interest(&omap->extcon_vbus_dev,
edev->name, "USB",
&omap->vbus_nb);
if (ret < 0)
dev_vdbg(omap->dev, "failed to register notifier for USB\n");
omap->id_nb.notifier_call = dwc3_omap_id_notifier;
ret = extcon_register_interest(&omap->extcon_id_dev,
edev->name, "USB-HOST",
&omap->id_nb);
if (ret < 0)
dev_vdbg(omap->dev, "failed to register notifier for USB-HOST\n");
if (extcon_get_cable_state(edev, "USB") == true)
dwc3_omap_set_mailbox(omap, OMAP_DWC3_VBUS_VALID);
if (extcon_get_cable_state(edev, "USB-HOST") == true)
dwc3_omap_set_mailbox(omap, OMAP_DWC3_ID_GROUND);
}
return 0;
}
static int omap_otg_probe(struct platform_device *pdev)
{
const struct omap_usb_config *config = pdev->dev.platform_data;
struct otg_device *otg_dev;
struct extcon_dev *extcon;
int ret;
u32 rev;
if (!config || !config->extcon)
return -ENODEV;
extcon = extcon_get_extcon_dev(config->extcon);
if (!extcon)
return -EPROBE_DEFER;
otg_dev = devm_kzalloc(&pdev->dev, sizeof(*otg_dev), GFP_KERNEL);
if (!otg_dev)
return -ENOMEM;
otg_dev->base = devm_ioremap_resource(&pdev->dev, &pdev->resource[0]);
if (IS_ERR(otg_dev->base))
return PTR_ERR(otg_dev->base);
otg_dev->id_nb.notifier_call = omap_otg_id_notifier;
otg_dev->vbus_nb.notifier_call = omap_otg_vbus_notifier;
ret = extcon_register_interest(&otg_dev->id_dev, config->extcon,
"USB-HOST", &otg_dev->id_nb);
if (ret)
return ret;
ret = extcon_register_interest(&otg_dev->vbus_dev, config->extcon,
"USB", &otg_dev->vbus_nb);
if (ret) {
extcon_unregister_interest(&otg_dev->id_dev);
return ret;
}
otg_dev->id = extcon_get_cable_state(extcon, "USB-HOST");
otg_dev->vbus = extcon_get_cable_state(extcon, "USB");
omap_otg_set_mode(otg_dev);
rev = readl(otg_dev->base);
dev_info(&pdev->dev,
"OMAP USB OTG controller rev %d.%d (%s, id=%d, vbus=%d)\n",
(rev >> 4) & 0xf, rev & 0xf, config->extcon, otg_dev->id,
otg_dev->vbus);
return 0;
}
static int muic_init_cable_notify(void)
{
int i, ret;
struct muic_cable *cable = NULL;
for (i = 0; i < ARRAY_SIZE(support_cable_list); i++) {
cable = &support_cable_list[i];
INIT_WORK(&cable->work, muic_cable_event_worker);
cable->nb.notifier_call = muic_cable_notifier;
ret = extcon_register_interest(&cable->extcon_nb,
EXTCON_DEV_NAME,
extcon_cable_name[cable->cable_type],
&cable->nb);
if (ret)
pr_err("%s: fail to register extcon notifier(%s, %d)\n",
__func__, extcon_cable_name[cable->cable_type],
ret);
cable->edev = cable->extcon_nb.edev;
if (!cable->edev)
pr_err("%s: fail to get extcon device\n", __func__);
}
return 0;
}
static int dwc3_omap_probe(struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
struct dwc3_omap *omap;
struct resource *res;
struct device *dev = &pdev->dev;
struct extcon_dev *edev;
struct regulator *vbus_reg = NULL;
int ret = -ENOMEM;
int irq;
int utmi_mode = 0;
int x_major;
u32 reg;
void __iomem *base;
if (!node) {
dev_err(dev, "device node not found\n");
return -EINVAL;
}
omap = devm_kzalloc(dev, sizeof(*omap), GFP_KERNEL);
if (!omap) {
dev_err(dev, "not enough memory\n");
return -ENOMEM;
}
platform_set_drvdata(pdev, omap);
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(dev, "missing IRQ resource\n");
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(dev, "missing memory base resource\n");
return -EINVAL;
}
base = devm_ioremap_resource(dev, res);
if (IS_ERR(base))
return PTR_ERR(base);
if (of_property_read_bool(node, "vbus-supply")) {
vbus_reg = devm_regulator_get(dev, "vbus");
if (IS_ERR(vbus_reg)) {
dev_err(dev, "vbus init failed\n");
return PTR_ERR(vbus_reg);
}
}
omap->dev = dev;
omap->irq = irq;
omap->base = base;
omap->vbus_reg = vbus_reg;
dev->dma_mask = &dwc3_omap_dma_mask;
pm_runtime_enable(dev);
ret = pm_runtime_get_sync(dev);
if (ret < 0) {
dev_err(dev, "get_sync failed with err %d\n", ret);
goto err0;
}
reg = dwc3_omap_readl(omap->base, USBOTGSS_REVISION);
omap->revision = reg;
x_major = USBOTGSS_REVISION_XMAJOR(reg);
/* Differentiate between OMAP5 and AM437x */
switch (x_major) {
case USBOTGSS_REVISION_XMAJOR1:
case USBOTGSS_REVISION_XMAJOR2:
omap->irq_eoi_offset = 0;
omap->irq0_offset = 0;
omap->irqmisc_offset = 0;
omap->utmi_otg_offset = 0;
omap->debug_offset = 0;
break;
default:
/* Default to the latest revision */
omap->irq_eoi_offset = USBOTGSS_EOI_OFFSET;
omap->irq0_offset = USBOTGSS_IRQ0_OFFSET;
omap->irqmisc_offset = USBOTGSS_IRQMISC_OFFSET;
omap->utmi_otg_offset = USBOTGSS_UTMI_OTG_OFFSET;
omap->debug_offset = USBOTGSS_DEBUG_OFFSET;
break;
}
/* For OMAP5(ES2.0) and AM437x x_major is 2 even though there are
* changes in wrapper registers, Using dt compatible for aegis
*/
if (of_device_is_compatible(node, "ti,am437x-dwc3")) {
omap->irq_eoi_offset = USBOTGSS_EOI_OFFSET;
omap->irq0_offset = USBOTGSS_IRQ0_OFFSET;
omap->irqmisc_offset = USBOTGSS_IRQMISC_OFFSET;
omap->utmi_otg_offset = USBOTGSS_UTMI_OTG_OFFSET;
omap->debug_offset = USBOTGSS_DEBUG_OFFSET;
}
reg = dwc3_omap_read_utmi_status(omap);
of_property_read_u32(node, "utmi-mode", &utmi_mode);
switch (utmi_mode) {
case DWC3_OMAP_UTMI_MODE_SW:
reg |= USBOTGSS_UTMI_OTG_STATUS_SW_MODE;
break;
case DWC3_OMAP_UTMI_MODE_HW:
reg &= ~USBOTGSS_UTMI_OTG_STATUS_SW_MODE;
break;
default:
dev_dbg(dev, "UNKNOWN utmi mode %d\n", utmi_mode);
}
dwc3_omap_write_utmi_status(omap, reg);
/* check the DMA Status */
reg = dwc3_omap_readl(omap->base, USBOTGSS_SYSCONFIG);
omap->dma_status = !!(reg & USBOTGSS_SYSCONFIG_DMADISABLE);
ret = devm_request_irq(dev, omap->irq, dwc3_omap_interrupt, 0,
"dwc3-omap", omap);
if (ret) {
dev_err(dev, "failed to request IRQ #%d --> %d\n",
omap->irq, ret);
goto err1;
}
dwc3_omap_enable_irqs(omap);
if (of_property_read_bool(node, "extcon")) {
edev = of_extcon_get_extcon_dev(dev, 0);
if (IS_ERR(edev)) {
dev_vdbg(dev, "couldn't get extcon device\n");
ret = -EPROBE_DEFER;
goto err2;
}
omap->vbus_nb.notifier_call = dwc3_omap_vbus_notifier;
ret = extcon_register_interest(&omap->extcon_vbus_dev,
edev->name, "USB", &omap->vbus_nb);
if (ret < 0)
dev_vdbg(dev, "failed to register notifier for USB\n");
omap->id_nb.notifier_call = dwc3_omap_id_notifier;
ret = extcon_register_interest(&omap->extcon_id_dev, edev->name,
"USB-HOST", &omap->id_nb);
if (ret < 0)
dev_vdbg(dev,
"failed to register notifier for USB-HOST\n");
if (extcon_get_cable_state(edev, "USB") == true)
dwc3_omap_set_mailbox(omap, OMAP_DWC3_VBUS_VALID);
if (extcon_get_cable_state(edev, "USB-HOST") == true)
dwc3_omap_set_mailbox(omap, OMAP_DWC3_ID_GROUND);
}
ret = of_platform_populate(node, NULL, NULL, dev);
if (ret) {
dev_err(&pdev->dev, "failed to create dwc3 core\n");
goto err3;
}
return 0;
err3:
if (omap->extcon_vbus_dev.edev)
extcon_unregister_interest(&omap->extcon_vbus_dev);
if (omap->extcon_id_dev.edev)
extcon_unregister_interest(&omap->extcon_id_dev);
err2:
dwc3_omap_disable_irqs(omap);
err1:
pm_runtime_put_sync(dev);
err0:
pm_runtime_disable(dev);
return ret;
}
int extcon_port_register(
char *extcon_name,
struct extcon_dev *edev,
struct extcon_cable_block *cables,
void (*fn)(struct extcon_cable_block *))
{
struct extcon_cable_block *cable;
int ret = 0, num_cables;
int i;
if (!extcon_name)
return -EINVAL;
edev = extcon_get_extcon_dev(extcon_name);
if (!edev)
return -ENODEV;
num_cables = edev->max_supported;
cables = kzalloc(sizeof(struct extcon_cable_block) * num_cables,
GFP_KERNEL);
if (!cables) {
pr_err("failed to allocate array of extcon_cable_block(%s)\n",
extcon_name);
return -ENOMEM;
}
for (i = 0 ; i < num_cables ; i++) {
cable = &cables[i];
strcpy(cable->extcon_name, extcon_name);
strcpy(cable->name, edev->supported_cable[i]);
cable->function = fn;
INIT_WORK(&cable->wq, extcon_work);
cable->nb.notifier_call = extcon_notifier;
ret = extcon_register_interest(&cable->obj,
cable->extcon_name, cable->name, &cable->nb);
if (ret < 0) {
pr_err("Cannot register extcon_dev for %s(cable: %s)\n",
cable->extcon_name, cable->name);
goto err_extcon;
}
}
return 0;
err_extcon:
for (i = 0 ; i < num_cables ; i++) {
cable = &cables[i];
/* Unregister only extcon device which is initialized */
if (cable->nb.notifier_call) {
ret = extcon_unregister_interest(&cable->obj);
pr_err("Unregister extcon_dev for %s(cable: %s)\n",
cable->extcon_name, cable->name);
}
}
kfree(cables);
return ret;
}
static int smsc375x_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct smsc375x_chip *chip;
int ret = 0, id_val = -1;
chip = kzalloc(sizeof(struct smsc375x_chip), GFP_KERNEL);
if (!chip) {
dev_err(&client->dev, "failed to allocate driver data\n");
return -ENOMEM;
}
chip->client = client;
#ifdef CONFIG_ACPI
chip->pdata = smsc375x_platform_data();
#else
chip->pdata = dev->platform_data;
#endif
i2c_set_clientdata(client, chip);
wake_lock_init(&chip->wakelock, WAKE_LOCK_SUSPEND,
"smsc375x_wakelock");
/* register with extcon */
chip->edev = kzalloc(sizeof(struct extcon_dev), GFP_KERNEL);
if (!chip->edev) {
dev_err(&client->dev, "mem alloc failed\n");
ret = -ENOMEM;
goto extcon_mem_failed;
}
chip->edev->name = "smsc375x";
chip->edev->supported_cable = smsc375x_extcon_cable;
ret = extcon_dev_register(chip->edev, &client->dev);
if (ret) {
dev_err(&client->dev, "extcon registration failed!!\n");
goto extcon_reg_failed;
}
/* register for EXTCON USB notification */
INIT_WORK(&chip->vbus_work, smsc375x_pwrsrc_event_worker);
chip->vbus_nb.notifier_call = smsc375x_handle_pwrsrc_notification;
ret = extcon_register_interest(&chip->cable_obj, NULL,
SMSC375X_EXTCON_USB, &chip->vbus_nb);
/* OTG notification */
chip->otg = usb_get_phy(USB_PHY_TYPE_USB2);
if (!chip->otg) {
dev_warn(&client->dev, "Failed to get otg transceiver!!\n");
goto otg_reg_failed;
}
INIT_WORK(&chip->otg_work, smsc375x_otg_event_worker);
chip->id_nb.notifier_call = smsc375x_handle_otg_notification;
ret = usb_register_notifier(chip->otg, &chip->id_nb);
if (ret) {
dev_err(&chip->client->dev,
"failed to register otg notifier\n");
goto id_reg_failed;
}
ret = smsc375x_irq_init(chip);
if (ret)
goto intr_reg_failed;
chip_ptr = chip;
if (chip->otg->get_id_status) {
ret = chip->otg->get_id_status(chip->otg, &id_val);
if (ret < 0) {
dev_warn(&client->dev,
"otg get ID status failed:%d\n", ret);
ret = 0;
}
}
if (!id_val && !chip->id_short)
atomic_notifier_call_chain(&chip->otg->notifier,
USB_EVENT_ID, &id_val);
else
smsc375x_detect_dev(chip);
/* Init Runtime PM State */
pm_runtime_put_noidle(&chip->client->dev);
pm_schedule_suspend(&chip->client->dev, MSEC_PER_SEC);
return 0;
intr_reg_failed:
usb_unregister_notifier(chip->otg, &chip->id_nb);
id_reg_failed:
usb_put_phy(chip->otg);
otg_reg_failed:
extcon_dev_unregister(chip->edev);
extcon_reg_failed:
kfree(chip->edev);
extcon_mem_failed:
kfree(chip);
return ret;
}
