From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-eopbgr60073.outbound.protection.outlook.com ([40.107.6.73]:32279 "EHLO EUR04-DB3-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1732400AbfCABZR (ORCPT ); Thu, 28 Feb 2019 20:25:17 -0500 From: Jun Li Subject: [PATCH v2 2/2] usb: typec: add typec switch via GPIO control Date: Fri, 1 Mar 2019 01:25:13 +0000 Message-ID: <1551402256-7815-2-git-send-email-jun.li@nxp.com> References: <1551402256-7815-1-git-send-email-jun.li@nxp.com> In-Reply-To: <1551402256-7815-1-git-send-email-jun.li@nxp.com> Content-Language: en-US Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Sender: devicetree-owner@vger.kernel.org To: "robh+dt@kernel.org" , "heikki.krogerus@linux.intel.com" Cc: "gregkh@linuxfoundation.org" , "hdegoede@redhat.com" , "andy.shevchenko@gmail.com" , "linux-usb@vger.kernel.org" , "devicetree@vger.kernel.org" , dl-linux-imx List-ID: This patch adds a simple typec switch driver which only needs a GPIO to switch the super speed active channel according to typec orientation. Signed-off-by: Li Jun --- Changes for v2: - Use the correct head files for gpio api and of_device_id: #include #include - Add driver dependency on GPIOLIB drivers/usb/typec/mux/Kconfig | 7 +++ drivers/usb/typec/mux/Makefile | 1 + drivers/usb/typec/mux/gpio-switch.c | 105 ++++++++++++++++++++++++++++++++= ++++ 3 files changed, 113 insertions(+) diff --git a/drivers/usb/typec/mux/Kconfig b/drivers/usb/typec/mux/Kconfig index 01ed0d5..27120e6 100644 --- a/drivers/usb/typec/mux/Kconfig +++ b/drivers/usb/typec/mux/Kconfig @@ -9,4 +9,11 @@ config TYPEC_MUX_PI3USB30532 Say Y or M if your system has a Pericom PI3USB30532 Type-C cross switch / mux chip found on some devices with a Type-C port. =20 +config TYPEC_SWITCH_GPIO + tristate "Simple Super Speed Active Switch via GPIO" + depends on GPIOLIB + help + Say Y or M if your system has a typec super speed channel + switch via a simple GPIO control. + endmenu diff --git a/drivers/usb/typec/mux/Makefile b/drivers/usb/typec/mux/Makefil= e index 1332e46..e29377c 100644 --- a/drivers/usb/typec/mux/Makefile +++ b/drivers/usb/typec/mux/Makefile @@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 =20 obj-$(CONFIG_TYPEC_MUX_PI3USB30532) +=3D pi3usb30532.o +obj-$(CONFIG_TYPEC_SWITCH_GPIO) +=3D gpio-switch.o diff --git a/drivers/usb/typec/mux/gpio-switch.c b/drivers/usb/typec/mux/gp= io-switch.c new file mode 100644 index 0000000..b01844c --- /dev/null +++ b/drivers/usb/typec/mux/gpio-switch.c @@ -0,0 +1,105 @@ +// SPDX-License-Identifier: GPL-2.0 +/** + * gpio-switch.c - typec switch via a simple GPIO control. + * + * Copyright 2019 NXP + * Author: Jun Li + * + */ + +#include +#include +#include +#include +#include +#include +#include + +struct gpio_typec_switch { + struct typec_switch sw; + struct mutex lock; + struct gpio_desc *ss_sel; +}; + +static int switch_gpio_set(struct typec_switch *sw, + enum typec_orientation orientation) +{ + struct gpio_typec_switch *gpio_sw =3D container_of(sw, + struct gpio_typec_switch, sw); + + mutex_lock(&gpio_sw->lock); + + switch (orientation) { + case TYPEC_ORIENTATION_NORMAL: + gpiod_set_value_cansleep(gpio_sw->ss_sel, 1); + break; + case TYPEC_ORIENTATION_REVERSE: + gpiod_set_value_cansleep(gpio_sw->ss_sel, 0); + break; + case TYPEC_ORIENTATION_NONE: + break; + } + + mutex_unlock(&gpio_sw->lock); + + return 0; +} + +static int typec_switch_gpio_probe(struct platform_device *pdev) +{ + struct gpio_typec_switch *gpio_sw; + struct device *dev =3D &pdev->dev; + int ret; + + gpio_sw =3D devm_kzalloc(dev, sizeof(*gpio_sw), GFP_KERNEL); + if (!gpio_sw) + return -ENOMEM; + + platform_set_drvdata(pdev, gpio_sw); + + gpio_sw->sw.dev =3D dev; + gpio_sw->sw.set =3D switch_gpio_set; + mutex_init(&gpio_sw->lock); + + /* Get the super speed active channel selection GPIO */ + gpio_sw->ss_sel =3D devm_gpiod_get(dev, NULL, GPIOD_OUT_LOW); + if (IS_ERR(gpio_sw->ss_sel)) + return PTR_ERR(gpio_sw->ss_sel); + + ret =3D typec_switch_register(&gpio_sw->sw); + if (ret) { + dev_err(dev, "Error registering typec switch: %d\n", ret); + return ret; + } + + return 0; +} + +static int typec_switch_gpio_remove(struct platform_device *pdev) +{ + struct gpio_typec_switch *gpio_sw =3D platform_get_drvdata(pdev); + + typec_switch_unregister(&gpio_sw->sw); + + return 0; +} + +static const struct of_device_id of_typec_switch_gpio_match[] =3D { + { .compatible =3D "nxp,ptn36043" }, + { /* Sentinel */ } +}; +MODULE_DEVICE_TABLE(of, of_typec_switch_gpio_match); + +static struct platform_driver typec_switch_gpio_driver =3D { + .probe =3D typec_switch_gpio_probe, + .remove =3D typec_switch_gpio_remove, + .driver =3D { + .name =3D "typec-switch-gpio", + .of_match_table =3D of_typec_switch_gpio_match, + }, +}; + +module_platform_driver(typec_switch_gpio_driver); +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("TypeC Super Speed Switch GPIO driver"); +MODULE_AUTHOR("Jun Li "); --=20 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v2,2/2] usb: typec: add typec switch via GPIO control From: Jun Li Message-Id: <1551402256-7815-2-git-send-email-jun.li@nxp.com> Date: Fri, 1 Mar 2019 01:25:13 +0000 To: "robh+dt@kernel.org" , "heikki.krogerus@linux.intel.com" Cc: "gregkh@linuxfoundation.org" , "hdegoede@redhat.com" , "andy.shevchenko@gmail.com" , "linux-usb@vger.kernel.org" , "devicetree@vger.kernel.org" , dl-linux-imx List-ID: VGhpcyBwYXRjaCBhZGRzIGEgc2ltcGxlIHR5cGVjIHN3aXRjaCBkcml2ZXIgd2hpY2ggb25seSBu ZWVkcwphIEdQSU8gdG8gc3dpdGNoIHRoZSBzdXBlciBzcGVlZCBhY3RpdmUgY2hhbm5lbCBhY2Nv cmRpbmcgdG8KdHlwZWMgb3JpZW50YXRpb24uCgpTaWduZWQtb2ZmLWJ5OiBMaSBKdW4gPGp1bi5s aUBueHAuY29tPgotLS0KCkNoYW5nZXMgZm9yIHYyOgotIFVzZSB0aGUgY29ycmVjdCBoZWFkIGZp bGVzIGZvciBncGlvIGFwaSBhbmQgb2ZfZGV2aWNlX2lkOgogICNpbmNsdWRlIDxsaW51eC9ncGlv L2NvbnN1bWVyLmg+CiAgI2luY2x1ZGUgPGxpbnV4L21vZF9kZXZpY2V0YWJsZS5oPgotIEFkZCBk cml2ZXIgZGVwZW5kZW5jeSBvbiBHUElPTElCCgogZHJpdmVycy91c2IvdHlwZWMvbXV4L0tjb25m aWcgICAgICAgfCAgIDcgKysrCiBkcml2ZXJzL3VzYi90eXBlYy9tdXgvTWFrZWZpbGUgICAgICB8 ICAgMSArCiBkcml2ZXJzL3VzYi90eXBlYy9tdXgvZ3Bpby1zd2l0Y2guYyB8IDEwNSArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgMTEzIGluc2Vy dGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi90eXBlYy9tdXgvS2NvbmZpZyBiL2Ry aXZlcnMvdXNiL3R5cGVjL211eC9LY29uZmlnCmluZGV4IDAxZWQwZDUuLjI3MTIwZTYgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvdXNiL3R5cGVjL211eC9LY29uZmlnCisrKyBiL2RyaXZlcnMvdXNiL3R5 cGVjL211eC9LY29uZmlnCkBAIC05LDQgKzksMTEgQEAgY29uZmlnIFRZUEVDX01VWF9QSTNVU0Iz MDUzMgogCSAgU2F5IFkgb3IgTSBpZiB5b3VyIHN5c3RlbSBoYXMgYSBQZXJpY29tIFBJM1VTQjMw NTMyIFR5cGUtQyBjcm9zcwogCSAgc3dpdGNoIC8gbXV4IGNoaXAgZm91bmQgb24gc29tZSBkZXZp Y2VzIHdpdGggYSBUeXBlLUMgcG9ydC4KIAorY29uZmlnIFRZUEVDX1NXSVRDSF9HUElPCisJdHJp c3RhdGUgIlNpbXBsZSBTdXBlciBTcGVlZCBBY3RpdmUgU3dpdGNoIHZpYSBHUElPIgorCWRlcGVu ZHMgb24gR1BJT0xJQgorCWhlbHAKKwkgIFNheSBZIG9yIE0gaWYgeW91ciBzeXN0ZW0gaGFzIGEg dHlwZWMgc3VwZXIgc3BlZWQgY2hhbm5lbAorCSAgc3dpdGNoIHZpYSBhIHNpbXBsZSBHUElPIGNv bnRyb2wuCisKIGVuZG1lbnUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3R5cGVjL211eC9NYWtl ZmlsZSBiL2RyaXZlcnMvdXNiL3R5cGVjL211eC9NYWtlZmlsZQppbmRleCAxMzMyZTQ2Li5lMjkz NzdjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi90eXBlYy9tdXgvTWFrZWZpbGUKKysrIGIvZHJp dmVycy91c2IvdHlwZWMvbXV4L01ha2VmaWxlCkBAIC0xLDMgKzEsNCBAQAogIyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMAogCiBvYmotJChDT05GSUdfVFlQRUNfTVVYX1BJM1VTQjMw NTMyKQkrPSBwaTN1c2IzMDUzMi5vCitvYmotJChDT05GSUdfVFlQRUNfU1dJVENIX0dQSU8pCQkr PSBncGlvLXN3aXRjaC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi90eXBlYy9tdXgvZ3Bpby1z d2l0Y2guYyBiL2RyaXZlcnMvdXNiL3R5cGVjL211eC9ncGlvLXN3aXRjaC5jCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIwMTg0NGMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL3VzYi90eXBlYy9tdXgvZ3Bpby1zd2l0Y2guYwpAQCAtMCwwICsxLDEwNSBAQAorLy8gU1BE WC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qKgorICogZ3Bpby1zd2l0Y2guYyAtIHR5 cGVjIHN3aXRjaCB2aWEgYSBzaW1wbGUgR1BJTyBjb250cm9sLgorICoKKyAqIENvcHlyaWdodCAy MDE5IE5YUAorICogQXV0aG9yOiBKdW4gTGkgPGp1bi5saUBueHAuY29tPgorICoKKyAqLworCisj aW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KKyNpbmNs dWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4K KyNpbmNsdWRlIDxsaW51eC9ncGlvL2NvbnN1bWVyLmg+CisjaW5jbHVkZSA8bGludXgvbW9kX2Rl dmljZXRhYmxlLmg+CisjaW5jbHVkZSA8bGludXgvdXNiL3R5cGVjX211eC5oPgorCitzdHJ1Y3Qg Z3Bpb190eXBlY19zd2l0Y2ggeworCXN0cnVjdCB0eXBlY19zd2l0Y2ggc3c7CisJc3RydWN0IG11 dGV4IGxvY2s7CisJc3RydWN0IGdwaW9fZGVzYyAqc3Nfc2VsOworfTsKKworc3RhdGljIGludCBz d2l0Y2hfZ3Bpb19zZXQoc3RydWN0IHR5cGVjX3N3aXRjaCAqc3csCisJCQkgICBlbnVtIHR5cGVj X29yaWVudGF0aW9uIG9yaWVudGF0aW9uKQoreworCXN0cnVjdCBncGlvX3R5cGVjX3N3aXRjaCAq Z3Bpb19zdyA9IGNvbnRhaW5lcl9vZihzdywKKwkJCQlzdHJ1Y3QgZ3Bpb190eXBlY19zd2l0Y2gs IHN3KTsKKworCW11dGV4X2xvY2soJmdwaW9fc3ctPmxvY2spOworCisJc3dpdGNoIChvcmllbnRh dGlvbikgeworCWNhc2UgVFlQRUNfT1JJRU5UQVRJT05fTk9STUFMOgorCQlncGlvZF9zZXRfdmFs dWVfY2Fuc2xlZXAoZ3Bpb19zdy0+c3Nfc2VsLCAxKTsKKwkJYnJlYWs7CisJY2FzZSBUWVBFQ19P UklFTlRBVElPTl9SRVZFUlNFOgorCQlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAoZ3Bpb19zdy0+ c3Nfc2VsLCAwKTsKKwkJYnJlYWs7CisJY2FzZSBUWVBFQ19PUklFTlRBVElPTl9OT05FOgorCQli cmVhazsKKwl9CisKKwltdXRleF91bmxvY2soJmdwaW9fc3ctPmxvY2spOworCisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyBpbnQgdHlwZWNfc3dpdGNoX2dwaW9fcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgZ3Bpb190eXBlY19zd2l0Y2gJKmdwaW9fc3c7CisJ c3RydWN0IGRldmljZQkJCSpkZXYgPSAmcGRldi0+ZGV2OworCWludAkJCQlyZXQ7CisKKwlncGlv X3N3ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpncGlvX3N3KSwgR0ZQX0tFUk5FTCk7CisJ aWYgKCFncGlvX3N3KQorCQlyZXR1cm4gLUVOT01FTTsKKworCXBsYXRmb3JtX3NldF9kcnZkYXRh KHBkZXYsIGdwaW9fc3cpOworCisJZ3Bpb19zdy0+c3cuZGV2ID0gZGV2OworCWdwaW9fc3ctPnN3 LnNldCA9IHN3aXRjaF9ncGlvX3NldDsKKwltdXRleF9pbml0KCZncGlvX3N3LT5sb2NrKTsKKwor CS8qIEdldCB0aGUgc3VwZXIgc3BlZWQgYWN0aXZlIGNoYW5uZWwgc2VsZWN0aW9uIEdQSU8gKi8K KwlncGlvX3N3LT5zc19zZWwgPSBkZXZtX2dwaW9kX2dldChkZXYsIE5VTEwsIEdQSU9EX09VVF9M T1cpOworCWlmIChJU19FUlIoZ3Bpb19zdy0+c3Nfc2VsKSkKKwkJcmV0dXJuIFBUUl9FUlIoZ3Bp b19zdy0+c3Nfc2VsKTsKKworCXJldCA9IHR5cGVjX3N3aXRjaF9yZWdpc3RlcigmZ3Bpb19zdy0+ c3cpOworCWlmIChyZXQpIHsKKwkJZGV2X2VycihkZXYsICJFcnJvciByZWdpc3RlcmluZyB0eXBl YyBzd2l0Y2g6ICVkXG4iLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKworCXJldHVybiAwOwor fQorCitzdGF0aWMgaW50IHR5cGVjX3N3aXRjaF9ncGlvX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1f ZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBncGlvX3R5cGVjX3N3aXRjaCAqZ3Bpb19zdyA9IHBs YXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCisJdHlwZWNfc3dpdGNoX3VucmVnaXN0ZXIoJmdw aW9fc3ctPnN3KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2Rl dmljZV9pZCBvZl90eXBlY19zd2l0Y2hfZ3Bpb19tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUg PSAibnhwLHB0bjM2MDQzIiB9LAorCXsgLyogU2VudGluZWwgKi8gfQorfTsKK01PRFVMRV9ERVZJ Q0VfVEFCTEUob2YsIG9mX3R5cGVjX3N3aXRjaF9ncGlvX21hdGNoKTsKKworc3RhdGljIHN0cnVj dCBwbGF0Zm9ybV9kcml2ZXIgdHlwZWNfc3dpdGNoX2dwaW9fZHJpdmVyID0geworCS5wcm9iZQkJ PSB0eXBlY19zd2l0Y2hfZ3Bpb19wcm9iZSwKKwkucmVtb3ZlCQk9IHR5cGVjX3N3aXRjaF9ncGlv X3JlbW92ZSwKKwkuZHJpdmVyCQk9IHsKKwkJLm5hbWUJPSAidHlwZWMtc3dpdGNoLWdwaW8iLAor CQkub2ZfbWF0Y2hfdGFibGUgPSBvZl90eXBlY19zd2l0Y2hfZ3Bpb19tYXRjaCwKKwl9LAorfTsK KworbW9kdWxlX3BsYXRmb3JtX2RyaXZlcih0eXBlY19zd2l0Y2hfZ3Bpb19kcml2ZXIpOworTU9E VUxFX0xJQ0VOU0UoIkdQTCB2MiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJUeXBlQyBTdXBlciBT cGVlZCBTd2l0Y2ggR1BJTyBkcml2ZXIiKTsKK01PRFVMRV9BVVRIT1IoIkp1biBMaSA8anVuLmxp QG54cC5jb20+Iik7Cg==