/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 */

#include <qlge.h>

/*

 * Local Function Prototypes.

 */

static int ql_read_flash(qlge_t *, uint32_t, uint32_t *);

static int ql_write_flash(qlge_t *, uint32_t, uint32_t);

static int ql_protect_flash(qlge_t *);

static int ql_unprotect_flash(qlge_t *);

/*

 * ql_flash_id

 * The flash memory chip exports 3 ID bytes in the order of manufacturer, id,

 * capability

 */

int

ql_flash_id(qlge_t *qlge)

{

	int rval;

	uint32_t fdata = 0;

	/*

	 * Send Restore command (0xAB) to release Flash from

	 * possible deep power down state

	 */

	rval = ql_read_flash(qlge, FLASH_CONF_ADDR | 0x300 | FLASH_RES_CMD,

	    &fdata);

	QL_PRINT(DBG_FLASH, ("%s(%d) flash electronic signature is %x \n",

	    __func__, qlge->instance, fdata));

	fdata = 0;

	/* 0x9F */

	rval = ql_read_flash(qlge, FLASH_CONF_ADDR | 0x0400 | FLASH_RDID_CMD,

	    &fdata);

	if ((rval != DDI_SUCCESS) || (fdata == 0)) {

		cmn_err(CE_WARN, "%s(%d) read_flash failed 0x%x.",

		    __func__, qlge->instance, fdata);

	} else {

		qlge->flash_info.flash_manuf = LSB(LSW(fdata));

		qlge->flash_info.flash_id = MSB(LSW(fdata));

		qlge->flash_info.flash_cap = LSB(MSW(fdata));

		QL_PRINT(DBG_FLASH, ("%s(%d) flash manufacturer 0x%x,"

		    " flash id 0x%x, flash cap 0x%x\n",

		    __func__, qlge->instance,

		    qlge->flash_info.flash_manuf, qlge->flash_info.flash_id,

		    qlge->flash_info.flash_cap));

	}

	return (rval);

}

/*

 * qlge_dump_fcode

 * Dumps fcode from flash.

 */

int

qlge_dump_fcode(qlge_t *qlge, uint8_t *dp, uint32_t size, uint32_t startpos)

{

	uint32_t cnt, data, addr;

	int rval = DDI_SUCCESS;

	QL_PRINT(DBG_FLASH, ("%s(%d) entered to read address %x, %x bytes\n",

	    __func__, qlge->instance, startpos, size));

	/* make sure startpos+size doesn't exceed flash */

	if (size + startpos > qlge->fdesc.flash_size) {

		cmn_err(CE_WARN, "%s(%d) exceeded flash range, sz=%xh, stp=%xh,"

		    " flsz=%xh", __func__, qlge->instance,

		    size, startpos, qlge->fdesc.flash_size);

		return (DDI_FAILURE);

	}

	/* check start addr is 32 bit or 4 byte aligned for M25Pxx */

	if ((startpos & 0x3) != 0) {

		cmn_err(CE_WARN, "%s(%d) incorrect buffer size alignment",

		    __func__, qlge->instance);

		return (DDI_FAILURE);

	}

	/* adjust flash start addr for 32 bit words */

	addr = startpos / 4;

	/* Read fcode data from flash. */

	cnt = startpos;

	size += startpos;

	while (cnt < size) {

		/* Allow other system activity. */

		if (cnt % 0x1000 == 0) {

			drv_usecwait(1);

		}

		rval = ql_read_flash(qlge, addr++, &data);

		if (rval != DDI_SUCCESS) {

			break;

		}

		*dp++ = LSB(LSW(data));

		*dp++ = MSB(LSW(data));

		*dp++ = LSB(MSW(data));

		*dp++ = MSB(MSW(data));

		cnt += 4;

	}

	if (rval != DDI_SUCCESS) {

		cmn_err(CE_WARN, "failed, rval = %xh", rval);

	}

	return (rval);

}

int

ql_erase_and_write_to_flash(qlge_t *qlge, uint8_t *dp, uint32_t size,

    uint32_t faddr)

