xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/fca/emlxs/emlxs_download.c (revision 8f23e9fa)

/*
 * 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
 * http://www.opensource.org/licenses/cddl1.txt.
 * 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
 */

/*
 * Copyright (c) 2004-2012 Emulex. All rights reserved.
 * Use is subject to license terms.
 */

#include <emlxs.h>

/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
EMLXS_MSG_DEF(EMLXS_DOWNLOAD_C);

#define	MAX_BOOTID	10

static uint32_t	emlxs_erase_fcode_flash(emlxs_hba_t *hba);

static uint32_t	emlxs_write_fcode_flash(emlxs_hba_t *hba,
			PIMAGE_HDR ImageHdr, caddr_t Buffer);

static int32_t	emlxs_build_parms(caddr_t Buffer, PWAKE_UP_PARMS AbsWakeUpParms,
			uint32_t BufferSize, PAIF_HDR AifHeader);
static uint32_t	emlxs_validate_image(emlxs_hba_t *hba, caddr_t Buffer,
			uint32_t Size, emlxs_fw_image_t *fw_image);
static void	emlxs_format_dump(emlxs_hba_t *hba, MAILBOXQ *mbq,
			uint32_t Type, uint32_t RegionId, uint32_t WordCnt,
			uint32_t BaseAddr);
static uint32_t	emlxs_start_abs_download(emlxs_hba_t *hba, PAIF_HDR AifHdr,
			caddr_t Buffer, uint32_t len,
			PWAKE_UP_PARMS WakeUpParms);
static uint32_t	emlxs_start_abs_download_2mb(emlxs_hba_t *hba, caddr_t buffer,
			uint32_t len, uint32_t offline,
			emlxs_fw_image_t *fw_image);
static uint32_t	emlxs_proc_abs_2mb(emlxs_hba_t *hba,
			caddr_t EntireBuffer, uint32_t FileType,
			uint32_t extType);
static void	emlxs_format_load_area_cmd(MAILBOXQ *mbq, uint32_t Base,
			uint32_t DlByteCount, uint32_t Function,
			uint32_t Complete, uint32_t DataOffset, uint32_t AreaId,
			uint8_t MbxCmd, uint32_t StepCmd);
static uint32_t	emlxs_build_parms_2mb_bwc(emlxs_hba_t *hba, PAIF_HDR AifHdr,
			uint32_t extType, PWAKE_UP_PARMS AbsWakeUpParms);
static uint32_t	emlxs_update_exp_rom(emlxs_hba_t *hba,
			PWAKE_UP_PARMS WakeUpParms);
extern uint32_t	emlxs_get_max_sram(emlxs_hba_t *hba, uint32_t *MaxRbusSize,
			uint32_t *MaxIbusSize);
static void	emlxs_format_prog_flash(MAILBOXQ *mbq, uint32_t Base,
			uint32_t DlByteCount, uint32_t Function,
			uint32_t Complete, uint32_t BdeAddress,
			uint32_t BdeSize, PROG_ID *ProgId, uint32_t keep);
static void	emlxs_format_update_parms(MAILBOXQ *mbq,
			PWAKE_UP_PARMS WakeUpParms);
static void	emlxs_format_update_pci_cfg(emlxs_hba_t *hba, MAILBOXQ *mbq,
			uint32_t region_id, uint32_t size);
static uint32_t	emlxs_update_wakeup_parms(emlxs_hba_t *hba,
			PWAKE_UP_PARMS AbsWakeUpParms,
			PWAKE_UP_PARMS WakeUpParms);
static uint32_t	emlxs_update_boot_wakeup_parms(emlxs_hba_t *hba,
			PWAKE_UP_PARMS WakeUpParms, PROG_ID *id,
			uint32_t proc_erom);
static uint32_t	emlxs_update_ff_wakeup_parms(emlxs_hba_t *hba,
			PWAKE_UP_PARMS WakeUpParms, PROG_ID *id);
static uint32_t	emlxs_update_sli1_wakeup_parms(emlxs_hba_t *hba,
			PWAKE_UP_PARMS WakeUpParms, PROG_ID *id);
static uint32_t	emlxs_update_sli2_wakeup_parms(emlxs_hba_t *hba,
			PWAKE_UP_PARMS WakeUpParms, PROG_ID *id);
static uint32_t	emlxs_update_sli3_wakeup_parms(emlxs_hba_t *hba,
			PWAKE_UP_PARMS WakeUpParms, PROG_ID *id);
static uint32_t	emlxs_update_sli4_wakeup_parms(emlxs_hba_t *hba,
			PWAKE_UP_PARMS WakeUpParms, PROG_ID *id);
static uint32_t	emlxs_start_rel_download(emlxs_hba_t *hba, PIMAGE_HDR ImageHdr,
			caddr_t Buffer, PWAKE_UP_PARMS WakeUpParms,
			uint32_t dwc_flag);
