emlxs_download.c (4baa2c25) | emlxs_download.c (82527734) |
---|---|
1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE --- 7 unchanged lines hidden (view full) --- 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22/* 23 * Copyright 2009 Emulex. All rights reserved. | 1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE --- 7 unchanged lines hidden (view full) --- 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22/* 23 * Copyright 2009 Emulex. All rights reserved. |
24 * Use is subject to License terms. | 24 * Use is subject to license terms. |
25 */ 26 | 25 */ 26 |
27 |
|
27#include <emlxs.h> 28 29/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */ 30EMLXS_MSG_DEF(EMLXS_DOWNLOAD_C); 31 32#define MAX_BOOTID 10 33 | 28#include <emlxs.h> 29 30/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */ 31EMLXS_MSG_DEF(EMLXS_DOWNLOAD_C); 32 33#define MAX_BOOTID 10 34 |
34#define DATA32_SWAP(x) ((((x) & 0xFF)<<24) | (((x) & 0xFF00)<<8) | \ 35 (((x) & 0xFF0000)>>8) | \ 36 (((x) & 0xFF000000)>>24)) 37 | |
38static uint32_t emlxs_erase_fcode_flash(emlxs_hba_t *hba); | 35static uint32_t emlxs_erase_fcode_flash(emlxs_hba_t *hba); |
36 |
|
39static uint32_t emlxs_write_fcode_flash(emlxs_hba_t *hba, 40 PIMAGE_HDR ImageHdr, caddr_t Buffer); 41 42static int32_t emlxs_build_parms(caddr_t Buffer, PWAKE_UP_PARMS AbsWakeUpParms, 43 uint32_t BufferSize, PAIF_HDR AifHeader, 44 int32_t DwcFile); | 37static uint32_t emlxs_write_fcode_flash(emlxs_hba_t *hba, 38 PIMAGE_HDR ImageHdr, caddr_t Buffer); 39 40static int32_t emlxs_build_parms(caddr_t Buffer, PWAKE_UP_PARMS AbsWakeUpParms, 41 uint32_t BufferSize, PAIF_HDR AifHeader, 42 int32_t DwcFile); |
45 | |
46static uint32_t emlxs_validate_image(emlxs_hba_t *hba, caddr_t Buffer, 47 uint32_t Size, emlxs_fw_image_t *fw_image); | 43static uint32_t emlxs_validate_image(emlxs_hba_t *hba, caddr_t Buffer, 44 uint32_t Size, emlxs_fw_image_t *fw_image); |
48 49static void emlxs_format_dump(MAILBOX *mb, uint32_t Type, uint32_t RegionId, 50 uint32_t WordCount, uint32_t BaseAddr); 51 | 45static void emlxs_format_dump(emlxs_hba_t *hba, MAILBOXQ *mbq, 46 uint32_t Type, uint32_t RegionId, uint32_t WordCnt, 47 uint32_t BaseAddr); |
52static uint32_t emlxs_start_abs_download(emlxs_hba_t *hba, PAIF_HDR AifHdr, 53 caddr_t Buffer, PWAKE_UP_PARMS WakeUpParms, 54 uint32_t MaxRbusSramSize, uint32_t MaxIbusSramSize, 55 PWAKE_UP_PARMS AbsWakeUpParms, int32_t DwcFile); | 48static uint32_t emlxs_start_abs_download(emlxs_hba_t *hba, PAIF_HDR AifHdr, 49 caddr_t Buffer, PWAKE_UP_PARMS WakeUpParms, 50 uint32_t MaxRbusSramSize, uint32_t MaxIbusSramSize, 51 PWAKE_UP_PARMS AbsWakeUpParms, int32_t DwcFile); |
56 | |
57static uint32_t emlxs_start_abs_download_2mb(emlxs_hba_t *hba, caddr_t buffer, 58 uint32_t len, uint32_t offline, 59 emlxs_fw_image_t *fw_image); | 52static uint32_t emlxs_start_abs_download_2mb(emlxs_hba_t *hba, caddr_t buffer, 53 uint32_t len, uint32_t offline, 54 emlxs_fw_image_t *fw_image); |
60 | |
61static uint32_t emlxs_proc_abs_2mb(emlxs_hba_t *hba, PAIF_HDR AifHdr, 62 caddr_t EntireBuffer, uint32_t FileType, 63 uint32_t BWCflag, uint32_t extType); | 55static uint32_t emlxs_proc_abs_2mb(emlxs_hba_t *hba, PAIF_HDR AifHdr, 56 caddr_t EntireBuffer, uint32_t FileType, 57 uint32_t BWCflag, uint32_t extType); |
64 65static void emlxs_format_load_area_cmd(MAILBOX *mb, uint32_t Base, | 58static void emlxs_format_load_area_cmd(MAILBOXQ *mbq, uint32_t Base, |
66 uint32_t DlByteCount, uint32_t Function, 67 uint32_t Complete, uint32_t DataOffset, uint32_t AreaId, 68 uint8_t MbxCmd, uint32_t StepCmd); | 59 uint32_t DlByteCount, uint32_t Function, 60 uint32_t Complete, uint32_t DataOffset, uint32_t AreaId, 61 uint8_t MbxCmd, uint32_t StepCmd); |
69 | |
70static uint32_t emlxs_build_parms_2mb_bwc(emlxs_hba_t *hba, PAIF_HDR AifHdr, 71 uint32_t extType, PWAKE_UP_PARMS AbsWakeUpParms); | 62static uint32_t emlxs_build_parms_2mb_bwc(emlxs_hba_t *hba, PAIF_HDR AifHdr, 63 uint32_t extType, PWAKE_UP_PARMS AbsWakeUpParms); |
72 | |
73static uint32_t emlxs_build_parms_2mb_dwc(emlxs_hba_t *hba, caddr_t Buffer, 74 uint32_t BufferSize, PAIF_HDR AifHeader, 75 PWAKE_UP_PARMS AbsWakeUpParms, uint32_t BWCflag, 76 uint32_t extType, uint32_t *numBootImage); | 64static uint32_t emlxs_build_parms_2mb_dwc(emlxs_hba_t *hba, caddr_t Buffer, 65 uint32_t BufferSize, PAIF_HDR AifHeader, 66 PWAKE_UP_PARMS AbsWakeUpParms, uint32_t BWCflag, 67 uint32_t extType, uint32_t *numBootImage); |
77 | |
78static uint32_t emlxs_update_exp_rom(emlxs_hba_t *hba, 79 PWAKE_UP_PARMS WakeUpParms); | 68static uint32_t emlxs_update_exp_rom(emlxs_hba_t *hba, 69 PWAKE_UP_PARMS WakeUpParms); |
80 | |
81extern uint32_t emlxs_get_max_sram(emlxs_hba_t *hba, uint32_t *MaxRbusSize, 82 uint32_t *MaxIbusSize); | 70extern uint32_t emlxs_get_max_sram(emlxs_hba_t *hba, uint32_t *MaxRbusSize, 71 uint32_t *MaxIbusSize); |
83 84static void emlxs_format_prog_flash(MAILBOX *mb, uint32_t Base, | 72static void emlxs_format_prog_flash(MAILBOXQ *mbq, uint32_t Base, |
85 uint32_t DlByteCount, uint32_t Function, 86 uint32_t Complete, uint32_t BdeAddress, 87 uint32_t BdeSize, PROG_ID *ProgId); | 73 uint32_t DlByteCount, uint32_t Function, 74 uint32_t Complete, uint32_t BdeAddress, 75 uint32_t BdeSize, PROG_ID *ProgId); |
88 89static void emlxs_format_update_parms(MAILBOX *mb, | 76static void emlxs_format_update_parms(MAILBOXQ *mbq, |
90 PWAKE_UP_PARMS WakeUpParms); | 77 PWAKE_UP_PARMS WakeUpParms); |
91 92static void emlxs_format_update_pci_cfg(emlxs_hba_t *hba, MAILBOX *mb, | 78static void emlxs_format_update_pci_cfg(emlxs_hba_t *hba, MAILBOXQ *mbq, |
93 uint32_t region_id, uint32_t size); | 79 uint32_t region_id, uint32_t size); |
94 | |
95static uint32_t emlxs_update_wakeup_parms(emlxs_hba_t *hba, 96 PWAKE_UP_PARMS AbsWakeUpParms, 97 PWAKE_UP_PARMS WakeUpParms); | 80static uint32_t emlxs_update_wakeup_parms(emlxs_hba_t *hba, 81 PWAKE_UP_PARMS AbsWakeUpParms, 82 PWAKE_UP_PARMS WakeUpParms); |
98 | |
99static uint32_t emlxs_update_boot_wakeup_parms(emlxs_hba_t *hba, 100 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id, 101 uint32_t proc_erom); | 83static uint32_t emlxs_update_boot_wakeup_parms(emlxs_hba_t *hba, 84 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id, 85 uint32_t proc_erom); |
102 | |
103static uint32_t emlxs_update_ff_wakeup_parms(emlxs_hba_t *hba, 104 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); | 86static uint32_t emlxs_update_ff_wakeup_parms(emlxs_hba_t *hba, 87 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); |
105 | |
106static uint32_t emlxs_update_sli1_wakeup_parms(emlxs_hba_t *hba, 107 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); | 88static uint32_t emlxs_update_sli1_wakeup_parms(emlxs_hba_t *hba, 89 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); |
108 | |
109static uint32_t emlxs_update_sli2_wakeup_parms(emlxs_hba_t *hba, 110 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); | 90static uint32_t emlxs_update_sli2_wakeup_parms(emlxs_hba_t *hba, 91 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); |
111 | |
112static uint32_t emlxs_update_sli3_wakeup_parms(emlxs_hba_t *hba, 113 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); | 92static uint32_t emlxs_update_sli3_wakeup_parms(emlxs_hba_t *hba, 93 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); |
114 | |
115static uint32_t emlxs_update_sli4_wakeup_parms(emlxs_hba_t *hba, 116 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); | 94static uint32_t emlxs_update_sli4_wakeup_parms(emlxs_hba_t *hba, 95 PWAKE_UP_PARMS WakeUpParms, PROG_ID *id); |
117 118 | |
119static uint32_t emlxs_start_rel_download(emlxs_hba_t *hba, PIMAGE_HDR ImageHdr, 120 caddr_t Buffer, PWAKE_UP_PARMS WakeUpParms, 121 uint32_t MaxRbusSramSize, uint32_t MaxIbusSramSize); | 96static uint32_t emlxs_start_rel_download(emlxs_hba_t *hba, PIMAGE_HDR ImageHdr, 97 caddr_t Buffer, PWAKE_UP_PARMS WakeUpParms, 98 uint32_t MaxRbusSramSize, uint32_t MaxIbusSramSize); |
122 | |
123static uint32_t emlxs_read_load_list(emlxs_hba_t *hba, LOAD_LIST *LoadList); 124 125static uint32_t emlxs_valid_cksum(uint32_t *StartAddr, uint32_t *EndAddr); | 99static uint32_t emlxs_read_load_list(emlxs_hba_t *hba, LOAD_LIST *LoadList); 100 101static uint32_t emlxs_valid_cksum(uint32_t *StartAddr, uint32_t *EndAddr); |
102 |
|
126static void emlxs_disp_aif_header(emlxs_hba_t *hba, PAIF_HDR AifHdr); | 103static void emlxs_disp_aif_header(emlxs_hba_t *hba, PAIF_HDR AifHdr); |
104 |
|
127static void emlxs_dump_image_header(emlxs_hba_t *hba, PIMAGE_HDR image); | 105static void emlxs_dump_image_header(emlxs_hba_t *hba, PIMAGE_HDR image); |
106 |
|
128static uint32_t emlxs_get_abs_image_type(caddr_t Buffer, uint32_t BufferSize); 129 130static uint32_t emlxs_get_dwc_image_type(emlxs_hba_t *hba, caddr_t Buffer, 131 uint32_t BufferSize, PAIF_HDR AifHeader); | 107static uint32_t emlxs_get_abs_image_type(caddr_t Buffer, uint32_t BufferSize); 108 109static uint32_t emlxs_get_dwc_image_type(emlxs_hba_t *hba, caddr_t Buffer, 110 uint32_t BufferSize, PAIF_HDR AifHeader); |
132 | |
133static uint32_t emlxs_type_check(uint32_t type); | 111static uint32_t emlxs_type_check(uint32_t type); |
112 |
|
134static uint32_t emlxs_kern_check(emlxs_hba_t *hba, uint32_t version); | 113static uint32_t emlxs_kern_check(emlxs_hba_t *hba, uint32_t version); |
114 |
|
135static uint32_t emlxs_stub_check(emlxs_hba_t *hba, uint32_t version); | 115static uint32_t emlxs_stub_check(emlxs_hba_t *hba, uint32_t version); |
116 |
|
136static uint32_t emlxs_sli1_check(emlxs_hba_t *hba, uint32_t version); | 117static uint32_t emlxs_sli1_check(emlxs_hba_t *hba, uint32_t version); |
118 |
|
137static uint32_t emlxs_sli2_check(emlxs_hba_t *hba, uint32_t version); | 119static uint32_t emlxs_sli2_check(emlxs_hba_t *hba, uint32_t version); |
120 |
|
138static uint32_t emlxs_sli3_check(emlxs_hba_t *hba, uint32_t version); | 121static uint32_t emlxs_sli3_check(emlxs_hba_t *hba, uint32_t version); |
122 |
|
139static uint32_t emlxs_sli4_check(emlxs_hba_t *hba, uint32_t version); | 123static uint32_t emlxs_sli4_check(emlxs_hba_t *hba, uint32_t version); |
124 |
|
140static uint32_t emlxs_bios_check(emlxs_hba_t *hba, uint32_t version); | 125static uint32_t emlxs_bios_check(emlxs_hba_t *hba, uint32_t version); |
126 |
|
141static uint32_t emlxs_sbus_fcode_check(emlxs_hba_t *hba, uint32_t version); | 127static uint32_t emlxs_sbus_fcode_check(emlxs_hba_t *hba, uint32_t version); |
128 |
|
142static uint32_t emlxs_validate_version(emlxs_hba_t *hba, 143 emlxs_fw_file_t *file, uint32_t id, uint32_t type, 144 char *file_type); | 129static uint32_t emlxs_validate_version(emlxs_hba_t *hba, 130 emlxs_fw_file_t *file, uint32_t id, uint32_t type, 131 char *file_type); |
132static uint32_t emlxs_sli4_validate_image(emlxs_hba_t *hba, caddr_t buffer, 133 uint32_t len, emlxs_be_fw_image_t *fw_image); 134static int32_t emlxs_sli4_verify_image(emlxs_hba_t *hba, caddr_t buffer, 135 emlxs_be_fw_file_t *file, 136 MAILBOXQ *mbq, MATCHMAP *mp); 137static int32_t emlxs_sli4_verify_crc(emlxs_hba_t *hba, 138 emlxs_be_fw_file_t *file, 139 MAILBOXQ *mbq, MATCHMAP *mp); 140static int32_t emlxs_sli4_flash_image(emlxs_hba_t *hba, caddr_t buffer, 141 emlxs_be_fw_file_t *file, MAILBOXQ *mbq, MATCHMAP *mp); 142static int32_t emlxs_sli4_fw_download(emlxs_hba_t *hba, caddr_t buffer, 143 uint32_t len, uint32_t offline); |
|
145 146/* ************************************************************************* */ 147 | 144 145/* ************************************************************************* */ 146 |
148 | |
149extern int32_t 150emlxs_fw_download(emlxs_hba_t *hba, caddr_t buffer, uint32_t len, 151 uint32_t offline) 152{ 153 emlxs_port_t *port = &PPORT; 154 uint32_t *Uptr; 155 IMAGE_HDR ImageHdr; 156 AIF_HDR AifHdr; 157 uint32_t ImageType; 158 WAKE_UP_PARMS WakeUpParms; 159 WAKE_UP_PARMS AbsWakeUpParms; 160 uint32_t MaxRbusSramSize; 161 uint32_t MaxIbusSramSize; 162 int32_t AbsChangeParams = 0; 163 int32_t DwcFile = FALSE; 164 uint32_t rval = 0; 165 emlxs_fw_image_t fw_image; 166 uint32_t i; 167 | 147extern int32_t 148emlxs_fw_download(emlxs_hba_t *hba, caddr_t buffer, uint32_t len, 149 uint32_t offline) 150{ 151 emlxs_port_t *port = &PPORT; 152 uint32_t *Uptr; 153 IMAGE_HDR ImageHdr; 154 AIF_HDR AifHdr; 155 uint32_t ImageType; 156 WAKE_UP_PARMS WakeUpParms; 157 WAKE_UP_PARMS AbsWakeUpParms; 158 uint32_t MaxRbusSramSize; 159 uint32_t MaxIbusSramSize; 160 int32_t AbsChangeParams = 0; 161 int32_t DwcFile = FALSE; 162 uint32_t rval = 0; 163 emlxs_fw_image_t fw_image; 164 uint32_t i; 165 |
168#ifdef EMLXS_I386 | 166#ifdef EMLXS_LITTLE_ENDIAN |
169 caddr_t local_buffer; 170 uint32_t *bptr1; 171 uint32_t *bptr2; | 167 caddr_t local_buffer; 168 uint32_t *bptr1; 169 uint32_t *bptr2; |
172#endif /* EMLXS_I386 */ | 170#endif /* EMLXS_LITTLE_ENDIAN */ |
173 | 171 |
172 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 173 rval = emlxs_sli4_fw_download(hba, buffer, len, offline); 174 return (rval); 175 } 176 |
|
174 if (buffer == NULL || len == 0) { 175 return (EMLXS_IMAGE_BAD); 176 } | 177 if (buffer == NULL || len == 0) { 178 return (EMLXS_IMAGE_BAD); 179 } |
177#ifdef EMLXS_I386 | 180 181#ifdef EMLXS_LITTLE_ENDIAN |
178 /* We need to swap the image buffer before we start */ 179 180 /* 181 * Use KM_SLEEP to allocate a temporary buffer 182 */ 183 local_buffer = (caddr_t)kmem_zalloc(len, KM_SLEEP); 184 | 182 /* We need to swap the image buffer before we start */ 183 184 /* 185 * Use KM_SLEEP to allocate a temporary buffer 186 */ 187 local_buffer = (caddr_t)kmem_zalloc(len, KM_SLEEP); 188 |
185 if (local_buffer == NULL) { 186 return (FC_NOMEM); 187 } 188 | |
189 /* Perform a 32 bit swap of the image */ 190 bptr1 = (uint32_t *)local_buffer; 191 bptr2 = (uint32_t *)buffer; 192 for (i = 0; i < (len / 4); i++) { | 189 /* Perform a 32 bit swap of the image */ 190 bptr1 = (uint32_t *)local_buffer; 191 bptr2 = (uint32_t *)buffer; 192 for (i = 0; i < (len / 4); i++) { |
193 *bptr1 = SWAP_DATA32(*bptr2); | 193 *bptr1 = LE_SWAP32(*bptr2); |
194 bptr1++; 195 bptr2++; 196 } 197 198 /* Replace the original buffer */ 199 buffer = local_buffer; | 194 bptr1++; 195 bptr2++; 196 } 197 198 /* Replace the original buffer */ 199 buffer = local_buffer; |
200#endif /* EMLXS_I386 */ | 200#endif /* EMLXS_LITTLE_ENDIAN */ |
201 | 201 |
202 | |
203 bzero(&fw_image, sizeof (emlxs_fw_image_t)); 204 for (i = 0; i < MAX_PROG_TYPES; i++) { 205 (void) strcpy(fw_image.prog[i].label, "none"); 206 } 207 208 /* Validate image */ 209 if ((rval = emlxs_validate_image(hba, buffer, len, &fw_image))) { 210 goto done; --- 57 unchanged lines hidden (view full) --- 268 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 269 "Unable to take adapter offline."); 270 271 rval = EMLXS_OFFLINE_FAILED; 272 273 goto SLI_DOWNLOAD_EXIT; 274 } 275 | 202 bzero(&fw_image, sizeof (emlxs_fw_image_t)); 203 for (i = 0; i < MAX_PROG_TYPES; i++) { 204 (void) strcpy(fw_image.prog[i].label, "none"); 205 } 206 207 /* Validate image */ 208 if ((rval = emlxs_validate_image(hba, buffer, len, &fw_image))) { 209 goto done; --- 57 unchanged lines hidden (view full) --- 267 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 268 "Unable to take adapter offline."); 269 270 rval = EMLXS_OFFLINE_FAILED; 271 272 goto SLI_DOWNLOAD_EXIT; 273 } 274 |
276 if (emlxs_sli_hba_reset(hba, 1, 1) != FC_SUCCESS) { | 275 if (EMLXS_SLI_HBA_RESET(hba, 1, 1, 0) != FC_SUCCESS) { |
277 offline = 0; 278 279 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 280 "Unable to restart adapter."); 281 282 rval = EMLXS_OFFLINE_FAILED; 283 284 goto SLI_DOWNLOAD_EXIT; --- 76 unchanged lines hidden (view full) --- 361 362SLI_DOWNLOAD_EXIT: 363 364 if (offline) { 365 (void) emlxs_online(hba); 366 } 367 368 if (rval == 0) { | 276 offline = 0; 277 278 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 279 "Unable to restart adapter."); 280 281 rval = EMLXS_OFFLINE_FAILED; 282 283 goto SLI_DOWNLOAD_EXIT; --- 76 unchanged lines hidden (view full) --- 360 361SLI_DOWNLOAD_EXIT: 362 363 if (offline) { 364 (void) emlxs_online(hba); 365 } 366 367 if (rval == 0) { |
369 370 | |
371 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_complete_msg, 372 "Status good."); 373 } 374 375done: 376 | 368 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_complete_msg, 369 "Status good."); 370 } 371 372done: 373 |
377#ifdef EMLXS_I386 | 374#ifdef EMLXS_LITTLE_ENDIAN |
378 /* Free the local buffer */ 379 kmem_free(local_buffer, len); | 375 /* Free the local buffer */ 376 kmem_free(local_buffer, len); |
380#endif /* EMLXS_I386 */ | 377#endif /* EMLXS_LITTLE_ENDIAN */ |
381 382 return (rval); 383 | 378 379 return (rval); 380 |
384} /* emlxs_fw_download */ | 381} /* emlxs_fw_download */ |
385 386 | 382 383 |
384static void 385emlxs_memset(uint8_t *buffer, uint8_t value, uint32_t size) 386{ 387 while (size--) { 388 *buffer++ = value; 389 } |
|
387 | 390 |
391} /* emlxs_memset () */ 392 393 394static int32_t 395emlxs_sli4_flash_image(emlxs_hba_t *hba, caddr_t buffer, 396 emlxs_be_fw_file_t *file, MAILBOXQ *mbq, MATCHMAP *mp) 397{ 398 emlxs_port_t *port = &PPORT; 399 uint8_t *image_ptr; 400 uint32_t *wptr; 401 uint8_t *payload; 402 MAILBOX4 *mb; 403 IOCTL_COMMON_FLASHROM *flashrom; 404 mbox_req_hdr_t *hdr_req; 405 uint32_t image_size; 406 uint32_t block_size; 407 uint32_t xfer_size; 408 uint32_t block_offset; 409 uint32_t count; 410 uint32_t rval = 0; 411 412 if (file->image_size == 0) { 413 return (0); 414 } 415 416 image_ptr = (uint8_t *)buffer + file->image_offset; 417 image_size = file->image_size; 418 block_size = file->block_size; 419 block_offset = 0; 420 mb = (MAILBOX4*)mbq; 421 422 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, 423 "%s: Downloading...", file->label); 424 425 while (block_size) { 426 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE); 427 bzero((void *) mp->virt, mp->size); 428 429 xfer_size = min(BE_MAX_XFER_SIZE, block_size); 430 431 mb->un.varSLIConfig.be.embedded = 0; 432 mbq->nonembed = (uint8_t *)mp; 433 mbq->mbox_cmpl = NULL; 434 435 mb->mbxCommand = MBX_SLI_CONFIG; 436 mb->mbxOwner = OWN_HOST; 437 438 hdr_req = (mbox_req_hdr_t *)mp->virt; 439 hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON; 440 hdr_req->opcode = COMMON_OPCODE_WRITE_FLASHROM; 441 hdr_req->timeout = 0; 442 hdr_req->req_length = sizeof (IOCTL_COMMON_FLASHROM) + 443 xfer_size; 444 445 flashrom = (IOCTL_COMMON_FLASHROM *)(hdr_req + 1); 446 flashrom->params.opcode = ((block_size == xfer_size)? 447 MGMT_FLASHROM_OPCODE_FLASH:MGMT_FLASHROM_OPCODE_SAVE); 448 flashrom->params.optype = file->type; 449 flashrom->params.data_buffer_size = xfer_size; 450 flashrom->params.offset = block_offset; 451 452 /* Build data buffer payload */ 453 payload = (uint8_t *)(&flashrom->params.data_buffer); 454 emlxs_memset(payload, 0xff, xfer_size); 455 456 /* Copy remaining image into payload */ 457 if (image_size) { 458 count = min(image_size, xfer_size); 459 BE_SWAP32_BCOPY(image_ptr, payload, count); 460 image_size -= count; 461 image_ptr += count; 462 } 463 464 /* Set last two words of last payload with */ 465 /* image size and block crc */ 466 if (flashrom->params.opcode == MGMT_FLASHROM_OPCODE_FLASH) { 467 wptr = (uint32_t *)&payload[(xfer_size - 8)]; 468 wptr[0] = file->image_size; 469 wptr[1] = file->block_crc; 470 } 471 472 /* Send write request */ 473 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != 474 MBX_SUCCESS) { 475 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 476 "%s: Unable to download image. status=%x", 477 file->label, mb->mbxStatus); 478 rval = EMLXS_IMAGE_FAILED; 479 goto done; 480 } 481 482 block_size -= xfer_size; 483 block_offset += xfer_size; 484 } 485 486 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, 487 "%s: Download complete.", file->label); 488done: 489 490 return (rval); 491 492} /* emlxs_sli4_flash_image() */ 493 494 495static int32_t 496emlxs_sli4_verify_image(emlxs_hba_t *hba, caddr_t buffer, 497 emlxs_be_fw_file_t *file, MAILBOXQ *mbq, MATCHMAP *mp) 498{ 499 emlxs_port_t *port = &PPORT; 500 uint8_t *image_ptr; 501 uint32_t *wptr; 502 uint32_t *wptr1; 503 uint8_t *payload; 504 MAILBOX4 *mb; 505 IOCTL_COMMON_FLASHROM *flashrom; 506 mbox_req_hdr_t *hdr_req; 507 uint32_t xfer_size; 508 uint32_t block_size; 509 uint32_t block_offset; 510 uint32_t rval = 0; 511 uint32_t i; 512 char signature[BE_SIGNATURE_SIZE]; 513 uint32_t ufi_plus = 0; 514 515 /* Check for special deflated format */ 516 (void) sprintf(signature, "%s+", BE_SIGNATURE); 517 if (strncmp(signature, buffer, 518 sizeof (signature)-1) == 0) { 519 ufi_plus = 1; 520 } 521 522 image_ptr = (uint8_t *)buffer + file->image_offset; 523 block_size = (ufi_plus)? file->image_size: file->block_size; 524 block_offset = 0; 525 mb = (MAILBOX4*)mbq; 526 527 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 528 "%s: Verifying image...", file->label); 529 530 while (block_size) { 531 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE); 532 bzero((void *) mp->virt, mp->size); 533 534 xfer_size = min(BE_MAX_XFER_SIZE, block_size); 535 536 mb->un.varSLIConfig.be.embedded = 0; 537 mbq->nonembed = (uint8_t *)mp; 538 mbq->mbox_cmpl = NULL; 539 540 mb->mbxCommand = MBX_SLI_CONFIG; 541 mb->mbxOwner = OWN_HOST; 542 543 hdr_req = (mbox_req_hdr_t *)mp->virt; 544 hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON; 545 hdr_req->opcode = COMMON_OPCODE_READ_FLASHROM; 546 hdr_req->timeout = 0; 547 hdr_req->req_length = sizeof (IOCTL_COMMON_FLASHROM) + 548 xfer_size; 549 550 flashrom = (IOCTL_COMMON_FLASHROM *)(hdr_req + 1); 551 flashrom->params.opcode = MGMT_FLASHROM_OPCODE_REPORT; 552 flashrom->params.optype = file->type; 553 flashrom->params.data_buffer_size = xfer_size; 554 flashrom->params.offset = block_offset; 555 556 /* Send read request */ 557 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != 558 MBX_SUCCESS) { 559 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 560 "%s: Unable to read image. status=%x", 561 file->label, mb->mbxStatus); 562 563 rval = EMLXS_IMAGE_FAILED; 564 goto done; 565 } 566 567 payload = (uint8_t *)(&flashrom->params.data_buffer); 568 569 BE_SWAP32_BUFFER(payload, xfer_size); 570 571 wptr = (uint32_t *)image_ptr; 572 wptr1 = (uint32_t *)payload; 573 for (i = 0; i < xfer_size; i += 4, wptr++, wptr1++) { 574 if (*wptr != *wptr1) { 575 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 576 "%s: Image mismatch. [%08x] %x, %x", 577 file->label, i, 578 BE_MAX_XFER_SIZE, xfer_size); 579 580 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 581 "%08x: %08x %08x %08x %08x %08x " \ 582 "%08x %08x %08x", 583 i, wptr[0], wptr[1], wptr[2], 584 wptr[3], wptr[4], wptr[5], wptr[6], 585 wptr[7]); 586 587 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 588 "%08x: %08x %08x %08x %08x %08x " \ 589 "%08x %08x %08x", 590 i, wptr1[0], wptr1[1], wptr1[2], 591 wptr1[3], wptr1[4], wptr1[5], wptr1[6], 592 wptr1[7]); 593 594 rval = EMLXS_IMAGE_FAILED; 595 goto done; 596 } 597 } 598 599 bcopy((uint8_t *)(&flashrom->params.data_buffer), image_ptr, 600 xfer_size); 601 602 block_size -= xfer_size; 603 block_offset += xfer_size; 604 image_ptr += xfer_size; 605 } 606 607 /* Verify CRC */ 608 rval = emlxs_sli4_verify_crc(hba, file, mbq, mp); 609 610done: 611 612 if (rval == 0) { 613 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 614 "%s: Image verified.", file->label); 615 } 616 617 return (rval); 618 619} /* emlxs_sli4_verify_image() */ 620 621 622static int32_t 623emlxs_sli4_verify_crc(emlxs_hba_t *hba, 624 emlxs_be_fw_file_t *file, MAILBOXQ *mbq, MATCHMAP *mp) 625{ 626 emlxs_port_t *port = &PPORT; 627 uint32_t *wptr; 628 uint8_t *payload; 629 MAILBOX4 *mb; 630 IOCTL_COMMON_FLASHROM *flashrom; 631 mbox_req_hdr_t *hdr_req; 632 uint32_t xfer_size; 633 uint32_t block_offset; 634 uint32_t rval = 0; 635 uint32_t value; 636 637 xfer_size = 8; 638 block_offset = file->block_size - xfer_size; 639 mb = (MAILBOX4*)mbq; 640 641 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 642 "%s: Verifying CRC...", file->label); 643 644 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE); 645 bzero((void *) mp->virt, mp->size); 646 647 mb->un.varSLIConfig.be.embedded = 0; 648 mbq->nonembed = (uint8_t *)mp; 649 mbq->mbox_cmpl = NULL; 650 651 mb->mbxCommand = MBX_SLI_CONFIG; 652 mb->mbxOwner = OWN_HOST; 653 654 hdr_req = (mbox_req_hdr_t *)mp->virt; 655 hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON; 656 hdr_req->opcode = COMMON_OPCODE_READ_FLASHROM; 657 hdr_req->timeout = 0; 658 hdr_req->req_length = sizeof (IOCTL_COMMON_FLASHROM) + 659 xfer_size; 660 661 flashrom = (IOCTL_COMMON_FLASHROM *)(hdr_req + 1); 662 flashrom->params.opcode = MGMT_FLASHROM_OPCODE_REPORT; 663 flashrom->params.optype = file->type; 664 flashrom->params.data_buffer_size = xfer_size; 665 flashrom->params.offset = block_offset; 666 667 /* Send read request */ 668 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != 669 MBX_SUCCESS) { 670 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 671 "%s: Unable to read CRC. status=%x", 672 file->label, mb->mbxStatus); 673 674 rval = EMLXS_IMAGE_FAILED; 675 goto done; 676 } 677 678 payload = (uint8_t *)(&flashrom->params.data_buffer); 679 wptr = (uint32_t *)(payload + xfer_size - 8); 680 681 /* Verify image size */ 682 value = *wptr++; 683 if (value != file->image_size) { 684 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 685 "%s: Image size mismatch. %08x != %08x", 686 file->label, value, file->image_size); 687 688 rval = EMLXS_IMAGE_FAILED; 689 goto done; 690 } 691 692 /* Verify block crc */ 693 value = *wptr; 694 if (value != file->block_crc) { 695 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 696 "%s: CRC mismatch. %08x != %08x", 697 file->label, value, file->block_crc); 698 rval = EMLXS_IMAGE_FAILED; 699 } 700 701done: 702 703 if (rval == 0) { 704 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 705 "%s: CRC verified.", file->label); 706 } 707 708 return (rval); 709 710} /* emlxs_sli4_verify_crc() */ 711 712 |
|
388extern int32_t | 713extern int32_t |
714emlxs_sli4_read_fw_version(emlxs_hba_t *hba, emlxs_firmware_t *fw) 715{ 716 emlxs_port_t *port = &PPORT; 717 MAILBOXQ *mbq = NULL; 718 MATCHMAP *mp = NULL; 719 MAILBOX4 *mb; 720 uint32_t *wptr; 721 uint8_t *payload; 722 IOCTL_COMMON_FLASHROM *flashrom; 723 mbox_req_hdr_t *hdr_req; 724 uint32_t xfer_size; 725 uint32_t block_offset; 726 uint32_t rval = 0; 727 728 bzero((void *) fw, sizeof (emlxs_firmware_t)); 729 730 if ((mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), 731 KM_SLEEP)) == NULL) { 732 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg, 733 "read_fw_version: Unable to allocate mailbox buffer."); 734 735 rval = 1; 736 goto done; 737 } 738 739 if ((mp = emlxs_mem_buf_alloc(hba, (sizeof (mbox_req_hdr_t) + 740 sizeof (IOCTL_COMMON_FLASHROM) + 32))) == NULL) { 741 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg, 742 "read_fw_version: Unable to allocate payload buffer."); 743 744 rval = EMLXS_IMAGE_FAILED; 745 goto done; 746 } 747 748 mb = (MAILBOX4*)mbq; 749 750 /* Read CRC and size */ 751 xfer_size = 8; 752 block_offset = 0x140000 - xfer_size; 753 754 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE); 755 bzero((void *) mp->virt, mp->size); 756 757 mb->un.varSLIConfig.be.embedded = 0; 758 mbq->nonembed = (uint8_t *)mp; 759 mbq->mbox_cmpl = NULL; 760 761 mb->mbxCommand = MBX_SLI_CONFIG; 762 mb->mbxOwner = OWN_HOST; 763 764 hdr_req = (mbox_req_hdr_t *)mp->virt; 765 hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON; 766 hdr_req->opcode = COMMON_OPCODE_READ_FLASHROM; 767 hdr_req->timeout = 0; 768 hdr_req->req_length = sizeof (IOCTL_COMMON_FLASHROM) + 769 xfer_size; 770 771 flashrom = (IOCTL_COMMON_FLASHROM *)(hdr_req + 1); 772 flashrom->params.opcode = MGMT_FLASHROM_OPCODE_REPORT; 773 flashrom->params.optype = MGMT_FLASHROM_OPTYPE_FCOE_FIRMWARE; 774 flashrom->params.data_buffer_size = xfer_size; 775 flashrom->params.offset = block_offset; 776 777 /* Send read request */ 778 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != 779 MBX_SUCCESS) { 780 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg, 781 "read_fw_version: Unable to read CRC. status=%x", 782 mb->mbxStatus); 783 784 rval = 1; 785 goto done; 786 } 787 788 payload = (uint8_t *)(&flashrom->params.data_buffer); 789 790 wptr = (uint32_t *)payload; 791 fw->size = *wptr++; /* image size */ 792 fw->sli4 = *wptr; /* block crc */ 793 fw->kern = *wptr; 794 fw->stub = *wptr; 795 796 /* Read version label */ 797 xfer_size = 32; 798 block_offset = 0x30; 799 800 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE); 801 bzero((void *) mp->virt, mp->size); 802 803 mb->un.varSLIConfig.be.embedded = 0; 804 mbq->nonembed = (uint8_t *)mp; 805 mbq->mbox_cmpl = NULL; 806 807 mb->mbxCommand = MBX_SLI_CONFIG; 808 mb->mbxOwner = OWN_HOST; 809 810 hdr_req = (mbox_req_hdr_t *)mp->virt; 811 hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON; 812 hdr_req->opcode = COMMON_OPCODE_READ_FLASHROM; 813 hdr_req->timeout = 0; 814 hdr_req->req_length = sizeof (IOCTL_COMMON_FLASHROM) + 815 xfer_size; 816 817 flashrom = (IOCTL_COMMON_FLASHROM *)(hdr_req + 1); 818 flashrom->params.opcode = MGMT_FLASHROM_OPCODE_REPORT; 819 flashrom->params.optype = MGMT_FLASHROM_OPTYPE_FCOE_FIRMWARE; 820 flashrom->params.data_buffer_size = xfer_size; 821 flashrom->params.offset = block_offset; 822 823 /* Send read request */ 824 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != 825 MBX_SUCCESS) { 826 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg, 827 "read_fw_version: Unable to read version string. status=%x", 828 mb->mbxStatus); 829 830 rval = 1; 831 goto done; 832 } 833 834 payload = (uint8_t *)(&flashrom->params.data_buffer); 835 BE_SWAP32_BCOPY(payload, (uint8_t *)fw->label, 32); 836 837 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg, 838 "FCOE FIRMWARE: size=%x version=%s (0x%08x)", 839 fw->size, fw->label, fw->sli4); 840 841done: 842 843 if (mbq) { 844 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbq); 845 } 846 847 if (mp) { 848 (void) emlxs_mem_buf_free(hba, mp); 849 } 850 851 return (rval); 852 853} /* emlxs_sli4_read_fw_version() */ 854 855 856static uint32_t 857emlxs_sli4_validate_image(emlxs_hba_t *hba, caddr_t buffer, 858 uint32_t len, emlxs_be_fw_image_t *fw_image) 859{ 860 emlxs_port_t *port = &PPORT; 861 emlxs_sli4_ufi_header_t *ufi_hdr; 862 emlxs_sli4_flash_dir_t *flash_dir; 863 emlxs_sli4_flash_entry_t *entry; 864 uint8_t *bptr; 865 uint32_t *wptr; 866 uint32_t i; 867 uint32_t k; 868 uint32_t mask; 869 uint32_t value; 870 uint32_t image_size; 871 emlxs_be_fw_file_t *file; 872 emlxs_be_fw_file_t *file2; 873 char signature[BE_SIGNATURE_SIZE]; 874 uint32_t ufi_plus = 0; 875 876 bzero(fw_image, sizeof (emlxs_be_fw_image_t)); 877 878 if (hba->model_info.chip != EMLXS_TIGERSHARK_CHIP) { 879 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_incompat_msg, 880 "Invalid adapter model."); 881 return (EMLXS_IMAGE_INCOMPATIBLE); 882 } 883 884 if (len < (sizeof (emlxs_sli4_ufi_header_t) + 885 sizeof (emlxs_sli4_flash_dir_t))) { 886 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 887 "Image too small. (%d < %d)", 888 len, (sizeof (emlxs_sli4_ufi_header_t) + 889 sizeof (emlxs_sli4_flash_dir_t))); 890 return (EMLXS_IMAGE_BAD); 891 } 892 ufi_hdr = (emlxs_sli4_ufi_header_t *)buffer; 893 894 /* Check if this is a standard UFI image */ 895 if (strncmp(BE_SIGNATURE, ufi_hdr->signature, 896 sizeof (BE_SIGNATURE)-1) != 0) { 897 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_incompat_msg, 898 "Invalid image provided."); 899 return (EMLXS_IMAGE_INCOMPATIBLE); 900 } 901 902 /* Check for special deflated format */ 903 (void) sprintf(signature, "%s+", BE_SIGNATURE); 904 if (strncmp(signature, ufi_hdr->signature, 905 sizeof (signature)-1) == 0) { 906 ufi_plus = 1; 907 } 908 909#ifdef EMLXS_BIG_ENDIAN 910 /* Big Endian Swapping */ 911 /* Swap ufi header */ 912 ufi_hdr->checksum = 913 SWAP32(ufi_hdr->checksum); 914 ufi_hdr->antidote = 915 SWAP32(ufi_hdr->antidote); 916 ufi_hdr->controller.vendor_id = 917 SWAP32(ufi_hdr->controller.vendor_id); 918 ufi_hdr->controller.device_id = 919 SWAP32(ufi_hdr->controller.device_id); 920 ufi_hdr->controller.sub_vendor_id = 921 SWAP32(ufi_hdr->controller.sub_vendor_id); 922 ufi_hdr->controller.sub_device_id = 923 SWAP32(ufi_hdr->controller.sub_device_id); 924 ufi_hdr->file_length = 925 SWAP32(ufi_hdr->file_length); 926 ufi_hdr->chunk_num = 927 SWAP32(ufi_hdr->chunk_num); 928 ufi_hdr->chunk_cnt = 929 SWAP32(ufi_hdr->chunk_cnt); 930 ufi_hdr->image_cnt = 931 SWAP32(ufi_hdr->image_cnt); 932#endif /* EMLXS_BIG_ENDIAN */ 933 934 if (len != ufi_hdr->file_length) { 935 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 936 "Invalid image size (%d != %d)", 937 len, ufi_hdr->file_length); 938 939 return (EMLXS_IMAGE_BAD); 940 } 941 942 /* Scan for flash dir signature */ 943 bptr = (uint8_t *)buffer; 944 flash_dir = NULL; 945 for (i = 0; i < len; i++, bptr++) { 946 if (strncmp((char *)bptr, BE_DIR_SIGNATURE, 947 sizeof (BE_DIR_SIGNATURE)) == 0) { 948 flash_dir = (emlxs_sli4_flash_dir_t *)bptr; 949 break; 950 } 951 } 952 953 if (!flash_dir) { 954 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 955 "Unable to find flash directory."); 956 957 return (EMLXS_IMAGE_BAD); 958 } 959 960#ifdef EMLXS_BIG_ENDIAN 961 /* Big Endian Swapping */ 962 /* Swap flash dir */ 963 flash_dir->header.format_rev = 964 SWAP32(flash_dir->header.format_rev); 965 flash_dir->header.checksum = 966 SWAP32(flash_dir->header.checksum); 967 flash_dir->header.antidote = 968 SWAP32(flash_dir->header.antidote); 969 flash_dir->header.build_num = 970 SWAP32(flash_dir->header.build_num); 971 flash_dir->header.active_entry_mask = 972 SWAP32(flash_dir->header.active_entry_mask); 973 flash_dir->header.valid_entry_mask = 974 SWAP32(flash_dir->header.valid_entry_mask); 975 flash_dir->header.orig_content_mask = 976 SWAP32(flash_dir->header.orig_content_mask); 977 flash_dir->header.resv0 = SWAP32(flash_dir->header.resv0); 978 flash_dir->header.resv1 = SWAP32(flash_dir->header.resv1); 979 flash_dir->header.resv2 = SWAP32(flash_dir->header.resv2); 980 flash_dir->header.resv3 = SWAP32(flash_dir->header.resv3); 981 flash_dir->header.resv4 = SWAP32(flash_dir->header.resv4); 982 983 for (i = 0; i < BE_CONTROLLER_SIZE; i++) { 984 flash_dir->header.controller[i].vendor_id = 985 SWAP32(flash_dir->header.controller[i].vendor_id); 986 flash_dir->header.controller[i].device_id = 987 SWAP32(flash_dir->header.controller[i].device_id); 988 flash_dir->header.controller[i].sub_vendor_id = 989 SWAP32(flash_dir->header.controller[i].sub_vendor_id); 990 flash_dir->header.controller[i].sub_device_id = 991 SWAP32(flash_dir->header.controller[i].sub_device_id); 992 } 993 994 for (i = 0, mask = 1; i < BE_FLASH_ENTRIES; i++, mask <<= 1) { 995 996 if (!(flash_dir->header.valid_entry_mask & mask)) { 997 continue; 998 } 999 1000 entry = &flash_dir->entry[i]; 1001 if (entry->image_size == 0) { 1002 continue; 1003 } 1004 1005 flash_dir->entry[i].type = 1006 SWAP32(flash_dir->entry[i].type); 1007 flash_dir->entry[i].offset = 1008 SWAP32(flash_dir->entry[i].offset); 1009 flash_dir->entry[i].pad_size = 1010 SWAP32(flash_dir->entry[i].pad_size); 1011 flash_dir->entry[i].image_size = 1012 SWAP32(flash_dir->entry[i].image_size); 1013 flash_dir->entry[i].checksum = 1014 SWAP32(flash_dir->entry[i].checksum); 1015 flash_dir->entry[i].entry_point = 1016 SWAP32(flash_dir->entry[i].entry_point); 1017 flash_dir->entry[i].resv0 = 1018 SWAP32(flash_dir->entry[i].resv0); 1019 flash_dir->entry[i].resv1 = 1020 SWAP32(flash_dir->entry[i].resv1); 1021 } 1022#endif /* EMLXS_BIG_ENDIAN */ 1023 1024 /* Build fw_image table */ 1025 for (i = 0, mask = 1; i < BE_FLASH_ENTRIES; i++, mask <<= 1) { 1026 1027 if (!(flash_dir->header.valid_entry_mask & mask)) { 1028 continue; 1029 } 1030 1031 entry = &flash_dir->entry[i]; 1032 if (entry->image_size == 0) { 1033 continue; 1034 } 1035 1036 switch (entry->type) { 1037 case BE_FLASHTYPE_REDBOOT: 1038 file = &fw_image->file[REDBOOT_FLASHTYPE]; 1039 (void) strcpy(file->label, "REDBOOT"); 1040 file->type = MGMT_FLASHROM_OPTYPE_REDBOOT; 1041 break; 1042 case BE_FLASHTYPE_ISCSI_BIOS: 1043 file = &fw_image->file[ISCSI_BIOS_FLASHTYPE]; 1044 (void) strcpy(file->label, "ISCSI BIOS"); 1045 file->type = MGMT_FLASHROM_OPTYPE_ISCSI_BIOS; 1046 break; 1047 case BE_FLASHTYPE_PXE_BIOS: 1048 file = &fw_image->file[PXE_BIOS_FLASHTYPE]; 1049 (void) strcpy(file->label, "PXE BIOS"); 1050 file->type = MGMT_FLASHROM_OPTYPE_PXE_BIOS; 1051 break; 1052 case BE_FLASHTYPE_FCOE_BIOS: 1053 file = &fw_image->file[FCOE_BIOS_FLASHTYPE]; 1054 (void) strcpy(file->label, "FCOE BIOS"); 1055 file->type = MGMT_FLASHROM_OPTYPE_FCOE_BIOS; 1056 break; 1057 case BE_FLASHTYPE_ISCSI_FIRMWARE: 1058 file = &fw_image->file[ISCSI_FIRMWARE_FLASHTYPE]; 1059 (void) strcpy(file->label, "ISCSI FIRMWARE"); 1060 file->type = MGMT_FLASHROM_OPTYPE_ISCSI_FIRMWARE; 1061 break; 1062 case BE_FLASHTYPE_FCOE_FIRMWARE: 1063 file = &fw_image->file[FCOE_FIRMWARE_FLASHTYPE]; 1064 (void) strcpy(file->label, "FCOE FIRMWARE"); 1065 file->type = MGMT_FLASHROM_OPTYPE_FCOE_FIRMWARE; 1066 break; 1067 case BE_FLASHTYPE_FCOE_BACKUP: 1068 case BE_FLASHTYPE_ISCSI_BACKUP: 1069 continue; 1070 1071 default: 1072 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 1073 "Unknown image type found. type=%x", 1074 entry->type); 1075 continue; 1076 } 1077 1078 file->image_size = entry->image_size; 1079 image_size = BE_SWAP32(entry->image_size); 1080 1081 if (ufi_plus) { 1082 file->image_offset = entry->offset; 1083 file->block_size = entry->pad_size; 1084 file->block_crc = entry->checksum; 1085 } else { 1086 file->image_offset = entry->offset + 1087 sizeof (emlxs_sli4_ufi_header_t); 1088 1089 /* Get entry block size and crc */ 1090 k = file->image_offset + file->image_size; 1091 k &= 0xFFFFFFFC; 1092 1093 wptr = (uint32_t *)(buffer + k); 1094 for (; k < len; k += 4) { 1095 if (*wptr++ == image_size) { 1096 /* Calculate block_size */ 1097 file->block_size = (k + 8) - 1098 file->image_offset; 1099 1100 /* Read block_crc */ 1101 value = *wptr; 1102 file->block_crc = BE_SWAP32(value); 1103 1104 break; 1105 } 1106 } 1107 1108 if (k >= len) { 1109 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 1110 "%s: End of block not found. offset=%x", 1111 file->label, file->image_offset); 1112 1113 bzero(fw_image, sizeof (emlxs_be_fw_image_t)); 1114 return (EMLXS_IMAGE_BAD); 1115 } 1116 } 1117 1118 /* Make sure image will fit in block specified */ 1119 if (file->image_size + 8 > file->block_size) { 1120 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 1121 "%s: Image too large for block. image=%x block=%x", 1122 file->label, file->image_size, file->block_size); 1123 1124 bzero(fw_image, sizeof (emlxs_be_fw_image_t)); 1125 return (EMLXS_IMAGE_BAD); 1126 } 1127 1128 /* Automatically create a backup file entry for firmware */ 1129 if (file->type == MGMT_FLASHROM_OPTYPE_FCOE_FIRMWARE) { 1130 file2 = &fw_image->file[FCOE_BACKUP_FLASHTYPE]; 1131 (void) strcpy(file2->label, "FCOE BACKUP"); 1132 file2->type = MGMT_FLASHROM_OPTYPE_FCOE_BACKUP; 1133 file2->image_offset = file->image_offset; 1134 file2->image_size = file->image_size; 1135 file2->block_size = file->block_size; 1136 file2->block_crc = file->block_crc; 1137 1138 /* Save FCOE version info */ 1139 bptr = (uint8_t *)buffer + file->image_offset + 0x30; 1140 (void) strncpy(fw_image->label, (char *)bptr, 1141 BE_VERSION_SIZE); 1142 fw_image->version = file->block_crc; 1143 1144 } else if (file->type == 1145 MGMT_FLASHROM_OPTYPE_ISCSI_FIRMWARE) { 1146 file2 = &fw_image->file[ISCSI_BACKUP_FLASHTYPE]; 1147 (void) strcpy(file2->label, "ISCSI BACKUP"); 1148 file2->type = MGMT_FLASHROM_OPTYPE_ISCSI_BACKUP; 1149 file2->image_offset = file->image_offset; 1150 file2->image_size = file->image_size; 1151 file2->block_size = file->block_size; 1152 file2->block_crc = file->block_crc; 1153 } 1154 } 1155 1156 if (fw_image->version == 0) { 1157 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 1158 "Unable to find FCOE firmware component."); 1159 1160 bzero(fw_image, sizeof (emlxs_be_fw_image_t)); 1161 return (EMLXS_IMAGE_BAD); 1162 } 1163 1164 /* Display contents */ 1165 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 1166 "UFI Image: %08x, %s", fw_image->version, fw_image->label); 1167 1168 for (i = 0; i < BE_MAX_FLASHTYPES; i++) { 1169 file = &fw_image->file[i]; 1170 1171 if (file->image_size == 0) { 1172 continue; 1173 } 1174 1175 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 1176 "%s: type=%x block=%x image=%x offset=%x crc=%x", 1177 file->label, file->type, file->block_size, 1178 file->image_size, file->image_offset, file->block_crc); 1179 } 1180 1181 return (0); 1182 1183} /* emlxs_sli4_validate_image() */ 1184 1185 1186static int32_t 1187emlxs_sli4_fw_download(emlxs_hba_t *hba, caddr_t buffer, uint32_t len, 1188 uint32_t offline) 1189{ 1190 emlxs_port_t *port = &PPORT; 1191 uint32_t i; 1192 uint32_t update = 0; 1193 uint32_t rval = 0; 1194 MAILBOXQ *mbq = NULL; 1195 MATCHMAP *mp = NULL; 1196 emlxs_be_fw_image_t fw_image; 1197 emlxs_be_fw_file_t *file; 1198 1199 /* For now we will not take the driver offline during a download */ 1200 offline = 0; 1201 1202 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { 1203 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_incompat_msg, 1204 "Invalid sli_mode. mode=%d", hba->sli_mode); 1205 return (EMLXS_IMAGE_INCOMPATIBLE); 1206 } 1207 1208 if (buffer == NULL || len == 0) { 1209 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 1210 "Empty buffer provided. buf=%p size=%d", buffer, len); 1211 return (EMLXS_IMAGE_BAD); 1212 } 1213 1214 /* Validate image */ 1215 if ((rval = emlxs_sli4_validate_image(hba, buffer, len, &fw_image))) { 1216 return (rval); 1217 } 1218 1219 /* Allocate resources */ 1220 1221 if ((mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), 1222 KM_SLEEP)) == NULL) { 1223 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1224 "Unable to allocate mailbox buffer."); 1225 1226 offline = 0; 1227 rval = EMLXS_IMAGE_FAILED; 1228 goto done; 1229 } 1230 1231 if ((mp = emlxs_mem_buf_alloc(hba, (sizeof (mbox_req_hdr_t) + 1232 sizeof (IOCTL_COMMON_FLASHROM) + BE_MAX_XFER_SIZE))) == NULL) { 1233 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1234 "Unable to allocate flash buffer."); 1235 1236 offline = 0; 1237 rval = EMLXS_IMAGE_FAILED; 1238 goto done; 1239 } 1240 1241 /* Check if update is required */ 1242 for (i = 0; i < BE_MAX_FLASHTYPES; i++) { 1243 file = &fw_image.file[i]; 1244 1245 if (file->image_size == 0) { 1246 continue; 1247 } 1248 1249 rval = emlxs_sli4_verify_crc(hba, file, mbq, mp); 1250 1251 if (rval == 0) { 1252 file->image_size = 0; 1253 continue; 1254 } 1255 1256 update++; 1257 } 1258 1259 if (!update) { 1260 offline = 0; 1261 goto done; 1262 } 1263 1264 /* 1265 * Everything checks out, now to just do it 1266 */ 1267 if (offline) { 1268 if (emlxs_offline(hba) != FC_SUCCESS) { 1269 1270 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1271 "Unable to take adapter offline."); 1272 1273 offline = 0; 1274 rval = EMLXS_OFFLINE_FAILED; 1275 goto done; 1276 } 1277 } 1278 1279 /* Download entries which require update */ 1280 for (i = 0; i < BE_MAX_FLASHTYPES; i++) { 1281 file = &fw_image.file[i]; 1282 1283 if (file->image_size == 0) { 1284 continue; 1285 } 1286 1287 rval = emlxs_sli4_flash_image(hba, buffer, file, mbq, mp); 1288 1289 if (rval != 0) { 1290 goto done; 1291 } 1292 } 1293 1294done: 1295 if (mbq) { 1296 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbq); 1297 } 1298 1299 if (mp) { 1300 (void) emlxs_mem_buf_free(hba, mp); 1301 } 1302 1303 if (offline) { 1304 (void) emlxs_online(hba); 1305 } 1306 1307 if (rval == 0) { 1308 if (update) { 1309 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_complete_msg, 1310 "Status good."); 1311 1312 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fw_updated_msg, 1313 "Please reboot system or power cycle adapter " 1314 "to activate new firmware: %s", fw_image.label); 1315 1316 } else { 1317 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 1318 "No firmware update required."); 1319 } 1320 } 1321 1322 return (rval); 1323 1324} /* emlxs_sli4_fw_download() */ 1325 1326 1327extern int32_t |
|
389emlxs_cfl_download(emlxs_hba_t *hba, uint32_t region, caddr_t buffer, 390 uint32_t len) 391{ 392 emlxs_port_t *port = &PPORT; 393 MAILBOXQ *mbox = NULL; 394 MAILBOX *mb; 395 uint32_t rval = 0; 396 uint32_t region_id; 397 uint32_t id; | 1328emlxs_cfl_download(emlxs_hba_t *hba, uint32_t region, caddr_t buffer, 1329 uint32_t len) 1330{ 1331 emlxs_port_t *port = &PPORT; 1332 MAILBOXQ *mbox = NULL; 1333 MAILBOX *mb; 1334 uint32_t rval = 0; 1335 uint32_t region_id; 1336 uint32_t id; |
398 399#ifndef EMLXS_I386 | 1337#ifdef EMLXS_BIG_ENDIAN |
400 caddr_t local_buffer; 401 uint32_t *bptr1; 402 uint32_t *bptr2; 403 uint32_t i; | 1338 caddr_t local_buffer; 1339 uint32_t *bptr1; 1340 uint32_t *bptr2; 1341 uint32_t i; |
404#endif /* !EMLXS_I386 */ | 1342#endif /* EMLXS_BIG_ENDIAN */ |
405 406 if (buffer == NULL || len == 0) { 407 return (EMLXS_IMAGE_BAD); 408 } | 1343 1344 if (buffer == NULL || len == 0) { 1345 return (EMLXS_IMAGE_BAD); 1346 } |
409#ifndef EMLXS_I386 | 1347 1348#ifdef EMLXS_BIG_ENDIAN |
410 /* We need to swap the image buffer before we start */ 411 412 /* 413 * Use KM_SLEEP to allocate a temporary buffer 414 */ 415 local_buffer = (caddr_t)kmem_zalloc(len, KM_SLEEP); 416 | 1349 /* We need to swap the image buffer before we start */ 1350 1351 /* 1352 * Use KM_SLEEP to allocate a temporary buffer 1353 */ 1354 local_buffer = (caddr_t)kmem_zalloc(len, KM_SLEEP); 1355 |
417 if (local_buffer == NULL) { 418 return (FC_NOMEM); 419 } 420 | |
421 /* Perform a 32 bit swap of the image */ 422 bptr1 = (uint32_t *)local_buffer; 423 bptr2 = (uint32_t *)buffer; 424 425 for (i = 0; i < (len / 4); i++) { | 1356 /* Perform a 32 bit swap of the image */ 1357 bptr1 = (uint32_t *)local_buffer; 1358 bptr2 = (uint32_t *)buffer; 1359 1360 for (i = 0; i < (len / 4); i++) { |
426 *bptr1 = DATA32_SWAP(*bptr2); | 1361 *bptr1 = SWAP32(*bptr2); |
427 bptr1++; 428 bptr2++; 429 } 430 431 /* Replace the original buffer */ 432 buffer = local_buffer; 433 | 1362 bptr1++; 1363 bptr2++; 1364 } 1365 1366 /* Replace the original buffer */ 1367 buffer = local_buffer; 1368 |
434#endif /* !EMLXS_I386 */ | 1369#endif /* EMLXS_BIG_ENDIAN */ |
435 436 if (len > 128) { 437 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 438 "Invalid image length: 0x%x > 128", len); 439 440 return (EMLXS_IMAGE_BAD); 441 } 442 --- 34 unchanged lines hidden (view full) --- 477 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 478 "Unable to take HBA offline."); 479 480 rval = EMLXS_OFFLINE_FAILED; 481 482 goto done; 483 } 484 | 1370 1371 if (len > 128) { 1372 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 1373 "Invalid image length: 0x%x > 128", len); 1374 1375 return (EMLXS_IMAGE_BAD); 1376 } 1377 --- 34 unchanged lines hidden (view full) --- 1412 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1413 "Unable to take HBA offline."); 1414 1415 rval = EMLXS_OFFLINE_FAILED; 1416 1417 goto done; 1418 } 1419 |
485 if (emlxs_sli_hba_reset(hba, 1, 1) != FC_SUCCESS) { | 1420 if (EMLXS_SLI_HBA_RESET(hba, 1, 1, 0) != FC_SUCCESS) { |
486 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 487 "Unable to restart adapter."); 488 489 rval = EMLXS_OFFLINE_FAILED; 490 491 goto done; 492 } 493 --- 16 unchanged lines hidden (view full) --- 510 region_id = DEF_PCI_CFG_REGION_ID + region; 511 512 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, 513 "PCI configuration: PCI%d region=%d id=0x%x size=%d", region, 514 region_id, id, len); 515 516 /* Copy the data buffer to SLIM */ 517 WRITE_SLIM_COPY(hba, (uint32_t *)buffer, | 1421 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1422 "Unable to restart adapter."); 1423 1424 rval = EMLXS_OFFLINE_FAILED; 1425 1426 goto done; 1427 } 1428 --- 16 unchanged lines hidden (view full) --- 1445 region_id = DEF_PCI_CFG_REGION_ID + region; 1446 1447 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, 1448 "PCI configuration: PCI%d region=%d id=0x%x size=%d", region, 1449 region_id, id, len); 1450 1451 /* Copy the data buffer to SLIM */ 1452 WRITE_SLIM_COPY(hba, (uint32_t *)buffer, |
518 (volatile uint32_t *)((volatile char *)hba->slim_addr + | 1453 (volatile uint32_t *)((volatile char *)hba->sli.sli3.slim_addr + |
519 sizeof (MAILBOX)), (len / sizeof (uint32_t))); 520 521#ifdef FMA_SUPPORT | 1454 sizeof (MAILBOX)), (len / sizeof (uint32_t))); 1455 1456#ifdef FMA_SUPPORT |
522 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle) | 1457 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.slim_acc_handle) |
523 != DDI_FM_OK) { 524 EMLXS_MSGF(EMLXS_CONTEXT, 525 &emlxs_invalid_access_handle_msg, NULL); 526 rval = 1; 527 } 528#endif /* FMA_SUPPORT */ 529 | 1458 != DDI_FM_OK) { 1459 EMLXS_MSGF(EMLXS_CONTEXT, 1460 &emlxs_invalid_access_handle_msg, NULL); 1461 rval = 1; 1462 } 1463#endif /* FMA_SUPPORT */ 1464 |
530 emlxs_format_update_pci_cfg(hba, mb, region_id, len); | 1465 emlxs_format_update_pci_cfg(hba, mbox, region_id, len); |
531 | 1466 |
532 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 1467 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
533 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 534 "Unable to update PCI configuration: Mailbox cmd=%x " 535 "status=%x info=%d", mb->mbxCommand, mb->mbxStatus, 536 mb->un.varUpdateCfg.rsp_info); 537 538 rval = 1; 539 } 540 --- 4 unchanged lines hidden (view full) --- 545 "Status good."); 546 } 547 548done: 549 550 if (mbox) { 551 kmem_free(mbox, sizeof (MAILBOXQ)); 552 } | 1468 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1469 "Unable to update PCI configuration: Mailbox cmd=%x " 1470 "status=%x info=%d", mb->mbxCommand, mb->mbxStatus, 1471 mb->un.varUpdateCfg.rsp_info); 1472 1473 rval = 1; 1474 } 1475 --- 4 unchanged lines hidden (view full) --- 1480 "Status good."); 1481 } 1482 1483done: 1484 1485 if (mbox) { 1486 kmem_free(mbox, sizeof (MAILBOXQ)); 1487 } |
553#ifndef EMLXS_I386 | 1488 1489#ifdef EMLXS_BIG_ENDIAN |
554 /* Free the local buffer */ 555 kmem_free(local_buffer, len); | 1490 /* Free the local buffer */ 1491 kmem_free(local_buffer, len); |
556#endif /* !EMLXS_I386 */ | 1492#endif /* EMLXS_BIG_ENDIAN */ |
557 558 return (rval); 559 | 1493 1494 return (rval); 1495 |
560} /* emlxs_cfl_download */ | 1496} /* emlxs_cfl_download */ |
561 562 | 1497 1498 |
563 | |
564static uint32_t 565emlxs_valid_cksum(uint32_t *StartAddr, uint32_t *EndAddr) 566{ 567 uint32_t Temp; 568 uint32_t CkSum; 569 570 EndAddr++; 571 CkSum = SLI_CKSUM_SEED; --- 4 unchanged lines hidden (view full) --- 576 Temp = *StartAddr; 577 578 CkSum ^= Temp; 579 StartAddr++; 580 } 581 582 return (CkSum << 1) | (CkSum >> 31); 583 | 1499static uint32_t 1500emlxs_valid_cksum(uint32_t *StartAddr, uint32_t *EndAddr) 1501{ 1502 uint32_t Temp; 1503 uint32_t CkSum; 1504 1505 EndAddr++; 1506 CkSum = SLI_CKSUM_SEED; --- 4 unchanged lines hidden (view full) --- 1511 Temp = *StartAddr; 1512 1513 CkSum ^= Temp; 1514 StartAddr++; 1515 } 1516 1517 return (CkSum << 1) | (CkSum >> 31); 1518 |
584} /* emlxs_valid_cksum() */ | 1519} /* emlxs_valid_cksum() */ |
585 586 587static void 588emlxs_disp_aif_header(emlxs_hba_t *hba, PAIF_HDR AifHdr) 589{ 590 emlxs_port_t *port = &PPORT; 591 592 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, "AIF Header: "); --- 29 unchanged lines hidden (view full) --- 622 "AIF Header: spare2 = 0x%x", AifHdr->Spare2); 623 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 624 "AIF Header: debug_swi = 0x%x", AifHdr->DebugSwi); 625 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 626 "AIF Header: zinitcode[0] = 0x%x", AifHdr->ZinitCode[0]); 627 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 628 "AIF Header: zinitcode[1] = 0x%x", AifHdr->ZinitCode[1]); 629 | 1520 1521 1522static void 1523emlxs_disp_aif_header(emlxs_hba_t *hba, PAIF_HDR AifHdr) 1524{ 1525 emlxs_port_t *port = &PPORT; 1526 1527 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, "AIF Header: "); --- 29 unchanged lines hidden (view full) --- 1557 "AIF Header: spare2 = 0x%x", AifHdr->Spare2); 1558 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 1559 "AIF Header: debug_swi = 0x%x", AifHdr->DebugSwi); 1560 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 1561 "AIF Header: zinitcode[0] = 0x%x", AifHdr->ZinitCode[0]); 1562 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 1563 "AIF Header: zinitcode[1] = 0x%x", AifHdr->ZinitCode[1]); 1564 |
630} /* emlxs_disp_aif_header() */ | 1565} /* emlxs_disp_aif_header() */ |
631 632 633 634static void 635emlxs_dump_image_header(emlxs_hba_t *hba, PIMAGE_HDR image) 636{ 637 emlxs_port_t *port = &PPORT; 638 --- 24 unchanged lines hidden (view full) --- 663 "Img Header: ImageSize = 0x%x", image->ImageSize); 664 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 665 "Img Header: ZinitSize = 0x%x", image->ZinitSize); 666 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 667 "Img Header: RelocSize = 0x%x", image->RelocSize); 668 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 669 "Img Header: HdrCks = 0x%x", image->HdrCks); 670 | 1566 1567 1568 1569static void 1570emlxs_dump_image_header(emlxs_hba_t *hba, PIMAGE_HDR image) 1571{ 1572 emlxs_port_t *port = &PPORT; 1573 --- 24 unchanged lines hidden (view full) --- 1598 "Img Header: ImageSize = 0x%x", image->ImageSize); 1599 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 1600 "Img Header: ZinitSize = 0x%x", image->ZinitSize); 1601 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 1602 "Img Header: RelocSize = 0x%x", image->RelocSize); 1603 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_detail_msg, 1604 "Img Header: HdrCks = 0x%x", image->HdrCks); 1605 |
671} /* emlxs_dump_image_header() */ | 1606} /* emlxs_dump_image_header() */ |
672 673 674static void | 1607 1608 1609static void |
675emlxs_format_dump(MAILBOX *mb, uint32_t Type, uint32_t RegionId, 676 uint32_t WordCount, uint32_t BaseAddr) | 1610emlxs_format_dump(emlxs_hba_t *hba, MAILBOXQ *mbq, uint32_t Type, 1611 uint32_t RegionId, uint32_t WordCount, uint32_t BaseAddr) |
677{ | 1612{ |
678 bzero((void *)mb, MAILBOX_CMD_BSIZE); | |
679 | 1613 |
680 mb->mbxCommand = MBX_DUMP_MEMORY; 681 mb->un.varDmp.type = Type; 682 mb->un.varDmp.region_id = RegionId; 683 mb->un.varDmp.word_cnt = WordCount; 684 mb->un.varDmp.base_adr = BaseAddr; 685 mb->mbxOwner = OWN_HOST; | 1614 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 1615 MAILBOX4 *mb = (MAILBOX4 *)mbq; |
686 | 1616 |
1617 /* Clear the local dump_region */ 1618 bzero(hba->sli.sli4.dump_region.virt, 1619 hba->sli.sli4.dump_region.size); 1620 1621 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE); 1622 1623 mb->mbxCommand = MBX_DUMP_MEMORY; 1624 mb->un.varDmp4.type = Type; 1625 mb->un.varDmp4.entry_index = BaseAddr; 1626 mb->un.varDmp4.region_id = RegionId; 1627 1628 mb->un.varDmp4.available_cnt = min((WordCount*4), 1629 hba->sli.sli4.dump_region.size); 1630 mb->un.varDmp4.addrHigh = 1631 PADDR_HI(hba->sli.sli4.dump_region.phys); 1632 mb->un.varDmp4.addrLow = 1633 PADDR_LO(hba->sli.sli4.dump_region.phys); 1634 mb->un.varDmp4.rsp_cnt = 0; 1635 1636 mb->mbxOwner = OWN_HOST; 1637 1638 } else { 1639 MAILBOX *mb = (MAILBOX *)mbq; 1640 1641 bzero((void *)mb, MAILBOX_CMD_BSIZE); 1642 1643 mb->mbxCommand = MBX_DUMP_MEMORY; 1644 mb->un.varDmp.type = Type; 1645 mb->un.varDmp.region_id = RegionId; 1646 mb->un.varDmp.word_cnt = WordCount; 1647 mb->un.varDmp.base_adr = BaseAddr; 1648 mb->mbxOwner = OWN_HOST; 1649 } 1650 1651 mbq->mbox_cmpl = NULL; /* no cmpl needed */ 1652 |
|
687 return; 688 | 1653 return; 1654 |
689} /* emlxs_format_dump() */ | 1655} /* emlxs_format_dump() */ |
690 691 692/* ARGSUSED */ 693static uint32_t 694emlxs_start_abs_download(emlxs_hba_t *hba, 695 PAIF_HDR AifHdr, 696 caddr_t Buffer, 697 PWAKE_UP_PARMS WakeUpParms, --- 37 unchanged lines hidden (view full) --- 735 736 mb = (MAILBOX *)mbox; 737 738 Buffer += sizeof (AIF_HDR); 739 740 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, "Erasing flash..."); 741 742 if (DwcFile) { | 1656 1657 1658/* ARGSUSED */ 1659static uint32_t 1660emlxs_start_abs_download(emlxs_hba_t *hba, 1661 PAIF_HDR AifHdr, 1662 caddr_t Buffer, 1663 PWAKE_UP_PARMS WakeUpParms, --- 37 unchanged lines hidden (view full) --- 1701 1702 mb = (MAILBOX *)mbox; 1703 1704 Buffer += sizeof (AIF_HDR); 1705 1706 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, "Erasing flash..."); 1707 1708 if (DwcFile) { |
743 emlxs_format_prog_flash(mb, 0x20000, 0x50000, ERASE_FLASH, 0, | 1709 emlxs_format_prog_flash(mbox, 0x20000, 0x50000, ERASE_FLASH, 0, |
744 0, 0, NULL); 745 } else { | 1710 0, 0, NULL); 1711 } else { |
746 emlxs_format_prog_flash(mb, DlToAddr, DlByteCount, | 1712 emlxs_format_prog_flash(mbox, DlToAddr, DlByteCount, |
747 ERASE_FLASH, 0, 0, 0, NULL); 748 } 749 | 1713 ERASE_FLASH, 0, 0, 0, NULL); 1714 } 1715 |
750 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 1716 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
751 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 752 "Unable to erase Flash: Mailbox cmd=%x status=%x", 753 mb->mbxCommand, mb->mbxStatus); 754 755 rval = 1; 756 757 goto EXIT_ABS_DOWNLOAD; 758 } --- 15 unchanged lines hidden (view full) --- 774 775 for (i = 0; i < (DlCount / 4); i++) { 776 *Dst = *Src; 777 Dst++; 778 Src++; 779 } 780 781 WRITE_SLIM_COPY(hba, (uint32_t *)DataBuffer, | 1717 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1718 "Unable to erase Flash: Mailbox cmd=%x status=%x", 1719 mb->mbxCommand, mb->mbxStatus); 1720 1721 rval = 1; 1722 1723 goto EXIT_ABS_DOWNLOAD; 1724 } --- 15 unchanged lines hidden (view full) --- 1740 1741 for (i = 0; i < (DlCount / 4); i++) { 1742 *Dst = *Src; 1743 Dst++; 1744 Src++; 1745 } 1746 1747 WRITE_SLIM_COPY(hba, (uint32_t *)DataBuffer, |
782 (volatile uint32_t *)((volatile char *)hba->slim_addr + | 1748 (volatile uint32_t *) 1749 ((volatile char *)hba->sli.sli3.slim_addr + |
783 sizeof (MAILBOX)), (DlCount / sizeof (uint32_t))); 784 | 1750 sizeof (MAILBOX)), (DlCount / sizeof (uint32_t))); 1751 |
785 emlxs_format_prog_flash(mb, DlToAddr, DlCount, | 1752 emlxs_format_prog_flash(mbox, DlToAddr, DlCount, |
786 PROGRAM_FLASH, (DlByteCount) ? 0 : 1, 0, DlCount, NULL); 787 | 1753 PROGRAM_FLASH, (DlByteCount) ? 0 : 1, 0, DlCount, NULL); 1754 |
788 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != | 1755 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != |
789 MBX_SUCCESS) { 790 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 791 "Unable to program Flash: Mailbox cmd=%x status=%x", 792 mb->mbxCommand, mb->mbxStatus); 793 794 rval = 1; 795 796 goto EXIT_ABS_DOWNLOAD; 797 } 798 799 Buffer += DlCount; 800 DlToAddr += DlCount; 801 } 802 803#ifdef FMA_SUPPORT | 1756 MBX_SUCCESS) { 1757 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1758 "Unable to program Flash: Mailbox cmd=%x status=%x", 1759 mb->mbxCommand, mb->mbxStatus); 1760 1761 rval = 1; 1762 1763 goto EXIT_ABS_DOWNLOAD; 1764 } 1765 1766 Buffer += DlCount; 1767 DlToAddr += DlCount; 1768 } 1769 1770#ifdef FMA_SUPPORT |
804 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle) | 1771 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.slim_acc_handle) |
805 != DDI_FM_OK) { 806 EMLXS_MSGF(EMLXS_CONTEXT, 807 &emlxs_invalid_access_handle_msg, NULL); 808 809 rval = 1; 810 811 goto EXIT_ABS_DOWNLOAD; 812 } --- 32 unchanged lines hidden (view full) --- 845 } 846 847 if (mbox) { 848 kmem_free(mbox, sizeof (MAILBOXQ)); 849 } 850 851 return (rval); 852 | 1772 != DDI_FM_OK) { 1773 EMLXS_MSGF(EMLXS_CONTEXT, 1774 &emlxs_invalid_access_handle_msg, NULL); 1775 1776 rval = 1; 1777 1778 goto EXIT_ABS_DOWNLOAD; 1779 } --- 32 unchanged lines hidden (view full) --- 1812 } 1813 1814 if (mbox) { 1815 kmem_free(mbox, sizeof (MAILBOXQ)); 1816 } 1817 1818 return (rval); 1819 |
853} /* emlxs_start_abs_download() */ | 1820} /* emlxs_start_abs_download() */ |
854 855 856/* ARGSUSED */ 857static void | 1821 1822 1823/* ARGSUSED */ 1824static void |
858emlxs_format_prog_flash(MAILBOX *mb, | 1825emlxs_format_prog_flash(MAILBOXQ *mbq, |
859 uint32_t Base, 860 uint32_t DlByteCount, 861 uint32_t Function, 862 uint32_t Complete, 863 uint32_t BdeAddress, uint32_t BdeSize, PROG_ID *ProgId) 864{ | 1826 uint32_t Base, 1827 uint32_t DlByteCount, 1828 uint32_t Function, 1829 uint32_t Complete, 1830 uint32_t BdeAddress, uint32_t BdeSize, PROG_ID *ProgId) 1831{ |
1832 MAILBOX *mb = (MAILBOX *)mbq; 1833 |
|
865 bzero((void *)mb, MAILBOX_CMD_BSIZE); 866 867 if (ProgId) 868 mb->mbxCommand = MBX_DOWN_LOAD; 869 else 870 mb->mbxCommand = MBX_LOAD_SM; 871 872 mb->un.varLdSM.load_cmplt = Complete; --- 7 unchanged lines hidden (view full) --- 880 mb->un.varLdSM.un.dl_from_slim_offset = DL_FROM_SLIM_OFFSET; 881 } else if (ProgId) { 882 mb->un.varLdSM.un.prog_id = *ProgId; 883 } else { 884 mb->un.varLdSM.un.dl_from_slim_offset = 0; 885 } 886 887 mb->mbxOwner = OWN_HOST; | 1834 bzero((void *)mb, MAILBOX_CMD_BSIZE); 1835 1836 if (ProgId) 1837 mb->mbxCommand = MBX_DOWN_LOAD; 1838 else 1839 mb->mbxCommand = MBX_LOAD_SM; 1840 1841 mb->un.varLdSM.load_cmplt = Complete; --- 7 unchanged lines hidden (view full) --- 1849 mb->un.varLdSM.un.dl_from_slim_offset = DL_FROM_SLIM_OFFSET; 1850 } else if (ProgId) { 1851 mb->un.varLdSM.un.prog_id = *ProgId; 1852 } else { 1853 mb->un.varLdSM.un.dl_from_slim_offset = 0; 1854 } 1855 1856 mb->mbxOwner = OWN_HOST; |
1857 mbq->mbox_cmpl = NULL; |
|
888 | 1858 |
889} /* emlxs_format_prog_flash() */ | 1859} /* emlxs_format_prog_flash() */ |
890 891 892static void | 1860 1861 1862static void |
893emlxs_format_update_parms(MAILBOX *mb, PWAKE_UP_PARMS WakeUpParms) | 1863emlxs_format_update_parms(MAILBOXQ *mbq, PWAKE_UP_PARMS WakeUpParms) |
894{ | 1864{ |
1865 MAILBOX *mb = (MAILBOX *)mbq; 1866 |
|
895 bzero((void *)mb, MAILBOX_CMD_BSIZE); 896 897 mb->mbxCommand = MBX_UPDATE_CFG; 898 mb->un.varUpdateCfg.req_type = UPDATE_DATA; 899 mb->un.varUpdateCfg.region_id = WAKE_UP_PARMS_REGION_ID; 900 mb->un.varUpdateCfg.entry_len = sizeof (WAKE_UP_PARMS); 901 mb->un.varUpdateCfg.byte_len = sizeof (WAKE_UP_PARMS); 902 903 bcopy((caddr_t)WakeUpParms, 904 (caddr_t)&(mb->un.varUpdateCfg.cfg_data), 905 sizeof (WAKE_UP_PARMS)); | 1867 bzero((void *)mb, MAILBOX_CMD_BSIZE); 1868 1869 mb->mbxCommand = MBX_UPDATE_CFG; 1870 mb->un.varUpdateCfg.req_type = UPDATE_DATA; 1871 mb->un.varUpdateCfg.region_id = WAKE_UP_PARMS_REGION_ID; 1872 mb->un.varUpdateCfg.entry_len = sizeof (WAKE_UP_PARMS); 1873 mb->un.varUpdateCfg.byte_len = sizeof (WAKE_UP_PARMS); 1874 1875 bcopy((caddr_t)WakeUpParms, 1876 (caddr_t)&(mb->un.varUpdateCfg.cfg_data), 1877 sizeof (WAKE_UP_PARMS)); |
1878 mbq->mbox_cmpl = NULL; |
|
906 | 1879 |
907} /* emlxs_format_update_parms () */ | 1880} /* emlxs_format_update_parms () */ |
908 909 910/* ARGSUSED */ 911static void | 1881 1882 1883/* ARGSUSED */ 1884static void |
912emlxs_format_update_pci_cfg(emlxs_hba_t *hba, MAILBOX *mb, | 1885emlxs_format_update_pci_cfg(emlxs_hba_t *hba, MAILBOXQ *mbq, |
913 uint32_t region_id, uint32_t size) 914{ | 1886 uint32_t region_id, uint32_t size) 1887{ |
1888 MAILBOX *mb = (MAILBOX *)mbq; 1889 |
|
915 bzero((void *)mb, MAILBOX_CMD_BSIZE); 916 917 mb->mbxCommand = MBX_UPDATE_CFG; 918 mb->un.varUpdateCfg.Vbit = 1; 919 mb->un.varUpdateCfg.Obit = 1; 920 mb->un.varUpdateCfg.cfg_data = DL_FROM_SLIM_OFFSET; 921 mb->un.varUpdateCfg.req_type = UPDATE_DATA; 922 mb->un.varUpdateCfg.region_id = region_id; 923 mb->un.varUpdateCfg.entry_len = size; 924 mb->un.varUpdateCfg.byte_len = size; | 1890 bzero((void *)mb, MAILBOX_CMD_BSIZE); 1891 1892 mb->mbxCommand = MBX_UPDATE_CFG; 1893 mb->un.varUpdateCfg.Vbit = 1; 1894 mb->un.varUpdateCfg.Obit = 1; 1895 mb->un.varUpdateCfg.cfg_data = DL_FROM_SLIM_OFFSET; 1896 mb->un.varUpdateCfg.req_type = UPDATE_DATA; 1897 mb->un.varUpdateCfg.region_id = region_id; 1898 mb->un.varUpdateCfg.entry_len = size; 1899 mb->un.varUpdateCfg.byte_len = size; |
1900 mbq->mbox_cmpl = NULL; |
|
925 | 1901 |
1902} /* emlxs_format_update_pci_cfg() */ |
|
926 | 1903 |
927} /* emlxs_format_update_pci_cfg() */ | |
928 929 | 1904 1905 |
930 | |
931static uint32_t 932emlxs_update_boot_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 933 PROG_ID * prog_id, uint32_t proc_erom) 934{ 935 emlxs_port_t *port = &PPORT; 936 MAILBOX *mb; 937 MAILBOXQ *mbox; 938 uint32_t rval = 0; --- 11 unchanged lines hidden (view full) --- 950 if (proc_erom && !(hba->model_info.chip & 951 (EMLXS_DRAGONFLY_CHIP | EMLXS_CENTAUR_CHIP))) { 952 WakeUpParms->u1.EROM_prog_id = *prog_id; 953 (void) emlxs_update_exp_rom(hba, WakeUpParms); 954 } 955 956 WakeUpParms->u0.boot_bios_id = *prog_id; 957 | 1906static uint32_t 1907emlxs_update_boot_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1908 PROG_ID * prog_id, uint32_t proc_erom) 1909{ 1910 emlxs_port_t *port = &PPORT; 1911 MAILBOX *mb; 1912 MAILBOXQ *mbox; 1913 uint32_t rval = 0; --- 11 unchanged lines hidden (view full) --- 1925 if (proc_erom && !(hba->model_info.chip & 1926 (EMLXS_DRAGONFLY_CHIP | EMLXS_CENTAUR_CHIP))) { 1927 WakeUpParms->u1.EROM_prog_id = *prog_id; 1928 (void) emlxs_update_exp_rom(hba, WakeUpParms); 1929 } 1930 1931 WakeUpParms->u0.boot_bios_id = *prog_id; 1932 |
958 emlxs_format_update_parms(mb, WakeUpParms); | 1933 emlxs_format_update_parms(mbox, WakeUpParms); |
959 | 1934 |
960 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 1935 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
961 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 962 "Unable to update boot wakeup parms: Mailbox cmd=%x " 963 "status=%x", mb->mbxCommand, mb->mbxStatus); 964 965 rval = 1; 966 } 967 968 if (mbox) { 969 kmem_free(mbox, sizeof (MAILBOXQ)); 970 } 971 972 return (rval); 973 | 1936 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1937 "Unable to update boot wakeup parms: Mailbox cmd=%x " 1938 "status=%x", mb->mbxCommand, mb->mbxStatus); 1939 1940 rval = 1; 1941 } 1942 1943 if (mbox) { 1944 kmem_free(mbox, sizeof (MAILBOXQ)); 1945 } 1946 1947 return (rval); 1948 |
974} /* emlxs_update_boot_wakeup_parms() */ | 1949} /* emlxs_update_boot_wakeup_parms() */ |
975 976 977 978static uint32_t 979emlxs_update_ff_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 980 PROG_ID *prog_id) 981{ 982 emlxs_port_t *port = &PPORT; --- 8 unchanged lines hidden (view full) --- 991 992 return (1); 993 } 994 995 mb = (MAILBOX *)mbox; 996 997 WakeUpParms->prog_id = *prog_id; 998 | 1950 1951 1952 1953static uint32_t 1954emlxs_update_ff_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1955 PROG_ID *prog_id) 1956{ 1957 emlxs_port_t *port = &PPORT; --- 8 unchanged lines hidden (view full) --- 1966 1967 return (1); 1968 } 1969 1970 mb = (MAILBOX *)mbox; 1971 1972 WakeUpParms->prog_id = *prog_id; 1973 |
999 emlxs_format_update_parms(mb, WakeUpParms); | 1974 emlxs_format_update_parms(mbox, WakeUpParms); |
1000 | 1975 |
1001 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 1976 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1002 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1003 "Unable to update wakeup parameters: Mailbox cmd=%x " 1004 "status=%x", mb->mbxCommand, mb->mbxStatus); 1005 1006 rval = 1; 1007 } 1008 1009 if (mbox) { 1010 kmem_free(mbox, sizeof (MAILBOXQ)); 1011 } 1012 1013 return (rval); 1014 | 1977 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1978 "Unable to update wakeup parameters: Mailbox cmd=%x " 1979 "status=%x", mb->mbxCommand, mb->mbxStatus); 1980 1981 rval = 1; 1982 } 1983 1984 if (mbox) { 1985 kmem_free(mbox, sizeof (MAILBOXQ)); 1986 } 1987 1988 return (rval); 1989 |
1015} /* emlxs_update_ff_wakeup_parms() */ | 1990} /* emlxs_update_ff_wakeup_parms() */ |
1016 1017 1018static uint32_t 1019emlxs_update_sli1_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1020 PROG_ID * prog_id) 1021{ 1022 emlxs_port_t *port = &PPORT; 1023 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 1031 1032 return (1); 1033 } 1034 1035 mb = (MAILBOX *)mbox; 1036 1037 WakeUpParms->sli1_prog_id = *prog_id; 1038 | 1991 1992 1993static uint32_t 1994emlxs_update_sli1_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1995 PROG_ID * prog_id) 1996{ 1997 emlxs_port_t *port = &PPORT; 1998 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 2006 2007 return (1); 2008 } 2009 2010 mb = (MAILBOX *)mbox; 2011 2012 WakeUpParms->sli1_prog_id = *prog_id; 2013 |
1039 emlxs_format_update_parms(mb, WakeUpParms); | 2014 emlxs_format_update_parms(mbox, WakeUpParms); |
1040 | 2015 |
1041 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 2016 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1042 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1043 "Unable to update wakeup parameters. Mailbox cmd=%x " 1044 "status=%x", mb->mbxCommand, mb->mbxStatus); 1045 1046 rval = 1; 1047 } 1048 1049 if (mbox) { 1050 kmem_free(mbox, sizeof (MAILBOXQ)); 1051 } 1052 1053 return (rval); 1054 | 2017 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2018 "Unable to update wakeup parameters. Mailbox cmd=%x " 2019 "status=%x", mb->mbxCommand, mb->mbxStatus); 2020 2021 rval = 1; 2022 } 2023 2024 if (mbox) { 2025 kmem_free(mbox, sizeof (MAILBOXQ)); 2026 } 2027 2028 return (rval); 2029 |
1055} /* emlxs_update_sli1_wakeup_parms() */ | 2030} /* emlxs_update_sli1_wakeup_parms() */ |
1056 1057 1058static uint32_t 1059emlxs_update_sli2_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1060 PROG_ID * prog_id) 1061{ 1062 emlxs_port_t *port = &PPORT; 1063 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 1071 1072 return (1); 1073 } 1074 1075 mb = (MAILBOX *)mbox; 1076 1077 WakeUpParms->sli2_prog_id = *prog_id; 1078 | 2031 2032 2033static uint32_t 2034emlxs_update_sli2_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 2035 PROG_ID * prog_id) 2036{ 2037 emlxs_port_t *port = &PPORT; 2038 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 2046 2047 return (1); 2048 } 2049 2050 mb = (MAILBOX *)mbox; 2051 2052 WakeUpParms->sli2_prog_id = *prog_id; 2053 |
1079 emlxs_format_update_parms(mb, WakeUpParms); | 2054 emlxs_format_update_parms(mbox, WakeUpParms); |
1080 | 2055 |
1081 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 2056 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1082 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1083 "Unable to update wakeup parameters. Mailbox cmd=%x " 1084 "status=%x", mb->mbxCommand, mb->mbxStatus); 1085 1086 rval = 1; 1087 } 1088 1089 if (mbox) { 1090 kmem_free(mbox, sizeof (MAILBOXQ)); 1091 } 1092 1093 return (rval); 1094 | 2057 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2058 "Unable to update wakeup parameters. Mailbox cmd=%x " 2059 "status=%x", mb->mbxCommand, mb->mbxStatus); 2060 2061 rval = 1; 2062 } 2063 2064 if (mbox) { 2065 kmem_free(mbox, sizeof (MAILBOXQ)); 2066 } 2067 2068 return (rval); 2069 |
1095} /* emlxs_update_sli2_wakeup_parms() */ | 2070} /* emlxs_update_sli2_wakeup_parms() */ |
1096 1097 1098static uint32_t 1099emlxs_update_sli3_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1100 PROG_ID *prog_id) 1101{ 1102 emlxs_port_t *port = &PPORT; 1103 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 1111 1112 return (1); 1113 } 1114 1115 mb = (MAILBOX *)mbox; 1116 1117 WakeUpParms->sli3_prog_id = *prog_id; 1118 | 2071 2072 2073static uint32_t 2074emlxs_update_sli3_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 2075 PROG_ID *prog_id) 2076{ 2077 emlxs_port_t *port = &PPORT; 2078 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 2086 2087 return (1); 2088 } 2089 2090 mb = (MAILBOX *)mbox; 2091 2092 WakeUpParms->sli3_prog_id = *prog_id; 2093 |
1119 emlxs_format_update_parms(mb, WakeUpParms); | 2094 emlxs_format_update_parms(mbox, WakeUpParms); |
1120 | 2095 |
1121 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 2096 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1122 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1123 "Unable to update wakeup parameters. Mailbox cmd=%x " 1124 "status=%x", mb->mbxCommand, mb->mbxStatus); 1125 1126 rval = 1; 1127 } 1128 1129 if (mbox) { 1130 kmem_free(mbox, sizeof (MAILBOXQ)); 1131 } 1132 1133 return (rval); 1134 | 2097 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2098 "Unable to update wakeup parameters. Mailbox cmd=%x " 2099 "status=%x", mb->mbxCommand, mb->mbxStatus); 2100 2101 rval = 1; 2102 } 2103 2104 if (mbox) { 2105 kmem_free(mbox, sizeof (MAILBOXQ)); 2106 } 2107 2108 return (rval); 2109 |
1135} /* emlxs_update_sli3_wakeup_parms() */ | 2110} /* emlxs_update_sli3_wakeup_parms() */ |
1136 1137 1138static uint32_t 1139emlxs_update_sli4_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1140 PROG_ID *prog_id) 1141{ 1142 emlxs_port_t *port = &PPORT; 1143 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 1151 1152 return (1); 1153 } 1154 1155 mb = (MAILBOX *)mbox; 1156 1157 WakeUpParms->sli4_prog_id = *prog_id; 1158 | 2111 2112 2113static uint32_t 2114emlxs_update_sli4_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 2115 PROG_ID *prog_id) 2116{ 2117 emlxs_port_t *port = &PPORT; 2118 uint32_t rval = 0; --- 7 unchanged lines hidden (view full) --- 2126 2127 return (1); 2128 } 2129 2130 mb = (MAILBOX *)mbox; 2131 2132 WakeUpParms->sli4_prog_id = *prog_id; 2133 |
1159 emlxs_format_update_parms(mb, WakeUpParms); | 2134 emlxs_format_update_parms(mbox, WakeUpParms); |
1160 | 2135 |
1161 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 2136 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1162 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1163 "Unable to update wakeup parameters. Mailbox cmd=%x " 1164 "status=%x", mb->mbxCommand, mb->mbxStatus); 1165 1166 rval = 1; 1167 } 1168 1169 if (mbox) { 1170 kmem_free(mbox, sizeof (MAILBOXQ)); 1171 } 1172 1173 return (rval); 1174 | 2137 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2138 "Unable to update wakeup parameters. Mailbox cmd=%x " 2139 "status=%x", mb->mbxCommand, mb->mbxStatus); 2140 2141 rval = 1; 2142 } 2143 2144 if (mbox) { 2145 kmem_free(mbox, sizeof (MAILBOXQ)); 2146 } 2147 2148 return (rval); 2149 |
1175} /* emlxs_update_sli4_wakeup_parms() */ | 2150} /* emlxs_update_sli4_wakeup_parms() */ |
1176 1177 1178/* ARGSUSED */ 1179static uint32_t 1180emlxs_start_rel_download(emlxs_hba_t *hba, 1181 PIMAGE_HDR ImageHdr, 1182 caddr_t Buffer, 1183 PWAKE_UP_PARMS WakeUpParms, --- 61 unchanged lines hidden (view full) --- 1245 return (1); 1246 } 1247 break; 1248 } 1249 } 1250 1251 mb = (MAILBOX *)mbox; 1252 | 2151 2152 2153/* ARGSUSED */ 2154static uint32_t 2155emlxs_start_rel_download(emlxs_hba_t *hba, 2156 PIMAGE_HDR ImageHdr, 2157 caddr_t Buffer, 2158 PWAKE_UP_PARMS WakeUpParms, --- 61 unchanged lines hidden (view full) --- 2220 return (1); 2221 } 2222 break; 2223 } 2224 } 2225 2226 mb = (MAILBOX *)mbox; 2227 |
1253 emlxs_format_prog_flash(mb, 0, DlByteCount, ERASE_FLASH, 0, 0, 0, | 2228 emlxs_format_prog_flash(mbox, 0, DlByteCount, ERASE_FLASH, 0, 0, 0, |
1254 &ImageHdr->Id); 1255 1256 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, "Erasing flash..."); 1257 | 2229 &ImageHdr->Id); 2230 2231 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, "Erasing flash..."); 2232 |
1258 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 2233 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1259 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1260 "Unable to erase flash. Mailbox cmd=%x status=%x", 1261 mb->mbxCommand, mb->mbxStatus); 1262 1263 rval = 1; 1264 1265 goto EXIT_REL_DOWNLOAD; 1266 } --- 14 unchanged lines hidden (view full) --- 1281 1282 for (i = 0; i < (DlCount / 4); i++) { 1283 *Dst = *Src; 1284 Dst++; 1285 Src++; 1286 } 1287 1288 WRITE_SLIM_COPY(hba, (uint32_t *)DataBuffer, | 2234 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2235 "Unable to erase flash. Mailbox cmd=%x status=%x", 2236 mb->mbxCommand, mb->mbxStatus); 2237 2238 rval = 1; 2239 2240 goto EXIT_REL_DOWNLOAD; 2241 } --- 14 unchanged lines hidden (view full) --- 2256 2257 for (i = 0; i < (DlCount / 4); i++) { 2258 *Dst = *Src; 2259 Dst++; 2260 Src++; 2261 } 2262 2263 WRITE_SLIM_COPY(hba, (uint32_t *)DataBuffer, |
1289 (volatile uint32_t *)((volatile char *)hba->slim_addr + | 2264 (volatile uint32_t *) 2265 ((volatile char *)hba->sli.sli3.slim_addr + |
1290 sizeof (MAILBOX)), (DlCount / sizeof (uint32_t))); 1291 | 2266 sizeof (MAILBOX)), (DlCount / sizeof (uint32_t))); 2267 |
1292 emlxs_format_prog_flash(mb, | 2268 emlxs_format_prog_flash(mbox, |
1293 0, 1294 DlCount, 1295 PROGRAM_FLASH, 1296 (DlByteCount) ? 0 : 1, 0, DlCount, &ImageHdr->Id); 1297 | 2269 0, 2270 DlCount, 2271 PROGRAM_FLASH, 2272 (DlByteCount) ? 0 : 1, 0, DlCount, &ImageHdr->Id); 2273 |
1298 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != | 2274 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != |
1299 MBX_SUCCESS) { 1300 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 1301 "Unable to program flash. Mailbox cmd=%x status=%x", 1302 mb->mbxCommand, mb->mbxStatus); 1303 1304 rval = 1; 1305 1306 goto EXIT_REL_DOWNLOAD; 1307 } 1308 1309 Buffer += DlCount; 1310 } 1311 1312#ifdef FMA_SUPPORT | 2275 MBX_SUCCESS) { 2276 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2277 "Unable to program flash. Mailbox cmd=%x status=%x", 2278 mb->mbxCommand, mb->mbxStatus); 2279 2280 rval = 1; 2281 2282 goto EXIT_REL_DOWNLOAD; 2283 } 2284 2285 Buffer += DlCount; 2286 } 2287 2288#ifdef FMA_SUPPORT |
1313 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle) | 2289 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.slim_acc_handle) |
1314 != DDI_FM_OK) { 1315 EMLXS_MSGF(EMLXS_CONTEXT, 1316 &emlxs_invalid_access_handle_msg, NULL); 1317 1318 rval = 1; 1319 1320 goto EXIT_REL_DOWNLOAD; 1321 } --- 65 unchanged lines hidden (view full) --- 1387 } 1388 1389 if (mbox) { 1390 kmem_free(mbox, sizeof (MAILBOXQ)); 1391 } 1392 1393 return (rval); 1394 | 2290 != DDI_FM_OK) { 2291 EMLXS_MSGF(EMLXS_CONTEXT, 2292 &emlxs_invalid_access_handle_msg, NULL); 2293 2294 rval = 1; 2295 2296 goto EXIT_REL_DOWNLOAD; 2297 } --- 65 unchanged lines hidden (view full) --- 2363 } 2364 2365 if (mbox) { 2366 kmem_free(mbox, sizeof (MAILBOXQ)); 2367 } 2368 2369 return (rval); 2370 |
1395} /* emlxs_start_rel_download() */ | 2371} /* emlxs_start_rel_download() */ |
1396 1397 1398#define FLASH_POLLING_BIT 0x80 1399#define FLASH_ERROR_BIT 0x20 1400 1401typedef struct _flash_t 1402{ 1403 uint32_t offset; --- 128 unchanged lines hidden (view full) --- 1532 1533 return (1); 1534 } 1535 } 1536 } 1537 } 1538 1539#ifdef FMA_SUPPORT | 2372 2373 2374#define FLASH_POLLING_BIT 0x80 2375#define FLASH_ERROR_BIT 0x20 2376 2377typedef struct _flash_t 2378{ 2379 uint32_t offset; --- 128 unchanged lines hidden (view full) --- 2508 2509 return (1); 2510 } 2511 } 2512 } 2513 } 2514 2515#ifdef FMA_SUPPORT |
1540 if (emlxs_fm_check_acc_handle(hba, hba->sbus_flash_acc_handle) | 2516 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.sbus_flash_acc_handle) |
1541 != DDI_FM_OK) { 1542 EMLXS_MSGF(EMLXS_CONTEXT, 1543 &emlxs_invalid_access_handle_msg, NULL); 1544 return (1); 1545 } 1546#endif /* FMA_SUPPORT */ 1547 1548 return (0); 1549 | 2517 != DDI_FM_OK) { 2518 EMLXS_MSGF(EMLXS_CONTEXT, 2519 &emlxs_invalid_access_handle_msg, NULL); 2520 return (1); 2521 } 2522#endif /* FMA_SUPPORT */ 2523 2524 return (0); 2525 |
1550} /* emlxs_write_fcode_flash() */ | 2526} /* emlxs_write_fcode_flash() */ |
1551 1552 1553 1554static uint32_t 1555emlxs_erase_fcode_flash(emlxs_hba_t *hba) 1556{ 1557 emlxs_port_t *port = &PPORT; 1558 int32_t i, j; --- 86 unchanged lines hidden (view full) --- 1645 "read:%x\n", i, 0xff, cc); 1646 1647 return (1); 1648 } 1649 } 1650 } 1651 1652#ifdef FMA_SUPPORT | 2527 2528 2529 2530static uint32_t 2531emlxs_erase_fcode_flash(emlxs_hba_t *hba) 2532{ 2533 emlxs_port_t *port = &PPORT; 2534 int32_t i, j; --- 86 unchanged lines hidden (view full) --- 2621 "read:%x\n", i, 0xff, cc); 2622 2623 return (1); 2624 } 2625 } 2626 } 2627 2628#ifdef FMA_SUPPORT |
1653 if (emlxs_fm_check_acc_handle(hba, hba->sbus_flash_acc_handle) | 2629 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.sbus_flash_acc_handle) |
1654 != DDI_FM_OK) { 1655 EMLXS_MSGF(EMLXS_CONTEXT, 1656 &emlxs_invalid_access_handle_msg, NULL); 1657 return (1); 1658 } 1659#endif /* FMA_SUPPORT */ 1660 1661 return (0); 1662 | 2630 != DDI_FM_OK) { 2631 EMLXS_MSGF(EMLXS_CONTEXT, 2632 &emlxs_invalid_access_handle_msg, NULL); 2633 return (1); 2634 } 2635#endif /* FMA_SUPPORT */ 2636 2637 return (0); 2638 |
1663} /* emlxs_erase_fcode_flash() */ | 2639} /* emlxs_erase_fcode_flash() */ |
1664 1665 1666extern uint32_t 1667emlxs_get_load_list(emlxs_hba_t *hba, PROG_ID *load_list) 1668{ 1669 emlxs_port_t *port = &PPORT; 1670 LOAD_ENTRY *LoadEntry; 1671 LOAD_LIST *LoadList = NULL; --- 30 unchanged lines hidden (view full) --- 1702done: 1703 1704 if (LoadList) { 1705 kmem_free(LoadList, sizeof (LOAD_LIST)); 1706 } 1707 1708 return (rval); 1709 | 2640 2641 2642extern uint32_t 2643emlxs_get_load_list(emlxs_hba_t *hba, PROG_ID *load_list) 2644{ 2645 emlxs_port_t *port = &PPORT; 2646 LOAD_ENTRY *LoadEntry; 2647 LOAD_LIST *LoadList = NULL; --- 30 unchanged lines hidden (view full) --- 2678done: 2679 2680 if (LoadList) { 2681 kmem_free(LoadList, sizeof (LOAD_LIST)); 2682 } 2683 2684 return (rval); 2685 |
1710} /* emlxs_get_load_list() */ | 2686} /* emlxs_get_load_list() */ |
1711 1712 1713extern uint32_t 1714emlxs_read_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 1715 uint32_t verbose) 1716{ 1717 emlxs_port_t *port = &PPORT; 1718 MAILBOXQ *mbox; --- 8 unchanged lines hidden (view full) --- 1727 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 1728 "Unable to allocate mailbox buffer."); 1729 1730 return (1); 1731 } 1732 1733 mb = (MAILBOX *)mbox; 1734 | 2687 2688 2689extern uint32_t 2690emlxs_read_wakeup_parms(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms, 2691 uint32_t verbose) 2692{ 2693 emlxs_port_t *port = &PPORT; 2694 MAILBOXQ *mbox; --- 8 unchanged lines hidden (view full) --- 2703 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 2704 "Unable to allocate mailbox buffer."); 2705 2706 return (1); 2707 } 2708 2709 mb = (MAILBOX *)mbox; 2710 |
1735 emlxs_format_dump(mb, | 2711 emlxs_format_dump(hba, mbox, |
1736 DMP_NV_PARAMS, 1737 WAKE_UP_PARMS_REGION_ID, 1738 sizeof (WAKE_UP_PARMS) / sizeof (uint32_t), 0); 1739 | 2712 DMP_NV_PARAMS, 2713 WAKE_UP_PARMS_REGION_ID, 2714 sizeof (WAKE_UP_PARMS) / sizeof (uint32_t), 0); 2715 |
1740 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 2716 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1741 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 1742 "Unable to get parameters: Mailbox cmd=%x status=%x", 1743 mb->mbxCommand, mb->mbxStatus); 1744 1745 if (mb->un.varDmp.word_cnt == (uint32_t)CFG_DATA_NO_REGION) { 1746 rval = (uint32_t)CFG_DATA_NO_REGION; 1747 } else { 1748 rval = 1; 1749 } 1750 } else { | 2717 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 2718 "Unable to get parameters: Mailbox cmd=%x status=%x", 2719 mb->mbxCommand, mb->mbxStatus); 2720 2721 if (mb->un.varDmp.word_cnt == (uint32_t)CFG_DATA_NO_REGION) { 2722 rval = (uint32_t)CFG_DATA_NO_REGION; 2723 } else { 2724 rval = 1; 2725 } 2726 } else { |
1751 bcopy((caddr_t)&mb->un.varDmp.resp_offset, 1752 (caddr_t)WakeUpParms, sizeof (WAKE_UP_PARMS)); | 2727 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 2728 EMLXS_MPDATA_SYNC(hba->sli.sli4.dump_region.dma_handle, 2729 0, hba->sli.sli4.dump_region.size, 2730 DDI_DMA_SYNC_FORKERNEL); |
1753 | 2731 |
2732 bcopy((caddr_t)hba->sli.sli4.dump_region.virt, 2733 (caddr_t)WakeUpParms, sizeof (WAKE_UP_PARMS)); 2734 } else { 2735 bcopy((caddr_t)&mb->un.varDmp.resp_offset, 2736 (caddr_t)WakeUpParms, sizeof (WAKE_UP_PARMS)); 2737 } 2738 |
|
1754 if (verbose) { 1755 wd = (uint32_t *)&WakeUpParms->prog_id; 1756 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg, 1757 "Wakeup: prog_id=%08x %08x", wd[0], wd[1]); 1758 1759 wd = (uint32_t *)&WakeUpParms->u0.boot_bios_id; 1760 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg, 1761 "Wakeup: boot_bios_id=%08x %08x", wd[0], wd[1]); --- 44 unchanged lines hidden (view full) --- 1806done: 1807 1808 if (mbox) { 1809 kmem_free(mbox, sizeof (MAILBOXQ)); 1810 } 1811 1812 return (rval); 1813 | 2739 if (verbose) { 2740 wd = (uint32_t *)&WakeUpParms->prog_id; 2741 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg, 2742 "Wakeup: prog_id=%08x %08x", wd[0], wd[1]); 2743 2744 wd = (uint32_t *)&WakeUpParms->u0.boot_bios_id; 2745 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg, 2746 "Wakeup: boot_bios_id=%08x %08x", wd[0], wd[1]); --- 44 unchanged lines hidden (view full) --- 2791done: 2792 2793 if (mbox) { 2794 kmem_free(mbox, sizeof (MAILBOXQ)); 2795 } 2796 2797 return (rval); 2798 |
1814} /* emlxs_read_wakeup_parms() */ | 2799} /* emlxs_read_wakeup_parms() */ |
1815 1816 1817static uint32_t 1818emlxs_read_load_list(emlxs_hba_t *hba, LOAD_LIST *LoadList) 1819{ 1820 emlxs_port_t *port = &PPORT; 1821 LOAD_ENTRY *LoadEntry; 1822 uint32_t *Uptr; --- 8 unchanged lines hidden (view full) --- 1831 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 1832 "Unable to allocate mailbox buffer."); 1833 1834 return (1); 1835 } 1836 1837 mb = (MAILBOX *)mbox; 1838 | 2800 2801 2802static uint32_t 2803emlxs_read_load_list(emlxs_hba_t *hba, LOAD_LIST *LoadList) 2804{ 2805 emlxs_port_t *port = &PPORT; 2806 LOAD_ENTRY *LoadEntry; 2807 uint32_t *Uptr; --- 8 unchanged lines hidden (view full) --- 2816 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 2817 "Unable to allocate mailbox buffer."); 2818 2819 return (1); 2820 } 2821 2822 mb = (MAILBOX *)mbox; 2823 |
1839 emlxs_format_dump(mb, DMP_MEM_REG, 0, 2, FLASH_LOAD_LIST_ADR); | 2824 emlxs_format_dump(hba, mbox, DMP_MEM_REG, 0, 2, FLASH_LOAD_LIST_ADR); |
1840 | 2825 |
1841 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 2826 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
1842 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 1843 "Unable to get load list: Mailbox cmd=%x status=%x", 1844 mb->mbxCommand, mb->mbxStatus); 1845 1846 goto done; 1847 } 1848 | 2827 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 2828 "Unable to get load list: Mailbox cmd=%x status=%x", 2829 mb->mbxCommand, mb->mbxStatus); 2830 2831 goto done; 2832 } 2833 |
1849 Uptr = (uint32_t *)&mb->un.varDmp.resp_offset; | 2834 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 2835 EMLXS_MPDATA_SYNC(hba->sli.sli4.dump_region.dma_handle, 0, 2836 hba->sli.sli4.dump_region.size, DDI_DMA_SYNC_FORKERNEL); 2837 Uptr = (uint32_t *)hba->sli.sli4.dump_region.virt; 2838 } else { 2839 Uptr = (uint32_t *)&mb->un.varDmp.resp_offset; 2840 } |
1850 1851 LoadList->head = Uptr[0]; 1852 LoadList->tail = Uptr[1]; 1853 1854 CurEntryAddr = LoadList->head; 1855 1856 while ((CurEntryAddr != FLASH_LOAD_LIST_ADR) && 1857 (LoadList->entry_cnt < MAX_LOAD_ENTRY)) { 1858 LoadEntry = &LoadList->load_entry[LoadList->entry_cnt]; 1859 LoadList->entry_cnt++; 1860 | 2841 2842 LoadList->head = Uptr[0]; 2843 LoadList->tail = Uptr[1]; 2844 2845 CurEntryAddr = LoadList->head; 2846 2847 while ((CurEntryAddr != FLASH_LOAD_LIST_ADR) && 2848 (LoadList->entry_cnt < MAX_LOAD_ENTRY)) { 2849 LoadEntry = &LoadList->load_entry[LoadList->entry_cnt]; 2850 LoadList->entry_cnt++; 2851 |
1861 emlxs_format_dump(mb, | 2852 emlxs_format_dump(hba, mbox, |
1862 DMP_MEM_REG, 0, FLASH_LOAD_ENTRY_SIZE, CurEntryAddr); 1863 | 2853 DMP_MEM_REG, 0, FLASH_LOAD_ENTRY_SIZE, CurEntryAddr); 2854 |
1864 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != | 2855 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != |
1865 MBX_SUCCESS) { 1866 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 1867 "Unable to get load list (%d): Mailbox cmd=%x " 1868 "status=%x", LoadList->entry_cnt, mb->mbxCommand, 1869 mb->mbxStatus); 1870 1871 goto done; 1872 } 1873 | 2856 MBX_SUCCESS) { 2857 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_msg, 2858 "Unable to get load list (%d): Mailbox cmd=%x " 2859 "status=%x", LoadList->entry_cnt, mb->mbxCommand, 2860 mb->mbxStatus); 2861 2862 goto done; 2863 } 2864 |
1874 Uptr = (uint32_t *)&(mb->un.varDmp.resp_offset); | 2865 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 2866 EMLXS_MPDATA_SYNC(hba->sli.sli4.dump_region.dma_handle, 2867 0, hba->sli.sli4.dump_region.size, 2868 DDI_DMA_SYNC_FORKERNEL); 2869 Uptr = (uint32_t *)hba->sli.sli4.dump_region.virt; 2870 } else { 2871 Uptr = (uint32_t *)&mb->un.varDmp.resp_offset; 2872 } |
1875 1876 LoadEntry->next = Uptr[0]; 1877 LoadEntry->prev = Uptr[1]; 1878 LoadEntry->start_adr = Uptr[2]; 1879 LoadEntry->len = Uptr[3]; 1880 LoadEntry->un.wd[0] = Uptr[4]; 1881 LoadEntry->un.wd[1] = Uptr[5]; 1882 --- 5 unchanged lines hidden (view full) --- 1888done: 1889 1890 if (mbox) { 1891 kmem_free(mbox, sizeof (MAILBOXQ)); 1892 } 1893 1894 return (0); 1895 | 2873 2874 LoadEntry->next = Uptr[0]; 2875 LoadEntry->prev = Uptr[1]; 2876 LoadEntry->start_adr = Uptr[2]; 2877 LoadEntry->len = Uptr[3]; 2878 LoadEntry->un.wd[0] = Uptr[4]; 2879 LoadEntry->un.wd[1] = Uptr[5]; 2880 --- 5 unchanged lines hidden (view full) --- 2886done: 2887 2888 if (mbox) { 2889 kmem_free(mbox, sizeof (MAILBOXQ)); 2890 } 2891 2892 return (0); 2893 |
1896} /* emlxs_read_load_list() */ | 2894} /* emlxs_read_load_list() */ |
1897 1898 | 2895 2896 |
1899 1900 | |
1901static uint32_t 1902emlxs_get_abs_image_type(caddr_t Buffer, uint32_t BufferSize) 1903{ 1904 uint32_t Version; 1905 1906 if (BufferSize < (SLI_VERSION_LOC + 4)) 1907 return (0xffffffff); 1908 1909 Buffer += SLI_VERSION_LOC; 1910 Version = *((uint32_t *)Buffer); 1911 1912 return (Version); 1913 | 2897static uint32_t 2898emlxs_get_abs_image_type(caddr_t Buffer, uint32_t BufferSize) 2899{ 2900 uint32_t Version; 2901 2902 if (BufferSize < (SLI_VERSION_LOC + 4)) 2903 return (0xffffffff); 2904 2905 Buffer += SLI_VERSION_LOC; 2906 Version = *((uint32_t *)Buffer); 2907 2908 return (Version); 2909 |
1914} /* emlxs_get_abs_image_type() */ | 2910} /* emlxs_get_abs_image_type() */ |
1915 1916 1917static uint32_t 1918emlxs_get_dwc_image_type(emlxs_hba_t *hba, caddr_t Buffer, 1919 uint32_t BufferSize, PAIF_HDR AifHeader) 1920{ 1921 emlxs_port_t *port = &PPORT; 1922 IMAGE_HDR ImageHdr; --- 31 unchanged lines hidden (view full) --- 1954 break; 1955 } 1956 1957 NextImage += ImageHdr.BlockSize; 1958 } 1959 1960 return (HwId); 1961 | 2911 2912 2913static uint32_t 2914emlxs_get_dwc_image_type(emlxs_hba_t *hba, caddr_t Buffer, 2915 uint32_t BufferSize, PAIF_HDR AifHeader) 2916{ 2917 emlxs_port_t *port = &PPORT; 2918 IMAGE_HDR ImageHdr; --- 31 unchanged lines hidden (view full) --- 2950 break; 2951 } 2952 2953 NextImage += ImageHdr.BlockSize; 2954 } 2955 2956 return (HwId); 2957 |
1962} /* emlxs_get_dwc_image_type() */ | 2958} /* emlxs_get_dwc_image_type() */ |
1963 1964 1965static int 1966emlxs_build_parms(caddr_t Buffer, 1967 PWAKE_UP_PARMS AbsWakeUpParms, 1968 uint32_t BufferSize, PAIF_HDR AifHeader, int32_t DwcFile) 1969{ 1970 IMAGE_HDR ImageHdr; --- 52 unchanged lines hidden (view full) --- 2023 break; 2024 } 2025 2026 NextImage += ImageHdr.BlockSize; 2027 } 2028 2029 return (ChangeParams); 2030 | 2959 2960 2961static int 2962emlxs_build_parms(caddr_t Buffer, 2963 PWAKE_UP_PARMS AbsWakeUpParms, 2964 uint32_t BufferSize, PAIF_HDR AifHeader, int32_t DwcFile) 2965{ 2966 IMAGE_HDR ImageHdr; --- 52 unchanged lines hidden (view full) --- 3019 break; 3020 } 3021 3022 NextImage += ImageHdr.BlockSize; 3023 } 3024 3025 return (ChangeParams); 3026 |
2031} /* emlxs_build_parms() */ | 3027} /* emlxs_build_parms() */ |
2032 2033 2034static uint32_t 2035emlxs_update_wakeup_parms(emlxs_hba_t *hba, 2036 PWAKE_UP_PARMS AbsWakeUpParms, PWAKE_UP_PARMS WakeUpParms) 2037{ 2038 emlxs_port_t *port = &PPORT; 2039 MAILBOX *mb; --- 12 unchanged lines hidden (view full) --- 2052 2053 WakeUpParms->prog_id = AbsWakeUpParms->prog_id; 2054 WakeUpParms->u0.boot_bios_id = AbsWakeUpParms->u0.boot_bios_id; 2055 WakeUpParms->sli1_prog_id = AbsWakeUpParms->sli1_prog_id; 2056 WakeUpParms->sli2_prog_id = AbsWakeUpParms->sli2_prog_id; 2057 WakeUpParms->sli3_prog_id = AbsWakeUpParms->sli3_prog_id; 2058 WakeUpParms->sli4_prog_id = AbsWakeUpParms->sli4_prog_id; 2059 | 3028 3029 3030static uint32_t 3031emlxs_update_wakeup_parms(emlxs_hba_t *hba, 3032 PWAKE_UP_PARMS AbsWakeUpParms, PWAKE_UP_PARMS WakeUpParms) 3033{ 3034 emlxs_port_t *port = &PPORT; 3035 MAILBOX *mb; --- 12 unchanged lines hidden (view full) --- 3048 3049 WakeUpParms->prog_id = AbsWakeUpParms->prog_id; 3050 WakeUpParms->u0.boot_bios_id = AbsWakeUpParms->u0.boot_bios_id; 3051 WakeUpParms->sli1_prog_id = AbsWakeUpParms->sli1_prog_id; 3052 WakeUpParms->sli2_prog_id = AbsWakeUpParms->sli2_prog_id; 3053 WakeUpParms->sli3_prog_id = AbsWakeUpParms->sli3_prog_id; 3054 WakeUpParms->sli4_prog_id = AbsWakeUpParms->sli4_prog_id; 3055 |
2060 emlxs_format_update_parms(mb, WakeUpParms); | 3056 emlxs_format_update_parms(mbox, WakeUpParms); |
2061 | 3057 |
2062 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 3058 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
2063 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2064 "Unable to update wakeup parameters: Mailbox cmd=%x " 2065 "status=%x", mb->mbxCommand, mb->mbxStatus); 2066 2067 rval = 1; 2068 } 2069 2070 if (mbox) { 2071 kmem_free(mbox, sizeof (MAILBOXQ)); 2072 } 2073 2074 return (rval); 2075 | 3059 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3060 "Unable to update wakeup parameters: Mailbox cmd=%x " 3061 "status=%x", mb->mbxCommand, mb->mbxStatus); 3062 3063 rval = 1; 3064 } 3065 3066 if (mbox) { 3067 kmem_free(mbox, sizeof (MAILBOXQ)); 3068 } 3069 3070 return (rval); 3071 |
2076} /* emlxs_update_wakeup_parms() */ | 3072} /* emlxs_update_wakeup_parms() */ |
2077 2078 2079static uint32_t 2080emlxs_validate_version(emlxs_hba_t *hba, emlxs_fw_file_t *file, uint32_t id, 2081 uint32_t type, char *file_type) 2082{ 2083 emlxs_port_t *port = &PPORT; 2084 --- 142 unchanged lines hidden (view full) --- 2227 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 2228 "%s: Image type not supported. type=%x", file_type, type); 2229 2230 return (EMLXS_IMAGE_BAD); 2231 } 2232 2233 return (0); 2234 | 3073 3074 3075static uint32_t 3076emlxs_validate_version(emlxs_hba_t *hba, emlxs_fw_file_t *file, uint32_t id, 3077 uint32_t type, char *file_type) 3078{ 3079 emlxs_port_t *port = &PPORT; 3080 --- 142 unchanged lines hidden (view full) --- 3223 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_image_bad_msg, 3224 "%s: Image type not supported. type=%x", file_type, type); 3225 3226 return (EMLXS_IMAGE_BAD); 3227 } 3228 3229 return (0); 3230 |
2235} /* emlxs_validate_version() */ | 3231} /* emlxs_validate_version() */ |
2236 2237 2238static uint32_t 2239emlxs_validate_image(emlxs_hba_t *hba, caddr_t Buffer, uint32_t Size, 2240 emlxs_fw_image_t *image) 2241{ 2242 emlxs_port_t *port = &PPORT; 2243 uint32_t ImageType; --- 147 unchanged lines hidden (view full) --- 2391 if ((rval = emlxs_validate_version(hba, 2392 &image->prog[type], ImageHdr.Id.Id, 2393 type, "DWC prog"))) { 2394 return (rval); 2395 } 2396 2397 NextImage += ImageHdr.BlockSize; 2398 | 3232 3233 3234static uint32_t 3235emlxs_validate_image(emlxs_hba_t *hba, caddr_t Buffer, uint32_t Size, 3236 emlxs_fw_image_t *image) 3237{ 3238 emlxs_port_t *port = &PPORT; 3239 uint32_t ImageType; --- 147 unchanged lines hidden (view full) --- 3387 if ((rval = emlxs_validate_version(hba, 3388 &image->prog[type], ImageHdr.Id.Id, 3389 type, "DWC prog"))) { 3390 return (rval); 3391 } 3392 3393 NextImage += ImageHdr.BlockSize; 3394 |
2399 } /* while() */ | 3395 } /* while () */ |
2400 2401 break; 2402 } 2403 2404 FileLen = 2405 sizeof (AIF_HDR) + ImageLength + 2406 sizeof (uint32_t); 2407 TotalLen += FileLen; --- 171 unchanged lines hidden (view full) --- 2579 2580 return (EMLXS_IMAGE_INCOMPATIBLE); 2581 } 2582 } 2583 } 2584 2585 return (0); 2586 | 3396 3397 break; 3398 } 3399 3400 FileLen = 3401 sizeof (AIF_HDR) + ImageLength + 3402 sizeof (uint32_t); 3403 TotalLen += FileLen; --- 171 unchanged lines hidden (view full) --- 3575 3576 return (EMLXS_IMAGE_INCOMPATIBLE); 3577 } 3578 } 3579 } 3580 3581 return (0); 3582 |
2587} /* emlxs_validate_image() */ | 3583} /* emlxs_validate_image() */ |
2588 2589 2590static uint32_t 2591emlxs_update_exp_rom(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms) 2592{ 2593 emlxs_port_t *port = &PPORT; 2594 MAILBOXQ *mbox; 2595 MAILBOX *mb; --- 14 unchanged lines hidden (view full) --- 2610 2611 bzero(mbox, sizeof (MAILBOXQ)); 2612 2613 mb = (MAILBOX *)mbox; 2614 mb->mbxCommand = MBX_LOAD_EXP_ROM; 2615 mb->un.varLdExpRom.step = EROM_CMD_FIND_IMAGE; 2616 mb->un.varLdExpRom.progress = 0; 2617 mb->un.varLdExpRom.un.prog_id = WakeUpParms->u1.EROM_prog_id; | 3584 3585 3586static uint32_t 3587emlxs_update_exp_rom(emlxs_hba_t *hba, PWAKE_UP_PARMS WakeUpParms) 3588{ 3589 emlxs_port_t *port = &PPORT; 3590 MAILBOXQ *mbox; 3591 MAILBOX *mb; --- 14 unchanged lines hidden (view full) --- 3606 3607 bzero(mbox, sizeof (MAILBOXQ)); 3608 3609 mb = (MAILBOX *)mbox; 3610 mb->mbxCommand = MBX_LOAD_EXP_ROM; 3611 mb->un.varLdExpRom.step = EROM_CMD_FIND_IMAGE; 3612 mb->un.varLdExpRom.progress = 0; 3613 mb->un.varLdExpRom.un.prog_id = WakeUpParms->u1.EROM_prog_id; |
3614 mbox->mbox_cmpl = NULL; |
|
2618 | 3615 |
2619 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 3616 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
2620 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2621 "Unable to load exp ROM. Mailbox cmd=%x status=%x", 2622 mb->mbxCommand, mb->mbxStatus); 2623 2624 rval = 1; 2625 2626 goto SLI_DOWNLOAD_EXIT; 2627 } --- 24 unchanged lines hidden (view full) --- 2652 2653 bzero((void *)mb, MAILBOX_CMD_BSIZE); 2654 2655 mb->mbxCommand = MBX_LOAD_EXP_ROM; 2656 mb->un.varLdExpRom.step = EROM_CMD_CONTINUE_ERASE; 2657 mb->un.varLdExpRom.dl_to_adr = next_address; 2658 mb->un.varLdExpRom.progress = 0; 2659 mb->un.varLdExpRom.un.prog_id = WakeUpParms->u1.EROM_prog_id; | 3617 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3618 "Unable to load exp ROM. Mailbox cmd=%x status=%x", 3619 mb->mbxCommand, mb->mbxStatus); 3620 3621 rval = 1; 3622 3623 goto SLI_DOWNLOAD_EXIT; 3624 } --- 24 unchanged lines hidden (view full) --- 3649 3650 bzero((void *)mb, MAILBOX_CMD_BSIZE); 3651 3652 mb->mbxCommand = MBX_LOAD_EXP_ROM; 3653 mb->un.varLdExpRom.step = EROM_CMD_CONTINUE_ERASE; 3654 mb->un.varLdExpRom.dl_to_adr = next_address; 3655 mb->un.varLdExpRom.progress = 0; 3656 mb->un.varLdExpRom.un.prog_id = WakeUpParms->u1.EROM_prog_id; |
3657 mbox->mbox_cmpl = NULL; |
|
2660 | 3658 |
2661 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != | 3659 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != |
2662 MBX_SUCCESS) { 2663 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2664 "Unable to load exp ROM. Mailbox cmd=%x status=%x", 2665 mb->mbxCommand, mb->mbxStatus); 2666 2667 rval = 1; 2668 goto SLI_DOWNLOAD_EXIT; 2669 } --- 5 unchanged lines hidden (view full) --- 2675 2676 bzero((void *)mb, MAILBOX_CMD_BSIZE); 2677 2678 mb->mbxCommand = MBX_LOAD_EXP_ROM; 2679 mb->un.varLdExpRom.step = EROM_CMD_COPY; 2680 mb->un.varLdExpRom.dl_to_adr = next_address; 2681 mb->un.varLdExpRom.progress = 0; 2682 mb->un.varLdExpRom.un.prog_id = WakeUpParms->u1.EROM_prog_id; | 3660 MBX_SUCCESS) { 3661 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3662 "Unable to load exp ROM. Mailbox cmd=%x status=%x", 3663 mb->mbxCommand, mb->mbxStatus); 3664 3665 rval = 1; 3666 goto SLI_DOWNLOAD_EXIT; 3667 } --- 5 unchanged lines hidden (view full) --- 3673 3674 bzero((void *)mb, MAILBOX_CMD_BSIZE); 3675 3676 mb->mbxCommand = MBX_LOAD_EXP_ROM; 3677 mb->un.varLdExpRom.step = EROM_CMD_COPY; 3678 mb->un.varLdExpRom.dl_to_adr = next_address; 3679 mb->un.varLdExpRom.progress = 0; 3680 mb->un.varLdExpRom.un.prog_id = WakeUpParms->u1.EROM_prog_id; |
3681 mbox->mbox_cmpl = NULL; |
|
2683 | 3682 |
2684 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != | 3683 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != |
2685 MBX_SUCCESS) { 2686 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2687 "Unable to load exp ROM. Mailbox cmd=%x status=%x", 2688 mb->mbxCommand, mb->mbxStatus); 2689 2690 rval = 1; 2691 2692 goto SLI_DOWNLOAD_EXIT; --- 5 unchanged lines hidden (view full) --- 2698SLI_DOWNLOAD_EXIT: 2699 2700 if (mbox) { 2701 kmem_free(mbox, sizeof (MAILBOXQ)); 2702 } 2703 2704 return (rval); 2705 | 3684 MBX_SUCCESS) { 3685 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3686 "Unable to load exp ROM. Mailbox cmd=%x status=%x", 3687 mb->mbxCommand, mb->mbxStatus); 3688 3689 rval = 1; 3690 3691 goto SLI_DOWNLOAD_EXIT; --- 5 unchanged lines hidden (view full) --- 3697SLI_DOWNLOAD_EXIT: 3698 3699 if (mbox) { 3700 kmem_free(mbox, sizeof (MAILBOXQ)); 3701 } 3702 3703 return (rval); 3704 |
2706} /* emlxs_update_exp_rom() */ | 3705} /* emlxs_update_exp_rom() */ |
2707 2708 2709/* 2710 * 2711 * FUNCTION NAME: emlxs_start_abs_download_2mb 2712 * 2713 * DESCRIPTION: Perform absolute download for 2 MB flash. A incoming 2714 * buffer may consist of more than 1 file. This function --- 75 unchanged lines hidden (view full) --- 2790 /* 2791 * Everything checks out, now to just do it 2792 */ 2793 if (offline) { 2794 if (emlxs_offline(hba) != FC_SUCCESS) { 2795 return (EMLXS_OFFLINE_FAILED); 2796 } 2797 | 3706 3707 3708/* 3709 * 3710 * FUNCTION NAME: emlxs_start_abs_download_2mb 3711 * 3712 * DESCRIPTION: Perform absolute download for 2 MB flash. A incoming 3713 * buffer may consist of more than 1 file. This function --- 75 unchanged lines hidden (view full) --- 3789 /* 3790 * Everything checks out, now to just do it 3791 */ 3792 if (offline) { 3793 if (emlxs_offline(hba) != FC_SUCCESS) { 3794 return (EMLXS_OFFLINE_FAILED); 3795 } 3796 |
2798 if (emlxs_sli_hba_reset(hba, 1, 1) != FC_SUCCESS) { | 3797 if (EMLXS_SLI_HBA_RESET(hba, 1, 1, 0) != FC_SUCCESS) { |
2799 return (EMLXS_OFFLINE_FAILED); 2800 } 2801 } 2802 2803 if (AwcBuffer) { 2804 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, 2805 "AWC file: KERN: old=%s new=%s ", vpd->postKernName, 2806 fw_image->awc.label); --- 57 unchanged lines hidden (view full) --- 2864SLI_DOWNLOAD_2MB_EXIT: 2865 2866 if (offline) { 2867 (void) emlxs_online(hba); 2868 } 2869 2870 return (rval); 2871 | 3798 return (EMLXS_OFFLINE_FAILED); 3799 } 3800 } 3801 3802 if (AwcBuffer) { 3803 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_msg, 3804 "AWC file: KERN: old=%s new=%s ", vpd->postKernName, 3805 fw_image->awc.label); --- 57 unchanged lines hidden (view full) --- 3863SLI_DOWNLOAD_2MB_EXIT: 3864 3865 if (offline) { 3866 (void) emlxs_online(hba); 3867 } 3868 3869 return (rval); 3870 |
2872} /* emlxs_start_abs_download_2mb() */ | 3871} /* emlxs_start_abs_download_2mb() */ |
2873 2874 2875/* 2876 * 2877 * FUNCTION NAME: emlxs_proc_abs_2mb 2878 * 2879 * DESCRIPTION: Given one of the 3 file types(awc/bwc/dwc), it will reset 2880 * the port and download the file with sliIssueMbCommand() --- 100 unchanged lines hidden (view full) --- 2981 2982 goto EXIT_ABS_DOWNLOAD; 2983 2984 } 2985 2986 EraseByteCount = AifHdr->Area_Size; 2987 AreaId = AifHdr->Area_ID; 2988 | 3872 3873 3874/* 3875 * 3876 * FUNCTION NAME: emlxs_proc_abs_2mb 3877 * 3878 * DESCRIPTION: Given one of the 3 file types(awc/bwc/dwc), it will reset 3879 * the port and download the file with sliIssueMbCommand() --- 100 unchanged lines hidden (view full) --- 3980 3981 goto EXIT_ABS_DOWNLOAD; 3982 3983 } 3984 3985 EraseByteCount = AifHdr->Area_Size; 3986 AreaId = AifHdr->Area_ID; 3987 |
2989 emlxs_format_load_area_cmd(mb, | 3988 emlxs_format_load_area_cmd(mbox, |
2990 DlToAddr, 2991 EraseByteCount, 2992 ERASE_FLASH, 2993 0, DL_FROM_SLIM_OFFSET, AreaId, MBX_LOAD_AREA, CMD_START_ERASE); 2994 | 3989 DlToAddr, 3990 EraseByteCount, 3991 ERASE_FLASH, 3992 0, DL_FROM_SLIM_OFFSET, AreaId, MBX_LOAD_AREA, CMD_START_ERASE); 3993 |
2995 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != MBX_SUCCESS) { | 3994 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != MBX_SUCCESS) { |
2996 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 2997 "%x: Could not erase 2MB Flash: Mailbox cmd=%x status=%x", 2998 FileType, mb->mbxCommand, mb->mbxStatus); 2999 3000 rval = EMLXS_IMAGE_FAILED; 3001 3002 goto EXIT_ABS_DOWNLOAD; 3003 } 3004 3005 while (mb->un.varLdArea.progress != RSP_ERASE_COMPLETE) { 3006 NextAddr = mb->un.varLdArea.dl_to_adr; 3007 | 3995 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3996 "%x: Could not erase 2MB Flash: Mailbox cmd=%x status=%x", 3997 FileType, mb->mbxCommand, mb->mbxStatus); 3998 3999 rval = EMLXS_IMAGE_FAILED; 4000 4001 goto EXIT_ABS_DOWNLOAD; 4002 } 4003 4004 while (mb->un.varLdArea.progress != RSP_ERASE_COMPLETE) { 4005 NextAddr = mb->un.varLdArea.dl_to_adr; 4006 |
3008 emlxs_format_load_area_cmd(mb, | 4007 emlxs_format_load_area_cmd(mbox, |
3009 NextAddr, 3010 EraseByteCount, 3011 ERASE_FLASH, 3012 0, 3013 DL_FROM_SLIM_OFFSET, 3014 AreaId, MBX_LOAD_AREA, CMD_CONTINUE_ERASE); 3015 | 4008 NextAddr, 4009 EraseByteCount, 4010 ERASE_FLASH, 4011 0, 4012 DL_FROM_SLIM_OFFSET, 4013 AreaId, MBX_LOAD_AREA, CMD_CONTINUE_ERASE); 4014 |
3016 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != | 4015 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != |
3017 MBX_SUCCESS) { 3018 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3019 "%x: Could not erase 2MB Flash2: Mailbox cmd=%x " 3020 "status=%x", FileType, mb->mbxCommand, 3021 mb->mbxStatus); 3022 3023 rval = EMLXS_IMAGE_FAILED; 3024 --- 14 unchanged lines hidden (view full) --- 3039 3040 for (i = 0; i < (DlCount / 4); i++) { 3041 *Dst = *Src; 3042 Dst++; 3043 Src++; 3044 } 3045 3046 WRITE_SLIM_COPY(hba, (uint32_t *)DataBuffer, | 4016 MBX_SUCCESS) { 4017 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 4018 "%x: Could not erase 2MB Flash2: Mailbox cmd=%x " 4019 "status=%x", FileType, mb->mbxCommand, 4020 mb->mbxStatus); 4021 4022 rval = EMLXS_IMAGE_FAILED; 4023 --- 14 unchanged lines hidden (view full) --- 4038 4039 for (i = 0; i < (DlCount / 4); i++) { 4040 *Dst = *Src; 4041 Dst++; 4042 Src++; 4043 } 4044 4045 WRITE_SLIM_COPY(hba, (uint32_t *)DataBuffer, |
3047 (volatile uint32_t *)((volatile char *)hba->slim_addr + 3048 sizeof (MAILBOX)), (DlCount / sizeof (uint32_t))); | 4046 (volatile uint32_t *)((volatile char *) 4047 hba->sli.sli3.slim_addr + sizeof (MAILBOX)), 4048 (DlCount / sizeof (uint32_t))); |
3049 3050 if ((RspProgress == RSP_DOWNLOAD_MORE) || (RspProgress == 0)) { | 4049 4050 if ((RspProgress == RSP_DOWNLOAD_MORE) || (RspProgress == 0)) { |
3051 emlxs_format_load_area_cmd(mb, | 4051 emlxs_format_load_area_cmd(mbox, |
3052 DlToAddr, 3053 DlCount, 3054 PROGRAM_FLASH, 3055 (DlByteCount) ? 0 : 1, 3056 DL_FROM_SLIM_OFFSET, 3057 AreaId, 3058 MBX_LOAD_AREA, 3059 (DlByteCount) ? CMD_DOWNLOAD : CMD_END_DOWNLOAD); 3060 | 4052 DlToAddr, 4053 DlCount, 4054 PROGRAM_FLASH, 4055 (DlByteCount) ? 0 : 1, 4056 DL_FROM_SLIM_OFFSET, 4057 AreaId, 4058 MBX_LOAD_AREA, 4059 (DlByteCount) ? CMD_DOWNLOAD : CMD_END_DOWNLOAD); 4060 |
3061 if (emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0) != | 4061 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0) != |
3062 MBX_SUCCESS) { 3063 EMLXS_MSGF(EMLXS_CONTEXT, 3064 &emlxs_download_failed_msg, 3065 "%x: Could not program 2MB Flash: Mailbox " 3066 "cmd=%x status=%x", FileType, 3067 mb->mbxCommand, mb->mbxStatus); 3068 3069 rval = EMLXS_IMAGE_FAILED; --- 4 unchanged lines hidden (view full) --- 3074 3075 RspProgress = mb->un.varLdArea.progress; 3076 3077 Buffer += DlCount; 3078 DlToAddr += DlCount; 3079 } 3080 3081#ifdef FMA_SUPPORT | 4062 MBX_SUCCESS) { 4063 EMLXS_MSGF(EMLXS_CONTEXT, 4064 &emlxs_download_failed_msg, 4065 "%x: Could not program 2MB Flash: Mailbox " 4066 "cmd=%x status=%x", FileType, 4067 mb->mbxCommand, mb->mbxStatus); 4068 4069 rval = EMLXS_IMAGE_FAILED; --- 4 unchanged lines hidden (view full) --- 4074 4075 RspProgress = mb->un.varLdArea.progress; 4076 4077 Buffer += DlCount; 4078 DlToAddr += DlCount; 4079 } 4080 4081#ifdef FMA_SUPPORT |
3082 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle) | 4082 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.slim_acc_handle) |
3083 != DDI_FM_OK) { 3084 EMLXS_MSGF(EMLXS_CONTEXT, 3085 &emlxs_invalid_access_handle_msg, NULL); 3086 3087 rval = EMLXS_IMAGE_FAILED; 3088 3089 goto EXIT_ABS_DOWNLOAD; 3090 } --- 26 unchanged lines hidden (view full) --- 3117 } 3118 3119 if (mbox) { 3120 kmem_free(mbox, sizeof (MAILBOXQ)); 3121 } 3122 3123 return (rval); 3124 | 4083 != DDI_FM_OK) { 4084 EMLXS_MSGF(EMLXS_CONTEXT, 4085 &emlxs_invalid_access_handle_msg, NULL); 4086 4087 rval = EMLXS_IMAGE_FAILED; 4088 4089 goto EXIT_ABS_DOWNLOAD; 4090 } --- 26 unchanged lines hidden (view full) --- 4117 } 4118 4119 if (mbox) { 4120 kmem_free(mbox, sizeof (MAILBOXQ)); 4121 } 4122 4123 return (rval); 4124 |
3125} /* emlxs_proc_abs_2mb() */ | 4125} /* emlxs_proc_abs_2mb() */ |
3126 3127 3128static void | 4126 4127 4128static void |
3129emlxs_format_load_area_cmd(MAILBOX * mb, | 4129emlxs_format_load_area_cmd(MAILBOXQ * mbq, |
3130 uint32_t Base, 3131 uint32_t DlByteCount, 3132 uint32_t Function, 3133 uint32_t Complete, 3134 uint32_t DataOffset, uint32_t AreaId, uint8_t MbxCmd, uint32_t StepCmd) 3135{ | 4130 uint32_t Base, 4131 uint32_t DlByteCount, 4132 uint32_t Function, 4133 uint32_t Complete, 4134 uint32_t DataOffset, uint32_t AreaId, uint8_t MbxCmd, uint32_t StepCmd) 4135{ |
4136 MAILBOX *mb = (MAILBOX *)mbq; 4137 |
|
3136 bzero((void *)mb, MAILBOX_CMD_BSIZE); 3137 3138 mb->mbxCommand = MbxCmd; 3139 mb->mbxOwner = OWN_HOST; 3140 mb->un.varLdArea.update_flash = 1; 3141 mb->un.varLdArea.erase_or_prog = Function; 3142 mb->un.varLdArea.dl_to_adr = Base; 3143 mb->un.varLdArea.dl_len = DlByteCount; 3144 mb->un.varLdArea.load_cmplt = Complete; 3145 mb->un.varLdArea.method = DL_FROM_SLIM; 3146 mb->un.varLdArea.area_id = AreaId; 3147 mb->un.varLdArea.step = StepCmd; 3148 mb->un.varLdArea.un.dl_from_slim_offset = DataOffset; | 4138 bzero((void *)mb, MAILBOX_CMD_BSIZE); 4139 4140 mb->mbxCommand = MbxCmd; 4141 mb->mbxOwner = OWN_HOST; 4142 mb->un.varLdArea.update_flash = 1; 4143 mb->un.varLdArea.erase_or_prog = Function; 4144 mb->un.varLdArea.dl_to_adr = Base; 4145 mb->un.varLdArea.dl_len = DlByteCount; 4146 mb->un.varLdArea.load_cmplt = Complete; 4147 mb->un.varLdArea.method = DL_FROM_SLIM; 4148 mb->un.varLdArea.area_id = AreaId; 4149 mb->un.varLdArea.step = StepCmd; 4150 mb->un.varLdArea.un.dl_from_slim_offset = DataOffset; |
4151 mbq->mbox_cmpl = NULL; |
|
3149 | 4152 |
3150} /* emlxs_format_load_area_cmd() */ | 4153} /* emlxs_format_load_area_cmd() */ |
3151 3152 3153/* ARGSUSED */ 3154static uint32_t 3155emlxs_build_parms_2mb_bwc(emlxs_hba_t *hba, 3156 PAIF_HDR AifHdr, uint32_t extType, PWAKE_UP_PARMS AbsWakeUpParms) 3157{ 3158 emlxs_port_t *port = &PPORT; --- 46 unchanged lines hidden (view full) --- 3205 pId[1]; 3206 } 3207 } 3208 } 3209 } 3210 3211 return (TRUE); 3212 | 4154 4155 4156/* ARGSUSED */ 4157static uint32_t 4158emlxs_build_parms_2mb_bwc(emlxs_hba_t *hba, 4159 PAIF_HDR AifHdr, uint32_t extType, PWAKE_UP_PARMS AbsWakeUpParms) 4160{ 4161 emlxs_port_t *port = &PPORT; --- 46 unchanged lines hidden (view full) --- 4208 pId[1]; 4209 } 4210 } 4211 } 4212 } 4213 4214 return (TRUE); 4215 |
3213} /* emlxs_build_parms_2mb_bwc() */ | 4216} /* emlxs_build_parms_2mb_bwc() */ |
3214 3215 3216/* ARGSUSED */ 3217static uint32_t 3218emlxs_build_parms_2mb_dwc(emlxs_hba_t *hba, 3219 caddr_t Buffer, 3220 uint32_t BufferSize, 3221 PAIF_HDR AifHeader, --- 125 unchanged lines hidden (view full) --- 3347 } 3348 } 3349 } 3350 } 3351 3352 return (ChangeParams); 3353 3354 | 4217 4218 4219/* ARGSUSED */ 4220static uint32_t 4221emlxs_build_parms_2mb_dwc(emlxs_hba_t *hba, 4222 caddr_t Buffer, 4223 uint32_t BufferSize, 4224 PAIF_HDR AifHeader, --- 125 unchanged lines hidden (view full) --- 4350 } 4351 } 4352 } 4353 } 4354 4355 return (ChangeParams); 4356 4357 |
3355} /* emlxs_build_parms_2mb_dwc() */ | 4358} /* emlxs_build_parms_2mb_dwc() */ |
3356 3357 3358extern uint32_t 3359emlxs_get_max_sram(emlxs_hba_t *hba, uint32_t *MaxRbusSize, 3360 uint32_t *MaxIbusSize) 3361{ 3362 emlxs_port_t *port = &PPORT; 3363 MAILBOXQ *mbox; --- 6 unchanged lines hidden (view full) --- 3370 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3371 "Unable to allocate mailbox buffer."); 3372 3373 return (1); 3374 } 3375 3376 mb = (MAILBOX *)mbox; 3377 | 4359 4360 4361extern uint32_t 4362emlxs_get_max_sram(emlxs_hba_t *hba, uint32_t *MaxRbusSize, 4363 uint32_t *MaxIbusSize) 4364{ 4365 emlxs_port_t *port = &PPORT; 4366 MAILBOXQ *mbox; --- 6 unchanged lines hidden (view full) --- 4373 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 4374 "Unable to allocate mailbox buffer."); 4375 4376 return (1); 4377 } 4378 4379 mb = (MAILBOX *)mbox; 4380 |
3378 emlxs_format_dump(mb, DMP_MEM_REG, 0, 2, MAX_RBUS_SRAM_SIZE_ADR); | 4381 emlxs_format_dump(hba, mbox, DMP_MEM_REG, 0, 2, MAX_RBUS_SRAM_SIZE_ADR); |
3379 | 4382 |
3380 if ((rval = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0)) != | 4383 if ((rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_WAIT, 0)) != |
3381 MBX_SUCCESS) { 3382 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 3383 "Unable to get SRAM size: Mailbox cmd=%x status=%x", 3384 mb->mbxCommand, mb->mbxStatus); 3385 3386 rval = 1; 3387 3388 goto Exit_Function; 3389 } 3390 | 4384 MBX_SUCCESS) { 4385 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_download_failed_msg, 4386 "Unable to get SRAM size: Mailbox cmd=%x status=%x", 4387 mb->mbxCommand, mb->mbxStatus); 4388 4389 rval = 1; 4390 4391 goto Exit_Function; 4392 } 4393 |
3391 Uptr = (uint32_t *)&mb->un.varDmp.resp_offset; | 4394 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 4395 EMLXS_MPDATA_SYNC(hba->sli.sli4.dump_region.dma_handle, 0, 4396 hba->sli.sli4.dump_region.size, DDI_DMA_SYNC_FORKERNEL); 4397 Uptr = (uint32_t *)hba->sli.sli4.dump_region.virt; 4398 } else { 4399 Uptr = (uint32_t *)&mb->un.varDmp.resp_offset; 4400 } |
3392 3393 *MaxRbusSize = Uptr[0]; 3394 *MaxIbusSize = Uptr[1]; 3395 3396Exit_Function: 3397 3398 if (mbox) { 3399 kmem_free(mbox, sizeof (MAILBOXQ)); 3400 } 3401 3402 return (rval); 3403 | 4401 4402 *MaxRbusSize = Uptr[0]; 4403 *MaxIbusSize = Uptr[1]; 4404 4405Exit_Function: 4406 4407 if (mbox) { 4408 kmem_free(mbox, sizeof (MAILBOXQ)); 4409 } 4410 4411 return (rval); 4412 |
3404} /* emlxs_get_max_sram() */ | 4413} /* emlxs_get_max_sram() */ |
3405 3406 3407static uint32_t 3408emlxs_kern_check(emlxs_hba_t *hba, uint32_t version) 3409{ 3410 uint8_t *ptr; 3411 uint8_t ver; 3412 3413 ver = version & 0xff; 3414 ptr = hba->model_info.pt_FF; 3415 3416 while (*ptr) { 3417 if (*ptr++ == ver) { 3418 return (1); 3419 } 3420 } 3421 3422 return (0); 3423 | 4414 4415 4416static uint32_t 4417emlxs_kern_check(emlxs_hba_t *hba, uint32_t version) 4418{ 4419 uint8_t *ptr; 4420 uint8_t ver; 4421 4422 ver = version & 0xff; 4423 ptr = hba->model_info.pt_FF; 4424 4425 while (*ptr) { 4426 if (*ptr++ == ver) { 4427 return (1); 4428 } 4429 } 4430 4431 return (0); 4432 |
3424} /* emlxs_kern_check() */ | 4433} /* emlxs_kern_check() */ |
3425 3426static uint32_t 3427emlxs_stub_check(emlxs_hba_t *hba, uint32_t version) 3428{ 3429 uint8_t *ptr; 3430 uint8_t ver; 3431 3432 ver = version & 0xff; 3433 ptr = hba->model_info.pt_2; 3434 3435 while (*ptr) { 3436 if (*ptr++ == ver) { 3437 return (1); 3438 } 3439 } 3440 3441 return (0); 3442 | 4434 4435static uint32_t 4436emlxs_stub_check(emlxs_hba_t *hba, uint32_t version) 4437{ 4438 uint8_t *ptr; 4439 uint8_t ver; 4440 4441 ver = version & 0xff; 4442 ptr = hba->model_info.pt_2; 4443 4444 while (*ptr) { 4445 if (*ptr++ == ver) { 4446 return (1); 4447 } 4448 } 4449 4450 return (0); 4451 |
3443} /* emlxs_stub_check() */ | 4452} /* emlxs_stub_check() */ |
3444 3445static uint32_t 3446emlxs_bios_check(emlxs_hba_t *hba, uint32_t version) 3447{ 3448 uint8_t *ptr; 3449 uint8_t ver; 3450 3451 ver = version & 0xff; 3452 ptr = hba->model_info.pt_3; 3453 3454 while (*ptr) { 3455 if (*ptr++ == ver) { 3456 return (1); 3457 } 3458 } 3459 3460 return (0); 3461 | 4453 4454static uint32_t 4455emlxs_bios_check(emlxs_hba_t *hba, uint32_t version) 4456{ 4457 uint8_t *ptr; 4458 uint8_t ver; 4459 4460 ver = version & 0xff; 4461 ptr = hba->model_info.pt_3; 4462 4463 while (*ptr) { 4464 if (*ptr++ == ver) { 4465 return (1); 4466 } 4467 } 4468 4469 return (0); 4470 |
3462} /* emlxs_bios_check() */ | 4471} /* emlxs_bios_check() */ |
3463 3464static uint32_t 3465emlxs_sli1_check(emlxs_hba_t *hba, uint32_t version) 3466{ 3467 uint8_t *ptr; 3468 uint8_t ver; 3469 3470 ver = version & 0xff; 3471 ptr = hba->model_info.pt_6; 3472 3473 while (*ptr) { 3474 if (*ptr++ == ver) { 3475 return (1); 3476 } 3477 } 3478 3479 return (0); 3480 | 4472 4473static uint32_t 4474emlxs_sli1_check(emlxs_hba_t *hba, uint32_t version) 4475{ 4476 uint8_t *ptr; 4477 uint8_t ver; 4478 4479 ver = version & 0xff; 4480 ptr = hba->model_info.pt_6; 4481 4482 while (*ptr) { 4483 if (*ptr++ == ver) { 4484 return (1); 4485 } 4486 } 4487 4488 return (0); 4489 |
3481} /* emlxs_sli1_check() */ | 4490} /* emlxs_sli1_check() */ |
3482 3483static uint32_t 3484emlxs_sli2_check(emlxs_hba_t *hba, uint32_t version) 3485{ 3486 uint8_t *ptr; 3487 uint8_t ver; 3488 3489 ver = version & 0xff; 3490 ptr = hba->model_info.pt_7; 3491 3492 while (*ptr) { 3493 if (*ptr++ == ver) { 3494 return (1); 3495 } 3496 } 3497 3498 return (0); 3499 | 4491 4492static uint32_t 4493emlxs_sli2_check(emlxs_hba_t *hba, uint32_t version) 4494{ 4495 uint8_t *ptr; 4496 uint8_t ver; 4497 4498 ver = version & 0xff; 4499 ptr = hba->model_info.pt_7; 4500 4501 while (*ptr) { 4502 if (*ptr++ == ver) { 4503 return (1); 4504 } 4505 } 4506 4507 return (0); 4508 |
3500} /* emlxs_sli2_check() */ | 4509} /* emlxs_sli2_check() */ |
3501 3502static uint32_t 3503emlxs_sli3_check(emlxs_hba_t *hba, uint32_t version) 3504{ 3505 uint8_t *ptr; 3506 uint8_t ver; 3507 3508 ver = version & 0xff; 3509 ptr = hba->model_info.pt_B; 3510 3511 while (*ptr) { 3512 if (*ptr++ == ver) { 3513 return (1); 3514 } 3515 } 3516 3517 return (0); 3518 | 4510 4511static uint32_t 4512emlxs_sli3_check(emlxs_hba_t *hba, uint32_t version) 4513{ 4514 uint8_t *ptr; 4515 uint8_t ver; 4516 4517 ver = version & 0xff; 4518 ptr = hba->model_info.pt_B; 4519 4520 while (*ptr) { 4521 if (*ptr++ == ver) { 4522 return (1); 4523 } 4524 } 4525 4526 return (0); 4527 |
3519} /* emlxs_sli3_check() */ | 4528} /* emlxs_sli3_check() */ |
3520 3521 3522static uint32_t 3523emlxs_sli4_check(emlxs_hba_t *hba, uint32_t version) 3524{ 3525 uint8_t *ptr; 3526 uint8_t ver; 3527 3528 ver = version & 0xff; 3529 ptr = hba->model_info.pt_E; 3530 3531 while (*ptr) { 3532 if (*ptr++ == ver) { 3533 return (1); 3534 } 3535 } 3536 3537 return (0); 3538 | 4529 4530 4531static uint32_t 4532emlxs_sli4_check(emlxs_hba_t *hba, uint32_t version) 4533{ 4534 uint8_t *ptr; 4535 uint8_t ver; 4536 4537 ver = version & 0xff; 4538 ptr = hba->model_info.pt_E; 4539 4540 while (*ptr) { 4541 if (*ptr++ == ver) { 4542 return (1); 4543 } 4544 } 4545 4546 return (0); 4547 |
3539} /* emlxs_sli4_check() */ | 4548} /* emlxs_sli4_check() */ |
3540 3541 3542static uint32_t 3543emlxs_sbus_fcode_check(emlxs_hba_t *hba, uint32_t version) 3544{ 3545 uint8_t *ptr; 3546 uint8_t ver; 3547 3548 ver = version & 0xff; 3549 ptr = hba->model_info.pt_A; 3550 3551 while (*ptr) { 3552 if (*ptr++ == ver) { 3553 return (1); 3554 } 3555 } 3556 3557 return (0); 3558 | 4549 4550 4551static uint32_t 4552emlxs_sbus_fcode_check(emlxs_hba_t *hba, uint32_t version) 4553{ 4554 uint8_t *ptr; 4555 uint8_t ver; 4556 4557 ver = version & 0xff; 4558 ptr = hba->model_info.pt_A; 4559 4560 while (*ptr) { 4561 if (*ptr++ == ver) { 4562 return (1); 4563 } 4564 } 4565 4566 return (0); 4567 |
3559} /* emlxs_sbus_fcode_check() */ | 4568} /* emlxs_sbus_fcode_check() */ |
3560 3561static uint32_t 3562emlxs_type_check(uint32_t type) 3563{ 3564 if (type == 0xff) { 3565 return (KERNEL_CODE); 3566 } 3567 3568 if (type >= MAX_PROG_TYPES) { 3569 return (RESERVED_D); 3570 } 3571 3572 return (type); 3573 | 4569 4570static uint32_t 4571emlxs_type_check(uint32_t type) 4572{ 4573 if (type == 0xff) { 4574 return (KERNEL_CODE); 4575 } 4576 4577 if (type >= MAX_PROG_TYPES) { 4578 return (RESERVED_D); 4579 } 4580 4581 return (type); 4582 |
3574} /* emlxs_type_check() */ | 4583} /* emlxs_type_check() */ |
3575 3576 3577 3578extern int32_t 3579emlxs_boot_code_disable(emlxs_hba_t *hba) 3580{ 3581 emlxs_port_t *port = &PPORT; 3582 PROG_ID Id; --- 34 unchanged lines hidden (view full) --- 3617 emlxs_decode_version(hba->wakeup_parms.u0.boot_bios_wd[0], 3618 vpd->boot_version); 3619 /* (void) strcpy(vpd->fcode_version, vpd->boot_version); */ 3620 3621 /* Return the result */ 3622 return ((hba->wakeup_parms.u0.boot_bios_wd[0] == 0) ? 3623 FC_SUCCESS : FC_FAILURE); 3624 | 4584 4585 4586 4587extern int32_t 4588emlxs_boot_code_disable(emlxs_hba_t *hba) 4589{ 4590 emlxs_port_t *port = &PPORT; 4591 PROG_ID Id; --- 34 unchanged lines hidden (view full) --- 4626 emlxs_decode_version(hba->wakeup_parms.u0.boot_bios_wd[0], 4627 vpd->boot_version); 4628 /* (void) strcpy(vpd->fcode_version, vpd->boot_version); */ 4629 4630 /* Return the result */ 4631 return ((hba->wakeup_parms.u0.boot_bios_wd[0] == 0) ? 4632 FC_SUCCESS : FC_FAILURE); 4633 |
3625} /* emlxs_boot_code_disable() */ | 4634} /* emlxs_boot_code_disable() */ |
3626 3627 3628extern int32_t 3629emlxs_boot_code_enable(emlxs_hba_t *hba) 3630{ 3631 emlxs_port_t *port = &PPORT; 3632 emlxs_vpd_t *vpd; 3633 PROG_ID load_list[MAX_LOAD_ENTRY]; --- 52 unchanged lines hidden (view full) --- 3686 emlxs_decode_version(hba->wakeup_parms.u0.boot_bios_wd[0], 3687 vpd->boot_version); 3688 /* (void) strcpy(vpd->fcode_version, vpd->boot_version); */ 3689 3690 /* return the result */ 3691 return ((hba->wakeup_parms.u0.boot_bios_wd[0] != 0) ? 3692 FC_SUCCESS : FC_FAILURE); 3693 | 4635 4636 4637extern int32_t 4638emlxs_boot_code_enable(emlxs_hba_t *hba) 4639{ 4640 emlxs_port_t *port = &PPORT; 4641 emlxs_vpd_t *vpd; 4642 PROG_ID load_list[MAX_LOAD_ENTRY]; --- 52 unchanged lines hidden (view full) --- 4695 emlxs_decode_version(hba->wakeup_parms.u0.boot_bios_wd[0], 4696 vpd->boot_version); 4697 /* (void) strcpy(vpd->fcode_version, vpd->boot_version); */ 4698 4699 /* return the result */ 4700 return ((hba->wakeup_parms.u0.boot_bios_wd[0] != 0) ? 4701 FC_SUCCESS : FC_FAILURE); 4702 |
3694} /* emlxs_boot_code_enable() */ | 4703} /* emlxs_boot_code_enable() */ |
3695 3696 3697 3698extern int32_t 3699emlxs_boot_code_state(emlxs_hba_t *hba) 3700{ 3701 emlxs_port_t *port = &PPORT; 3702 --- 4 unchanged lines hidden (view full) --- 3707 3708 return (FC_FAILURE); 3709 } 3710 3711 /* return the result */ 3712 return ((hba->wakeup_parms.u0.boot_bios_wd[0] != 0) ? 3713 FC_SUCCESS : FC_FAILURE); 3714 | 4704 4705 4706 4707extern int32_t 4708emlxs_boot_code_state(emlxs_hba_t *hba) 4709{ 4710 emlxs_port_t *port = &PPORT; 4711 --- 4 unchanged lines hidden (view full) --- 4716 4717 return (FC_FAILURE); 4718 } 4719 4720 /* return the result */ 4721 return ((hba->wakeup_parms.u0.boot_bios_wd[0] != 0) ? 4722 FC_SUCCESS : FC_FAILURE); 4723 |
3715} /* emlxs_boot_code_state() */ | 4724} /* emlxs_boot_code_state() */ |