{

	int rval = DDI_FAILURE;

	uint32_t cnt, rest_addr, fdata;

	QL_PRINT(DBG_FLASH, ("%s(%d) entered to write addr %x, %d bytes\n",

	    __func__, qlge->instance, faddr, size));

	/* start address must be 32 bit word aligned */

	if ((faddr & 0x3) != 0) {

		cmn_err(CE_WARN, "%s(%d) incorrect buffer size alignment",

		    __func__, qlge->instance);

		return (DDI_FAILURE);

	}

	/* setup mask of address range within a sector */

	rest_addr = (qlge->fdesc.block_size - 1) >> 2;

	faddr = faddr >> 2;	/* flash gets 32 bit words */

	/*

	 * Write data to flash.

	 */

	cnt = 0;

	size = (size + 3) >> 2;	/* Round up & convert to dwords */

	while (cnt < size) {

		/* Beginning of a sector? do a sector erase */

		if ((faddr & rest_addr) == 0) {

			fdata = (faddr & ~rest_addr) << 2;

			fdata = (fdata & 0xff00) |

			    (fdata << 16 & 0xff0000) |

			    (fdata >> 16 & 0xff);

			/* 64k bytes sector erase */

			rval = ql_write_flash(qlge, /* 0xd8 */

			    FLASH_CONF_ADDR | 0x0300 | qlge->fdesc.erase_cmd,

			    fdata);

			if (rval != DDI_SUCCESS) {

				cmn_err(CE_WARN, "Unable to flash sector: "

				    "address=%xh", faddr);

				goto out;

			}

		}

		/* Write data */

		fdata = *dp++;

		fdata |= *dp++ << 8;

		fdata |= *dp++ << 16;

		fdata |= *dp++ << 24;

		rval = ql_write_flash(qlge, faddr, fdata);

		if (rval != DDI_SUCCESS) {

			cmn_err(CE_WARN, "Unable to program flash "

			    "address=%xh data=%xh", faddr,

			    *dp);

			goto out;

		}

		cnt++;

		faddr++;

		/* Allow other system activity. */

		if (cnt % 0x1000 == 0) {

			qlge_delay(10000);

		}

	}

	rval = DDI_SUCCESS;

out:

	if (rval != DDI_SUCCESS) {

		cmn_err(CE_WARN, "%s(%d failed=%xh",

		    __func__, qlge->instance, rval);

	}

	return (rval);

}

void

get_sector_number(qlge_t *qlge, uint32_t faddr, uint32_t *psector)

{

	*psector = faddr / qlge->fdesc.block_size; /* 0x10000 */

}

/*

 * qlge_load_flash

 * Write "size" bytes from memory "dp" to flash address "faddr".

 * faddr = 32bit word flash address.

 */

int

qlge_load_flash(qlge_t *qlge, uint8_t *dp, uint32_t len, uint32_t faddr)

{

	int rval = DDI_FAILURE;

	uint32_t start_block, end_block;

	uint32_t start_byte, end_byte;

	uint32_t num;

	uint32_t sector_size, addr_src, addr_desc;

	uint8_t *temp;

	caddr_t bp, bdesc;

	QL_PRINT(DBG_FLASH, ("%s(%d) entered to write addr %x, %d bytes\n",

	    __func__, qlge->instance, faddr, len));

	sector_size = qlge->fdesc.block_size;

	if (faddr > qlge->fdesc.flash_size) {

		cmn_err(CE_WARN, "%s(%d): invalid flash write address %x",

		    __func__, qlge->instance, faddr);

		return (DDI_FAILURE);

	}

	/* Get semaphore to access Flash Address and Flash Data Registers */

	if (ql_sem_spinlock(qlge, QL_FLASH_SEM_MASK) != DDI_SUCCESS) {

		return (DDI_FAILURE);

	}

	temp = kmem_zalloc(sector_size, KM_SLEEP);

	if (temp == NULL) {

		cmn_err(CE_WARN, "%s(%d): Unable to allocate buffer",

		    __func__, qlge->instance);

		ql_sem_unlock(qlge, QL_FLASH_SEM_MASK);

		return (DDI_FAILURE);

	}

	(void) ql_unprotect_flash(qlge);

	get_sector_number(qlge, faddr, &start_block);

	get_sector_number(qlge, faddr + len - 1, &end_block);

	QL_PRINT(DBG_FLASH, ("%s(%d) start_block %x, end_block %x\n",

	    __func__, qlge->instance, start_block, end_block));

	for (num = start_block; num <= end_block; num++) {

		QL_PRINT(DBG_FLASH,

		    ("%s(%d) sector_size 0x%x, sector read addr %x\n",

		    __func__, qlge->instance, sector_size, num * sector_size));

		/* read one whole sector flash data to buffer */

		rval = qlge_dump_fcode(qlge, (uint8_t *)temp, sector_size,

		    num * sector_size);

		start_byte = num * sector_size;

		end_byte = start_byte + sector_size -1;

		if (start_byte < faddr)

			start_byte = faddr;

		if (end_byte > (faddr + len))

			end_byte = (faddr + len - 1);

		addr_src = start_byte - faddr;

		addr_desc = start_byte - num * sector_size;

		bp = (caddr_t)dp + addr_src;

		bdesc = (caddr_t)temp + addr_desc;

		bcopy(bp, bdesc, (end_byte - start_byte + 1));

		/* write the whole sector data to flash */

		if (ql_erase_and_write_to_flash(qlge, temp, sector_size,

		    num * sector_size) != DDI_SUCCESS)

			goto out;

	}

	rval = DDI_SUCCESS;

out:

	(void) ql_protect_flash(qlge);

	kmem_free(temp, sector_size);

	ql_sem_unlock(qlge, QL_FLASH_SEM_MASK);

	if (rval != DDI_SUCCESS) {

		cmn_err(CE_WARN, "%s(%d failed=%xh",

		    __func__, qlge->instance, rval);

	}

	return (rval);

}

