Print this page
NEX-5717 import QLogic 16G FC drivers
Reviewed by: Steve Peng <steve.peng@nexenta.com>
Reviewed by: Josef 'Jeff' Sipek <josef.sipek@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_hba_fru.c
+++ new/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_hba_fru.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 -/* Copyright 2010 QLogic Corporation */
22 +/* Copyright 2015 QLogic Corporation */
23 23
24 24 /*
25 25 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
26 26 */
27 27
28 -#pragma ident "Copyright 2010 QLogic Corporation; ql_hba_fru.c"
28 +#pragma ident "Copyright 2015 QLogic Corporation; ql_hba_fru.c"
29 29
30 30 /*
31 31 * ISP2xxx Solaris Fibre Channel Adapter (FCA) driver source file.
32 32 *
33 33 * ***********************************************************************
34 34 * * **
35 35 * * NOTICE **
36 - * * COPYRIGHT (C) 1996-2010 QLOGIC CORPORATION **
36 + * * COPYRIGHT (C) 1996-2015 QLOGIC CORPORATION **
37 37 * * ALL RIGHTS RESERVED **
38 38 * * **
39 39 * ***********************************************************************
40 40 *
41 41 */
42 42
43 43 /*
44 44 * Determine HBA FRU card information for T11 FC-HBA
45 45 */
46 46
47 47 #include <ql_apps.h>
48 48 #include <ql_api.h>
49 49 #include <ql_debug.h>
50 50 #include <ql_ioctl.h>
51 51 #include <ql_xioctl.h>
52 52
53 53 /*
54 54 * Temporary define until LV headers are updated
55 55 */
56 56 #ifndef FC_HBA_PORTSPEED_8GBIT
57 57 #define FC_HBA_PORTSPEED_8GBIT 16 /* 8 GBit/sec */
58 58 #endif
59 59
60 60 /* Local prototypes */
61 61 static uint32_t ql_get_basedev_len(ql_adapter_state_t *, uint32_t *,
62 62 uint32_t *);
63 63 static ql_adapter_state_t *ql_search_basedev(ql_adapter_state_t *, uint32_t);
64 64
65 65 /* Local structures */
66 66 static struct ql_known_models {
67 67 uint16_t ssid; /* Subsystem ID */
68 68 uint16_t ssvid; /* Subsystem Vendor ID */
69 69 char model[256];
70 70 char model_description[256];
71 71
72 72 } models[] = {
73 73 {
74 74 /* QLogic */
75 75 0x2, 0x1077, "QLA2200", "QLogic PCI to 1Gb FC, Single Channel"
76 76 }, {
77 77 /* QLogic */
78 78 0x9, 0x1077, "QLA2300", "QLogic PCI to 2Gb FC, Single Channel"
79 79 }, {
80 80 /* QLA2200, SUN2200 Amber */
81 81 0x4082, 0x1077, "375-3019-xx", "X6799A"
82 82 }, {
83 83 /* QLA2212, SUN2212 Crystal+ */
84 84 0x4083, 0x1077, "375-3030-xx", "X6727A"
85 85 }, {
86 86 /* QCP2202, SUNQCP2202 Diamond */
87 87 0x4084, 0x1077, "375-0118-xx", "X6748A"
88 88 }, {
89 89 /* QLA2202FS, SUN2202FS Ivory */
90 90 0x4085, 0x1077, "375-3048-xx", "X6757A"
91 91 }, {
92 92 /* QLogic */
93 93 0x100, 0x1077, "QLA2340",
94 94 "QLogic 133MHz PCI-X to 2Gb FC, Single Channel"
95 95 }, {
96 96 /* QLogic */
97 97 0x101, 0x1077, "QLA2342",
98 98 "QLogic 133MHz PCI-X to 2Gb FC, Dual Channel"
99 99 }, {
100 100 /* QLogic */
101 101 0x102, 0x1077, "QLA2344",
102 102 "QLogic 133MHz PCI-X to 2Gb FC, Quad Channel"
103 103 }, {
104 104 /* QLogic */
105 105 0x103, 0x1077, "QCP2342", "QLogic cPCI to 2Gb FC, Dual Channel"
106 106 }, {
107 107 /* QLogic */
108 108 0x104, 0x1077, "QSB2340", "QLogic SBUS to 2Gb FC, Single Channel"
109 109 }, {
110 110 /* QLogic */
111 111 0x105, 0x1077, "QSB2342", "QLogic SBUS to 2Gb FC, Dual Channel"
112 112 }, {
113 113 /* QLA2310, SUN-66MHz PCI-X to 2Gb FC, Single Channel, Amber 2 */
114 114 0x0106, 0x1077, "375-3102-xx", "SG-XPCI1FC-QF2 (X6767A)"
115 115 }, {
116 116 /* QLogic */
117 117 0x109, 0x1077, "QCP2340", "QLogic cPCI to 2Gb FC, Single Channel"
118 118 }, {
119 119 /* QLA2342, SUN-133MHz PCI-X to 2Gb FC, Dualchannel, Crystal 2A */
120 120 0x010A, 0x1077, "375-3108-xx", "SG-XPCI2FC-QF2 (X6768A)"
121 121 }, {
122 122 /* QLogic */
123 123 0x115, 0x1077, "QLA2360",
124 124 "QLogic 133MHz PCI-X to 2Gb FC, Single Channel"
125 125 }, {
126 126 /* QLogic */
127 127 0x116, 0x1077, "QLA2362",
128 128 "QLogic 133MHz PCI-X to 2Gb FC, Dual Channel"
129 129 }, {
130 130 /* QLogic */
131 131 0x117, 0x1077, "QLE2360",
132 132 "QLogic PCI-Express to 2Gb FC, Single Channel"
133 133 }, {
134 134 /* QLogic */
135 135 0x118, 0x1077, "QLE2362",
136 136 "QLogic PCI Express to 2Gb FC, Dual Channel"
137 137 }, {
138 138 /* QLogic */
139 139 0x119, 0x1077, "QLA200",
140 140 "QLogic 133MHz PCI-X to 2Gb FC, Single Channel"
141 141 }, {
142 142 /* QLogic */
143 143 0x11c, 0x1077, "QLA200P",
144 144 "QLogic 133MHz PCI-X to 2Gb FC, Single Channel"
145 145 }, {
146 146 /* QLogic */
147 147 0x12f, 0x1077, "QLA210",
148 148 "QLogic 133MHz PCI-X to 2Gb FC, Single Channel"
149 149 }, {
150 150 /* QLogic */
151 151 0x130, 0x1077, "EMC250-051-900",
152 152 "QLogic 133MHz PCI-X to 2Gb FC, Single Channel"
153 153 }, {
154 154 /* QLA210, SUN-133MHz PCI-X to 2Gb FC, Single Channel, Prism */
155 155 0x132, 0x1077, "375-32X3-01", "SG-PCI1FC-QLC"
156 156 }, {
157 157 /* QLogic */
158 158 0x13e, 0x1077, "QLE210",
159 159 "QLogic PCI Express 2Gb FC, Single Channel"
160 160 }, {
161 161 /* Sun */
162 162 0x149, 0x1077, "QLA2340",
163 163 "SUN - 133MHz PCI-X to 2Gb FC, Single Channel"
164 164 }, {
165 165 /* HP */
166 166 0x100, 0x0e11, "QLA2340-HP", "PCIX to 2Gb FC, Single Channel"
167 167 }, {
168 168 /* HP */
169 169 0x101, 0x0e11, "QLA2342-HP", "PCIX to 2Gb FC, Dual Channel"
170 170 }, {
171 171 /* HP */
172 172 0x103, 0x0e11, "QLA2312-HP",
173 173 "HP Bladed Server Balcony Card - HP BalcnL"
174 174 }, {
175 175 /* HP */
176 176 0x104, 0x0e11, "QLA2312-HP", "HP Bladed Server - HP MezzF"
177 177 }, {
178 178 /* HP */
179 179 0x105, 0x0e11, "QLA2312-HP", "HP Bladed Server - HP BalcnL"
180 180 }, {
181 181 /* HP */
182 182 0x106, 0x0e11, "QLA2312-HP", "HP Bladed Server - HP BalcnF"
183 183 }, {
184 184 /* HP */
185 185 0x107, 0x0e11, "QLA2312-HP", "HP Bladed Server"
186 186 }, {
187 187 /* HP */
188 188 0x108, 0x0e11, "QLA2312-HP", "HP Bladed Server"
189 189 }, {
190 190 /* IBM FCEC */
191 191 0x27d, 0x1014, "IBM-FCEC",
192 192 "IBM eServer Blade Center FC Expansion Card"
193 193 }, {
194 194 /* IBM FCEC */
195 195 0x2fb, 0x1014, "IBM-FCEC",
196 196 "IBM eServer Blade Center FC SFF Expansion Card"
197 197 }, {
198 198 /* Intel */
199 199 0x34ba, 0x8086, "Intel SBFCM",
200 200 "Intel Server FC Expansion Card SBFCM"
201 201 }, {
202 202 /* Intel */
203 203 0x34a0, 0x8086, "Intel SBEFCM",
204 204 "Intel Server SFF FC Expansion Card SBFCM"
205 205 }, {
206 206 /* FCI/O */
207 207 0x1051, 0x1734, "FCI/O-CARD2Gb/s",
208 208 "FSC-Quanta FC I/O-Card 2GBit/s"
209 209 }, {
210 210 /* Dell */
211 211 0x18a, 0x1028, "FCI/O-CARD2Gb/s", "Dell Glacier Blade Server"
212 212 }, {
213 213 /* end of list */
214 214 0, 0, 0, 0, 0, 0
215 215 } };
216 216
217 217 /*
218 218 * ql_populate_hba_fru_details
219 219 * Sets up HBA fru information for UL utilities
220 220 * (cfgadm, fcinfo, et. al.)
221 221 *
222 222 * Input:
223 223 * ha = adapter state structure
224 224 * port_info = ptr to LV port strcture.
225 225 *
226 226 * Returns:
227 227 *
228 228 * Context:
229 229 * Kernel context.
230 230 */
231 231 void
|
↓ open down ↓ |
185 lines elided |
↑ open up ↑ |
232 232 ql_populate_hba_fru_details(ql_adapter_state_t *ha,
233 233 fc_fca_port_info_t *port_info)
234 234 {
235 235 fca_port_attrs_t *attrs = &port_info->pi_attrs;
236 236 uint16_t chip = ha->device_id;
237 237 uint16_t model = ha->subsys_id;
238 238 uint16_t ssdevid = ha->subven_id;
239 239 size_t vlen;
240 240 int32_t i;
241 241
242 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
242 + QL_PRINT_3(ha, "started\n");
243 243
244 244 attrs = &port_info->pi_attrs;
245 245
246 246 /* Constants */
247 247 (void) snprintf(attrs->manufacturer, FCHBA_MANUFACTURER_LEN,
248 248 "QLogic Corp.");
249 249 (void) snprintf(attrs->driver_name, FCHBA_DRIVER_NAME_LEN,
250 250 "%s", QL_NAME);
251 251 (void) snprintf(attrs->driver_version, FCHBA_DRIVER_VERSION_LEN,
252 252 "%s", ha->adapter_stats->revlvl.qlddv);
253 253
254 254 if ((i = ql_vpd_lookup(ha, (uint8_t *)VPD_TAG_SN, (uint8_t *)
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
255 255 attrs->serial_number, FCHBA_SERIAL_NUMBER_LEN)) == -1) {
256 256 attrs->serial_number[0] = '\0';
257 257 }
258 258 attrs->hardware_version[0] = '\0';
259 259
260 260 /* Dynamic data */
261 261 (void) snprintf(attrs->firmware_version, FCHBA_FIRMWARE_VERSION_LEN,
262 262 "%02d.%02d.%02d", ha->fw_major_version, ha->fw_minor_version,
263 263 ha->fw_subminor_version);
264 264
265 - CACHE_LOCK(ha);
266 -
267 265 /* Report FCode / BIOS / EFI version(s). */
268 266 if (ha->fcache != NULL) {
269 267 uint32_t types = FTYPE_BIOS|FTYPE_FCODE|FTYPE_EFI;
270 268 ql_fcache_t *fptr = ha->fcache;
271 269 int8_t *orv = &*attrs->option_rom_version;
272 270
273 271 while ((fptr != NULL) && (types != 0)) {
274 272 /* Get the next image */
275 273 if ((fptr = ql_get_fbuf(ha->fcache, types)) != NULL) {
276 274
277 275 switch (fptr->type) {
278 276 case FTYPE_FCODE:
279 277 (void) snprintf(orv,
280 278 FCHBA_OPTION_ROM_VERSION_LEN,
281 279 "%s fcode: %s;", orv, fptr->verstr);
282 280 break;
283 281 case FTYPE_BIOS:
284 282 (void) snprintf(orv,
285 283 FCHBA_OPTION_ROM_VERSION_LEN,
286 284 "%s BIOS: %s;", orv, fptr->verstr);
287 285 break;
288 286 case FTYPE_EFI:
289 287 (void) snprintf(orv,
290 288 FCHBA_OPTION_ROM_VERSION_LEN,
291 289 "%s EFI: %s;", orv, fptr->verstr);
292 290 break;
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
293 291 default:
294 292 EL(ha, "ignoring ftype: %xh\n",
295 293 fptr->type);
296 294 break;
297 295 }
298 296 types &= ~(fptr->type);
299 297 }
300 298 }
301 299 }
302 300
303 - CACHE_UNLOCK(ha);
304 -
305 301 if (strlen(attrs->option_rom_version) == 0) {
306 302 int rval = -1;
307 303 uint32_t i = 0;
308 304 caddr_t fcode_ver_buf = NULL;
309 305
310 - if (CFG_IST(ha, CFG_CTRL_2200)) {
306 + if (CFG_IST(ha, CFG_CTRL_22XX)) {
311 307 /*LINTED [Solaris DDI_DEV_T_ANY Lint warning]*/
312 308 rval = ddi_getlongprop(DDI_DEV_T_ANY, ha->dip,
313 309 DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "version",
314 310 (caddr_t)&fcode_ver_buf, (int32_t *)&i);
315 311 }
316 312
317 313 (void) snprintf(attrs->option_rom_version,
318 314 FCHBA_OPTION_ROM_VERSION_LEN, "%s",
319 315 (rval == DDI_PROP_SUCCESS ? fcode_ver_buf :
320 316 "No boot image detected"));
321 317
322 318 if (fcode_ver_buf != NULL) {
323 319 kmem_free(fcode_ver_buf, (size_t)i);
324 320 }
325 321
326 322 }
327 323
328 324 attrs->vendor_specific_id = ha->adapter_features;
329 - attrs->max_frame_size = CFG_IST(ha, CFG_CTRL_24258081) ?
330 - (ha->init_ctrl_blk.cb24.max_frame_length[1] << 8 |
331 - ha->init_ctrl_blk.cb24.max_frame_length[0]) :
332 - (ha->init_ctrl_blk.cb.max_frame_length[1] << 8 |
333 - ha->init_ctrl_blk.cb.max_frame_length[0]);
325 + attrs->max_frame_size = ha->loginparams.common_service.rx_bufsize;
334 326 attrs->supported_cos = 0x10000000; /* Class 3 only */
335 327
336 328 switch (chip & 0xFF00) {
329 + case 0x2000:
330 + attrs->supported_speed = chip == 0x2071 ?
331 + FC_HBA_PORTSPEED_32GBIT : FC_HBA_PORTSPEED_16GBIT;
332 + break;
337 333 case 0x2200:
338 - attrs->supported_speed = FC_HBA_PORTSPEED_1GBIT;
334 + attrs->supported_speed = chip == 0x2261 ?
335 + FC_HBA_PORTSPEED_16GBIT : FC_HBA_PORTSPEED_1GBIT;
339 336 break;
340 337 case 0x2300:
341 338 attrs->supported_speed = FC_HBA_PORTSPEED_2GBIT |
342 339 FC_HBA_PORTSPEED_1GBIT;
343 340 break;
344 341 case 0x2400:
345 342 case 0x8400:
346 343 attrs->supported_speed = FC_HBA_PORTSPEED_4GBIT |
347 344 FC_HBA_PORTSPEED_2GBIT | FC_HBA_PORTSPEED_1GBIT;
348 345 break;
349 346 case 0x8000:
350 347 attrs->supported_speed = FC_HBA_PORTSPEED_10GBIT;
351 348 break;
352 349 case 0x2500:
353 350 attrs->supported_speed = FC_HBA_PORTSPEED_8GBIT |
354 351 FC_HBA_PORTSPEED_4GBIT | FC_HBA_PORTSPEED_2GBIT |
355 352 FC_HBA_PORTSPEED_1GBIT;
356 353
357 354 /*
358 355 * Correct supported speeds based on type of
359 356 * sfp that is present
360 357 */
361 358 switch (ha->sfp_stat) {
362 359 case 2:
363 360 case 4:
364 361 /* 4GB sfp */
365 362 attrs->supported_speed &= ~FC_HBA_PORTSPEED_8GBIT;
366 363 break;
367 364 case 3:
368 365 case 5:
369 366 /* 8GB sfp */
370 367 attrs->supported_speed &= ~FC_HBA_PORTSPEED_1GBIT;
371 368 break;
372 369 default:
373 370 EL(ha, "sfp_stat: %xh\n", ha->sfp_stat);
374 371 break;
375 372
376 373 }
377 374
378 375 break;
379 376 case 0x5400:
380 377 if (model == 0x13e) {
381 378 /* QLE210 */
382 379 attrs->supported_speed = FC_HBA_PORTSPEED_2GBIT;
383 380 } else {
384 381 attrs->supported_speed = FC_HBA_PORTSPEED_4GBIT;
385 382 }
386 383 break;
387 384 case 0x6300:
388 385 attrs->supported_speed = FC_HBA_PORTSPEED_2GBIT;
389 386 break;
390 387 default:
391 388 attrs->supported_speed = FC_HBA_PORTSPEED_UNKNOWN;
392 389 break;
393 390 }
394 391
395 392 /* Use parent dip as adapter identifier */
396 393 attrs->hba_fru_details.low = 0x514C6F6769630000; /* QLogic */
397 394
398 395 if (ha->fru_hba_index == 0) {
399 396 EL(ha, "unable to generate high_fru details from "
400 397 "device path: %s\n", ha->devpath);
401 398 attrs->hba_fru_details.low = 0;
402 399 attrs->hba_fru_details.high = 0;
403 400 attrs->hba_fru_details.port_index = 0;
404 401 } else {
405 402 attrs->hba_fru_details.high = ha->fru_hba_index;
406 403 attrs->hba_fru_details.port_index = ha->fru_port_index;
407 404 }
408 405
409 406 /*
410 407 * Populate the model info. Legacy (22xx, 23xx, 63xx) do not
411 408 * have vpd info, so use the hard coded table. Anything else
412 409 * has VPD (or is suppose to have VPD), so use that. For both
413 410 * cases, if the model isn't found, use defaults.
414 411 */
415 412
416 413 switch (chip & 0xFF00) {
417 414 case 0x2200:
418 415 case 0x2300:
419 416 case 0x6300:
420 417 /* Table based data */
421 418 for (i = 0; models[i].ssid; i++) {
422 419 if ((model == models[i].ssid) &&
423 420 (ssdevid == models[i].ssvid)) {
424 421 break;
425 422 }
426 423 }
427 424
428 425 if (models[i].ssid) {
429 426 (void) snprintf(attrs->model, FCHBA_MODEL_LEN, "%s",
430 427 models[i].model);
431 428 (void) snprintf(attrs->model_description,
432 429 FCHBA_MODEL_DESCRIPTION_LEN, "%s",
433 430 models[i].model_description);
434 431 } else {
435 432 (void) snprintf(attrs->model, FCHBA_MODEL_LEN,
436 433 "%x", chip);
437 434 (void) snprintf(attrs->model_description,
438 435 FCHBA_MODEL_DESCRIPTION_LEN, "%x", chip);
439 436 }
440 437
441 438 /* Special model handling for RoHS version of the HBA */
442 439 if (models[i].ssid == 0x10a && ha->adapInfo[10] ==
443 440 (uint8_t)0x36) {
444 441 (void) snprintf(attrs->model, FCHBA_MODEL_LEN, "%s",
445 442 "375-3363-xx");
446 443 (void) snprintf(attrs->model_description,
447 444 FCHBA_MODEL_DESCRIPTION_LEN, "%s",
448 445 "SG-XPCI2FC-QF2-Z");
449 446 }
450 447 break;
451 448
452 449 case 0x2400:
453 450 case 0x2500:
454 451 case 0x5400:
455 452 case 0x8400:
456 453 case 0x8000:
457 454 default:
458 455 if ((i = ql_vpd_lookup(ha, (uint8_t *)VPD_TAG_PN,
459 456 (uint8_t *)attrs->model, FCHBA_MODEL_LEN)) >= 0) {
460 457 (void) ql_vpd_lookup(ha, (uint8_t *)VPD_TAG_PRODID,
461 458 (uint8_t *)attrs->model_description,
462 459 FCHBA_MODEL_DESCRIPTION_LEN);
463 460 } else {
464 461 (void) snprintf(attrs->model, FCHBA_MODEL_LEN,
465 462 "%x", chip);
466 463 (void) snprintf(attrs->model_description,
467 464 FCHBA_MODEL_DESCRIPTION_LEN, "%x", chip);
468 465 }
469 466 break;
470 467 }
471 468
472 469 /*
473 470 * Populate the LV symbolic node and port name strings
474 471 *
475 472 * Symbolic node name format is:
476 473 * <hostname>
477 474 *
478 475 * Symbolic port name format is:
479 476 * <driver_name>(<instance>,<vp index>)
480 477 */
|
↓ open down ↓ |
132 lines elided |
↑ open up ↑ |
481 478 vlen = (strlen(utsname.nodename) > FCHBA_SYMB_NAME_LEN ?
482 479 FCHBA_SYMB_NAME_LEN : strlen(utsname.nodename));
483 480 (void) snprintf((int8_t *)attrs->sym_node_name, vlen, "%s",
484 481 utsname.nodename);
485 482
486 483 vlen = (strlen(QL_NAME) + 9 > FCHBA_SYMB_NAME_LEN ?
487 484 FCHBA_SYMB_NAME_LEN : strlen(QL_NAME) + 9);
488 485 (void) snprintf((int8_t *)attrs->sym_port_name, vlen,
489 486 "%s(%d,%d)", QL_NAME, ha->instance, ha->vp_index);
490 487
491 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
488 + QL_PRINT_3(ha, "done\n");
492 489 }
493 490
494 491 /*
495 492 * ql_setup_fruinfo
496 493 * Generates common id's for instances on the same
497 494 * physical HBA.
498 495 *
499 496 * Input:
500 497 * ha = adapter state structure
501 498 *
502 499 * Returns:
503 500 *
504 501 * Context:
505 502 * Kernel context.
506 503 */
507 504 void
508 505 ql_setup_fruinfo(ql_adapter_state_t *ha)
509 506 {
510 - uint32_t mybasedev_len;
507 + uint32_t mybasedev_len;
511 508 ql_adapter_state_t *base_ha = NULL;
512 509
513 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
510 + QL_PRINT_3(ha, "started\n");
514 511
515 512 /*
516 513 * To generate common id for instances residing on the
517 514 * the same HBA, the devpath for each instance is parsed
518 515 * and those instances which have matching base devpaths are
519 516 * given same hba_index, and each port on the same hba are
520 517 * then assigned unique port_indexs based on the devpath.
521 518 */
522 519
523 520 /*
524 521 * Get this ha's basedev path and its port index
525 522 */
526 523 if (ql_get_basedev_len(ha, &mybasedev_len, &ha->fru_port_index) == 0) {
527 524
528 - GLOBAL_STATE_LOCK();
529 -
530 525 /*
531 526 * Search for this basedev against all of the
532 527 * ha in the ql_hba global list. If found one
533 528 * then we are part of other adapter in the
534 529 * ql_hba list and hence use that ha's hba_index.
535 530 * If not create a new one from the global hba index.
536 531 */
537 532 base_ha = ql_search_basedev(ha, mybasedev_len);
538 533 if (base_ha != NULL && base_ha->fru_hba_index != 0) {
539 534 ha->fru_hba_index = base_ha->fru_hba_index;
535 + ha->fru_port_index = base_ha->fru_port_index + 1;
540 536 } else {
541 537 ha->fru_hba_index = ql_gfru_hba_index++;
538 + ha->fru_port_index = 0;
542 539 }
543 -
544 - if (CFG_IST(ha, CFG_CTRL_8081)) {
545 - /*
546 - * The FC functions on 81xx hbas are functions 2 and 3
547 - * while the Nic functions occupy 0 and 1. Adjust
548 - * fru port index to be like previous FCAs.
549 - */
550 - ha->fru_port_index = ha->flags & FUNCTION_1 ? 1 : 0;
551 - }
552 -
553 - GLOBAL_STATE_UNLOCK();
554 -
555 540 } else {
556 541 ha->fru_hba_index = 0;
557 542 ha->fru_port_index = 0;
558 543 }
559 544
560 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
545 + QL_PRINT_3(ha, "done\n");
561 546 }
562 547
563 548 /*
564 549 * ql_get_basedev_len
565 550 *
566 551 * Gets the length of the base device name in the
567 552 * devpath of the current instance.
568 553 *
569 554 * Input:
570 555 * ha - adapter state pointer.
571 556 * basedev_len - pointer to the integer which
572 557 * holds the calculated length.
573 558 * port_index - pointer to the integer which
574 559 * contains the port index of
575 560 * for this device.
576 561 * Returns:
577 562 * 0 if successfully parsed, -1 otherwise.
578 563 *
579 564 * Context:
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
580 565 * Kernel context.
581 566 */
582 567 static uint32_t
583 568 ql_get_basedev_len(ql_adapter_state_t *ha, uint32_t *basedev_len,
584 569 uint32_t *port_index)
585 570 {
586 571 int32_t dev_off;
587 572 int32_t port_off;
588 573 int8_t *devstr;
589 574
590 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
575 + QL_PRINT_3(ha, "started\n");
591 576
592 577 if (ha->devpath == NULL) {
593 578 return ((uint32_t)-1);
594 579 }
595 580
596 581 dev_off = (int32_t)(strlen(ha->devpath) - 1);
597 582 port_off = -1;
598 583
599 584 /* Until we reach the first char or a '@' char in the path */
600 585 while ((dev_off >= 0) && (ha->devpath[dev_off] != '@')) {
601 586
602 587 if (ha->devpath[dev_off] == ',') {
603 588 port_off = dev_off + 1;
604 589 }
605 590
606 591 dev_off--;
607 592 }
608 593
609 594 if (dev_off < 0) {
610 595 EL(ha, "Invalid device path '%s'. Cannot get basedev\n",
611 596 ha->devpath);
612 597 return ((uint32_t)-1);
613 598 }
614 599
615 600 if (port_off == -1) {
616 601 *port_index = 0;
617 602 *basedev_len = (uint32_t)strlen(ha->devpath);
618 603 } else {
619 604 /* Get the port index */
620 605 devstr = ha->devpath + port_off;
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
621 606 *port_index = stoi(&devstr);
622 607 if (*port_index == 0) {
623 608 EL(ha, "Invalid device path '%s'. Cannot get "
624 609 "port_index\n", ha->devpath);
625 610 return ((uint32_t)-1);
626 611 }
627 612
628 613 *basedev_len = (uint32_t)(port_off - 1);
629 614 }
630 615
631 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
616 + QL_PRINT_3(ha, "done\n");
632 617
633 618 return (0);
634 619 }
635 620
636 621 /*
637 622 * ql_search_basedev
638 623 * Searches the list of ha instances to find which
639 624 * ha instance has same base device path as input's.
640 625 *
641 626 * Input:
642 627 * myha = current adapter state pointer.
643 628 * mybasedev_len = Length of the base device in the
644 629 * device path name.
645 630 *
646 631 * Returns:
647 632 * If match = ptr to matching ha structure.
648 633 * If no match = NULL ptr.
649 634 *
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
650 635 * Context:
651 636 * Kernel context.
652 637 */
653 638 static ql_adapter_state_t *
654 639 ql_search_basedev(ql_adapter_state_t *myha, uint32_t mybasedev_len)
655 640 {
656 641 ql_link_t *link;
657 642 ql_adapter_state_t *ha;
658 643 uint32_t basedev_len, port_index;
659 644
660 - QL_PRINT_3(CE_CONT, "(%d): started\n", myha->instance);
645 + QL_PRINT_3(myha, "started\n", myha->instance);
661 646
662 647 for (link = ql_hba.first; link != NULL; link = link->next) {
663 648
664 649 ha = link->base_address;
665 650
666 651 if (ha == NULL) {
667 652 EL(myha, "null ha link detected!\n");
668 653 return (NULL);
669 654 }
670 655
671 656 if (ha == myha) {
672 657 continue;
673 658 }
674 659
675 660 if (ql_get_basedev_len(ha, &basedev_len, &port_index) != 0) {
676 661 if (ha->devpath == NULL) {
677 662 EL(myha, "Device path NULL. Unable to get "
678 663 "the basedev\n");
679 664 } else {
680 665 EL(myha, "Invalid device path '%s'. Cannot "
681 666 "get the hba index and port index\n",
682 667 ha->devpath);
683 668 }
684 669 continue;
685 670 }
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
686 671
687 672 /*
688 673 * If both the basedev len do not match, then it
689 674 * is obvious that both are not pointing to the
690 675 * same base device.
691 676 */
692 677 if ((basedev_len == mybasedev_len) && (strncmp(myha->devpath,
693 678 ha->devpath, basedev_len) == 0)) {
694 679
695 680 /* We found the ha with same basedev */
696 - QL_PRINT_3(CE_CONT, "(%d): found, done\n",
681 + QL_PRINT_3(myha, "found, done\n",
697 682 myha->instance);
698 683 return (ha);
699 684 }
700 685 }
701 686
702 - QL_PRINT_3(CE_CONT, "(%d): not found, done\n", myha->instance);
687 + QL_PRINT_3(myha, "not found, done\n", myha->instance);
703 688
704 689 return (NULL);
705 690 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX