1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * GPIO based MDIO bitbang driver. 4 * Supports OpenFirmware. 5 * 6 * Copyright (c) 2008 CSE Semaphore Belgium. 7 * by Laurent Pinchart <laurentp@cse-semaphore.com> 8 * 9 * Copyright (C) 2008, Paulius Zaleckas <paulius.zaleckas@teltonika.lt> 10 * 11 * Based on earlier work by 12 * 13 * Copyright (c) 2003 Intracom S.A. 14 * by Pantelis Antoniou <panto@intracom.gr> 15 * 16 * 2005 (c) MontaVista Software, Inc. 17 * Vitaly Bordug <vbordug@ru.mvista.com> 18 */ 19 20 #include <linux/gpio/consumer.h> 21 #include <linux/interrupt.h> 22 #include <linux/mdio-bitbang.h> 23 #include <linux/module.h> 24 #include <linux/of_mdio.h> 25 #include <linux/platform_device.h> 26 #include <linux/slab.h> 27 28 #define MDIO_GPIO_MDC 0 29 #define MDIO_GPIO_MDIO 1 30 #define MDIO_GPIO_MDO 2 31 32 struct mdio_gpio_info { 33 struct mdiobb_ctrl ctrl; 34 struct gpio_desc *mdc, *mdio, *mdo; 35 }; 36 37 static int mdio_gpio_get_data(struct device *dev, 38 struct mdio_gpio_info *bitbang) 39 { 40 bitbang->mdc = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDC, 41 GPIOD_OUT_LOW); 42 if (IS_ERR(bitbang->mdc)) 43 return PTR_ERR(bitbang->mdc); 44 45 bitbang->mdio = devm_gpiod_get_index(dev, NULL, MDIO_GPIO_MDIO, 46 GPIOD_IN); 47 if (IS_ERR(bitbang->mdio)) 48 return PTR_ERR(bitbang->mdio); 49 50 bitbang->mdo = devm_gpiod_get_index_optional(dev, NULL, MDIO_GPIO_MDO, 51 GPIOD_OUT_LOW); 52 return PTR_ERR_OR_ZERO(bitbang->mdo); 53 } 54 55 static void mdio_dir(struct mdiobb_ctrl *ctrl, int dir) 56 { 57 struct mdio_gpio_info *bitbang = 58 container_of(ctrl, struct mdio_gpio_info, ctrl); 59 60 if (bitbang->mdo) { 61 /* Separate output pin. Always set its value to high 62 * when changing direction. If direction is input, 63 * assume the pin serves as pull-up. If direction is 64 * output, the default value is high. 65 */ 66 gpiod_set_value_cansleep(bitbang->mdo, 1); 67 return; 68 } 69 70 if (dir) 71 gpiod_direction_output(bitbang->mdio, 1); 72 else 73 gpiod_direction_input(bitbang->mdio); 74 } 75 76 static int mdio_get(struct mdiobb_ctrl *ctrl) 77 { 78 struct mdio_gpio_info *bitbang = 79 container_of(ctrl, struct mdio_gpio_info, ctrl); 80 81 return gpiod_get_value_cansleep(bitbang->mdio); 82 } 83 84 static void mdio_set(struct mdiobb_ctrl *ctrl, int what) 85 { 86 struct mdio_gpio_info *bitbang = 87 container_of(ctrl, struct mdio_gpio_info, ctrl); 88 89 if (bitbang->mdo) 90 gpiod_set_value_cansleep(bitbang->mdo, what); 91 else 92 gpiod_set_value_cansleep(bitbang->mdio, what); 93 } 94 95 static void mdc_set(struct mdiobb_ctrl *ctrl, int what) 96 { 97 struct mdio_gpio_info *bitbang = 98 container_of(ctrl, struct mdio_gpio_info, ctrl); 99 100 gpiod_set_value_cansleep(bitbang->mdc, what); 101 } 102 103 static const struct mdiobb_ops mdio_gpio_ops = { 104 .owner = THIS_MODULE, 105 .set_mdc = mdc_set, 106 .set_mdio_dir = mdio_dir, 107 .set_mdio_data = mdio_set, 108 .get_mdio_data = mdio_get, 109 }; 110 111 static struct mii_bus *mdio_gpio_bus_init(struct device *dev, 112 struct mdio_gpio_info *bitbang, 113 int bus_id) 114 { 115 struct mii_bus *new_bus; 116 117 bitbang->ctrl.ops = &mdio_gpio_ops; 118 119 new_bus = alloc_mdio_bitbang(&bitbang->ctrl); 120 if (!new_bus) 121 return NULL; 122 123 new_bus->name = "GPIO Bitbanged MDIO"; 124 new_bus->parent = dev; 125 126 if (bus_id != -1) 127 snprintf(new_bus->id, sizeof(new_bus->id), "gpio-%x", bus_id); 128 else 129 strscpy(new_bus->id, "gpio", sizeof(new_bus->id)); 130 131 if (device_is_compatible(dev, "microchip,mdio-smi0")) { 132 bitbang->ctrl.op_c22_read = 0; 133 bitbang->ctrl.op_c22_write = 0; 134 bitbang->ctrl.override_op_c22 = 1; 135 } 136 137 dev_set_drvdata(dev, new_bus); 138 139 return new_bus; 140 } 141 142 static void mdio_gpio_bus_deinit(struct device *dev) 143 { 144 struct mii_bus *bus = dev_get_drvdata(dev); 145 146 free_mdio_bitbang(bus); 147 } 148 149 static void mdio_gpio_bus_destroy(struct device *dev) 150 { 151 struct mii_bus *bus = dev_get_drvdata(dev); 152 153 mdiobus_unregister(bus); 154 mdio_gpio_bus_deinit(dev); 155 } 156 157 static int mdio_gpio_probe(struct platform_device *pdev) 158 { 159 struct mdio_gpio_info *bitbang; 160 struct mii_bus *new_bus; 161 int ret, bus_id; 162 163 bitbang = devm_kzalloc(&pdev->dev, sizeof(*bitbang), GFP_KERNEL); 164 if (!bitbang) 165 return -ENOMEM; 166 167 ret = mdio_gpio_get_data(&pdev->dev, bitbang); 168 if (ret) 169 return ret; 170 171 if (pdev->dev.of_node) { 172 bus_id = of_alias_get_id(pdev->dev.of_node, "mdio-gpio"); 173 if (bus_id < 0) { 174 dev_warn(&pdev->dev, "failed to get alias id\n"); 175 bus_id = 0; 176 } 177 } else { 178 bus_id = pdev->id; 179 } 180 181 new_bus = mdio_gpio_bus_init(&pdev->dev, bitbang, bus_id); 182 if (!new_bus) 183 return -ENODEV; 184 185 ret = of_mdiobus_register(new_bus, pdev->dev.of_node); 186 if (ret) 187 mdio_gpio_bus_deinit(&pdev->dev); 188 189 return ret; 190 } 191 192 static void mdio_gpio_remove(struct platform_device *pdev) 193 { 194 mdio_gpio_bus_destroy(&pdev->dev); 195 } 196 197 static const struct of_device_id mdio_gpio_of_match[] = { 198 { .compatible = "virtual,mdio-gpio", }, 199 { .compatible = "microchip,mdio-smi0" }, 200 { /* sentinel */ } 201 }; 202 MODULE_DEVICE_TABLE(of, mdio_gpio_of_match); 203 204 static struct platform_driver mdio_gpio_driver = { 205 .probe = mdio_gpio_probe, 206 .remove = mdio_gpio_remove, 207 .driver = { 208 .name = "mdio-gpio", 209 .of_match_table = mdio_gpio_of_match, 210 }, 211 }; 212 213 module_platform_driver(mdio_gpio_driver); 214 215 MODULE_ALIAS("platform:mdio-gpio"); 216 MODULE_AUTHOR("Laurent Pinchart, Paulius Zaleckas"); 217 MODULE_LICENSE("GPL v2"); 218 MODULE_DESCRIPTION("Generic driver for MDIO bus emulation using GPIO"); 219