/*

 * ql_check_pci

 * checks the passed buffer for a valid pci signature and

 * expected (and in range) pci length values.

 * On successful pci check, nextpos adjusted to next pci header.

 */

static int

ql_check_pci(qlge_t *qlge, uint8_t *buf, uint32_t *nextpos)

{

	pci_header_t *pcih;

	pci_data_t *pcid;

	uint32_t doff;

	uint8_t *pciinfo;

	uint32_t image_size = 0;

	int rval = CONTINUE_SEARCH;

	QL_PRINT(DBG_FLASH, ("%s(%d) check image at 0x%x\n",

	    __func__, qlge->instance, *nextpos));

	if (buf != NULL) {

		pciinfo = buf;

	} else {

		cmn_err(CE_WARN, "%s(%d) failed, null buf ptr passed",

		    __func__, qlge->instance);

		return (STOP_SEARCH);

	}

	/* get the pci header image length */

	pcih = (pci_header_t *)pciinfo;

	doff = pcih->dataoffset[1];

	doff <<= 8;

	doff |= pcih->dataoffset[0];

	/* some header section sanity check */

	if (pcih->signature[0] != PCI_HEADER0 /* '55' */ ||

	    pcih->signature[1] != PCI_HEADER1 /* 'AA' */ || doff > 50) {

		cmn_err(CE_WARN, "%s(%d) image format error: s0=%xh, s1=%xh,"

		    "off=%xh\n", __func__, qlge->instance,

		    pcih->signature[0], pcih->signature[1], doff);

		return (STOP_SEARCH);

	}

	pcid = (pci_data_t *)(pciinfo + doff);

	/* a slight sanity data section check */

	if (pcid->signature[0] != 'P' || pcid->signature[1] != 'C' ||

	    pcid->signature[2] != 'I' || pcid->signature[3] != 'R') {

		cmn_err(CE_WARN, "%s(%d) failed, data sig mismatch!",

		    __func__, qlge->instance);

		return (STOP_SEARCH);

	}

	image_size =

	    (pcid->imagelength[0] | (pcid->imagelength[1] << 8))*

	    PCI_SECTOR_SIZE /* 512 */;

	switch (pcid->codetype) {

	case PCI_CODE_X86PC:

		QL_PRINT(DBG_FLASH, ("%s(%d) boot image is FTYPE_BIOS \n",

		    __func__, qlge->instance));

		break;

	case PCI_CODE_FCODE:

		QL_PRINT(DBG_FLASH, ("%s(%d) boot image is FTYPE_FCODE \n",

		    __func__, qlge->instance));

		break;

	case PCI_CODE_EFI:

		QL_PRINT(DBG_FLASH, ("%s(%d) boot image is FTYPE_EFI \n",

		    __func__, qlge->instance));

		break;

	case PCI_CODE_HPPA:

		QL_PRINT(DBG_FLASH, ("%s(%d) boot image is PCI_CODE_HPPA \n",

		    __func__, qlge->instance));

		break;

	default:

		QL_PRINT(DBG_FLASH, ("%s(%d) boot image is FTYPE_UNKNOWN \n",

		    __func__, qlge->instance));

		break;

	}

	QL_PRINT(DBG_FLASH, ("%s(%d) image size %x at %x\n",

	    __func__, qlge->instance, image_size, *nextpos));

	if (pcid->indicator == PCI_IND_LAST_IMAGE) {

		QL_PRINT(DBG_FLASH, ("%s(%d) last boot image found \n",

		    __func__, qlge->instance));

		rval = LAST_IMAGE_FOUND;

	} else {

		rval = CONTINUE_SEARCH;

	}

	/* Get the next flash image address */

	*nextpos += image_size;

	return (rval);

}

/*

 * ql_find_flash_layout_table_data_structure

 * Find Flash Layout Table Data Structure (FLTDS) that

 * is located at the end of last boot image.

 * Assume FLTDS is located with first 2M bytes.

 * Note:

 * Driver must be in stalled state prior to entering or

 * add code to this function prior to calling ql_setup_flash()

 */

int

ql_find_flash_layout_table_data_structure_addr(qlge_t *qlge)

