kernel/drivers/infiniband/hw/qib/qib_qsfp.c

   1 /*
   2  * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
   3  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      - Redistributions of source code must retain the above
  16  *        copyright notice, this list of conditions and the following
  17  *        disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer in the documentation and/or other materials
  22  *        provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 #include <linux/delay.h>
  35 #include <linux/pci.h>
  36 #include <linux/vmalloc.h>
  37
  38 #include "qib.h"
  39 #include "qib_qsfp.h"
  40
  41 /*
  42  * QSFP support for ib_qib driver, using "Two Wire Serial Interface" driver
  43  * in qib_twsi.c
  44  */
  45 #define QSFP_MAX_RETRY 4
  46
  47 static int qsfp_read(struct qib_pportdata *ppd, int addr, void *bp, int len)
  48 {
  49         struct qib_devdata *dd = ppd->dd;
  50         u32 out, mask;
  51         int ret, cnt, pass = 0;
  52         int stuck = 0;
  53         u8 *buff = bp;
  54
  55         ret = mutex_lock_interruptible(&dd->eep_lock);
  56         if (ret)
  57                 goto no_unlock;
  58
  59         if (dd->twsi_eeprom_dev == QIB_TWSI_NO_DEV) {
  60                 ret = -ENXIO;
  61                 goto bail;
  62         }
  63
  64         /*
  65          * We presume, if we are called at all, that this board has
  66          * QSFP. This is on the same i2c chain as the legacy parts,
  67          * but only responds if the module is selected via GPIO pins.
  68          * Further, there are very long setup and hold requirements
  69          * on MODSEL.
  70          */
  71         mask = QSFP_GPIO_MOD_SEL_N | QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
  72         out = QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
  73         if (ppd->hw_pidx) {
  74                 mask <<= QSFP_GPIO_PORT2_SHIFT;
  75                 out <<= QSFP_GPIO_PORT2_SHIFT;
  76         }
  77
  78         dd->f_gpio_mod(dd, out, mask, mask);
  79
  80         /*
  81          * Module could take up to 2 Msec to respond to MOD_SEL, and there
  82          * is no way to tell if it is ready, so we must wait.
  83          */
  84         msleep(20);
  85
  86         /* Make sure TWSI bus is in sane state. */
  87         ret = qib_twsi_reset(dd);
  88         if (ret) {
  89                 qib_dev_porterr(dd, ppd->port,
  90                                 "QSFP interface Reset for read failed\n");
  91                 ret = -EIO;
  92                 stuck = 1;
  93                 goto deselect;
  94         }
  95
  96         /* All QSFP modules are at A0 */
  97
  98         cnt = 0;
  99         while (cnt < len) {
 100                 unsigned in_page;
 101                 int wlen = len - cnt;
 102
 103                 in_page = addr % QSFP_PAGESIZE;
 104                 if ((in_page + wlen) > QSFP_PAGESIZE)
 105                         wlen = QSFP_PAGESIZE - in_page;
 106                 ret = qib_twsi_blk_rd(dd, QSFP_DEV, addr, buff + cnt, wlen);
 107                 /* Some QSFP's fail first try. Retry as experiment */
 108                 if (ret && cnt == 0 && ++pass < QSFP_MAX_RETRY)
 109                         continue;
 110                 if (ret) {
 111                         /* qib_twsi_blk_rd() 1 for error, else 0 */
 112                         ret = -EIO;
 113                         goto deselect;
 114                 }
 115                 addr += wlen;
 116                 cnt += wlen;
 117         }
 118         ret = cnt;
 119
 120 deselect:
 121         /*
 122          * Module could take up to 10 uSec after transfer before
 123          * ready to respond to MOD_SEL negation, and there is no way
 124          * to tell if it is ready, so we must wait.
 125          */
 126         udelay(10);
 127         /* set QSFP MODSEL, RST. LP all high */
 128         dd->f_gpio_mod(dd, mask, mask, mask);
 129
 130         /*
 131          * Module could take up to 2 Msec to respond to MOD_SEL
 132          * going away, and there is no way to tell if it is ready.
 133          * so we must wait.
 134          */
 135         if (stuck)
 136                 qib_dev_err(dd, "QSFP interface bus stuck non-idle\n");
 137
 138         if (pass >= QSFP_MAX_RETRY && ret)
 139                 qib_dev_porterr(dd, ppd->port, "QSFP failed even retrying\n");
 140         else if (pass)
 141                 qib_dev_porterr(dd, ppd->port, "QSFP retries: %d\n", pass);
 142
 143         msleep(20);
 144
 145 bail:
 146         mutex_unlock(&dd->eep_lock);
 147
 148 no_unlock:
 149         return ret;
 150 }
 151
 152 /*
 153  * qsfp_write
 154  * We do not ordinarily write the QSFP, but this is needed to select
 155  * the page on non-flat QSFPs, and possibly later unusual cases
 156  */
 157 static int qib_qsfp_write(struct qib_pportdata *ppd, int addr, void *bp,
 158                           int len)
 159 {
 160         struct qib_devdata *dd = ppd->dd;
 161         u32 out, mask;
 162         int ret, cnt;
 163         u8 *buff = bp;
 164
 165         ret = mutex_lock_interruptible(&dd->eep_lock);
 166         if (ret)
 167                 goto no_unlock;
 168
 169         if (dd->twsi_eeprom_dev == QIB_TWSI_NO_DEV) {
 170                 ret = -ENXIO;
 171                 goto bail;
 172         }
 173
 174         /*
 175          * We presume, if we are called at all, that this board has
 176          * QSFP. This is on the same i2c chain as the legacy parts,
 177          * but only responds if the module is selected via GPIO pins.
 178          * Further, there are very long setup and hold requirements
 179          * on MODSEL.
 180          */
 181         mask = QSFP_GPIO_MOD_SEL_N | QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
 182         out = QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
 183         if (ppd->hw_pidx) {
 184                 mask <<= QSFP_GPIO_PORT2_SHIFT;
 185                 out <<= QSFP_GPIO_PORT2_SHIFT;
 186         }
 187         dd->f_gpio_mod(dd, out, mask, mask);
 188
 189         /*
 190          * Module could take up to 2 Msec to respond to MOD_SEL,
 191          * and there is no way to tell if it is ready, so we must wait.
 192          */
 193         msleep(20);
 194
 195         /* Make sure TWSI bus is in sane state. */
 196         ret = qib_twsi_reset(dd);
 197         if (ret) {
 198                 qib_dev_porterr(dd, ppd->port,
 199                                 "QSFP interface Reset for write failed\n");
 200                 ret = -EIO;
 201                 goto deselect;
 202         }
 203
 204         /* All QSFP modules are at A0 */
 205
 206         cnt = 0;
 207         while (cnt < len) {
 208                 unsigned in_page;
 209                 int wlen = len - cnt;
 210
 211                 in_page = addr % QSFP_PAGESIZE;
 212                 if ((in_page + wlen) > QSFP_PAGESIZE)
 213                         wlen = QSFP_PAGESIZE - in_page;
 214                 ret = qib_twsi_blk_wr(dd, QSFP_DEV, addr, buff + cnt, wlen);
 215                 if (ret) {
 216                         /* qib_twsi_blk_wr() 1 for error, else 0 */
 217                         ret = -EIO;
 218                         goto deselect;
 219                 }
 220                 addr += wlen;
 221                 cnt += wlen;
 222         }
 223         ret = cnt;
 224
 225 deselect:
 226         /*
 227          * Module could take up to 10 uSec after transfer before
 228          * ready to respond to MOD_SEL negation, and there is no way
 229          * to tell if it is ready, so we must wait.
 230          */
 231         udelay(10);
 232         /* set QSFP MODSEL, RST, LP high */
 233         dd->f_gpio_mod(dd, mask, mask, mask);
 234         /*
 235          * Module could take up to 2 Msec to respond to MOD_SEL
 236          * going away, and there is no way to tell if it is ready.
 237          * so we must wait.
 238          */
 239         msleep(20);
 240
 241 bail:
 242         mutex_unlock(&dd->eep_lock);
 243
 244 no_unlock:
 245         return ret;
 246 }
 247
 248 /*
 249  * For validation, we want to check the checksums, even of the
 250  * fields we do not otherwise use. This function reads the bytes from
 251  * <first> to <next-1> and returns the 8lsbs of the sum, or <0 for errors
 252  */
 253 static int qsfp_cks(struct qib_pportdata *ppd, int first, int next)
 254 {
 255         int ret;
 256         u16 cks;
 257         u8 bval;
 258
 259         cks = 0;
 260         while (first < next) {
 261                 ret = qsfp_read(ppd, first, &bval, 1);
 262                 if (ret < 0)
 263                         goto bail;
 264                 cks += bval;
 265                 ++first;
 266         }
 267         ret = cks & 0xFF;
 268 bail:
 269         return ret;
 270
 271 }
 272
 273 int qib_refresh_qsfp_cache(struct qib_pportdata *ppd, struct qib_qsfp_cache *cp)
 274 {
 275         int ret;
 276         int idx;
 277         u16 cks;
 278         u8 peek[4];
 279
 280         /* ensure sane contents on invalid reads, for cable swaps */
 281         memset(cp, 0, sizeof(*cp));
 282
 283         if (!qib_qsfp_mod_present(ppd)) {
 284                 ret = -ENODEV;
 285                 goto bail;
 286         }
 287
 288         ret = qsfp_read(ppd, 0, peek, 3);
 289         if (ret < 0)
 290                 goto bail;
 291         if ((peek[0] & 0xFE) != 0x0C)
 292                 qib_dev_porterr(ppd->dd, ppd->port,
 293                                 "QSFP byte0 is 0x%02X, S/B 0x0C/D\n", peek[0]);
 294
 295         if ((peek[2] & 2) == 0) {
 296                 /*
 297                  * If cable is paged, rather than "flat memory", we need to
 298                  * set the page to zero, Even if it already appears to be zero.
 299                  */
 300                 u8 poke = 0;
 301
 302                 ret = qib_qsfp_write(ppd, 127, &poke, 1);
 303                 udelay(50);
 304                 if (ret != 1) {
 305                         qib_dev_porterr(ppd->dd, ppd->port,
 306                                         "Failed QSFP Page set\n");
 307                         goto bail;
 308                 }
 309         }
 310
 311         ret = qsfp_read(ppd, QSFP_MOD_ID_OFFS, &cp->id, 1);
 312         if (ret < 0)
 313                 goto bail;
 314         if ((cp->id & 0xFE) != 0x0C)
 315                 qib_dev_porterr(ppd->dd, ppd->port,
 316                                 "QSFP ID byte is 0x%02X, S/B 0x0C/D\n", cp->id);
 317         cks = cp->id;
 318
 319         ret = qsfp_read(ppd, QSFP_MOD_PWR_OFFS, &cp->pwr, 1);
 320         if (ret < 0)
 321                 goto bail;
 322         cks += cp->pwr;
 323
 324         ret = qsfp_cks(ppd, QSFP_MOD_PWR_OFFS + 1, QSFP_MOD_LEN_OFFS);
 325         if (ret < 0)
 326                 goto bail;
 327         cks += ret;
 328
 329         ret = qsfp_read(ppd, QSFP_MOD_LEN_OFFS, &cp->len, 1);
 330         if (ret < 0)
 331                 goto bail;
 332         cks += cp->len;
 333
 334         ret = qsfp_read(ppd, QSFP_MOD_TECH_OFFS, &cp->tech, 1);
 335         if (ret < 0)
 336                 goto bail;
 337         cks += cp->tech;
 338
 339         ret = qsfp_read(ppd, QSFP_VEND_OFFS, &cp->vendor, QSFP_VEND_LEN);
 340         if (ret < 0)
 341                 goto bail;
 342         for (idx = 0; idx < QSFP_VEND_LEN; ++idx)
 343                 cks += cp->vendor[idx];
 344
 345         ret = qsfp_read(ppd, QSFP_IBXCV_OFFS, &cp->xt_xcv, 1);
 346         if (ret < 0)
 347                 goto bail;
 348         cks += cp->xt_xcv;
 349
 350         ret = qsfp_read(ppd, QSFP_VOUI_OFFS, &cp->oui, QSFP_VOUI_LEN);
 351         if (ret < 0)
 352                 goto bail;
 353         for (idx = 0; idx < QSFP_VOUI_LEN; ++idx)
 354                 cks += cp->oui[idx];
 355
 356         ret = qsfp_read(ppd, QSFP_PN_OFFS, &cp->partnum, QSFP_PN_LEN);
 357         if (ret < 0)
 358                 goto bail;
 359         for (idx = 0; idx < QSFP_PN_LEN; ++idx)
 360                 cks += cp->partnum[idx];
 361
 362         ret = qsfp_read(ppd, QSFP_REV_OFFS, &cp->rev, QSFP_REV_LEN);
 363         if (ret < 0)
 364                 goto bail;
 365         for (idx = 0; idx < QSFP_REV_LEN; ++idx)
 366                 cks += cp->rev[idx];
 367
 368         ret = qsfp_read(ppd, QSFP_ATTEN_OFFS, &cp->atten, QSFP_ATTEN_LEN);
 369         if (ret < 0)
 370                 goto bail;
 371         for (idx = 0; idx < QSFP_ATTEN_LEN; ++idx)
 372                 cks += cp->atten[idx];
 373
 374         ret = qsfp_cks(ppd, QSFP_ATTEN_OFFS + QSFP_ATTEN_LEN, QSFP_CC_OFFS);
 375         if (ret < 0)
 376                 goto bail;
 377         cks += ret;
 378
 379         cks &= 0xFF;
 380         ret = qsfp_read(ppd, QSFP_CC_OFFS, &cp->cks1, 1);
 381         if (ret < 0)
 382                 goto bail;
 383         if (cks != cp->cks1)
 384                 qib_dev_porterr(ppd->dd, ppd->port,
 385                                 "QSFP cks1 is %02X, computed %02X\n", cp->cks1,
 386                                 cks);
 387
 388         /* Second checksum covers 192 to (serial, date, lot) */
 389         ret = qsfp_cks(ppd, QSFP_CC_OFFS + 1, QSFP_SN_OFFS);
 390         if (ret < 0)
 391                 goto bail;
 392         cks = ret;
 393
 394         ret = qsfp_read(ppd, QSFP_SN_OFFS, &cp->serial, QSFP_SN_LEN);
 395         if (ret < 0)
 396                 goto bail;
 397         for (idx = 0; idx < QSFP_SN_LEN; ++idx)
 398                 cks += cp->serial[idx];
 399
 400         ret = qsfp_read(ppd, QSFP_DATE_OFFS, &cp->date, QSFP_DATE_LEN);
 401         if (ret < 0)
 402                 goto bail;
 403         for (idx = 0; idx < QSFP_DATE_LEN; ++idx)
 404                 cks += cp->date[idx];
 405
 406         ret = qsfp_read(ppd, QSFP_LOT_OFFS, &cp->lot, QSFP_LOT_LEN);
 407         if (ret < 0)
 408                 goto bail;
 409         for (idx = 0; idx < QSFP_LOT_LEN; ++idx)
 410                 cks += cp->lot[idx];
 411
 412         ret = qsfp_cks(ppd, QSFP_LOT_OFFS + QSFP_LOT_LEN, QSFP_CC_EXT_OFFS);
 413         if (ret < 0)
 414                 goto bail;
 415         cks += ret;
 416
 417         ret = qsfp_read(ppd, QSFP_CC_EXT_OFFS, &cp->cks2, 1);
 418         if (ret < 0)
 419                 goto bail;
 420         cks &= 0xFF;
 421         if (cks != cp->cks2)
 422                 qib_dev_porterr(ppd->dd, ppd->port,
 423                                 "QSFP cks2 is %02X, computed %02X\n", cp->cks2,
 424                                 cks);
 425         return 0;
 426
 427 bail:
 428         cp->id = 0;
 429         return ret;
 430 }
 431
 432 const char * const qib_qsfp_devtech[16] = {
 433         "850nm VCSEL", "1310nm VCSEL", "1550nm VCSEL", "1310nm FP",
 434         "1310nm DFB", "1550nm DFB", "1310nm EML", "1550nm EML",
 435         "Cu Misc", "1490nm DFB", "Cu NoEq", "Cu Eq",
 436         "Undef", "Cu Active BothEq", "Cu FarEq", "Cu NearEq"
 437 };
 438
 439 #define QSFP_DUMP_CHUNK 16 /* Holds longest string */
 440 #define QSFP_DEFAULT_HDR_CNT 224
 441
 442 static const char *pwr_codes = "1.5W2.0W2.5W3.5W";
 443
 444 int qib_qsfp_mod_present(struct qib_pportdata *ppd)
 445 {
 446         u32 mask;
 447         int ret;
 448
 449         mask = QSFP_GPIO_MOD_PRS_N <<
 450                 (ppd->hw_pidx * QSFP_GPIO_PORT2_SHIFT);
 451         ret = ppd->dd->f_gpio_mod(ppd->dd, 0, 0, 0);
 452
 453         return !((ret & mask) >>
 454                  ((ppd->hw_pidx * QSFP_GPIO_PORT2_SHIFT) + 3));
 455 }
 456
 457 /*
 458  * Initialize structures that control access to QSFP. Called once per port
 459  * on cards that support QSFP.
 460  */
 461 void qib_qsfp_init(struct qib_qsfp_data *qd,
 462                    void (*fevent)(struct work_struct *))
 463 {
 464         u32 mask, highs;
 465
 466         struct qib_devdata *dd = qd->ppd->dd;
 467
 468         /* Initialize work struct for later QSFP events */
 469         INIT_WORK(&qd->work, fevent);
 470
 471         /*
 472          * Later, we may want more validation. For now, just set up pins and
 473          * blip reset. If module is present, call qib_refresh_qsfp_cache(),
 474          * to do further init.
 475          */
 476         mask = QSFP_GPIO_MOD_SEL_N | QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
 477         highs = mask - QSFP_GPIO_MOD_RST_N;
 478         if (qd->ppd->hw_pidx) {
 479                 mask <<= QSFP_GPIO_PORT2_SHIFT;
 480                 highs <<= QSFP_GPIO_PORT2_SHIFT;
 481         }
 482         dd->f_gpio_mod(dd, highs, mask, mask);
 483         udelay(20); /* Generous RST dwell */
 484
 485         dd->f_gpio_mod(dd, mask, mask, mask);
 486 }
 487
 488 void qib_qsfp_deinit(struct qib_qsfp_data *qd)
 489 {
 490         /*
 491          * There is nothing to do here for now.  our work is scheduled
 492          * with queue_work(), and flush_workqueue() from remove_one
 493          * will block until all work setup with queue_work()
 494          * completes.
 495          */
 496 }
 497
 498 int qib_qsfp_dump(struct qib_pportdata *ppd, char *buf, int len)
 499 {
 500         struct qib_qsfp_cache cd;
 501         u8 bin_buff[QSFP_DUMP_CHUNK];
 502         char lenstr[6];
 503         int sofar, ret;
 504         int bidx = 0;
 505
 506         sofar = 0;
 507         ret = qib_refresh_qsfp_cache(ppd, &cd);
 508         if (ret < 0)
 509                 goto bail;
 510
 511         lenstr[0] = ' ';
 512         lenstr[1] = '\0';
 513         if (QSFP_IS_CU(cd.tech))
 514                 sprintf(lenstr, "%dM ", cd.len);
 515
 516         sofar += scnprintf(buf + sofar, len - sofar, "PWR:%.3sW\n", pwr_codes +
 517                            (QSFP_PWR(cd.pwr) * 4));
 518
 519         sofar += scnprintf(buf + sofar, len - sofar, "TECH:%s%s\n", lenstr,
 520                            qib_qsfp_devtech[cd.tech >> 4]);
 521
 522         sofar += scnprintf(buf + sofar, len - sofar, "Vendor:%.*s\n",
 523                            QSFP_VEND_LEN, cd.vendor);
 524
 525         sofar += scnprintf(buf + sofar, len - sofar, "OUI:%06X\n",
 526                            QSFP_OUI(cd.oui));
 527
 528         sofar += scnprintf(buf + sofar, len - sofar, "Part#:%.*s\n",
 529                            QSFP_PN_LEN, cd.partnum);
 530         sofar += scnprintf(buf + sofar, len - sofar, "Rev:%.*s\n",
 531                            QSFP_REV_LEN, cd.rev);
 532         if (QSFP_IS_CU(cd.tech))
 533                 sofar += scnprintf(buf + sofar, len - sofar, "Atten:%d, %d\n",
 534                                    QSFP_ATTEN_SDR(cd.atten),
 535                                    QSFP_ATTEN_DDR(cd.atten));
 536         sofar += scnprintf(buf + sofar, len - sofar, "Serial:%.*s\n",
 537                            QSFP_SN_LEN, cd.serial);
 538         sofar += scnprintf(buf + sofar, len - sofar, "Date:%.*s\n",
 539                            QSFP_DATE_LEN, cd.date);
 540         sofar += scnprintf(buf + sofar, len - sofar, "Lot:%.*s\n",
 541                            QSFP_LOT_LEN, cd.date);
 542
 543         while (bidx < QSFP_DEFAULT_HDR_CNT) {
 544                 int iidx;
 545
 546                 ret = qsfp_read(ppd, bidx, bin_buff, QSFP_DUMP_CHUNK);
 547                 if (ret < 0)
 548                         goto bail;
 549                 for (iidx = 0; iidx < ret; ++iidx) {
 550                         sofar += scnprintf(buf + sofar, len-sofar, " %02X",
 551                                 bin_buff[iidx]);
 552                 }
 553                 sofar += scnprintf(buf + sofar, len - sofar, "\n");
 554                 bidx += QSFP_DUMP_CHUNK;
 555         }
 556         ret = sofar;
 557 bail:
 558         return ret;
 559 }