GNU Linux-libre 4.9.287-gnu1
[releases.git] / 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] & 4) == 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.lot);
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 }