static uint32_t	emlxs_read_load_list(emlxs_hba_t *hba, LOAD_LIST *LoadList);

static uint32_t	emlxs_valid_cksum(uint32_t *StartAddr, uint32_t *EndAddr);

static void	emlxs_disp_aif_header(emlxs_hba_t *hba, PAIF_HDR AifHdr);

static void	emlxs_dump_image_header(emlxs_hba_t *hba, PIMAGE_HDR image);


static uint32_t	emlxs_type_check(uint32_t type);

static uint32_t	emlxs_kern_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_stub_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_sli1_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_sli2_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_sli3_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_sli4_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_bios_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_sbus_fcode_check(emlxs_hba_t *hba, uint32_t version);

static uint32_t	emlxs_validate_version(emlxs_hba_t *hba,
			emlxs_fw_file_t *file, uint32_t id, uint32_t type,
			char *file_type);
static uint32_t emlxs_be2_validate_image(emlxs_hba_t *hba, caddr_t buffer,
			uint32_t len, emlxs_be_fw_image_t *fw_image);
static uint32_t emlxs_be3_validate_image(emlxs_hba_t *hba, caddr_t buffer,
			uint32_t len, emlxs_be_fw_image_t *fw_image);


static int32_t emlxs_be_verify_phy(emlxs_hba_t *hba, emlxs_be_fw_file_t *file,
			MAILBOXQ *mbq, MATCHMAP *mp);
static int32_t emlxs_be_verify_crc(emlxs_hba_t *hba,
			emlxs_be_fw_file_t *file,
			MAILBOXQ *mbq, MATCHMAP *mp);
static int32_t emlxs_be_flash_image(emlxs_hba_t *hba, caddr_t buffer,
			emlxs_be_fw_file_t *file, MAILBOXQ *mbq, MATCHMAP *mp);
static int32_t emlxs_be_fw_download(emlxs_hba_t *hba, caddr_t buffer,
			uint32_t len, uint32_t offline);
static int32_t emlxs_obj_fw_download(emlxs_hba_t *hba, caddr_t buffer,
			uint32_t len, uint32_t offline);
static int32_t emlxs_obj_flash_image(emlxs_hba_t *hba, caddr_t buffer,
			uint32_t size, MAILBOXQ *mbq, MATCHMAP *mp,
			uint32_t *change_status);
static uint32_t emlxs_obj_validate_image(emlxs_hba_t *hba, caddr_t buffer,
			uint32_t len, emlxs_obj_header_t *obj_hdr);
static uint32_t emlxs_be_version(caddr_t buffer, uint32_t size,
			uint32_t *plus_flag);
static uint32_t emlxs_proc_rel_2mb(emlxs_hba_t *hba, caddr_t buffer,
			emlxs_fw_image_t *fw_image);
static uint32_t emlxs_delete_load_entry(emlxs_hba_t *hba, PROG_ID *progId);

static void emlxs_verify_image(emlxs_hba_t *hba, emlxs_fw_image_t *image);

static uint32_t emlxs_clean_flash(emlxs_hba_t *hba,
			PWAKE_UP_PARMS OldWakeUpParms,
			PWAKE_UP_PARMS NewWakeUpParms);

/* ************************************************************************* */

extern int32_t
emlxs_fw_download(emlxs_hba_t *hba, caddr_t buffer, uint32_t len,
    uint32_t offline)
{
	emlxs_port_t *port = &PPORT;
	uint32_t *Uptr;
	IMAGE_HDR ImageHdr;
	AIF_HDR AifHdr;
	uint32_t ImageType;
	WAKE_UP_PARMS WakeUpParms;
	uint32_t rval = 0;
	emlxs_fw_image_t fw_image;
	uint32_t i;

#ifdef EMLXS_LITTLE_ENDIAN
	caddr_t local_buffer;
	uint32_t *bptr1;
	uint32_t *bptr2;
#endif /* EMLXS_LITTLE_ENDIAN */

	if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
		if (hba->model_info.chip & EMLXS_BE_CHIPS) {
			rval = emlxs_be_fw_download(hba, buffer, len, offline);
		} else {
			rval = emlxs_obj_fw_download(hba, buffer, len, offline);
		}
		return (rval);
	}

	if (buffer == NULL || len == 0) {
		return (EMLXS_IMAGE_BAD);
	}

#ifdef EMLXS_LITTLE_ENDIAN
	/* We need to swap the image buffer before we start */

	/*
	 * Use KM_SLEEP to allocate a temporary buffer
	 */
	local_buffer = (caddr_t)kmem_zalloc(len, KM_SLEEP);

	/* Perform a 32 bit swap of the image */
	bptr1 = (uint32_t *)local_buffer;
	bptr2 = (uint32_t *)buffer;
	for (i = 0; i < (len / 4); i++) {
		*bptr1 = LE_SWAP32(*bptr2);
		bptr1++;
		bptr2++;
	}

	/* Replace the original buffer */
	buffer = local_buffer;
