?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add UNLEASHED_OBJ to unleashed.mk
[unleashed/tickless.git] / usr / src / cmd / luxadm / qlgcupdate.c
blob404f4b7c06592649eb144f4395909125b2784631
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
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * I18N message number ranges
28 * This file: 21000 - 21499
29 * Shared common messages: 1 - 1999
30 */
31
32 /*
33 * Functions to support the download of FCode to PCI HBAs
34 * Qlogic ISP21XX/22XX boards: FC100/P single port, ISP2200 dual port
35 * and Emulex cards
36 */
37 #include <errno.h>
38 #include <ctype.h>
39 #include <fcntl.h>
40 #include <stdio.h>
41 #include <string.h>
42 #include <strings.h>
43 #include <unistd.h>
44 #include <stdlib.h>
45 #include <sys/stat.h>
46 #include <limits.h>
47 #include <signal.h>
48 #include <dirent.h>
49 #include <nl_types.h>
50 #include <utmpx.h>
51 #include <sys/mnttab.h>
52 #include <sys/file.h>
53 #include <sys/mtio.h>
54 #include <sys/scsi/impl/uscsi.h>
55 #include <sys/fibre-channel/fcio.h>
56 #include <stgcom.h>
57 #include <sys/scsi/adapters/ifpio.h>
58 #include <libdevinfo.h>
59 #include "luxadm.h"
60
61 /* Error codes - used by the fcode_load_file routine */
62 #define FCODE_SUCCESS 0 /* successful completion */
63 #define FCODE_LOAD_FAILURE 1 /* general failure */
64 #define FCODE_IOCTL_FAILURE 2 /* FCODE ioctl download failure */
65
66 #define HBA_MAX 128
67 #define FCODE_HDR 200
68 #define MAX_RETRIES 3
69 #define MAX_WAIT_TIME 30
70
71 /*
72 * EMULEX Fcode attributes
73 */
74 #define EMULEX_FCODE_VERSION_LENGTH 16
75 #define EMULEX_READ_BUFFER_SIZE 128
76
77 /* Emulex specific error codes */
78 #define EMLX_ERRNO_START 0x100
79
80 /* Diagnostic error codes */
81 #define EMLX_TEST_FAILED (EMLX_ERRNO_START + 0)
82
83 /* Download image contains bad data */
84 #define EMLX_IMAGE_BAD (EMLX_ERRNO_START + 1)
85 /* Download image not compatible with current hardware */
86 #define EMLX_IMAGE_INCOMPATIBLE (EMLX_ERRNO_START + 2)
87 /* Unable to take adapter offline */
88 #define EMLX_IMAGE_FAILED (EMLX_ERRNO_START + 3)
89 /* Image download failed */
90 #define EMLX_OFFLINE_FAILED (EMLX_ERRNO_START + 4)
91
92
93
94
95 /*
96 * This is just a random value chosen to identify Sbus Fcodes. Sbus FCode
97 * for Ivory is based on a 2200 chip but this value does not reflect that.
98 */
99 #define SBUS_CHIP_ID 0x1969
100 #define IVORY_BUS "/sbus@"
101 #define IVORY_DRVR "/SUNW,qlc@"
102
103 /* Global variables */
104 static char fc_trans[] = "SUNW,ifp"; /* fibre channel transport */
105 static char fp_trans[] = "SUNW,qlc"; /* fca layer driver */
106 static char fp_trans_id[] = "fp@"; /* transport layer id */
107 static char qlgc2100[] = "FC100/P"; /* product name for 2100 */
108 static char qlgc2200[] = "ISP2200"; /* product name for 2200 */
109 static char qlgc2300[] = "ISP2300"; /* product name for 2300 */
110 static char qlgc2312[] = "ISP2312"; /* product name for 2312 */
111 /*
112 * The variable qlgc2200Sbus represents the string which is always the
113 * starting string of the version information in an ISP2200 Sbus Fcode.
114 */
115 static char qlgc2200Sbus[] = "ISP2200 Sbus FC-AL Host Adapter Driver";
116 static char pcibus_list[HBA_MAX][PATH_MAX];
117 /* Internal functions */
118 static int q_load_file(int, char *);
119 static int q_getbootdev(uchar_t *);
120 static int q_getdevctlpath(char *, int *);
121 static int q_warn(int);
122 static int q_findversion(int, int, uchar_t *, uint16_t *);
123 static int q_findfileversion(char *, uchar_t *, uint16_t *, int, int *);
124 static int q_findSbusfile(int, int *);
125 static int memstrstr(char *, char *, int, int);
126 static int fcode_load_file(int, char *, int *);
127
128 /*
129 * Functions to support Fcode download for Emulex HBAs
130 */
131 static int emulex_fcodeversion(di_node_t, uchar_t *);
132 static void handle_emulex_error(int, char *);
133
134 /*
135 * Searches for and updates the cards. This is the "main" function
136 * and will give the output to the user by calling the subfunctions.
137 * args: FCode file; if NULL only the current FCode version is printed
138 */
139 int
140 q_qlgc_update(unsigned int verbose, char *file)
141 /*ARGSUSED*/
142 {
143 int fd, fcode_fd = -1, errnum = 0, devcnt = 0, retval = 0, isSbus = 0;
144 int sbus_off;
145 uint_t i, fflag = 0;
146 uint16_t chip_id = 0, file_id = 0;
147 uchar_t fcode_buf[FCODE_HDR];
148 static uchar_t bootpath[PATH_MAX];
149 static uchar_t version[MAXNAMELEN], version_file[MAXNAMELEN];
150 char devpath[PATH_MAX], tmppath[PATH_MAX];
151 void (*sigint)(); /* to store default SIGTERM setting */
152 static struct utmpx *utmpp = NULL; /* pointer for getutxent() */
153 char *ptr1, *ptr2;
154 char phys_path[PATH_MAX];
155 /*
156 * The variables port1 and port2 are used to store the bus id
157 * e.g. the bus id for this path:
158 * /devices/sbus@12,0/SUNW,qlc@2,30000/fp@0,0:devctl
159 * is "sbus@12". They are initialized to a random value and are
160 * set such that they are not equal initially.
161 */
162 static char port1[MAXNAMELEN] = {NULL};
163 static char port2[MAXNAMELEN] = {NULL};
164
165 if (file) {
166 fflag++;
167
168 /* check for a valid file */
169 if ((fcode_fd = open(file, O_RDONLY)) < 0) {
170 (void) fprintf(stderr,
171 MSGSTR(21000, "Error: Could not open %s\n"), file);
172 return (1);
173 }
174 if (read(fcode_fd, fcode_buf, FCODE_HDR) != FCODE_HDR) {
175 perror(MSGSTR(21001, "read"));
176 (void) close(fcode_fd);
177 return (1);
178 }
179
180 /*
181 * Check if it's SBUS FCode by calling q_findSbusfile
182 * if it is then isSbus will be 1, if not it will be 0
183 * in case of an error, it will be -1
184 */
185 isSbus = q_findSbusfile(fcode_fd, &sbus_off);
186 if (isSbus == -1) {
187 (void) close(fcode_fd);
188 return (1);
189 }
190
191 /*
192 * FCode header check - make sure it's PCI FCode
193 * Structure of FCode header (byte# refers to byte numbering
194 * in FCode spec, not the byte# of our fcode_buf buffer):
195 * header byte 00 0x55 prom signature byte one
196 * byte 01 0xaa prom signature byte two
197 * data byte 00-03 P C I R
198 * OR
199 * header byte 32 0x55
200 * byte 33 0xaa
201 * data byte 60-63 P C I R
202 * The second format with an offset of 32 is used for ifp prom
203 */
204 if (!(((fcode_buf[0x00] == 0x55) &&
205 (fcode_buf[0x01] == 0xaa) &&
206 (fcode_buf[0x1c] == 'P') &&
207 (fcode_buf[0x1d] == 'C') &&
208 (fcode_buf[0x1e] == 'I') &&
209 (fcode_buf[0x1f] == 'R')) ||
210
211 ((fcode_buf[0x20] == 0x55) &&
212 (fcode_buf[0x21] == 0xaa) &&
213 (fcode_buf[0x3c] == 'P') &&
214 (fcode_buf[0x3d] == 'C') &&
215 (fcode_buf[0x3e] == 'I') &&
216 (fcode_buf[0x3f] == 'R')) ||
217
218 (isSbus))) {
219 (void) fprintf(stderr, MSGSTR(21002,
220 "Error: %s is not a valid FC100/P, "
221 "ISP2200, ISP23xx FCode file.\n"),
222 file);
223 (void) close(fcode_fd);
224 return (1);
225 }
226
227 /* check for single user mode */
228 while ((utmpp = getutxent()) != NULL) {
229 if (strstr(utmpp->ut_line, "run-level") &&
230 (strcmp(utmpp->ut_line, "run-level S") &&
231 strcmp(utmpp->ut_line, "run-level 1"))) {
232 if (q_warn(1)) {
233 (void) endutxent();
234 (void) close(fcode_fd);
235 return (1);
236 }
237 break;
238 }
239 }
240 (void) endutxent();
241
242 /* get bootpath */
243 if (!q_getbootdev((uchar_t *)&bootpath[0]) &&
244 getenv("_LUX_D_DEBUG") != NULL) {
245 (void) fprintf(stdout, " Bootpath: %s\n", bootpath);
246 }
247 }
248 /*
249 * Get count of, and names of PCI slots with ifp device control
250 * (devctl) nodes. Search /devices.
251 */
252 (void) strcpy(devpath, "/devices");
253 if (q_getdevctlpath(devpath, (int *)&devcnt) == 0) {
254 (void) fprintf(stdout, MSGSTR(21003,
255 "\n Found Path to %d FC100/P, ISP2200, ISP23xx Devices\n"),
256 devcnt);
257 } else {
258 (void) fprintf(stderr, MSGSTR(21004,
259 "Error: Could not get /devices path to FC100/P,"
260 "ISP2200, ISP23xx Cards.\n"));
261 retval++;
262 }
263
264 for (i = 0; i < devcnt; i++) {
265
266 (void) strncpy((char *)phys_path, &pcibus_list[i][0],
267 strlen(&pcibus_list[i][0]));
268 if (fflag && (strstr((char *)bootpath,
269 strtok((char *)phys_path, ":")) != NULL)) {
270 (void) fprintf(stderr,
271 MSGSTR(21005, "Ignoring %s (bootpath)\n"),
272 &pcibus_list[i][0]);
273 continue;
274 }
275
276 (void) fprintf(stdout,
277 MSGSTR(21006, "\n Opening Device: %s\n"), &pcibus_list[i][0]);
278 /* Check if the device is valid */
279 if ((fd = open(&pcibus_list[i][0], O_RDWR)) < 0) {
280 (void) fprintf(stderr,
281 MSGSTR(21000, "Error: Could not open %s\n"),
282 &pcibus_list[i][0]);
283 retval++;
284 continue;
285 }
286 (void) close(fd);
287 /*
288 * Check FCode version present on the adapter (at last boot)
289 */
290 if (q_findversion(verbose, i, (uchar_t *)&version[0],
291 &chip_id) == 0) {
292 if (strlen((char *)version) == 0) {
293 (void) fprintf(stdout, MSGSTR(21007,
294 " Detected FCode Version:\tNo version available for this FCode\n"));
295 } else {
296 (void) fprintf(stdout, MSGSTR(21008,
297 " Detected FCode Version:\t%s\n"), version);
298 }
299 } else {
300 chip_id = 0x0;
301 }
302
303 if (fflag) {
304 /*
305 * For ISP2200, Sbus HBA, do just 1 download
306 * for both the ports (dual port HBA)
307 * Here it is assumed that readdir() always
308 * returns the paths in pcibus_list[] in the
309 * sorted order.
310 */
311 (void) strcpy(tmppath, pcibus_list[i]);
312 if (ptr1 = strstr(tmppath, IVORY_BUS)) {
313 if (ptr2 = strstr(ptr1, IVORY_DRVR)) {
314 ptr2 = strchr(ptr2, ',');
315 if (ptr2 = strchr(++ptr2, ',')) {
316 *ptr2 = '\0';
317 }
318 }
319 (void) strcpy(port2, ptr1);
320 if (strcmp(port1, port2) == 0) {
321 (void) fprintf(stdout, MSGSTR(21037,
322 "/n New FCode has already been downloaded "
323 "to this ISP2200 SBus HBA Card.\n"
324 "It is sufficient to download to one "
325 "port of the ISP2200 SBus HBA Card. "
326 "Moving on...\n"));
327 continue;
328 }
329 }
330 /*
331 * Check version of the supplied FCode file (once)
332 */
333 if ((file_id != 0 && version_file != NULL) ||
334 (q_findfileversion((char *)
335 &fcode_buf[0], (uchar_t *)&version_file[0],
336 &file_id, isSbus, &sbus_off) == 0)) {
337 (void) fprintf(stdout, MSGSTR(21009,
338 " New FCode Version:\t\t%s\n"),
339 version_file);
340 } else {
341 (void) close(fcode_fd);
342 return (1);
343 }
344
345 /*
346 * Load the New FCode
347 * Give warning if file doesn't appear to be correct
348 *
349 */
350 if (chip_id == 0) {
351 errnum = 2; /* can't get chip_id */
352 retval++;
353 } else if (chip_id - file_id != 0) {
354 errnum = 3; /* file/card mismatch */
355 retval++;
356 } else {
357 errnum = 0; /* everything is ok */
358 }
359
360 if (!q_warn(errnum)) {
361 /* Disable user-interrupt Control-C */
362 sigint =
363 (void (*)(int)) signal(SIGINT, SIG_IGN);
364
365 /* Load FCode */
366 (void) fprintf(stdout, MSGSTR(21010,
367 " Loading FCode: %s\n"), file);
368
369 if (q_load_file(fcode_fd,
370 &pcibus_list[i][0]) == 0) {
371 (void) fprintf(stdout, MSGSTR(21011,
372 " Successful FCode download: %s\n"),
373 &pcibus_list[i][0]);
374 (void) strcpy(port1, port2);
375 } else {
376 (void) fprintf(stderr, MSGSTR(21012,
377 "Error: FCode download failed: %s\n"),
378 &pcibus_list[i][0]);
379 retval++;
380 }
381 /* Restore SIGINT (user interrupt) setting */
382 (void) signal(SIGINT, sigint);
383 }
384 }
385 }
386 (void) fprintf(stdout, " ");
387 (void) fprintf(stdout, MSGSTR(125, "Complete\n"));
388 if (fcode_fd != -1)
389 (void) close(fcode_fd);
390 return (retval);
391 }
392
393
394 /*
395 * Retrieve the version banner from the card
396 * uses ioctl: FCIO_FCODE_MCODE_VERSION FCode revision
397 */
398 static int
399 q_findversion(int verbose, int index, uchar_t *version, uint16_t *chip_id)
400 /*ARGSUSED*/
401 {
402 int fd, ntries;
403 struct ifp_fm_version *version_buffer = NULL;
404 char prom_ver[100] = {NULL};
405 char mcode_ver[100] = {NULL};
406 fcio_t fcio;
407
408 if (strstr(&pcibus_list[index][0], fc_trans)) {
409
410 if ((fd = open(&pcibus_list[index][0], O_RDWR)) < 0) {
411 (void) fprintf(stderr,
412 MSGSTR(21000, "Error: Could not open %s\n"),
413 &pcibus_list[index][0]);
414 return (1);
415 }
416
417 if ((version_buffer = (struct ifp_fm_version *)malloc(
418 sizeof (struct ifp_fm_version))) == NULL) {
419 (void) fprintf(stderr,
420 MSGSTR(21013, "Error: Memory allocation failed\n"));
421 (void) close(fd);
422 return (1);
423 }
424
425 version_buffer->fcode_ver = (char *)version;
426 version_buffer->mcode_ver = mcode_ver;
427 version_buffer->prom_ver = prom_ver;
428 version_buffer->fcode_ver_len = MAXNAMELEN - 1;
429 version_buffer->mcode_ver_len = 100;
430 version_buffer->prom_ver_len = 100;
431
432 if (ioctl(fd, FCIO_FCODE_MCODE_VERSION, version_buffer) < 0) {
433 (void) fprintf(stderr, MSGSTR(21014,
434 "Error: Driver interface FCIO_FCODE_MCODE_VERSION failed\n"));
435 free(version_buffer);
436 (void) close(fd);
437 return (1);
438 }
439 version[version_buffer->fcode_ver_len] = '\0';
440
441 /* Need a way to get card MCODE (firmware) to track certain HW bugs */
442 if (getenv("_LUX_D_DEBUG") != NULL) {
443 (void) fprintf(stdout, " Device %i: QLGC chip_id %x\n",
444 index+1, *chip_id);
445 (void) fprintf(stdout, " FCode:%s\n MCODE:%s\n PROM:%s\n",
446 (char *)version, mcode_ver, prom_ver);
447 }
448 free(version_buffer);
449
450 } else if (strstr(&pcibus_list[index][0], fp_trans)) {
451 /*
452 * Get the fcode and prom's fw version
453 * using the fp ioctls. Currently, we pass
454 * only the fcode version to the calling function
455 * and ignore the FW version (using the existing
456 * implementation).
457 */
458
459 if ((fd = open(&pcibus_list[index][0], O_RDWR)) < 0) {
460 (void) fprintf(stderr,
461 MSGSTR(4511, "Could not open %s\n"),
462 &pcibus_list[index][0]);
463 (void) close(fd);
464 return (1);
465 }
466 /* Get the fcode version */
467 bzero(version, sizeof (version));
468 fcio.fcio_cmd = FCIO_GET_FCODE_REV;
469 /* Information read operation */
470 fcio.fcio_xfer = FCIO_XFER_READ;
471 fcio.fcio_obuf = (caddr_t)version;
472 fcio.fcio_olen = MAXNAMELEN;
473
474 for (ntries = 0; ntries < MAX_RETRIES; ntries++) {
475 if (ioctl(fd, FCIO_CMD, &fcio) != 0) {
476 if ((errno == EAGAIN) &&
477 (ntries+1 < MAX_RETRIES)) {
478 /* wait 30 secs */
479 (void) sleep(MAX_WAIT_TIME);
480 continue;
481 }
482 (void) close(fd);
483 return (L_FCIO_GET_FCODE_REV_FAIL);
484 }
485 break;
486 }
487 version[MAXNAMELEN-1] = '\0';
488 }
489
490 /* Get type of card from product name in FCode version banner */
491 if (strstr((char *)version, qlgc2100)) {
492 *chip_id = 0x2100;
493 } else if (strstr((char *)version, qlgc2200)) {
494 *chip_id = 0x2200;
495 if (strstr((char *)version, "Sbus")) {
496 *chip_id = SBUS_CHIP_ID;
497 }
498 } else if (strstr((char *)version, qlgc2300)) {
499 *chip_id = 0x2300;
500 } else if (strstr((char *)version, qlgc2312)) {
501 *chip_id = 0x2312;
502 } else {
503 *chip_id = 0x0;
504 }
505
506 (void) close(fd);
507 return (0);
508 }
509
510 /*
511 * Retrieve the version banner and file type (2100 or 2200) from the file
512 */
513 static int
514 q_findfileversion(char *dl_fcode, uchar_t *version_file, uint16_t *file_id,
515 int isSbus, int *sbus_offset)
516 {
517 int mark;
518 int qlc_offset = 0;
519 char temp[4] = {NULL};
520
521
522 /*
523 * Get file version from FCode for 2100 or 2202
524 */
525 if (isSbus) {
526 *file_id = SBUS_CHIP_ID;
527 } else {
528 if ((dl_fcode[0x23] == 0x22) ||
529 (dl_fcode[0x23] == 0x23)) {
530 *file_id = dl_fcode[0x22] & 0xff;
531 *file_id |= (dl_fcode[0x23] << 8) & 0xff00;
532 } else {
533 *file_id = dl_fcode[0x42] & 0xff;
534 *file_id |= (dl_fcode[0x43] << 8) & 0xff00;
535 }
536 }
537
538 /*
539 * Ok, we're just checking for 2200 here. If it is we need
540 * to offset to find the banner.
541 */
542 if ((*file_id == 0x2200) ||
543 (*file_id == 0x2300) ||
544 (*file_id == 0x2312)) {
545 qlc_offset = -32;
546 }
547
548 /*
549 * If this is an ISP2200 Sbus Fcode file, then search for the string
550 * "ISP2200 FC-AL Host Adapter Driver" in the whole fcode file
551 */
552 if (isSbus) {
553 *file_id = SBUS_CHIP_ID;
554 qlc_offset = *sbus_offset;
555 /* Subtract 111 from the offset we add below for PCI Fcodes */
556 qlc_offset -= 111;
557 }
558
559 /* Banner length varies; grab banner to end of date marker yr/mo/da */
560 version_file[0] = '\0';
561 for (mark = (111 + qlc_offset); mark < (191 + qlc_offset); mark++) {
562 (void) strncpy(temp, (char *)&dl_fcode[mark], 4);
563 if ((strncmp(&temp[0], "/", 1) == 0) &&
564 (strncmp(&temp[3], "/", 1) == 0)) {
565 (void) strncat((char *)version_file,
566 (char *)&dl_fcode[mark], 6);
567 break;
568 }
569 (void) strncat((char *)version_file, temp, 1);
570 }
571 return (0);
572 }
573
574 /*
575 * Find if the FCode file is a ISP2200 SBUS Fcode file
576 */
577 static int
578 q_findSbusfile(int fd, int *sbus_offset)
579 {
580 static int file_size;
581 char *sbus_info;
582 struct stat statinfo;
583
584 if (lseek(fd, 0, SEEK_SET) == -1) {
585 perror(MSGSTR(21022, "seek"));
586 return (-1);
587 }
588 if (fstat(fd, &statinfo)) {
589 perror(MSGSTR(21023, "fstat"));
590 return (-1);
591 }
592 file_size = statinfo.st_size;
593
594 if ((sbus_info = (char *)malloc(file_size)) == NULL) {
595 (void) fprintf(stderr,
596 MSGSTR(21013, "Error: Memory allocation failed\n"));
597 return (-1);
598 }
599
600 if (read(fd, sbus_info, file_size) < 0) {
601 perror(MSGSTR(21001, "read"));
602 free(sbus_info);
603 return (-1);
604 }
605
606 /*
607 * Search for the version string in the whole file
608 */
609 if ((*sbus_offset = memstrstr((char *)sbus_info, qlgc2200Sbus,
610 file_size, strlen(qlgc2200Sbus))) != -1) {
611 free(sbus_info);
612 return (1);
613 } else {
614 free(sbus_info);
615 return (0);
616 }
617 }
618
619
620 /*
621 * Build a list of all the devctl entries for all the 2100/2200 based adapters
622 */
623 static int
624 q_getdevctlpath(char *devpath, int *devcnt)
625 {
626 struct stat statbuf;
627 struct dirent *dirp = NULL;
628 DIR *dp = NULL;
629 char *ptr = NULL;
630 int err = 0;
631 int testopen;
632
633 if (lstat(devpath, &statbuf) < 0) {
634 (void) fprintf(stderr,
635 MSGSTR(21016, "Error: %s lstat() error\n"), devpath);
636 return (1);
637 }
638
639 if ((strstr(devpath, fc_trans) ||
640 (strstr(devpath, fp_trans_id) && strstr(devpath, fp_trans))) &&
641 strstr(devpath, "devctl")) {
642 /* Verify the path is valid */
643 if ((testopen = open(devpath, O_RDONLY)) >= 0) {
644 (void) close(testopen);
645 (void) strcpy(pcibus_list[*devcnt], devpath);
646 *devcnt += 1;
647 return (0);
648 }
649 }
650
651 if (S_ISDIR(statbuf.st_mode) == 0) {
652 /*
653 * not a directory so
654 * we don't care about it - return
655 */
656 return (0);
657 }
658
659 /*
660 * It's a directory. Call ourself to
661 * traverse the path(s)
662 */
663 ptr = devpath + strlen(devpath);
664 *ptr++ = '/';
665 *ptr = 0;
666
667 /* Forget the /devices/pseudo/ directory */
668 if (strcmp(devpath, "/devices/pseudo/") == 0) {
669 return (0);
670 }
671
672 if ((dp = opendir(devpath)) == NULL) {
673 (void) fprintf(stderr,
674 MSGSTR(21017, "Error: %s Can't read directory\n"), devpath);
675 return (1);
676 }
677
678 while ((dirp = readdir(dp)) != NULL) {
679
680 if (strcmp(dirp->d_name, ".") == 0 ||
681 strcmp(dirp->d_name, "..") == 0) {
682 continue;
683 }
684 (void) strcpy(ptr, dirp->d_name); /* append name */
685 err = q_getdevctlpath(devpath, devcnt);
686 }
687
688 if (closedir(dp) < 0) {
689 (void) fprintf(stderr,
690 MSGSTR(21018, "Error: Can't close directory %s\n"), devpath);
691 return (1);
692 }
693 return (err);
694 }
695
696 /*
697 * Get the boot device. Cannot load FCode to current boot device.
698 * Boot devices under volume management will prompt a warning.
699 */
700 static int
701 q_getbootdev(uchar_t *bootpath)
702 {
703 struct mnttab mp;
704 struct mnttab mpref;
705 FILE *fp = NULL;
706 static char buf[BUFSIZ];
707 char *p = NULL, *p1 = NULL; /* p = full device, p1 = chunk to rm */
708 char *slot = ":devctl";
709 char *root = "/";
710
711 if ((fp = fopen(MNTTAB, "r")) == NULL) {
712 (void) fprintf(stderr,
713 MSGSTR(21000, "Error: Could not open %s\n"), MNTTAB);
714 return (1);
715 }
716
717 mntnull(&mpref);
718 mpref.mnt_mountp = (char *)root;
719
720 if (getmntany(fp, &mp, &mpref) != 0 ||
721 mpref.mnt_mountp == NULL) {
722 (void) fprintf(stderr, MSGSTR(21019,
723 "Error: Cannot get boot device, check %s.\n"), MNTTAB);
724 (void) fclose(fp);
725 return (1);
726 }
727 (void) fclose(fp);
728
729 /*
730 * If we can't get a link, we may be dealing with a volume mgr
731 * so give a warning. If a colon is present, we likely have a
732 * non-local disk or cd-rom, so no warning is necessary.
733 * e.g. /devices/pci@1f,4000/scsi@3/sd@6,0:b (cdrom, no link) or
734 * storage-e4:/blah/blah remote boot server
735 */
736 if (readlink(mp.mnt_special, buf, BUFSIZ) < 0) {
737 if (strstr(mp.mnt_special, ":") == NULL) {
738 (void) fprintf(stderr, MSGSTR(21020,
739 "\nWarning: Cannot read boot device link, check %s.\n"), MNTTAB);
740 (void) fprintf(stderr, MSGSTR(21021,
741 "Do not upgrade FCode on adapters controlling the boot device.\n"));
742 }
743 return (1);
744 }
745 /*
746 * Copy boot device path to bootpath. First remove leading
747 * path junk (../../..) then if it's an ifp device, chop off
748 * the disk and add the devctl to the end of the path.
749 */
750 if (p = strstr(buf, "/devices")) {
751 if (strstr(buf, fc_trans) != NULL) {
752 p1 = strrchr(p, '/');
753 *p1 = '\0';
754 }
755 }
756 (void) strcpy((char *)bootpath, (char *)p);
757 if (p1) {
758 (void) strcat((char *)bootpath, slot);
759 }
760 return (0);
761 }
762
763 /*
764 * Load FCode to card.
765 * uses ioctl: IFPIO_FCODE_DOWNLOAD
766 */
767 static int
768 q_load_file(int fcode_fd, char *device)
769 {
770 static int dev_fd, fcode_size;
771 struct stat stat;
772 ifp_download_t *download_p = NULL;
773 fcio_t fcio;
774 uint16_t file_id = 0;
775 uchar_t *bin;
776
777 if (lseek(fcode_fd, 0, SEEK_SET) == -1) {
778 perror(MSGSTR(21022, "seek"));
779 (void) close(fcode_fd);
780 return (1);
781 }
782 if (fstat(fcode_fd, &stat) == -1) {
783 perror(MSGSTR(21023, "fstat"));
784 (void) close(fcode_fd);
785 return (1);
786 }
787
788 fcode_size = stat.st_size;
789
790 if (strstr(device, fc_trans)) {
791 if ((download_p = (ifp_download_t *)malloc(
792 sizeof (ifp_download_t) + fcode_size)) == NULL) {
793 (void) fprintf(stderr,
794 MSGSTR(21013, "Error: Memory allocation failed\n"));
795 (void) close(fcode_fd);
796 return (1);
797 }
798 } else {
799 if ((bin = (uchar_t *)malloc(fcode_size)) == NULL) {
800 (void) fprintf(stderr,
801 MSGSTR(21013, "Error: Memory allocation failed\n"));
802 (void) close(fcode_fd);
803 return (1);
804 }
805 }
806
807 if (strstr(device, fc_trans)) {
808 if (read(fcode_fd, download_p->dl_fcode, fcode_size)
809 != fcode_size) {
810 perror(MSGSTR(21001, "read"));
811 free(download_p);
812 (void) close(fcode_fd);
813 return (1);
814 }
815 } else {
816 if (read(fcode_fd, bin, fcode_size)
817 != fcode_size) {
818 perror(MSGSTR(21001, "read"));
819 free(bin);
820 (void) close(fcode_fd);
821 return (1);
822 }
823 }
824
825
826 if ((dev_fd = open(device, O_RDWR|O_EXCL)) < 0) {
827 (void) fprintf(stderr,
828 MSGSTR(21000, "Error: Could not open %s\n"), device);
829 free(download_p);
830 return (1);
831 }
832 if (strstr(device, fc_trans)) {
833 download_p->dl_fcode_len = fcode_size;
834 file_id = download_p->dl_fcode[0x42] & 0xff;
835 file_id |= (download_p->dl_fcode[0x43] << 8) & 0xff00;
836 download_p->dl_chip_id = file_id;
837 if (ioctl(dev_fd, IFPIO_FCODE_DOWNLOAD, download_p) < 0) {
838 (void) fprintf(stderr, MSGSTR(21024,
839 "Error: Driver interface IFPIO_FCODE_DOWNLOAD failed\n"));
840 free(download_p);
841 (void) close(dev_fd);
842 return (1);
843 }
844 free(download_p);
845 } else if (strstr(device, fp_trans)) {
846 fcio.fcio_cmd = FCIO_DOWNLOAD_FCODE;
847 /* Information read operation */
848 fcio.fcio_xfer = FCIO_XFER_WRITE;
849 fcio.fcio_ibuf = (caddr_t)bin;
850 fcio.fcio_ilen = fcode_size;
851
852 if (ioctl(dev_fd, FCIO_CMD, &fcio) != 0) {
853 (void) fprintf(stderr, MSGSTR(21036,
854 "Error: Driver interface FCIO_DOWNLOAD_FCODE failed\n"));
855 free(download_p);
856 (void) close(dev_fd);
857 return (1);
858 }
859 free(bin);
860 }
861 (void) close(dev_fd);
862 return (0);
863 }
864
865 /*
866 * Issue warning strings and loop for Yes/No user interaction
867 * err# 0 -- we're ok, warn for pending FCode load
868 * 1 -- not in single user mode
869 * 2 -- can't get chip_id
870 * 3 -- card and file do not have same type (2100/2200)
871 */
872 static int
873 q_warn(int errnum)
874 {
875 char input[1024];
876 input[0] = '\0';
877
878 if (errnum == 1) {
879 (void) fprintf(stderr, MSGSTR(21025,
880 "\nWarning: System is not in single-user mode.\n"));
881 (void) fprintf(stderr, MSGSTR(21026,
882 "Loading FCode will reset the adapter and terminate I/O activity\n"));
883 } else {
884 if (errnum == 2) {
885 (void) fprintf(stderr, MSGSTR(21027,
886 " Warning: FCode is missing or existing FCode has"
887 " unrecognized version.\n"));
888 return (1);
889 } else if (errnum == 3) {
890 (void) fprintf(stderr, MSGSTR(21028,
891 " Warning: New FCode file version does not match this"
892 " board type. Skipping...\n"));
893 return (1);
894 }
895 (void) fprintf(stderr, MSGSTR(21029,
896 "\nWARNING!! This program will update the FCode in this"
897 " FC100/PCI, ISP2200/PCI, ISP23xx/PCI "
898 " and Emulex devices.\n"));
899 (void) fprintf(stderr, MSGSTR(21030,
900 "This may take a few (5) minutes. Please be patient.\n"));
901 }
902
903 loop1:
904 (void) fprintf(stderr, MSGSTR(21031,
905 "Do you wish to continue ? (y/n) "));
906
907 (void) gets(input);
908
909 if ((strcmp(input, MSGSTR(21032, "y")) == 0) ||
910 (strcmp(input, MSGSTR(40, "yes")) == 0)) {
911 return (0);
912 } else if ((strcmp(input, MSGSTR(21033, "n")) == 0) ||
913 (strcmp(input, MSGSTR(45, "no")) == 0)) {
914 (void) fprintf(stderr,
915 MSGSTR(21034, "Not Downloading FCode\n"));
916 return (1);
917 } else {
918 (void) fprintf(stderr, MSGSTR(21035, "Invalid input\n"));
919 goto loop1;
920 }
921 }
922
923 /*
924 * Name : memstrstr
925 * Input : pointer to buf1, pointer to buf2, size of buf1, size of buf2
926 * Returns :
927 * Offset of the start of contents-of-buf2 in buf1 if it is found
928 * -1 if buf1 does not contain contents of buf2
929 * Synopsis:
930 * This function works similar to strstr(). The difference is that null
931 * characters in the buffer are treated like any other character. So, buf1
932 * and buf2 can have embedded null characters in them.
933 */
934 static int
935 memstrstr(char *s1, char *s2, int size1, int size2)
936 {
937 int count1, count2;
938 char *s1_ptr, *s2_ptr;
939
940 count1 = size1; count2 = size2;
941 s1_ptr = s1; s2_ptr = s2;
942
943 if ((size2 == 0)||(size1 == 0))
944 return (-1);
945
946 for (count1 = 0; count1 < (size1 - size2 + 1); count1++) {
947 if (*s1_ptr++ == *s2_ptr++) {
948 if (--count2 == 0) {
949 return (count1 - size2 + 1);
950 }
951 continue;
952 }
953 count2 = size2;
954 s2_ptr = s2;
955 }
956
957 return (-1);
958 }
959
960 /*
961 * generic fcode load file routine. given a file descriptor to a fcode file
962 * this routine will issue the FCIO_DOWNLOAD_FCODE ioctl to the given
963 * device. Any ioctl errors will be returned in fcio_errno
964 *
965 * Arguments:
966 * fcode_fd file descriptor to a fcode file
967 * device path to the device we will be downloading the fcode onto
968 * fcio_errno pointer to an int that will be used to return any errors
969 * back to the caller
970 * Retrurn Values:
971 * 0 successful download
972 * >0 otherwise
973 */
974 static int
975 fcode_load_file(int fcode_fd, char *device, int *fcio_errno)
976 {
977
978 fcio_t fcio;
979 static int dev_fd, fcode_size;
980 uchar_t *bin;
981 struct stat stat;
982
983 if (device == NULL || fcio_errno == NULL) {
984 return (FCODE_LOAD_FAILURE);
985 }
986
987 *fcio_errno = 0;
988 if (lseek(fcode_fd, 0, SEEK_SET) == -1) {
989 perror(MSGSTR(21022, "seek"));
990 return (FCODE_LOAD_FAILURE);
991 }
992
993 if (fstat(fcode_fd, &stat) == -1) {
994 perror(MSGSTR(21023, "fstat"));
995 return (FCODE_LOAD_FAILURE);
996 }
997
998 fcode_size = stat.st_size;
999
1000 if ((bin = (uchar_t *)malloc(fcode_size)) == NULL) {
1001 (void) fprintf(stderr,
1002 MSGSTR(21013, "Error: Memory allocation failed\n"));
1003 return (FCODE_LOAD_FAILURE);
1004 }
1005
1006 if (read(fcode_fd, bin, fcode_size)
1007 != fcode_size) {
1008 perror(MSGSTR(21001, "read"));
1009 free(bin);
1010 return (FCODE_LOAD_FAILURE);
1011 }
1012
1013 if ((dev_fd = open(device, O_RDWR|O_EXCL)) < 0) {
1014 (void) fprintf(stderr,
1015 MSGSTR(21122, "Error: Could not open %s, failed "
1016 "with errno %d\n"), device, errno);
1017 free(bin);
1018 return (FCODE_LOAD_FAILURE);
1019 }
1020
1021 fcio.fcio_cmd = FCIO_DOWNLOAD_FCODE;
1022 fcio.fcio_xfer = FCIO_XFER_WRITE;
1023 fcio.fcio_ibuf = (caddr_t)bin;
1024 fcio.fcio_ilen = fcode_size;
1025
1026 if (ioctl(dev_fd, FCIO_CMD, &fcio) != 0) {
1027 (void) close(dev_fd);
1028 *fcio_errno = fcio.fcio_errno;
1029 free(bin);
1030 return (FCODE_IOCTL_FAILURE);
1031 }
1032
1033 free(bin);
1034 (void) close(dev_fd);
1035 return (FCODE_SUCCESS);
1036 }
1037
1038 /*
1039 * Searches for and updates the fcode for Emulex HBA cards
1040 * args: FCode file; if NULL only the current FCode
1041 * version is printed
1042 */
1043
1044 int
1045 emulex_update(char *file)
1046 {
1047
1048 int fd, retval = 0;
1049 int devcnt = 0;
1050 uint_t state = 0, fflag = 0;
1051 static uchar_t bootpath[PATH_MAX];
1052 int fcode_fd = -1;
1053 static struct utmpx *utmpp = NULL;
1054 di_node_t root;
1055 di_node_t node, sib_node, count_node;
1056 di_minor_t minor_node;
1057 char phys_path[PATH_MAX], *path;
1058 int errnum = 0, fcio_errno = 0;
1059 static uchar_t prom_ver_data[MAXNAMELEN];
1060 static char ver_file[EMULEX_FCODE_VERSION_LENGTH];
1061 void (*sigint)();
1062 int prop_entries = -1;
1063 int *port_data = NULL;
1064
1065 if (file) {
1066 /* set the fcode download flag */
1067 fflag++;
1068
1069 /* check for a valid file */
1070 if ((fcode_fd = open(file, O_RDONLY)) < 0) {
1071 (void) fprintf(stderr,
1072 MSGSTR(21118, "Error: Could not open %s, failed "
1073 "with errno %d\n"), file, errno);
1074 return (1);
1075 }
1076
1077 /* check for single user mode */
1078 while ((utmpp = getutxent()) != NULL) {
1079 if (strstr(utmpp->ut_line, "run-level") &&
1080 (strcmp(utmpp->ut_line, "run-level S") &&
1081 strcmp(utmpp->ut_line, "run-level 1"))) {
1082 if (q_warn(1)) {
1083 (void) endutxent();
1084 (void) close(fcode_fd);
1085 return (1);
1086 }
1087 break;
1088 }
1089 }
1090 (void) endutxent();
1091
1092 /* get bootpath */
1093 if (!q_getbootdev((uchar_t *)&bootpath[0]) &&
1094 getenv("_LUX_D_DEBUG") != NULL) {
1095 (void) fprintf(stdout, " Bootpath: %s\n", bootpath);
1096 }
1097 }
1098
1099 /*
1100 * Download the Fcode to all the emulex cards found
1101 */
1102
1103 /* Create a snapshot of the kernel device tree */
1104 if ((root = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
1105 (void) fprintf(stderr, MSGSTR(21114,
1106 "Error: Could not get /devices path to "
1107 "Emulex Devices.\n"));
1108 retval++;
1109 }
1110
1111 /* point to first node which matches emulex driver */
1112 node = di_drv_first_node("emlxs", root);
1113
1114 if (node == DI_NODE_NIL) {
1115 /*
1116 * Could not find any emulex cards
1117 */
1118 (void) di_fini(root);
1119 (void) fprintf(stderr, MSGSTR(21115,
1120 "\n Found Path to %d Emulex Devices.\n"), devcnt);
1121 retval++;
1122 } else {
1123 count_node = node;
1124 while (count_node != DI_NODE_NIL) {
1125 state = di_state(count_node);
1126 if ((state & DI_DRIVER_DETACHED)
1127 != DI_DRIVER_DETACHED) {
1128 sib_node = di_child_node(count_node);
1129 while (sib_node != DI_NODE_NIL) {
1130 state = di_state(sib_node);
1131 if ((state & DI_DRIVER_DETACHED) !=
1132 DI_DRIVER_DETACHED) {
1133 /* Found an attached node */
1134 prop_entries =
1135 di_prop_lookup_ints(
1136 DDI_DEV_T_ANY, sib_node,
1137 "port", &port_data);
1138 if (prop_entries != -1) {
1139 devcnt++;
1140 break;
1141 }
1142 }
1143
1144 sib_node = di_sibling_node(sib_node);
1145 }
1146 }
1147 count_node = di_drv_next_node(count_node);
1148 }
1149 (void) fprintf(stdout, MSGSTR(21116,
1150 "\n Found Path to %d Emulex Devices.\n"), devcnt);
1151 }
1152
1153
1154 /*
1155 * Traverse device tree to find all emulex cards
1156 */
1157 while (node != DI_NODE_NIL) {
1158
1159 state = di_state(node);
1160 if ((state & DI_DRIVER_DETACHED) == DI_DRIVER_DETACHED) {
1161 node = di_drv_next_node(node);
1162 continue;
1163 }
1164
1165 sib_node = di_child_node(node);
1166 while (sib_node != DI_NODE_NIL) {
1167 state = di_state(sib_node);
1168 if ((state & DI_DRIVER_DETACHED) !=
1169 DI_DRIVER_DETACHED) {
1170
1171 /* Found an attached node */
1172 prop_entries = di_prop_lookup_ints(
1173 DDI_DEV_T_ANY, sib_node,
1174 "port", &port_data);
1175 if (prop_entries != -1) {
1176
1177 /* Found a node with "port" property */
1178 minor_node = di_minor_next(sib_node,
1179 DI_MINOR_NIL);
1180 break;
1181 }
1182 }
1183 sib_node = di_sibling_node(sib_node);
1184 }
1185
1186 if (sib_node == DI_NODE_NIL) {
1187 goto try_next;
1188 }
1189
1190 path = di_devfs_path(sib_node);
1191 (void) strcpy(phys_path, "/devices");
1192 (void) strncat(phys_path, path, strlen(path));
1193 di_devfs_path_free(path);
1194
1195 if (fflag && (strstr((char *)bootpath,
1196 (char *)phys_path) != NULL)) {
1197 (void) fprintf(stderr,
1198 MSGSTR(21117, "Ignoring %s (bootpath)\n"),
1199 phys_path);
1200 node = di_drv_next_node(node);
1201 continue;
1202 }
1203
1204 if (minor_node) {
1205 (void) strncat(phys_path, ":", 1);
1206 (void) strncat(phys_path,
1207 di_minor_name(minor_node),
1208 strlen(di_minor_name(minor_node)));
1209 }
1210
1211 (void) fprintf(stdout,
1212 MSGSTR(21107, "\n Opening Device: %s\n"),
1213 phys_path);
1214
1215 /* Check if the device is valid */
1216 if ((fd = open(phys_path, O_RDWR)) < 0) {
1217 (void) fprintf(stderr,
1218 MSGSTR(21121, "Error: Could not open %s, failed "
1219 "with errno %d\n"), phys_path, errno);
1220 retval++;
1221 node = di_drv_next_node(node);
1222 continue;
1223 }
1224
1225 (void) close(fd);
1226
1227 /*
1228 * Check FCode version present on the adapter
1229 * (at last boot)
1230 */
1231 memset(prom_ver_data, 0, sizeof (prom_ver_data));
1232 if (emulex_fcodeversion(node, (uchar_t *)&prom_ver_data[0])
1233 == 0) {
1234 errnum = 0;
1235 if (strlen((char *)prom_ver_data) == 0) {
1236 (void) fprintf(stdout, MSGSTR(21108,
1237 " Detected FCode Version:\tNo version available for this FCode\n"));
1238 } else {
1239 (void) fprintf(stdout, MSGSTR(21109,
1240 " Detected FCode Version:\t%s\n"),
1241 prom_ver_data);
1242 }
1243 } else {
1244 errnum = 2; /* can't get prom properties */
1245 retval++;
1246 }
1247
1248 if (fflag) {
1249
1250 memset(ver_file, 0, sizeof (ver_file));
1251 if (emulex_fcode_reader(fcode_fd, "fcode-version",
1252 ver_file, sizeof (ver_file)) == 0) {
1253 (void) fprintf(stdout, MSGSTR(21110,
1254 " New FCode Version:\t\t%s\n"),
1255 ver_file);
1256 } else {
1257 di_fini(root);
1258 (void) close(fcode_fd);
1259 return (1);
1260 }
1261
1262 /*
1263 * Load the New FCode
1264 * Give warning if file doesn't appear to be correct
1265 */
1266 if (!q_warn(errnum)) {
1267 /* Disable user-interrupt Control-C */
1268 sigint =
1269 (void (*)(int)) signal(SIGINT, SIG_IGN);
1270 /* Load FCode */
1271 (void) fprintf(stdout, MSGSTR(21111,
1272 " Loading FCode: %s\n"), file);
1273 if (fcode_load_file(fcode_fd, phys_path,
1274 &fcio_errno) == FCODE_SUCCESS) {
1275 (void) fprintf(stdout, MSGSTR(21112,
1276 " Successful FCode download: %s\n"),
1277 phys_path);
1278 } else {
1279 handle_emulex_error(fcio_errno,
1280 phys_path);
1281 retval++;
1282 }
1283
1284 /* Restore SIGINT (user interrupt) setting */
1285 (void) signal(SIGINT, sigint);
1286 }
1287 }
1288
1289 try_next:
1290 node = di_drv_next_node(node);
1291 }
1292
1293 di_fini(root);
1294 (void) fprintf(stdout, " ");
1295 (void) fprintf(stdout, MSGSTR(125, "Complete\n"));
1296 if (fcode_fd != -1)
1297 (void) close(fcode_fd);
1298 return (retval);
1299
1300 }
1301
1302 /*
1303 * Retrieve the version from the card.
1304 * uses PROM properties
1305 */
1306 static int
1307 emulex_fcodeversion(di_node_t node, uchar_t *ver) {
1308 di_prom_prop_t promprop;
1309 di_prom_handle_t ph;
1310 char *promname;
1311 uchar_t *ver_data = NULL;
1312 int size, found = 0;
1313
1314 /* check to make sure ver is not NULL */
1315 if (ver == NULL) {
1316 return (1);
1317 }
1318
1319 if ((ph = di_prom_init()) == DI_PROM_HANDLE_NIL) {
1320 return (1);
1321 }
1322
1323 for (promprop = di_prom_prop_next(ph, node,
1324 DI_PROM_PROP_NIL);
1325 promprop != DI_PROM_PROP_NIL;
1326 promprop = di_prom_prop_next(ph, node, promprop)) {
1327 if (((promname = di_prom_prop_name(
1328 promprop)) != NULL) &&
1329 (strcmp(promname, "fcode-version") == 0)) {
1330 size = di_prom_prop_data(promprop, &ver_data);
1331 (void) memset(ver, NULL, size);
1332 (void) memcpy(ver, ver_data, size);
1333 found = 1;
1334 }
1335 }
1336
1337 if (found) {
1338 return (0);
1339 } else {
1340 return (1);
1341 }
1342 }
1343
1344 /*
1345 * Retrieves information from the Emulex fcode
1346 *
1347 * Given a pattern, this routine will look for this pattern in the fcode
1348 * file and if found will return the pattern value
1349 *
1350 * possible patterns are manufacturer and fcode-version
1351 */
1352 int
1353 emulex_fcode_reader(int fcode_fd, char *pattern, char *pattern_value,
1354 uint32_t pattern_value_size) {
1355 int32_t i = 0;
1356 uint32_t n = 0;
1357 uint32_t b = 0;
1358 char byte1;
1359 char byte2;
1360 char byte3;
1361 char byte4;
1362 char buffer1[EMULEX_READ_BUFFER_SIZE];
1363 char buffer2[EMULEX_READ_BUFFER_SIZE];
1364 uint32_t plen, image_size;
1365 struct stat stat;
1366 uchar_t *image;
1367
1368 /* Check the arguments */
1369 if (!fcode_fd || !pattern_value || pattern_value_size < 8) {
1370 return (1);
1371 }
1372
1373 if (fstat(fcode_fd, &stat) == -1) {
1374 perror(MSGSTR(21023, "fstat"));
1375 return (1);
1376 }
1377 image_size = stat.st_size;
1378 if (image_size < 2) {
1379 return (1);
1380 }
1381 if ((image = (uchar_t *)calloc(image_size, 1)) == NULL) {
1382 (void) fprintf(stderr,
1383 MSGSTR(21013, "Error: Memory allocation failed\n"));
1384 return (1);
1385 }
1386
1387 /* Read the fcode image file */
1388 lseek(fcode_fd, 0, SEEK_SET);
1389 read(fcode_fd, image, image_size);
1390
1391 /* Initialize */
1392 bzero(buffer1, sizeof (buffer1));
1393 bzero(buffer2, sizeof (buffer2));
1394 /* Default pattern_value string */
1395 strcpy((char *)pattern_value, "<unknown>");
1396 plen = strlen(pattern);
1397 n = 0;
1398 b = 0;
1399 i = 0;
1400
1401 /* Search entire image for pattern string */
1402 while (i <= (image_size - 2)) {
1403 /* Read next two bytes */
1404 byte1 = image[i++];
1405 byte2 = image[i++];
1406
1407 /* Check second byte first due to endianness */
1408
1409 /* Save byte in circular buffer */
1410 buffer1[b++] = byte2;
1411 if (b == sizeof (buffer1)) {
1412 b = 0;
1413 }
1414
1415 /* Check byte for pattern match */
1416 if (pattern[n++] != byte2) {
1417 /* If no match, then reset pattern */
1418 n = 0;
1419 } else {
1420 /*
1421 * If complete pattern has been matched then
1422 * exit loop
1423 */
1424 if (n == plen) {
1425 goto found;
1426 }
1427 }
1428
1429
1430 /* Check first byte second due to endianness */
1431 /* Save byte in circular buffer */
1432 buffer1[b++] = byte1;
1433 if (b == sizeof (buffer1)) {
1434 b = 0;
1435 }
1436 /* Check byte for pattern match */
1437 if (pattern[n++] != byte1) {
1438 /* If no match, then reset pattern */
1439 n = 0;
1440 } else {
1441 /*
1442 * If complete pattern has been matched
1443 * then exit loop
1444 */
1445 if (n == plen) {
1446 goto found;
1447 }
1448 }
1449 }
1450
1451 /* Not found. Try again with different endianess */
1452
1453 /* Initialize */
1454 bzero(buffer1, sizeof (buffer1));
1455 bzero(buffer2, sizeof (buffer2));
1456 n = 0;
1457 b = 0;
1458 i = 0;
1459
1460 /* Search entire 32bit endian image for pattern string */
1461 while (i <= (image_size - 4)) {
1462 /* Read next four bytes */
1463 byte1 = image[i++];
1464 byte2 = image[i++];
1465 byte3 = image[i++];
1466 byte4 = image[i++];
1467
1468 /* Save byte in circular buffer */
1469 buffer1[b++] = byte4;
1470 if (b == sizeof (buffer1)) {
1471 b = 0;
1472 }
1473
1474 /* Check byte for pattern match */
1475 if (pattern[n++] != byte4) {
1476 /* If no match, then reset pattern */
1477 n = 0;
1478 } else {
1479 /*
1480 * If complete pattern has been matched then exit loop
1481 */
1482 if (n == plen) {
1483 goto found;
1484 }
1485 }
1486
1487 /* Save byte in circular buffer */
1488 buffer1[b++] = byte3;
1489 if (b == sizeof (buffer1)) {
1490 b = 0;
1491 }
1492
1493 /* Check byte for pattern match */
1494 if (pattern[n++] != byte3) {
1495 /* If no match, then reset pattern */
1496 n = 0;
1497 } else {
1498 /*
1499 * If complete pattern has been matched then exit loop
1500 */
1501 if (n == plen) {
1502 goto found;
1503 }
1504 }
1505
1506 /* Save byte in circular buffer */
1507 buffer1[b++] = byte2;
1508 if (b == sizeof (buffer1)) {
1509 b = 0;
1510 }
1511
1512 /* Check byte for pattern match */
1513 if (pattern[n++] != byte2) {
1514 /* If no match, then reset pattern */
1515 n = 0;
1516 } else {
1517 /*
1518 * If complete pattern has been matched then exit loop
1519 */
1520 if (n == plen) {
1521 goto found;
1522 }
1523 }
1524
1525 /* Save byte in circular buffer */
1526 buffer1[b++] = byte1;
1527 if (b == sizeof (buffer1)) {
1528 b = 0;
1529 }
1530
1531 /* Check byte for pattern match */
1532 if (pattern[n++] != byte1) {
1533 /* If no match, then reset pattern */
1534 n = 0;
1535 } else {
1536 /*
1537 * If complete pattern has been matched then exit loop
1538 */
1539 if (n == plen) {
1540 goto found;
1541 }
1542 }
1543 }
1544
1545 free(image);
1546 return (1);
1547
1548 found:
1549 free(image);
1550
1551 /* Align buffer and eliminate non-printable characters */
1552 for (i = 0; i < (sizeof (buffer1)-plen); i++) {
1553 byte1 = buffer1[b++];
1554 if (b == sizeof (buffer1)) {
1555 b = 0;
1556 }
1557 /* Zero any non-printable characters */
1558 if (byte1 >= 33 && byte1 <= 126) {
1559 buffer2[i] = byte1;
1560 } else {
1561 buffer2[i] = 0;
1562 }
1563 }
1564
1565 /*
1566 * Scan backwards for first non-zero string. This will be the
1567 * version string
1568 */
1569 for (i = sizeof (buffer1)-plen-1; i >= 0; i--) {
1570 if (buffer2[i] != 0) {
1571 for (; i >= 0; i--) {
1572 if (buffer2[i] == 0) {
1573 i++;
1574 strncpy((char *)pattern_value,
1575 &buffer2[i], pattern_value_size);
1576 break;
1577 }
1578 }
1579 break;
1580 }
1581 }
1582 return (0);
1583 }
1584
1585 /*
1586 * error handling routine to handle emulex error conditions
1587 */
1588 static void
1589 handle_emulex_error(int fcio_errno, char *phys_path) {
1590 if (fcio_errno == EMLX_IMAGE_BAD) {
1591 fprintf(stderr, MSGSTR(21119,
1592 "Error: Fcode download failed. "
1593 "Bad fcode image.\n"));
1594 } else if (fcio_errno == EMLX_IMAGE_INCOMPATIBLE) {
1595 fprintf(stderr, MSGSTR(21120,
1596 "Error: Fcode download failed. Fcode is not "
1597 "compatible with card.\n"));
1598 } else {
1599 (void) fprintf(stderr, MSGSTR(21036,
1600 "Error: Driver interface FCIO_DOWNLOAD_FCODE failed\n"));
1601 (void) fprintf(stderr,
1602 MSGSTR(21113,
1603 "Error: FCode download failed: %s\n"),
1604 phys_path);
1605 }
1606 }
unleashed repo fork