/* * Copyright (c) 2012 Intel Corporation. All rights reserved. * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved. * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved. * * This software is available to you under a choice of one of two * licenses. You may choose to be licensed under the terms of the GNU * General Public License (GPL) Version 2, available from the file * COPYING in the main directory of this source tree, or the * OpenIB.org BSD license below: * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following * disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include <linux/delay.h> #include <linux/pci.h> #include <linux/vmalloc.h> #include "qib.h" /* * Functions specific to the serial EEPROM on cards handled by ib_qib. * The actual serail interface code is in qib_twsi.c. This file is a client */ /** * 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; } /* * Actually update the eeprom, first doing write enable if * needed, then restoring write enable state. * Must be called with eep_lock held */ static int eeprom_write_with_enable(struct qib_devdata *dd, u8 offset, const void *buf, int len) { int ret, pwen; pwen = dd->f_eeprom_wen(dd, 1); ret = qib_twsi_reset(dd); if (ret) qib_dev_err(dd, "EEPROM Reset for write failed\n"); else ret = qib_twsi_blk_wr(dd, dd->twsi_eeprom_dev, offset, buf, len); dd->f_eeprom_wen(dd, pwen); return ret; } /** * qib_eeprom_write - writes data to the eeprom via I2C * @dd: the qlogic_ib device * @eeprom_offset: where to place data * @buffer: data to write * @len: number of bytes to write */ int qib_eeprom_write(struct qib_devdata *dd, u8 eeprom_offset, const void *buff, int len) { int ret; ret = mutex_lock_interruptible(&dd->eep_lock); if (!ret) { ret = eeprom_write_with_enable(dd, eeprom_offset, buff, len); mutex_unlock(&dd->eep_lock); } return ret; } static u8 flash_csum(struct qib_flash *ifp, int adjust) { u8 *ip = (u8 *) ifp; u8 csum = 0, len; /* * Limit length checksummed to max length of actual data. * Checksum of erased eeprom will still be bad, but we avoid * reading past the end of the buffer we were passed. */ len = ifp->if_length; if (len > sizeof(struct qib_flash)) len = sizeof(struct qib_flash); while (len--) csum += *ip++; csum -= ifp->if_csum; csum = ~csum; if (adjust) ifp->if_csum = csum; return csum; } /** * qib_get_eeprom_info- get the GUID et al. from the TSWI EEPROM device * @dd: the qlogic_ib device * * We have the capability to use the nguid field, and get * the guid from the first chip's flash, to use for all of them. */ void qib_get_eeprom_info(struct qib_devdata *dd) { void *buf; struct qib_flash *ifp; __be64 guid; int len, eep_stat; u8 csum, *bguid; int t = dd->unit; struct qib_devdata *dd0 = qib_lookup(0); if (t && dd0->nguid > 1 && t <= dd0->nguid) { u8 oguid; dd->base_guid = dd0->base_guid; bguid = (u8 *) &dd->base_guid; oguid = bguid[7]; bguid[7] += t; if (oguid > bguid[7]) { if (bguid[6] == 0xff) { if (bguid[5] == 0xff) { qib_dev_err(dd, "Can't set %s GUID from base, wraps to OUI!\n", qib_get_unit_name(t)); dd->base_guid = 0; goto bail; } bguid[5]++; } bguid[6]++; } dd->nguid = 1; goto bail; } /* * 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); if (!buf) { qib_dev_err(dd, "Couldn't allocate memory to read %u bytes from eeprom for GUID\n", len); goto bail; } /* * Use "public" eeprom read function, which does locking and * figures out device. This will migrate to chip-specific. */ eep_stat = qib_eeprom_read(dd, 0, buf, len); if (eep_stat) { qib_dev_err(dd, "Failed reading GUID from eeprom\n"); goto done; } ifp = (struct qib_flash *)buf; csum = flash_csum(ifp, 0); if (csum != ifp->if_csum) { qib_devinfo(dd->pcidev, "Bad I2C flash checksum: 0x%x, not 0x%x\n", csum, ifp->if_csum); goto done; } if (*(__be64 *) ifp->if_guid == cpu_to_be64(0) || *(__be64 *) ifp->if_guid == ~cpu_to_be64(0)) { qib_dev_err(dd, "Invalid GUID %llx from flash; ignoring\n", *(unsigned long long *) ifp->if_guid); /* don't allow GUID if all 0 or all 1's */ goto done; } /* complain, but allow it */ if (*(u64 *) ifp->if_guid == 0x100007511000000ULL) qib_devinfo(dd->pcidev, "Warning, GUID %llx is default, probably not correct!\n", *(unsigned long long *) ifp->if_guid); bguid = ifp->if_guid; if (!bguid[0] && !bguid[1] && !bguid[2]) { /* * Original incorrect GUID format in flash; fix in * core copy, by shifting up 2 octets; don't need to * change top octet, since both it and shifted are 0. */ bguid[1] = bguid[3]; bguid[2] = bguid[4]; bguid[3] = 0; bguid[4] = 0; guid = *(__be64 *) ifp->if_guid; } else guid = *(__be64 *) ifp->if_guid; dd->base_guid = guid; dd->nguid = ifp->if_numguid; /* * Things are slightly complicated by the desire to transparently * support both the Pathscale 10-digit serial number and the QLogic * 13-character version. */ if ((ifp->if_fversion > 1) && ifp->if_sprefix[0] && ((u8 *) ifp->if_sprefix)[0] != 0xFF) { char *snp = dd->serial; /* * This board has a Serial-prefix, which is stored * elsewhere for backward-compatibility. */ memcpy(snp, ifp->if_sprefix, sizeof(ifp->if_sprefix)); snp[sizeof(ifp->if_sprefix)] = '\0'; len = strlen(snp); snp += len; len = sizeof(dd->serial) - len; if (len > sizeof(ifp->if_serial)) len = sizeof(ifp->if_serial); memcpy(snp, ifp->if_serial, len); } else { memcpy(dd->serial, ifp->if_serial, sizeof(ifp->if_serial)); } if (!strstr(ifp->if_comment, "Tested successfully")) qib_dev_err(dd, "Board SN %s did not pass functional test: %s\n", dd->serial, ifp->if_comment); done: vfree(buf); bail:; }