1 // SPDX-License-Identifier: GPL-2.0+ 2 /* Realtek Simple Management Interface (SMI) driver 3 * It can be discussed how "simple" this interface is. 4 * 5 * The SMI protocol piggy-backs the MDIO MDC and MDIO signals levels 6 * but the protocol is not MDIO at all. Instead it is a Realtek 7 * pecularity that need to bit-bang the lines in a special way to 8 * communicate with the switch. 9 * 10 * ASICs we intend to support with this driver: 11 * 12 * RTL8366 - The original version, apparently 13 * RTL8369 - Similar enough to have the same datsheet as RTL8366 14 * RTL8366RB - Probably reads out "RTL8366 revision B", has a quite 15 * different register layout from the other two 16 * RTL8366S - Is this "RTL8366 super"? 17 * RTL8367 - Has an OpenWRT driver as well 18 * RTL8368S - Seems to be an alternative name for RTL8366RB 19 * RTL8370 - Also uses SMI 20 * 21 * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org> 22 * Copyright (C) 2010 Antti Seppälä <a.seppala@gmail.com> 23 * Copyright (C) 2010 Roman Yeryomin <roman@advem.lv> 24 * Copyright (C) 2011 Colin Leitner <colin.leitner@googlemail.com> 25 * Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org> 26 */ 27 28 #include <linux/kernel.h> 29 #include <linux/module.h> 30 #include <linux/device.h> 31 #include <linux/spinlock.h> 32 #include <linux/skbuff.h> 33 #include <linux/of.h> 34 #include <linux/delay.h> 35 #include <linux/gpio/consumer.h> 36 #include <linux/platform_device.h> 37 #include <linux/regmap.h> 38 #include <linux/bitops.h> 39 #include <linux/if_bridge.h> 40 41 #include "realtek.h" 42 #include "realtek-smi.h" 43 #include "rtl83xx.h" 44 45 #define REALTEK_SMI_ACK_RETRY_COUNT 5 46 47 static inline void realtek_smi_clk_delay(struct realtek_priv *priv) 48 { 49 ndelay(priv->variant->clk_delay); 50 } 51 52 static void realtek_smi_start(struct realtek_priv *priv) 53 { 54 /* Set GPIO pins to output mode, with initial state: 55 * SCK = 0, SDA = 1 56 */ 57 gpiod_direction_output(priv->mdc, 0); 58 gpiod_direction_output(priv->mdio, 1); 59 realtek_smi_clk_delay(priv); 60 61 /* CLK 1: 0 -> 1, 1 -> 0 */ 62 gpiod_set_value(priv->mdc, 1); 63 realtek_smi_clk_delay(priv); 64 gpiod_set_value(priv->mdc, 0); 65 realtek_smi_clk_delay(priv); 66 67 /* CLK 2: */ 68 gpiod_set_value(priv->mdc, 1); 69 realtek_smi_clk_delay(priv); 70 gpiod_set_value(priv->mdio, 0); 71 realtek_smi_clk_delay(priv); 72 gpiod_set_value(priv->mdc, 0); 73 realtek_smi_clk_delay(priv); 74 gpiod_set_value(priv->mdio, 1); 75 } 76 77 static void realtek_smi_stop(struct realtek_priv *priv) 78 { 79 realtek_smi_clk_delay(priv); 80 gpiod_set_value(priv->mdio, 0); 81 gpiod_set_value(priv->mdc, 1); 82 realtek_smi_clk_delay(priv); 83 gpiod_set_value(priv->mdio, 1); 84 realtek_smi_clk_delay(priv); 85 gpiod_set_value(priv->mdc, 1); 86 realtek_smi_clk_delay(priv); 87 gpiod_set_value(priv->mdc, 0); 88 realtek_smi_clk_delay(priv); 89 gpiod_set_value(priv->mdc, 1); 90 91 /* Add a click */ 92 realtek_smi_clk_delay(priv); 93 gpiod_set_value(priv->mdc, 0); 94 realtek_smi_clk_delay(priv); 95 gpiod_set_value(priv->mdc, 1); 96 97 /* Set GPIO pins to input mode */ 98 gpiod_direction_input(priv->mdio); 99 gpiod_direction_input(priv->mdc); 100 } 101 102 static void realtek_smi_write_bits(struct realtek_priv *priv, u32 data, u32 len) 103 { 104 for (; len > 0; len--) { 105 realtek_smi_clk_delay(priv); 106 107 /* Prepare data */ 108 gpiod_set_value(priv->mdio, !!(data & (1 << (len - 1)))); 109 realtek_smi_clk_delay(priv); 110 111 /* Clocking */ 112 gpiod_set_value(priv->mdc, 1); 113 realtek_smi_clk_delay(priv); 114 gpiod_set_value(priv->mdc, 0); 115 } 116 } 117 118 static void realtek_smi_read_bits(struct realtek_priv *priv, u32 len, u32 *data) 119 { 120 gpiod_direction_input(priv->mdio); 121 122 for (*data = 0; len > 0; len--) { 123 u32 u; 124 125 realtek_smi_clk_delay(priv); 126 127 /* Clocking */ 128 gpiod_set_value(priv->mdc, 1); 129 realtek_smi_clk_delay(priv); 130 u = !!gpiod_get_value(priv->mdio); 131 gpiod_set_value(priv->mdc, 0); 132 133 *data |= (u << (len - 1)); 134 } 135 136 gpiod_direction_output(priv->mdio, 0); 137 } 138 139 static int realtek_smi_wait_for_ack(struct realtek_priv *priv) 140 { 141 int retry_cnt; 142 143 retry_cnt = 0; 144 do { 145 u32 ack; 146 147 realtek_smi_read_bits(priv, 1, &ack); 148 if (ack == 0) 149 break; 150 151 if (++retry_cnt > REALTEK_SMI_ACK_RETRY_COUNT) { 152 dev_err(priv->dev, "ACK timeout\n"); 153 return -ETIMEDOUT; 154 } 155 } while (1); 156 157 return 0; 158 } 159 160 static int realtek_smi_write_byte(struct realtek_priv *priv, u8 data) 161 { 162 realtek_smi_write_bits(priv, data, 8); 163 return realtek_smi_wait_for_ack(priv); 164 } 165 166 static int realtek_smi_write_byte_noack(struct realtek_priv *priv, u8 data) 167 { 168 realtek_smi_write_bits(priv, data, 8); 169 return 0; 170 } 171 172 static int realtek_smi_read_byte0(struct realtek_priv *priv, u8 *data) 173 { 174 u32 t; 175 176 /* Read data */ 177 realtek_smi_read_bits(priv, 8, &t); 178 *data = (t & 0xff); 179 180 /* Send an ACK */ 181 realtek_smi_write_bits(priv, 0x00, 1); 182 183 return 0; 184 } 185 186 static int realtek_smi_read_byte1(struct realtek_priv *priv, u8 *data) 187 { 188 u32 t; 189 190 /* Read data */ 191 realtek_smi_read_bits(priv, 8, &t); 192 *data = (t & 0xff); 193 194 /* Send an ACK */ 195 realtek_smi_write_bits(priv, 0x01, 1); 196 197 return 0; 198 } 199 200 static int realtek_smi_read_reg(struct realtek_priv *priv, u32 addr, u32 *data) 201 { 202 unsigned long flags; 203 u8 lo = 0; 204 u8 hi = 0; 205 int ret; 206 207 spin_lock_irqsave(&priv->lock, flags); 208 209 realtek_smi_start(priv); 210 211 /* Send READ command */ 212 ret = realtek_smi_write_byte(priv, priv->variant->cmd_read); 213 if (ret) 214 goto out; 215 216 /* Set ADDR[7:0] */ 217 ret = realtek_smi_write_byte(priv, addr & 0xff); 218 if (ret) 219 goto out; 220 221 /* Set ADDR[15:8] */ 222 ret = realtek_smi_write_byte(priv, addr >> 8); 223 if (ret) 224 goto out; 225 226 /* Read DATA[7:0] */ 227 realtek_smi_read_byte0(priv, &lo); 228 /* Read DATA[15:8] */ 229 realtek_smi_read_byte1(priv, &hi); 230 231 *data = ((u32)lo) | (((u32)hi) << 8); 232 233 ret = 0; 234 235 out: 236 realtek_smi_stop(priv); 237 spin_unlock_irqrestore(&priv->lock, flags); 238 239 return ret; 240 } 241 242 static int realtek_smi_write_reg(struct realtek_priv *priv, 243 u32 addr, u32 data, bool ack) 244 { 245 unsigned long flags; 246 int ret; 247 248 spin_lock_irqsave(&priv->lock, flags); 249 250 realtek_smi_start(priv); 251 252 /* Send WRITE command */ 253 ret = realtek_smi_write_byte(priv, priv->variant->cmd_write); 254 if (ret) 255 goto out; 256 257 /* Set ADDR[7:0] */ 258 ret = realtek_smi_write_byte(priv, addr & 0xff); 259 if (ret) 260 goto out; 261 262 /* Set ADDR[15:8] */ 263 ret = realtek_smi_write_byte(priv, addr >> 8); 264 if (ret) 265 goto out; 266 267 /* Write DATA[7:0] */ 268 ret = realtek_smi_write_byte(priv, data & 0xff); 269 if (ret) 270 goto out; 271 272 /* Write DATA[15:8] */ 273 if (ack) 274 ret = realtek_smi_write_byte(priv, data >> 8); 275 else 276 ret = realtek_smi_write_byte_noack(priv, data >> 8); 277 if (ret) 278 goto out; 279 280 ret = 0; 281 282 out: 283 realtek_smi_stop(priv); 284 spin_unlock_irqrestore(&priv->lock, flags); 285 286 return ret; 287 } 288 289 /* There is one single case when we need to use this accessor and that 290 * is when issueing soft reset. Since the device reset as soon as we write 291 * that bit, no ACK will come back for natural reasons. 292 */ 293 static int realtek_smi_write_reg_noack(void *ctx, u32 reg, u32 val) 294 { 295 return realtek_smi_write_reg(ctx, reg, val, false); 296 } 297 298 /* Regmap accessors */ 299 300 static int realtek_smi_write(void *ctx, u32 reg, u32 val) 301 { 302 struct realtek_priv *priv = ctx; 303 304 return realtek_smi_write_reg(priv, reg, val, true); 305 } 306 307 static int realtek_smi_read(void *ctx, u32 reg, u32 *val) 308 { 309 struct realtek_priv *priv = ctx; 310 311 return realtek_smi_read_reg(priv, reg, val); 312 } 313 314 static const struct realtek_interface_info realtek_smi_info = { 315 .reg_read = realtek_smi_read, 316 .reg_write = realtek_smi_write, 317 }; 318 319 /** 320 * realtek_smi_probe() - Probe a platform device for an SMI-connected switch 321 * @pdev: platform_device to probe on. 322 * 323 * This function should be used as the .probe in a platform_driver. After 324 * calling the common probe function for both interfaces, it initializes the 325 * values specific for SMI-connected devices. Finally, it calls a common 326 * function to register the DSA switch. 327 * 328 * Context: Can sleep. Takes and releases priv->map_lock. 329 * Return: Returns 0 on success, a negative error on failure. 330 */ 331 int realtek_smi_probe(struct platform_device *pdev) 332 { 333 struct device *dev = &pdev->dev; 334 struct realtek_priv *priv; 335 int ret; 336 337 priv = rtl83xx_probe(dev, &realtek_smi_info); 338 if (IS_ERR(priv)) 339 return PTR_ERR(priv); 340 341 /* Fetch MDIO pins */ 342 priv->mdc = devm_gpiod_get_optional(dev, "mdc", GPIOD_OUT_LOW); 343 if (IS_ERR(priv->mdc)) { 344 rtl83xx_remove(priv); 345 return PTR_ERR(priv->mdc); 346 } 347 348 priv->mdio = devm_gpiod_get_optional(dev, "mdio", GPIOD_OUT_LOW); 349 if (IS_ERR(priv->mdio)) { 350 rtl83xx_remove(priv); 351 return PTR_ERR(priv->mdio); 352 } 353 354 priv->write_reg_noack = realtek_smi_write_reg_noack; 355 356 ret = rtl83xx_register_switch(priv); 357 if (ret) { 358 rtl83xx_remove(priv); 359 return ret; 360 } 361 362 return 0; 363 } 364 EXPORT_SYMBOL_NS_GPL(realtek_smi_probe, REALTEK_DSA); 365 366 /** 367 * realtek_smi_remove() - Remove the driver of a SMI-connected switch 368 * @pdev: platform_device to be removed. 369 * 370 * This function should be used as the .remove_new in a platform_driver. First 371 * it unregisters the DSA switch and then it calls the common remove function. 372 * 373 * Context: Can sleep. 374 * Return: Nothing. 375 */ 376 void realtek_smi_remove(struct platform_device *pdev) 377 { 378 struct realtek_priv *priv = platform_get_drvdata(pdev); 379 380 if (!priv) 381 return; 382 383 rtl83xx_unregister_switch(priv); 384 385 rtl83xx_remove(priv); 386 } 387 EXPORT_SYMBOL_NS_GPL(realtek_smi_remove, REALTEK_DSA); 388 389 /** 390 * realtek_smi_shutdown() - Shutdown the driver of a SMI-connected switch 391 * @pdev: platform_device shutting down. 392 * 393 * This function should be used as the .shutdown in a platform_driver. It calls 394 * the common shutdown function. 395 * 396 * Context: Can sleep. 397 * Return: Nothing. 398 */ 399 void realtek_smi_shutdown(struct platform_device *pdev) 400 { 401 struct realtek_priv *priv = platform_get_drvdata(pdev); 402 403 if (!priv) 404 return; 405 406 rtl83xx_shutdown(priv); 407 } 408 EXPORT_SYMBOL_NS_GPL(realtek_smi_shutdown, REALTEK_DSA); 409