{

	int rval = DDI_FAILURE;

	int result = CONTINUE_SEARCH;

	uint32_t freadpos = 0;

	uint8_t buf[FBUFSIZE];

	if (qlge->flash_fltds_addr != 0) {

		QL_PRINT(DBG_FLASH, ("%s(%d) done already\n",

		    __func__, qlge->instance));

		return (DDI_SUCCESS);

	}

	/*

	 * Temporarily set the fdesc.flash_size to

	 * 1M flash size to avoid failing of ql_dump_focde.

	 */

	qlge->fdesc.flash_size = FLASH_FIRMWARE_IMAGE_ADDR;

	while (result == CONTINUE_SEARCH) {

		if ((rval = qlge_dump_fcode(qlge, buf, FBUFSIZE, freadpos))

		    != DDI_SUCCESS) {

			cmn_err(CE_WARN, "%s(%d) qlge_dump_fcode failed"

			    " pos=%xh rval=%xh",

			    __func__, qlge->instance, freadpos, rval);

			break;

		}

		/*

		 * checkout the pci boot image format

		 * and get next read address

		 */

		result = ql_check_pci(qlge, buf, &freadpos);

		/*

		 * find last image? If so, then the freadpos

		 * is the address of FLTDS

		 */

		if (result == LAST_IMAGE_FOUND) {

			QL_PRINT(DBG_FLASH,

			    ("%s(%d) flash layout table data structure "

			    "(FLTDS) address is at %x \n", __func__,

			    qlge->instance, freadpos));

			qlge->flash_fltds_addr = freadpos;

			rval = DDI_SUCCESS;

			break;

		} else if (result == STOP_SEARCH) {

			cmn_err(CE_WARN, "%s(%d) flash header incorrect,"

			    "stop searching",

			    __func__, qlge->instance);

			break;

		}

	}

	return (rval);

}

/*

 * ql_flash_fltds

 * Get flash layout table data structure table.

 */

static int

ql_flash_fltds(qlge_t *qlge)

{

	uint32_t cnt;

	uint16_t chksum, *bp, data;

	int rval;

	rval = qlge_dump_fcode(qlge, (uint8_t *)&qlge->fltds,

	    sizeof (ql_fltds_t), qlge->flash_fltds_addr);

	if (rval != DDI_SUCCESS) {

		cmn_err(CE_WARN, "%s(%d)read error",

		    __func__, qlge->instance);

		bzero(&qlge->fltds, sizeof (ql_fltds_t));

		return (rval);

	}

	QL_DUMP(DBG_FLASH, "flash layout table data structure:\n",

	    &qlge->fltds, 8, sizeof (ql_fltds_t));

	chksum = 0;

	data = 0;

	bp = (uint16_t *)&qlge->fltds;

	for (cnt = 0; cnt < (sizeof (ql_fltds_t)) / 2; cnt++) {

		data = *bp;

		LITTLE_ENDIAN_16(&data);

		chksum += data;

		bp++;

	}

	LITTLE_ENDIAN_32(&qlge->fltds.signature);

	LITTLE_ENDIAN_16(&qlge->fltds.flt_addr_lo);

	LITTLE_ENDIAN_16(&qlge->fltds.flt_addr_hi);

	LITTLE_ENDIAN_16(&qlge->fltds.checksum);

	QL_PRINT(DBG_FLASH, ("%s(%d) signature %xh\n",

	    __func__, qlge->instance, qlge->fltds.signature));

	QL_PRINT(DBG_FLASH, ("%s(%d) flt_addr_lo %xh\n",

	    __func__, qlge->instance, qlge->fltds.flt_addr_lo));

	QL_PRINT(DBG_FLASH, ("%s(%d) flt_addr_hi %xh\n",

	    __func__, qlge->instance, qlge->fltds.flt_addr_hi));

	QL_PRINT(DBG_FLASH, ("%s(%d) version %xh\n",

	    __func__, qlge->instance, qlge->fltds.version));

	QL_PRINT(DBG_FLASH, ("%s(%d) checksum %xh\n",

	    __func__, qlge->instance, qlge->fltds.checksum));

	/* QFLT */

	if (chksum != 0 || qlge->fltds.signature != FLASH_FLTDS_SIGNATURE) {

		cmn_err(CE_WARN, "%s(%d) invalid flash layout table data"

		    " structure", __func__, qlge->instance);

		bzero(&qlge->fltds, sizeof (ql_fltds_t));

		return (DDI_FAILURE);

	}

	return (DDI_SUCCESS);

}

/*

 * ql_flash_flt

 * Get flash layout table.

 */

int

ql_flash_flt(qlge_t *qlge)

{

	uint32_t addr, cnt;

	int rval = DDI_FAILURE;

	ql_flt_entry_t *entry;

	uint8_t region;