drivers/net/mdio/mdio-i2c.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * MDIO I2C bridge
   4  *
   5  * Copyright (C) 2015-2016 Russell King
   6  * Copyright (C) 2021 Marek Behun
   7  *
   8  * Network PHYs can appear on I2C buses when they are part of SFP module.
   9  * This driver exposes these PHYs to the networking PHY code, allowing
  10  * our PHY drivers access to these PHYs, and so allowing configuration
  11  * of their settings.
  12  */
  13 #include <linux/i2c.h>
  14 #include <linux/mdio/mdio-i2c.h>
  15 #include <linux/phy.h>
  16 #include <linux/sfp.h>
  17
  18 /*
  19  * I2C bus addresses 0x50 and 0x51 are normally an EEPROM, which is
  20  * specified to be present in SFP modules.  These correspond with PHY
  21  * addresses 16 and 17.  Disallow access to these "phy" addresses.
  22  */
  23 static bool i2c_mii_valid_phy_id(int phy_id)
  24 {
  25         return phy_id != 0x10 && phy_id != 0x11;
  26 }
  27
  28 static unsigned int i2c_mii_phy_addr(int phy_id)
  29 {
  30         return phy_id + 0x40;
  31 }
  32
  33 static int i2c_mii_read_default_c45(struct mii_bus *bus, int phy_id, int devad,
  34                                     int reg)
  35 {
  36         struct i2c_adapter *i2c = bus->priv;
  37         struct i2c_msg msgs[2];
  38         u8 addr[3], data[2], *p;
  39         int bus_addr, ret;
  40
  41         if (!i2c_mii_valid_phy_id(phy_id))
  42                 return 0xffff;
  43
  44         p = addr;
  45         if (devad >= 0) {
  46                 *p++ = 0x20 | devad;
  47                 *p++ = reg >> 8;
  48         }
  49         *p++ = reg;
  50
  51         bus_addr = i2c_mii_phy_addr(phy_id);
  52         msgs[0].addr = bus_addr;
  53         msgs[0].flags = 0;
  54         msgs[0].len = p - addr;
  55         msgs[0].buf = addr;
  56         msgs[1].addr = bus_addr;
  57         msgs[1].flags = I2C_M_RD;
  58         msgs[1].len = sizeof(data);
  59         msgs[1].buf = data;
  60
  61         ret = i2c_transfer(i2c, msgs, ARRAY_SIZE(msgs));
  62         if (ret != ARRAY_SIZE(msgs))
  63                 return 0xffff;
  64
  65         return data[0] << 8 | data[1];
  66 }
  67
  68 static int i2c_mii_write_default_c45(struct mii_bus *bus, int phy_id,
  69                                      int devad, int reg, u16 val)
  70 {
  71         struct i2c_adapter *i2c = bus->priv;
  72         struct i2c_msg msg;
  73         int ret;
  74         u8 data[5], *p;
  75
  76         if (!i2c_mii_valid_phy_id(phy_id))
  77                 return 0;
  78
  79         p = data;
  80         if (devad >= 0) {
  81                 *p++ = devad;
  82                 *p++ = reg >> 8;
  83         }
  84         *p++ = reg;
  85         *p++ = val >> 8;
  86         *p++ = val;
  87
  88         msg.addr = i2c_mii_phy_addr(phy_id);
  89         msg.flags = 0;
  90         msg.len = p - data;
  91         msg.buf = data;
  92
  93         ret = i2c_transfer(i2c, &msg, 1);
  94
  95         return ret < 0 ? ret : 0;
  96 }
  97
  98 static int i2c_mii_read_default_c22(struct mii_bus *bus, int phy_id, int reg)
  99 {
 100         return i2c_mii_read_default_c45(bus, phy_id, -1, reg);
 101 }
 102
 103 static int i2c_mii_write_default_c22(struct mii_bus *bus, int phy_id, int reg,
 104                                      u16 val)
 105 {
 106         return i2c_mii_write_default_c45(bus, phy_id, -1, reg, val);
 107 }
 108
 109 /* RollBall SFPs do not access internal PHY via I2C address 0x56, but
 110  * instead via address 0x51, when SFP page is set to 0x03 and password to
 111  * 0xffffffff.
 112  *
 113  * address  size  contents  description
 114  * -------  ----  --------  -----------
 115  * 0x80     1     CMD       0x01/0x02/0x04 for write/read/done
 116  * 0x81     1     DEV       Clause 45 device
 117  * 0x82     2     REG       Clause 45 register
 118  * 0x84     2     VAL       Register value
 119  */
 120 #define ROLLBALL_PHY_I2C_ADDR           0x51
 121
 122 #define ROLLBALL_PASSWORD               (SFP_VSL + 3)
 123
 124 #define ROLLBALL_CMD_ADDR               0x80
 125 #define ROLLBALL_DATA_ADDR              0x81
 126
 127 #define ROLLBALL_CMD_WRITE              0x01
 128 #define ROLLBALL_CMD_READ               0x02
 129 #define ROLLBALL_CMD_DONE               0x04
 130
 131 #define SFP_PAGE_ROLLBALL_MDIO          3
 132
 133 static int __i2c_transfer_err(struct i2c_adapter *i2c, struct i2c_msg *msgs,
 134                               int num)
 135 {
 136         int ret;
 137
 138         ret = __i2c_transfer(i2c, msgs, num);
 139         if (ret < 0)
 140                 return ret;
 141         else if (ret != num)
 142                 return -EIO;
 143         else
 144                 return 0;
 145 }
 146
 147 static int __i2c_rollball_get_page(struct i2c_adapter *i2c, int bus_addr,
 148                                    u8 *page)
 149 {
 150         struct i2c_msg msgs[2];
 151         u8 addr = SFP_PAGE;
 152
 153         msgs[0].addr = bus_addr;
 154         msgs[0].flags = 0;
 155         msgs[0].len = 1;
 156         msgs[0].buf = &addr;
 157
 158         msgs[1].addr = bus_addr;
 159         msgs[1].flags = I2C_M_RD;
 160         msgs[1].len = 1;
 161         msgs[1].buf = page;
 162
 163         return __i2c_transfer_err(i2c, msgs, 2);
 164 }
 165
 166 static int __i2c_rollball_set_page(struct i2c_adapter *i2c, int bus_addr,
 167                                    u8 page)
 168 {
 169         struct i2c_msg msg;
 170         u8 buf[2];
 171
 172         buf[0] = SFP_PAGE;
 173         buf[1] = page;
 174
 175         msg.addr = bus_addr;
 176         msg.flags = 0;
 177         msg.len = 2;
 178         msg.buf = buf;
 179
 180         return __i2c_transfer_err(i2c, &msg, 1);
 181 }
 182
 183 /* In order to not interfere with other SFP code (which possibly may manipulate
 184  * SFP_PAGE), for every transfer we do this:
 185  *   1. lock the bus
 186  *   2. save content of SFP_PAGE
 187  *   3. set SFP_PAGE to 3
 188  *   4. do the transfer
 189  *   5. restore original SFP_PAGE
 190  *   6. unlock the bus
 191  * Note that one might think that steps 2 to 5 could be theoretically done all
 192  * in one call to i2c_transfer (by constructing msgs array in such a way), but
 193  * unfortunately tests show that this does not work :-( Changed SFP_PAGE does
 194  * not take into account until i2c_transfer() is done.
 195  */
 196 static int i2c_transfer_rollball(struct i2c_adapter *i2c,
 197                                  struct i2c_msg *msgs, int num)
 198 {
 199         int ret, main_err = 0;
 200         u8 saved_page;
 201
 202         i2c_lock_bus(i2c, I2C_LOCK_SEGMENT);
 203
 204         /* save original page */
 205         ret = __i2c_rollball_get_page(i2c, msgs->addr, &saved_page);
 206         if (ret)
 207                 goto unlock;
 208
 209         /* change to RollBall MDIO page */
 210         ret = __i2c_rollball_set_page(i2c, msgs->addr, SFP_PAGE_ROLLBALL_MDIO);
 211         if (ret)
 212                 goto unlock;
 213
 214         /* do the transfer; we try to restore original page if this fails */
 215         ret = __i2c_transfer_err(i2c, msgs, num);
 216         if (ret)
 217                 main_err = ret;
 218
 219         /* restore original page */
 220         ret = __i2c_rollball_set_page(i2c, msgs->addr, saved_page);
 221
 222 unlock:
 223         i2c_unlock_bus(i2c, I2C_LOCK_SEGMENT);
 224
 225         return main_err ? : ret;
 226 }
 227
 228 static int i2c_rollball_mii_poll(struct mii_bus *bus, int bus_addr, u8 *buf,
 229                                  size_t len)
 230 {
 231         struct i2c_adapter *i2c = bus->priv;
 232         struct i2c_msg msgs[2];
 233         u8 cmd_addr, tmp, *res;
 234         int i, ret;
 235
 236         cmd_addr = ROLLBALL_CMD_ADDR;
 237
 238         res = buf ? buf : &tmp;
 239         len = buf ? len : 1;
 240
 241         msgs[0].addr = bus_addr;
 242         msgs[0].flags = 0;
 243         msgs[0].len = 1;
 244         msgs[0].buf = &cmd_addr;
 245
 246         msgs[1].addr = bus_addr;
 247         msgs[1].flags = I2C_M_RD;
 248         msgs[1].len = len;
 249         msgs[1].buf = res;
 250
 251         /* By experiment it takes up to 70 ms to access a register for these
 252          * SFPs. Sleep 20ms between iterations and try 10 times.
 253          */
 254         i = 10;
 255         do {
 256                 msleep(20);
 257
 258                 ret = i2c_transfer_rollball(i2c, msgs, ARRAY_SIZE(msgs));
 259                 if (ret)
 260                         return ret;
 261
 262                 if (*res == ROLLBALL_CMD_DONE)
 263                         return 0;
 264         } while (i-- > 0);
 265
 266         dev_dbg(&bus->dev, "poll timed out\n");
 267
 268         return -ETIMEDOUT;
 269 }
 270
 271 static int i2c_rollball_mii_cmd(struct mii_bus *bus, int bus_addr, u8 cmd,
 272                                 u8 *data, size_t len)
 273 {
 274         struct i2c_adapter *i2c = bus->priv;
 275         struct i2c_msg msgs[2];
 276         u8 cmdbuf[2];
 277
 278         cmdbuf[0] = ROLLBALL_CMD_ADDR;
 279         cmdbuf[1] = cmd;
 280
 281         msgs[0].addr = bus_addr;
 282         msgs[0].flags = 0;
 283         msgs[0].len = len;
 284         msgs[0].buf = data;
 285
 286         msgs[1].addr = bus_addr;
 287         msgs[1].flags = 0;
 288         msgs[1].len = sizeof(cmdbuf);
 289         msgs[1].buf = cmdbuf;
 290
 291         return i2c_transfer_rollball(i2c, msgs, ARRAY_SIZE(msgs));
 292 }
 293
 294 static int i2c_mii_read_rollball(struct mii_bus *bus, int phy_id, int devad,
 295                                  int reg)
 296 {
 297         u8 buf[4], res[6];
 298         int bus_addr, ret;
 299         u16 val;
 300
 301         bus_addr = i2c_mii_phy_addr(phy_id);
 302         if (bus_addr != ROLLBALL_PHY_I2C_ADDR)
 303                 return 0xffff;
 304
 305         buf[0] = ROLLBALL_DATA_ADDR;
 306         buf[1] = devad;
 307         buf[2] = (reg >> 8) & 0xff;
 308         buf[3] = reg & 0xff;
 309
 310         ret = i2c_rollball_mii_cmd(bus, bus_addr, ROLLBALL_CMD_READ, buf,
 311                                    sizeof(buf));
 312         if (ret < 0)
 313                 return ret;
 314
 315         ret = i2c_rollball_mii_poll(bus, bus_addr, res, sizeof(res));
 316         if (ret == -ETIMEDOUT)
 317                 return 0xffff;
 318         else if (ret < 0)
 319                 return ret;
 320
 321         val = res[4] << 8 | res[5];
 322
 323         return val;
 324 }
 325
 326 static int i2c_mii_write_rollball(struct mii_bus *bus, int phy_id, int devad,
 327                                   int reg, u16 val)
 328 {
 329         int bus_addr, ret;
 330         u8 buf[6];
 331
 332         bus_addr = i2c_mii_phy_addr(phy_id);
 333         if (bus_addr != ROLLBALL_PHY_I2C_ADDR)
 334                 return 0;
 335
 336         buf[0] = ROLLBALL_DATA_ADDR;
 337         buf[1] = devad;
 338         buf[2] = (reg >> 8) & 0xff;
 339         buf[3] = reg & 0xff;
 340         buf[4] = val >> 8;
 341         buf[5] = val & 0xff;
 342
 343         ret = i2c_rollball_mii_cmd(bus, bus_addr, ROLLBALL_CMD_WRITE, buf,
 344                                    sizeof(buf));
 345         if (ret < 0)
 346                 return ret;
 347
 348         ret = i2c_rollball_mii_poll(bus, bus_addr, NULL, 0);
 349         if (ret < 0)
 350                 return ret;
 351
 352         return 0;
 353 }
 354
 355 static int i2c_mii_init_rollball(struct i2c_adapter *i2c)
 356 {
 357         struct i2c_msg msg;
 358         u8 pw[5];
 359         int ret;
 360
 361         pw[0] = ROLLBALL_PASSWORD;
 362         pw[1] = 0xff;
 363         pw[2] = 0xff;
 364         pw[3] = 0xff;
 365         pw[4] = 0xff;
 366
 367         msg.addr = ROLLBALL_PHY_I2C_ADDR;
 368         msg.flags = 0;
 369         msg.len = sizeof(pw);
 370         msg.buf = pw;
 371
 372         ret = i2c_transfer(i2c, &msg, 1);
 373         if (ret < 0)
 374                 return ret;
 375         else if (ret != 1)
 376                 return -EIO;
 377         else
 378                 return 0;
 379 }
 380
 381 struct mii_bus *mdio_i2c_alloc(struct device *parent, struct i2c_adapter *i2c,
 382                                enum mdio_i2c_proto protocol)
 383 {
 384         struct mii_bus *mii;
 385         int ret;
 386
 387         if (!i2c_check_functionality(i2c, I2C_FUNC_I2C))
 388                 return ERR_PTR(-EINVAL);
 389
 390         mii = mdiobus_alloc();
 391         if (!mii)
 392                 return ERR_PTR(-ENOMEM);
 393
 394         snprintf(mii->id, MII_BUS_ID_SIZE, "i2c:%s", dev_name(parent));
 395         mii->parent = parent;
 396         mii->priv = i2c;
 397
 398         switch (protocol) {
 399         case MDIO_I2C_ROLLBALL:
 400                 ret = i2c_mii_init_rollball(i2c);
 401                 if (ret < 0) {
 402                         dev_err(parent,
 403                                 "Cannot initialize RollBall MDIO I2C protocol: %d\n",
 404                                 ret);
 405                         mdiobus_free(mii);
 406                         return ERR_PTR(ret);
 407                 }
 408
 409                 mii->read_c45 = i2c_mii_read_rollball;
 410                 mii->write_c45 = i2c_mii_write_rollball;
 411                 break;
 412         default:
 413                 mii->read = i2c_mii_read_default_c22;
 414                 mii->write = i2c_mii_write_default_c22;
 415                 mii->read_c45 = i2c_mii_read_default_c45;
 416                 mii->write_c45 = i2c_mii_write_default_c45;
 417                 break;
 418         }
 419
 420         return mii;
 421 }
 422 EXPORT_SYMBOL_GPL(mdio_i2c_alloc);
 423
 424 MODULE_AUTHOR("Russell King");
 425 MODULE_DESCRIPTION("MDIO I2C bridge library");
 426 MODULE_LICENSE("GPL v2");