#endif /* EMLXS_LITTLE_ENDIAN */

	bzero(&fw_image, sizeof (emlxs_fw_image_t));
	for (i = 0; i < MAX_PROG_TYPES; i++) {
		(void) strlcpy(fw_image.prog[i].label, "none",
		    sizeof (fw_image.prog[i].label));
	}

	/* Validate image */
	if ((rval = emlxs_validate_image(hba, buffer, len, &fw_image))) {
		goto done;
	}

	/* Verify image */
	emlxs_verify_image(hba, &fw_image);

	/* Get image type */
	Uptr = (uint32_t *)buffer;
	ImageType = *Uptr;

	/*
	 * Pegasus and beyond FW download is done differently
	 * for absolute download.
	 */

	/* Check for absolute image */
	if ((ImageType == NOP_IMAGE_TYPE) &&
	    !(hba->model_info.chip &
	    (EMLXS_DRAGONFLY_CHIP | EMLXS_CENTAUR_CHIP))) {
		/*
		 * Because 2Mb flash download file format is different from
		 * 512k, it needs to be handled differently
		 */
		if (rval = emlxs_start_abs_download_2mb(hba, buffer, len,
		    offline, &fw_image)) {
			goto done;
		}

		/* Offline already handled */
		offline = 0;

		goto SLI_DOWNLOAD_EXIT;
	}

	/* Pre-pegasus adapters only */

	/* Initialize headers */
	if (ImageType == NOP_IMAGE_TYPE) {
		bcopy(buffer, &AifHdr, sizeof (AIF_HDR));
		bzero((void *)&ImageHdr, sizeof (IMAGE_HDR));
	} else { /* PRG file */
		bzero((void *)&AifHdr, sizeof (AIF_HDR));
		bcopy(buffer, &ImageHdr, sizeof (IMAGE_HDR));
	}

	/* Everything checks out, now to just do it */

	if (offline) {
		if (emlxs_offline(hba, 0) != FC_SUCCESS) {
			offline = 0;

			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg,
			    "Unable to take adapter offline.");

			rval = EMLXS_OFFLINE_FAILED;
			goto SLI_DOWNLOAD_EXIT;
		}

		if (EMLXS_SLI_HBA_RESET(hba, 1, 1, 0) != FC_SUCCESS) {
			offline = 0;

			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg,
			    "Unable to restart adapter.");

			rval = EMLXS_OFFLINE_FAILED;
			goto SLI_DOWNLOAD_EXIT;
		}
	}

	/* Pre-pegasus adapters */

	if (ImageHdr.Id.Type == SBUS_FCODE) {
		/* Erase Flash */
		if (emlxs_erase_fcode_flash(hba)) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg,
			    "Unable to erase flash.");

			rval = EMLXS_IMAGE_FAILED;
			goto SLI_DOWNLOAD_EXIT;
		}

		/* Write FCODE */
		if (emlxs_write_fcode_flash(hba, &ImageHdr, buffer)) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg,
			    "Unable to write flash.");

			rval = EMLXS_IMAGE_FAILED;
			goto SLI_DOWNLOAD_EXIT;
		}

		goto SLI_DOWNLOAD_EXIT;
	}

	/* Pre-pegasus PCI adapters */

	if (emlxs_read_wakeup_parms(hba, &WakeUpParms, 1)) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg,
		    "Unable to get parameters.");

		rval = EMLXS_IMAGE_FAILED;

		goto SLI_DOWNLOAD_EXIT;
	}

	if (ImageType == NOP_IMAGE_TYPE) {
		if (emlxs_start_abs_download(hba, &AifHdr,
		    buffer, len, &WakeUpParms)) {
			EMLXS_MSGF(EMLXS_CONTEXT,
			    &emlxs_download_failed_msg,
			    "Failed to program flash.");

			rval = EMLXS_IMAGE_FAILED;

			goto SLI_DOWNLOAD_EXIT;
		}

	} else { /* Relative PRG file */
		if (emlxs_start_rel_download(hba, &ImageHdr, buffer,
		    &WakeUpParms, 0)) {
			EMLXS_MSGF(EMLXS_CONTEXT,
			    &emlxs_download_failed_msg,
			    "Failed to program flash.");

			rval = EMLXS_IMAGE_FAILED;

			goto SLI_DOWNLOAD_EXIT;
		}
	}

SLI_DOWNLOAD_EXIT:

	if (offline) {
		(void) emlxs_online(hba);
	}

	if (rval == 0) {
		EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_complete_msg,
		    "Status good.");
	}

