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() */