/** * qib_eeprom_read - receives bytes from the eeprom via I2C * @dd: the qlogic_ib device * @eeprom_offset: address to read from * @buffer: where to store result * @len: number of bytes to receive */ int qib_eeprom_read(struct qib_devdata *dd, u8 eeprom_offset, void *buff, int len) { int ret; ret = mutex_lock_interruptible(&dd->eep_lock); if (!ret) { ret = qib_twsi_reset(dd); if (ret) qib_dev_err(dd, "EEPROM Reset for read failed\n"); else ret = qib_twsi_blk_rd(dd, dd->twsi_eeprom_dev, eeprom_offset, buff, len); mutex_unlock(&dd->eep_lock); } return ret; }
static int qsfp_read(struct qib_pportdata *ppd, int addr, void *bp, int len) { struct qib_devdata *dd = ppd->dd; u32 out, mask; int ret, cnt, pass = 0; int stuck = 0; u8 *buff = bp; qib_cdbg(VERBOSE, "Grabbing Mutex for QSFP in %d:%d\n", dd->unit, ppd->port); ret = mutex_lock_interruptible(&dd->eep_lock); if (ret) goto no_unlock; if (dd->twsi_eeprom_dev == QIB_TWSI_NO_DEV) { qib_dbg("QSFP read on board without QSFP\n"); ret = -ENXIO; goto bail; } /* * We presume, if we are called at all, that this board has * QSFP. This is on the same i2c chain as the legacy parts, * but only responds if the module is selected via GPIO pins. * Further, there are very long setup and hold requirements * on MODSEL. */ mask = QSFP_GPIO_MOD_SEL_N | QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE; out = QSFP_GPIO_MOD_RST_N | QSFP_GPIO_LP_MODE; if (ppd->hw_pidx) { mask <<= QSFP_GPIO_PORT2_SHIFT; out <<= QSFP_GPIO_PORT2_SHIFT; } dd->f_gpio_mod(dd, out, mask, mask); /* * Module could take up to 2 Msec to respond to MOD_SEL, and there * is no way to tell if it is ready, so we must wait. */ msleep(2); /* Make sure TWSI bus is in sane state. */ ret = qib_twsi_reset(dd); if (ret) { qib_dev_porterr(dd, ppd->port, "QSFP interface Reset for read failed\n"); ret = -EIO; stuck = 1; goto deselect; } /* All QSFP modules are at A0 */ cnt = 0; while (cnt < len) { unsigned in_page; int wlen = len - cnt; in_page = addr % QSFP_PAGESIZE; if ((in_page + wlen) > QSFP_PAGESIZE) wlen = QSFP_PAGESIZE - in_page; ret = qib_twsi_blk_rd(dd, QSFP_DEV, addr, buff + cnt, wlen); /* Some QSFP's fail first try. Retry as experiment */ if (ret && cnt == 0 && ++pass < QSFP_MAX_RETRY) continue; if (ret) { /* qib_twsi_blk_rd() 1 for error, else 0 */ ret = -EIO; goto deselect; } addr += wlen; cnt += wlen; } ret = cnt; deselect: /* * Module could take up to 10 uSec after transfer before * ready to respond to MOD_SEL negation, and there is no way * to tell if it is ready, so we must wait. */ udelay(10); /* set QSFP MODSEL, RST. LP all high */ dd->f_gpio_mod(dd, mask, mask, mask); /* * Module could take up to 2 Msec to respond to MOD_SEL * going away, and there is no way to tell if it is ready. * so we must wait. */ if (stuck) qib_dev_err(dd, "QSFP interface bus stuck non-idle\n"); if (pass >= QSFP_MAX_RETRY && ret) qib_dev_porterr(dd, ppd->port, "QSFP failed even retrying\n"); else if (pass) qib_dev_porterr(dd, ppd->port, "QSFP retries: %d\n", pass); msleep(2); bail: mutex_unlock(&dd->eep_lock); qib_cdbg(VERBOSE, "Released Mutex for QSFP %d:%d, ret %d\n", dd->unit, ppd->port, ret); no_unlock: return ret; }
/** * qib_update_eeprom_log - copy active-time and error counters to eeprom * @dd: the qlogic_ib device * * Although the time is kept as seconds in the qib_devdata struct, it is * rounded to hours for re-write, as we have only 16 bits in EEPROM. * First-cut code reads whole (expected) struct qib_flash, modifies, * re-writes. Future direction: read/write only what we need, assuming * that the EEPROM had to have been "good enough" for driver init, and * if not, we aren't making it worse. * */ int qib_update_eeprom_log(struct qib_devdata *dd) { void *buf; struct qib_flash *ifp; int len, hi_water; uint32_t new_time, new_hrs; u8 csum; int ret, idx; unsigned long flags; /* first, check if we actually need to do anything. */ ret = 0; for (idx = 0; idx < QIB_EEP_LOG_CNT; ++idx) { if (dd->eep_st_new_errs[idx]) { ret = 1; break; } } new_time = atomic_read(&dd->active_time); if (ret == 0 && new_time < 3600) goto bail; /* * The quick-check above determined that there is something worthy * of logging, so get current contents and do a more detailed idea. * read full flash, not just currently used part, since it may have * been written with a newer definition */ len = sizeof(struct qib_flash); buf = vmalloc(len); ret = 1; if (!buf) { qib_dev_err(dd, "Couldn't allocate memory to read %u " "bytes from eeprom for logging\n", len); goto bail; } /* Grab semaphore and read current EEPROM. If we get an * error, let go, but if not, keep it until we finish write. */ ret = mutex_lock_interruptible(&dd->eep_lock); if (ret) { qib_dev_err(dd, "Unable to acquire EEPROM for logging\n"); goto free_bail; } ret = qib_twsi_blk_rd(dd, dd->twsi_eeprom_dev, 0, buf, len); if (ret) { mutex_unlock(&dd->eep_lock); qib_dev_err(dd, "Unable read EEPROM for logging\n"); goto free_bail; } ifp = (struct qib_flash *)buf; csum = flash_csum(ifp, 0); if (csum != ifp->if_csum) { mutex_unlock(&dd->eep_lock); qib_dev_err(dd, "EEPROM cks err (0x%02X, S/B 0x%02X)\n", csum, ifp->if_csum); ret = 1; goto free_bail; } hi_water = 0; spin_lock_irqsave(&dd->eep_st_lock, flags); for (idx = 0; idx < QIB_EEP_LOG_CNT; ++idx) { int new_val = dd->eep_st_new_errs[idx]; if (new_val) { /* * If we have seen any errors, add to EEPROM values * We need to saturate at 0xFF (255) and we also * would need to adjust the checksum if we were * trying to minimize EEPROM traffic * Note that we add to actual current count in EEPROM, * in case it was altered while we were running. */ new_val += ifp->if_errcntp[idx]; if (new_val > 0xFF) new_val = 0xFF; if (ifp->if_errcntp[idx] != new_val) { ifp->if_errcntp[idx] = new_val; hi_water = offsetof(struct qib_flash, if_errcntp) + idx; } /* * update our shadow (used to minimize EEPROM * traffic), to match what we are about to write. */ dd->eep_st_errs[idx] = new_val; dd->eep_st_new_errs[idx] = 0; } }