done:

#ifdef EMLXS_LITTLE_ENDIAN
	/* Free the local buffer */
	kmem_free(local_buffer, len);
#endif /* EMLXS_LITTLE_ENDIAN */

	return (rval);

} /* emlxs_fw_download */


extern void
emlxs_memset(uint8_t *buffer, uint8_t value, uint32_t size)
{
	while (size--) {
		*buffer++ = value;
	}

} /* emlxs_memset () */


static int32_t
emlxs_be_flash_image(emlxs_hba_t *hba, caddr_t buffer,
    emlxs_be_fw_file_t *file, MAILBOXQ *mbq, MATCHMAP *mp)
{
	emlxs_port_t *port = &PPORT;
	uint8_t *image_ptr;
	uint32_t *wptr;
	uint8_t *payload;
	MAILBOX4 *mb;
	IOCTL_COMMON_FLASHROM *flashrom;
	mbox_req_hdr_t	*hdr_req;
	uint32_t	image_size;
	uint32_t	block_size;
	uint32_t	xfer_size;
	uint32_t	block_offset;
	uint32_t	count;
	uint32_t	rval = 0;

	if (file->image_size == 0) {
		return (0);
	}

	image_ptr  = (uint8_t *)buffer + file->image_offset;
	image_size = file->image_size;
	block_size = file->block_size;
	block_offset = 0;
	mb = (MAILBOX4*)mbq;

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg,
	    "%s: Downloading...", file->label);

	while (block_size) {
		bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);
		bzero((void *) mp->virt, mp->size);

		xfer_size = min(BE_MAX_XFER_SIZE, block_size);

		mb->un.varSLIConfig.be.embedded = 0;
		mbq->nonembed = (void *)mp;
		mbq->mbox_cmpl = NULL;

		mb->mbxCommand = MBX_SLI_CONFIG;
		mb->mbxOwner = OWN_HOST;

		hdr_req = (mbox_req_hdr_t *)mp->virt;
		hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON;
		hdr_req->opcode = COMMON_OPCODE_WRITE_FLASHROM;
		hdr_req->timeout = 0;
		hdr_req->req_length = sizeof (IOCTL_COMMON_FLASHROM) +
		    xfer_size;

		flashrom = (IOCTL_COMMON_FLASHROM *)(hdr_req + 1);

		if (file->type == MGMT_FLASHROM_OPTYPE_PHY_FIRMWARE) {
			flashrom->params.opcode = ((block_size == xfer_size)?
			    MGMT_PHY_FLASHROM_OPCODE_FLASH:
			    MGMT_PHY_FLASHROM_OPCODE_SAVE);
			flashrom->params.optype = 0; /* ignored */
		} else {
			flashrom->params.opcode = ((block_size == xfer_size)?
			    MGMT_FLASHROM_OPCODE_FLASH:
			    MGMT_FLASHROM_OPCODE_SAVE);
			flashrom->params.optype = file->type;
		}

		flashrom->params.data_buffer_size = xfer_size;
		flashrom->params.offset = block_offset;

		/* Build data buffer payload */
		payload = (uint8_t *)(&flashrom->params.data_buffer);
		emlxs_memset(payload, 0xff, xfer_size);

		/* Copy remaining image into payload */
		if (image_size) {
			count = min(image_size, xfer_size);
			BE_SWAP32_BCOPY(image_ptr, payload, count);
			image_size -= count;
			image_ptr  += count;
		}

		if ((flashrom->params.opcode == MGMT_FLASHROM_OPCODE_FLASH) ||
		    (flashrom->params.opcode ==
		    MGMT_PHY_FLASHROM_OPCODE_FLASH)) {
			wptr = (uint32_t *)&payload[(xfer_size - 12)];

			wptr[0] = file->load_address;
			wptr[1] = file->image_size;
			wptr[2] = file->block_crc;
		}

		/* Send write request */
		if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) !=
		    MBX_SUCCESS) {
			EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg,
			    "%s: Unable to download image. status=%x",
			    file->label, mb->mbxStatus);
			rval = EMLXS_IMAGE_FAILED;
			goto done;
		}

		block_size -= xfer_size;
		block_offset += xfer_size;
	}

	EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg,
	    "%s: Download complete.", file->label);
done:

	return (rval);

} /* emlxs_be_flash_image() */




static int32_t
emlxs_be_verify_crc(emlxs_hba_t *hba,
    emlxs_be_fw_file_t *file, MAILBOXQ *mbq, MATCHMAP *mp)
{
	emlxs_port_t *port = &PPORT;
	uint32_t *wptr;
	uint8_t *payload;
	MAILBOX4 *mb;
	IOCTL_COMMON_FLASHROM *flashrom;
	mbox_req_hdr_t	*hdr_req;
	uint32_t	xfer_size;