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(2);
  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                 in_page = addr % QSFP_PAGESIZE;
 103                 if ((in_page + wlen) > QSFP_PAGESIZE)
 104                         wlen = QSFP_PAGESIZE - in_page;
 105                 ret = qib_twsi_blk_rd(dd, QSFP_DEV, addr, buff + cnt, wlen);
 106                 /* Some QSFP's fail first try. Retry as experiment */
 107                 if (ret && cnt == 0 && ++pass < QSFP_MAX_RETRY)
 108                         continue;
 109                 if (ret) {
 110                         /* qib_twsi_blk_rd() 1 for error, else 0 */
 111                         ret = -EIO;
 112                         goto deselect;
 113                 }
 114                 addr += wlen;
 115                 cnt += wlen;
 116         }
 117         ret = cnt;
 118
 119 deselect:
 120         /*
 121          * Module could take up to 10 uSec after transfer before
 122          * ready to respond to MOD_SEL negation, and there is no way
 123          * to tell if it is ready, so we must wait.
 124          */
 125         udelay(10);
 126         /* set QSFP MODSEL, RST. LP all high */
 127         dd->f_gpio_mod(dd, mask, mask, mask);
 128
 129         /*
 130          * Module could take up to 2 Msec to respond to MOD_SEL
 131          * going away, and there is no way to tell if it is ready.
 132          * so we must wait.
 133          */
 134         if (stuck)
 135                 qib_dev_err(dd, "QSFP interface bus stuck non-idle\n");
 136
 137         if (pass >= QSFP_MAX_RETRY && ret)
 138                 qib_dev_porterr(dd, ppd->port, "QSFP failed even retrying\n");
 139         else if (pass)
 140                 qib_dev_porterr(dd, ppd->port, "QSFP retries: %d\n", pass);
 141
 142         msleep(2);
 143
 144 bail:
 145         mutex_unlock(&dd->eep_lock);
 146
 147 no_unlock:
 148         return ret;
 149 }
 150
 151 /*
 152  * qsfp_write
 153  * We do not ordinarily write the QSFP, but this is needed to select
 154  * the page on non-flat QSFPs, and possibly later unusual cases
 155  */
 156 static int qib_qsfp_write(struct qib_pportdata *ppd, int addr, void *bp,
 157                           int len)
 158 {
 159         struct qib_devdata *dd = ppd->dd;
 160         u32 out, mask;
 161         int ret, cnt;
 162         u8 *buff = bp;
 163
 164         ret = mutex_lock_interruptible(&dd->eep_lock);
 165         if (ret)
 166                 goto no_unlock;
 167
 168         if (dd->twsi_eeprom_dev == QIB_TWSI_NO_DEV) {
 169                 ret = -ENXIO;
 170                 goto bail;
 171         }
 172
 173         /*
 174          * We presume, if we are called at all, that this board has
 175          * QSFP. This is on the same i2c chain as the legacy parts,
 176          * but only responds if the module is selected via GPIO pins.
 177          * Further, there are very long setup and hold requirements
 178          * on MODSEL.
 179          */
 180         mask = QSFP_GPIO_MOD_SEL_N | QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
 181         out = QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
 182         if (ppd->hw_pidx) {
 183                 mask <<= QSFP_GPIO_PORT2_SHIFT;
 184                 out <<= QSFP_GPIO_PORT2_SHIFT;
 185         }
 186         dd->f_gpio_mod(dd, out, mask, mask);
 187
 188         /*
 189          * Module could take up to 2 Msec to respond to MOD_SEL,
 190          * and there is no way to tell if it is ready, so we must wait.
 191          */
 192         msleep(2);
 193
 194         /* Make sure TWSI bus is in sane state. */
 195         ret = qib_twsi_reset(dd);
 196         if (ret) {
 197                 qib_dev_porterr(dd, ppd->port,
 198                                 "QSFP interface Reset for write failed\n");
 199                 ret = -EIO;
 200                 goto deselect;
 201         }
 202
 203         /* All QSFP modules are at A0 */
 204
 205         cnt = 0;
 206         while (cnt < len) {
 207                 unsigned in_page;
 208                 int wlen = len - cnt;
 209                 in_page = addr % QSFP_PAGESIZE;
 210                 if ((in_page + wlen) > QSFP_PAGESIZE)
 211                         wlen = QSFP_PAGESIZE - in_page;
 212                 ret = qib_twsi_blk_wr(dd, QSFP_DEV, addr, buff + cnt, wlen);
 213                 if (ret) {
 214                         /* qib_twsi_blk_wr() 1 for error, else 0 */
 215                         ret = -EIO;
 216                         goto deselect;
 217                 }
 218                 addr += wlen;
 219                 cnt += wlen;
 220         }
 221         ret = cnt;
 222
 223 deselect:
 224         /*
 225          * Module could take up to 10 uSec after transfer before
 226          * ready to respond to MOD_SEL negation, and there is no way
 227          * to tell if it is ready, so we must wait.
 228          */
 229         udelay(10);
 230         /* set QSFP MODSEL, RST, LP high */
 231         dd->f_gpio_mod(dd, mask, mask, mask);
 232         /*
 233          * Module could take up to 2 Msec to respond to MOD_SEL
 234          * going away, and there is no way to tell if it is ready.
 235          * so we must wait.
 236          */
 237         msleep(2);
 238
 239 bail:
 240         mutex_unlock(&dd->eep_lock);
 241
 242 no_unlock:
 243         return ret;
 244 }
 245
 246 /*
 247  * For validation, we want to check the checksums, even of the
 248  * fields we do not otherwise use. This function reads the bytes from
 249  * <first> to <next-1> and returns the 8lsbs of the sum, or <0 for errors
 250  */
 251 static int qsfp_cks(struct qib_pportdata *ppd, int first, int next)
 252 {
 253         int ret;
 254         u16 cks;
 255         u8 bval;
 256
 257         cks = 0;
 258         while (first < next) {
 259                 ret = qsfp_read(ppd, first, &bval, 1);
 260                 if (ret < 0)
 261                         goto bail;
 262                 cks += bval;
 263                 ++first;
 264         }
 265         ret = cks & 0xFF;
 266 bail:
 267         return ret;
 268
 269 }
 270
 271 int qib_refresh_qsfp_cache(struct qib_pportdata *ppd, struct qib_qsfp_cache *cp)
 272 {
 273         int ret;
 274         int idx;
 275         u16 cks;
 276         u32 mask;
 277         u8 peek[4];
 278
 279         /* ensure sane contents on invalid reads, for cable swaps */
 280         memset(cp, 0, sizeof(*cp));
 281
 282         mask = QSFP_GPIO_MOD_PRS_N;
 283         if (ppd->hw_pidx)
 284                 mask <<= QSFP_GPIO_PORT2_SHIFT;
 285
 286         ret = ppd->dd->f_gpio_mod(ppd->dd, 0, 0, 0);
 287         if (ret & mask) {
 288                 ret = -ENODEV;
 289                 goto bail;
 290         }
 291
 292         ret = qsfp_read(ppd, 0, peek, 3);
 293         if (ret < 0)
 294                 goto bail;
 295         if ((peek[0] & 0xFE) != 0x0C)
 296                 qib_dev_porterr(ppd->dd, ppd->port,
 297                                 "QSFP byte0 is 0x%02X, S/B 0x0C/D\n", peek[0]);
 298
 299         if ((peek[2] & 2) == 0) {
 300                 /*
 301                  * If cable is paged, rather than "flat memory", we need to
 302                  * set the page to zero, Even if it already appears to be zero.
 303                  */
 304                 u8 poke = 0;
 305                 ret = qib_qsfp_write(ppd, 127, &poke, 1);
 306                 udelay(50);
 307                 if (ret != 1) {
 308                         qib_dev_porterr(ppd->dd, ppd->port,
 309                                         "Failed QSFP Page set\n");
 310                         goto bail;
 311                 }
 312         }
 313
 314         ret = qsfp_read(ppd, QSFP_MOD_ID_OFFS, &cp->id, 1);
 315         if (ret < 0)
 316                 goto bail;
 317         if ((cp->id & 0xFE) != 0x0C)
 318                 qib_dev_porterr(ppd->dd, ppd->port,
 319                                 "QSFP ID byte is 0x%02X, S/B 0x0C/D\n", cp->id);
 320         cks = cp->id;
 321
 322         ret = qsfp_read(ppd, QSFP_MOD_PWR_OFFS, &cp->pwr, 1);
 323         if (ret < 0)
 324                 goto bail;
 325         cks += cp->pwr;
 326
 327         ret = qsfp_cks(ppd, QSFP_MOD_PWR_OFFS + 1, QSFP_MOD_LEN_OFFS);
 328         if (ret < 0)
 329                 goto bail;
 330         cks += ret;
 331
 332         ret = qsfp_read(ppd, QSFP_MOD_LEN_OFFS, &cp->len, 1);
 333         if (ret < 0)
 334                 goto bail;
 335         cks += cp->len;
 336
 337         ret = qsfp_read(ppd, QSFP_MOD_TECH_OFFS, &cp->tech, 1);
 338         if (ret < 0)
 339                 goto bail;
 340         cks += cp->tech;
 341
 342         ret = qsfp_read(ppd, QSFP_VEND_OFFS, &cp->vendor, QSFP_VEND_LEN);
 343         if (ret < 0)
 344                 goto bail;
 345         for (idx = 0; idx < QSFP_VEND_LEN; ++idx)
 346                 cks += cp->vendor[idx];
 347
 348         ret = qsfp_read(ppd, QSFP_IBXCV_OFFS, &cp->xt_xcv, 1);
 349         if (ret < 0)
 350                 goto bail;
 351         cks += cp->xt_xcv;
 352
 353         ret = qsfp_read(ppd, QSFP_VOUI_OFFS, &cp->oui, QSFP_VOUI_LEN);
 354         if (ret < 0)
 355                 goto bail;
 356         for (idx = 0; idx < QSFP_VOUI_LEN; ++idx)
 357                 cks += cp->oui[idx];
 358
 359         ret = qsfp_read(ppd, QSFP_PN_OFFS, &cp->partnum, QSFP_PN_LEN);
 360         if (ret < 0)
 361                 goto bail;
 362         for (idx = 0; idx < QSFP_PN_LEN; ++idx)
 363                 cks += cp->partnum[idx];
 364
 365         ret = qsfp_read(ppd, QSFP_REV_OFFS, &cp->rev, QSFP_REV_LEN);
 366         if (ret < 0)
 367                 goto bail;
 368         for (idx = 0; idx < QSFP_REV_LEN; ++idx)
 369                 cks += cp->rev[idx];
 370
 371         ret = qsfp_read(ppd, QSFP_ATTEN_OFFS, &cp->atten, QSFP_ATTEN_LEN);
 372         if (ret < 0)
 373                 goto bail;
 374         for (idx = 0; idx < QSFP_ATTEN_LEN; ++idx)
 375                 cks += cp->atten[idx];
 376
 377         ret = qsfp_cks(ppd, QSFP_ATTEN_OFFS + QSFP_ATTEN_LEN, QSFP_CC_OFFS);
 378         if (ret < 0)
 379                 goto bail;
 380         cks += ret;
 381
 382         cks &= 0xFF;
 383         ret = qsfp_read(ppd, QSFP_CC_OFFS, &cp->cks1, 1);
 384         if (ret < 0)
 385                 goto bail;
 386         if (cks != cp->cks1)
 387                 qib_dev_porterr(ppd->dd, ppd->port,
 388                                 "QSFP cks1 is %02X, computed %02X\n", cp->cks1,
 389                                 cks);
 390
 391         /* Second checksum covers 192 to (serial, date, lot) */
 392         ret = qsfp_cks(ppd, QSFP_CC_OFFS + 1, QSFP_SN_OFFS);
 393         if (ret < 0)
 394                 goto bail;
 395         cks = ret;
 396
 397         ret = qsfp_read(ppd, QSFP_SN_OFFS, &cp->serial, QSFP_SN_LEN);
 398         if (ret < 0)
 399                 goto bail;
 400         for (idx = 0; idx < QSFP_SN_LEN; ++idx)
 401                 cks += cp->serial[idx];
 402
 403         ret = qsfp_read(ppd, QSFP_DATE_OFFS, &cp->date, QSFP_DATE_LEN);
 404         if (ret < 0)
 405                 goto bail;
 406         for (idx = 0; idx < QSFP_DATE_LEN; ++idx)
 407                 cks += cp->date[idx];
 408
 409         ret = qsfp_read(ppd, QSFP_LOT_OFFS, &cp->lot, QSFP_LOT_LEN);
 410         if (ret < 0)
 411                 goto bail;
 412         for (idx = 0; idx < QSFP_LOT_LEN; ++idx)
 413                 cks += cp->lot[idx];
 414
 415         ret = qsfp_cks(ppd, QSFP_LOT_OFFS + QSFP_LOT_LEN, QSFP_CC_EXT_OFFS);
 416         if (ret < 0)
 417                 goto bail;
 418         cks += ret;
 419
 420         ret = qsfp_read(ppd, QSFP_CC_EXT_OFFS, &cp->cks2, 1);
 421         if (ret < 0)
 422                 goto bail;
 423         cks &= 0xFF;
 424         if (cks != cp->cks2)
 425                 qib_dev_porterr(ppd->dd, ppd->port,
 426                                 "QSFP cks2 is %02X, computed %02X\n", cp->cks2,
 427                                 cks);
 428         return 0;
 429
 430 bail:
 431         cp->id = 0;
 432         return ret;
 433 }
 434
 435 const char * const qib_qsfp_devtech[16] = {
 436         "850nm VCSEL", "1310nm VCSEL", "1550nm VCSEL", "1310nm FP",
 437         "1310nm DFB", "1550nm DFB", "1310nm EML", "1550nm EML",
 438         "Cu Misc", "1490nm DFB", "Cu NoEq", "Cu Eq",
 439         "Undef", "Cu Active BothEq", "Cu FarEq", "Cu NearEq"
 440 };
 441
 442 #define QSFP_DUMP_CHUNK 16 /* Holds longest string */
 443 #define QSFP_DEFAULT_HDR_CNT 224
 444
 445 static const char *pwr_codes = "1.5W2.0W2.5W3.5W";
 446
 447 /*
 448  * Initialize structures that control access to QSFP. Called once per port
 449  * on cards that support QSFP.
 450  */
 451 void qib_qsfp_init(struct qib_qsfp_data *qd,
 452                    void (*fevent)(struct work_struct *))
 453 {
 454         u32 mask, highs;
 455         int pins;
 456
 457         struct qib_devdata *dd = qd->ppd->dd;
 458
 459         /* Initialize work struct for later QSFP events */
 460         INIT_WORK(&qd->work, fevent);
 461
 462         /*
 463          * Later, we may want more validation. For now, just set up pins and
 464          * blip reset. If module is present, call qib_refresh_qsfp_cache(),
 465          * to do further init.
 466          */
 467         mask = QSFP_GPIO_MOD_SEL_N | QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE;
 468         highs = mask - QSFP_GPIO_MOD_RST_N;
 469         if (qd->ppd->hw_pidx) {
 470                 mask <<= QSFP_GPIO_PORT2_SHIFT;
 471                 highs <<= QSFP_GPIO_PORT2_SHIFT;
 472         }
 473         dd->f_gpio_mod(dd, highs, mask, mask);
 474         udelay(20); /* Generous RST dwell */
 475
 476         dd->f_gpio_mod(dd, mask, mask, mask);
 477         /* Spec says module can take up to two seconds! */
 478         mask = QSFP_GPIO_MOD_PRS_N;
 479         if (qd->ppd->hw_pidx)
 480                 mask <<= QSFP_GPIO_PORT2_SHIFT;
 481
 482         /* Do not try to wait here. Better to let event handle it */
 483         pins = dd->f_gpio_mod(dd, 0, 0, 0);
 484         if (pins & mask)
 485                 goto bail;
 486         /* We see a module, but it may be unwise to look yet. Just schedule */
 487         qd->t_insert = get_jiffies_64();
 488         schedule_work(&qd->work);
 489 bail:
 490         return;
 491 }
 492
 493 void qib_qsfp_deinit(struct qib_qsfp_data *qd)
 494 {
 495         /*
 496          * There is nothing to do here for now.  our
 497          * work is scheduled with schedule_work(), and
 498          * flush_scheduled_work() from remove_one will
 499          * block until all work ssetup with schedule_work()
 500          * completes.
 501          */
 502 }
 503
 504 int qib_qsfp_dump(struct qib_pportdata *ppd, char *buf, int len)
 505 {
 506         struct qib_qsfp_cache cd;
 507         u8 bin_buff[QSFP_DUMP_CHUNK];
 508         char lenstr[6];
 509         int sofar, ret;
 510         int bidx = 0;
 511
 512         sofar = 0;
 513         ret = qib_refresh_qsfp_cache(ppd, &cd);
 514         if (ret < 0)
 515                 goto bail;
 516
 517         lenstr[0] = ' ';
 518         lenstr[1] = '\0';
 519         if (QSFP_IS_CU(cd.tech))
 520                 sprintf(lenstr, "%dM ", cd.len);
 521
 522         sofar += scnprintf(buf + sofar, len - sofar, "PWR:%.3sW\n", pwr_codes +
 523                            (QSFP_PWR(cd.pwr) * 4));
 524
 525         sofar += scnprintf(buf + sofar, len - sofar, "TECH:%s%s\n", lenstr,
 526                            qib_qsfp_devtech[cd.tech >> 4]);
 527
 528         sofar += scnprintf(buf + sofar, len - sofar, "Vendor:%.*s\n",
 529                            QSFP_VEND_LEN, cd.vendor);
 530
 531         sofar += scnprintf(buf + sofar, len - sofar, "OUI:%06X\n",
 532                            QSFP_OUI(cd.oui));
 533
 534         sofar += scnprintf(buf + sofar, len - sofar, "Part#:%.*s\n",
 535                            QSFP_PN_LEN, cd.partnum);
 536         sofar += scnprintf(buf + sofar, len - sofar, "Rev:%.*s\n",
 537                            QSFP_REV_LEN, cd.rev);
 538         if (QSFP_IS_CU(cd.tech))
 539                 sofar += scnprintf(buf + sofar, len - sofar, "Atten:%d, %d\n",
 540                                    QSFP_ATTEN_SDR(cd.atten),
 541                                    QSFP_ATTEN_DDR(cd.atten));
 542         sofar += scnprintf(buf + sofar, len - sofar, "Serial:%.*s\n",
 543                            QSFP_SN_LEN, cd.serial);
 544         sofar += scnprintf(buf + sofar, len - sofar, "Date:%.*s\n",
 545                            QSFP_DATE_LEN, cd.date);
 546         sofar += scnprintf(buf + sofar, len - sofar, "Lot:%.*s\n",
 547                            QSFP_LOT_LEN, cd.date);
 548
 549         while (bidx < QSFP_DEFAULT_HDR_CNT) {
 550                 int iidx;
 551                 ret = qsfp_read(ppd, bidx, bin_buff, QSFP_DUMP_CHUNK);
 552                 if (ret < 0)
 553                         goto bail;
 554                 for (iidx = 0; iidx < ret; ++iidx) {
 555                         sofar += scnprintf(buf + sofar, len-sofar, " %02X",
 556                                 bin_buff[iidx]);
 557                 }
 558                 sofar += scnprintf(buf + sofar, len - sofar, "\n");
 559                 bidx += QSFP_DUMP_CHUNK;
 560         }
 561         ret = sofar;
 562 bail:
 563         return ret;
 564 }