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_ioctl.c
+++ new/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_ioctl.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 - * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
25 + * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
26 26 */
27 27
28 -#pragma ident "Copyright 2010 QLogic Corporation; ql_ioctl.c"
28 +#pragma ident "Copyright 2015 QLogic Corporation; ql_ioctl.c"
29 29
30 30 /*
31 31 * ISP2xxx Solaris Fibre Channel Adapter (FCA) driver source file.
32 32 * Fibre Channel Adapter (FCA) driver IOCTL source file.
33 33 *
34 34 * ***********************************************************************
35 35 * * **
36 36 * * NOTICE **
37 - * * COPYRIGHT (C) 1996-2010 QLOGIC CORPORATION **
37 + * * COPYRIGHT (C) 1996-2015 QLOGIC CORPORATION **
38 38 * * ALL RIGHTS RESERVED **
39 39 * * **
40 40 * ***********************************************************************
41 41 *
42 42 */
43 43
44 44 #include <ql_apps.h>
45 45 #include <ql_api.h>
46 46 #include <ql_debug.h>
47 47 #include <ql_init.h>
48 48 #include <ql_ioctl.h>
49 49 #include <ql_mbx.h>
50 +#include <ql_nx.h>
50 51 #include <ql_xioctl.h>
51 52
52 53 /*
53 54 * Local Function Prototypes.
54 55 */
55 56 static int ql_busy_notification(ql_adapter_state_t *);
56 57 static int ql_idle_notification(ql_adapter_state_t *);
57 58 static int ql_get_feature_bits(ql_adapter_state_t *ha, uint16_t *features);
58 59 static int ql_set_feature_bits(ql_adapter_state_t *ha, uint16_t features);
59 60 static int ql_set_nvram_adapter_defaults(ql_adapter_state_t *ha);
60 61 static void ql_load_nvram(ql_adapter_state_t *ha, uint8_t addr,
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
61 62 uint16_t value);
62 63 static int ql_24xx_load_nvram(ql_adapter_state_t *, uint32_t, uint32_t);
63 64 static int ql_adm_op(ql_adapter_state_t *, void *, int);
64 65 static int ql_adm_adapter_info(ql_adapter_state_t *, ql_adm_op_t *, int);
65 66 static int ql_adm_extended_logging(ql_adapter_state_t *, ql_adm_op_t *);
66 67 static int ql_adm_device_list(ql_adapter_state_t *, ql_adm_op_t *, int);
67 68 static int ql_adm_update_properties(ql_adapter_state_t *);
68 69 static int ql_adm_prop_update_int(ql_adapter_state_t *, ql_adm_op_t *, int);
69 70 static int ql_adm_loop_reset(ql_adapter_state_t *);
70 71 static int ql_adm_fw_dump(ql_adapter_state_t *, ql_adm_op_t *, void *, int);
72 +static int ql_adm_fw_t_dump(ql_adapter_state_t *);
73 +static int ql_adm_beacon(ql_adapter_state_t *, ql_adm_op_t *);
71 74 static int ql_adm_nvram_dump(ql_adapter_state_t *, ql_adm_op_t *, int);
72 75 static int ql_adm_nvram_load(ql_adapter_state_t *, ql_adm_op_t *, int);
73 76 static int ql_adm_flash_load(ql_adapter_state_t *, ql_adm_op_t *, int);
74 77 static int ql_adm_vpd_dump(ql_adapter_state_t *, ql_adm_op_t *, int);
75 78 static int ql_adm_vpd_load(ql_adapter_state_t *, ql_adm_op_t *, int);
76 79 static int ql_adm_vpd_gettag(ql_adapter_state_t *, ql_adm_op_t *, int);
77 80 static int ql_adm_updfwmodule(ql_adapter_state_t *, ql_adm_op_t *, int);
78 81 static uint8_t *ql_vpd_findtag(ql_adapter_state_t *, uint8_t *, int8_t *);
79 82
80 83 /* ************************************************************************ */
81 84 /* cb_ops functions */
82 85 /* ************************************************************************ */
83 86
84 87 /*
85 88 * ql_open
86 89 * opens device
87 90 *
88 91 * Input:
89 92 * dev_p = device pointer
90 93 * flags = open flags
91 94 * otype = open type
92 95 * cred_p = credentials pointer
93 96 *
94 97 * Returns:
95 98 * 0 = success
96 99 *
97 100 * Context:
98 101 * Kernel context.
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
99 102 */
100 103 /* ARGSUSED */
101 104 int
102 105 ql_open(dev_t *dev_p, int flags, int otyp, cred_t *cred_p)
103 106 {
104 107 ql_adapter_state_t *ha;
105 108 int rval = 0;
106 109
107 110 ha = ddi_get_soft_state(ql_state, (int32_t)getminor(*dev_p));
108 111 if (ha == NULL) {
109 - QL_PRINT_2(CE_CONT, "failed, no adapter\n");
112 + QL_PRINT_2(NULL, "failed, no adapter\n");
110 113 return (ENXIO);
111 114 }
112 115
113 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
116 + QL_PRINT_3(ha, "started\n");
114 117
115 118 /* Allow only character opens */
116 119 if (otyp != OTYP_CHR) {
117 - QL_PRINT_2(CE_CONT, "(%d): failed, open type\n",
118 - ha->instance);
120 + QL_PRINT_2(ha, "failed, open type\n");
119 121 return (EINVAL);
120 122 }
121 123
122 124 ADAPTER_STATE_LOCK(ha);
123 125 if (flags & FEXCL && ha->flags & QL_OPENED) {
124 126 ADAPTER_STATE_UNLOCK(ha);
125 127 rval = EBUSY;
126 128 } else {
127 129 ha->flags |= QL_OPENED;
128 130 ADAPTER_STATE_UNLOCK(ha);
129 131 }
130 132
131 133 if (rval != 0) {
132 134 EL(ha, "failed, rval = %xh\n", rval);
133 135 } else {
134 136 /*EMPTY*/
135 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
137 + QL_PRINT_3(ha, "done\n");
136 138 }
137 139 return (rval);
138 140 }
139 141
140 142 /*
141 143 * ql_close
142 144 * opens device
143 145 *
144 146 * Input:
145 147 * dev_p = device pointer
146 148 * flags = open flags
147 149 * otype = open type
148 150 * cred_p = credentials pointer
149 151 *
150 152 * Returns:
151 153 * 0 = success
152 154 *
153 155 * Context:
154 156 * Kernel context.
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
155 157 */
156 158 /* ARGSUSED */
157 159 int
158 160 ql_close(dev_t dev, int flags, int otyp, cred_t *cred_p)
159 161 {
160 162 ql_adapter_state_t *ha;
161 163 int rval = 0;
162 164
163 165 ha = ddi_get_soft_state(ql_state, (int32_t)getminor(dev));
164 166 if (ha == NULL) {
165 - QL_PRINT_2(CE_CONT, "failed, no adapter\n");
167 + QL_PRINT_2(ha, "failed, no adapter\n");
166 168 return (ENXIO);
167 169 }
168 170
169 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
171 + QL_PRINT_3(ha, "started\n");
170 172
171 173 if (otyp != OTYP_CHR) {
172 - QL_PRINT_2(CE_CONT, "(%d): failed, open type\n",
173 - ha->instance);
174 + QL_PRINT_2(ha, "failed, open type\n");
174 175 return (EINVAL);
175 176 }
176 177
177 178 ADAPTER_STATE_LOCK(ha);
178 179 ha->flags &= ~QL_OPENED;
179 180 ADAPTER_STATE_UNLOCK(ha);
180 181
181 182 if (rval != 0) {
182 183 EL(ha, "failed, rval = %xh\n", rval);
183 184 } else {
184 185 /*EMPTY*/
185 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
186 + QL_PRINT_3(ha, "done\n");
186 187 }
187 188 return (rval);
188 189 }
189 190
190 191 /*
191 192 * ql_ioctl
192 193 * control a character device
193 194 *
194 195 * Input:
195 196 * dev = device number
196 197 * cmd = function to perform
197 198 * arg = data type varies with request
198 199 * mode = flags
199 200 * cred_p = credentials pointer
200 201 * rval_p = pointer to result value
201 202 *
202 203 * Returns:
203 204 * 0 = success
204 205 *
205 206 * Context:
206 207 * Kernel context.
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
207 208 */
208 209 /* ARGSUSED */
209 210 int
210 211 ql_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred_p,
211 212 int *rval_p)
212 213 {
213 214 ql_adapter_state_t *ha;
214 215 int rval = 0;
215 216
216 217 if (ddi_in_panic()) {
217 - QL_PRINT_2(CE_CONT, "ql_ioctl: ddi_in_panic exit\n");
218 + QL_PRINT_2(NULL, "ql_ioctl: ddi_in_panic exit\n");
218 219 return (ENOPROTOOPT);
219 220 }
220 221
221 222 ha = ddi_get_soft_state(ql_state, (int32_t)getminor(dev));
222 223 if (ha == NULL) {
223 - QL_PRINT_2(CE_CONT, "failed, no adapter\n");
224 + QL_PRINT_2(ha, "failed, no adapter\n");
224 225 return (ENXIO);
225 226 }
226 227
227 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
228 + QL_PRINT_3(ha, "started\n");
228 229
229 230 /*
230 231 * Quick clean exit for qla2x00 foapi calls which are
231 232 * not supported in qlc.
232 233 */
233 234 if (cmd >= QL_FOAPI_START && cmd <= QL_FOAPI_END) {
234 - QL_PRINT_9(CE_CONT, "failed, fo api not supported\n");
235 + QL_PRINT_9(ha, "failed, fo api not supported\n");
235 236 return (ENOTTY);
236 237 }
237 238
238 239 /* PWR management busy. */
239 240 rval = ql_busy_notification(ha);
240 241 if (rval != FC_SUCCESS) {
241 242 EL(ha, "failed, ql_busy_notification\n");
242 243 return (ENXIO);
243 244 }
244 245
245 246 rval = ql_xioctl(ha, cmd, arg, mode, cred_p, rval_p);
246 247 if (rval == ENOPROTOOPT || rval == EINVAL) {
247 248 switch (cmd) {
248 249 case QL_GET_ADAPTER_FEATURE_BITS: {
249 250 uint16_t bits;
250 251
251 252 rval = ql_get_feature_bits(ha, &bits);
252 253
253 254 if (!rval && ddi_copyout((void *)&bits, (void *)arg,
254 255 sizeof (bits), mode)) {
255 256 rval = EFAULT;
256 257 }
257 258 break;
258 259 }
259 260
260 261 case QL_SET_ADAPTER_FEATURE_BITS: {
261 262 uint16_t bits;
262 263
263 264 if (ddi_copyin((void *)arg, (void *)&bits,
264 265 sizeof (bits), mode)) {
265 266 rval = EFAULT;
266 267 break;
267 268 }
268 269
269 270 rval = ql_set_feature_bits(ha, bits);
270 271 break;
271 272 }
272 273
273 274 case QL_SET_ADAPTER_NVRAM_DEFAULTS:
274 275 rval = ql_set_nvram_adapter_defaults(ha);
275 276 break;
276 277
277 278 case QL_UTIL_LOAD:
278 279 rval = ql_nv_util_load(ha, (void *)arg, mode);
279 280 break;
280 281
281 282 case QL_UTIL_DUMP:
282 283 rval = ql_nv_util_dump(ha, (void *)arg, mode);
283 284 break;
284 285
285 286 case QL_ADM_OP:
286 287 rval = ql_adm_op(ha, (void *)arg, mode);
287 288 break;
288 289
289 290 default:
290 291 EL(ha, "unknown command = %d\n", cmd);
291 292 rval = ENOTTY;
292 293 break;
293 294 }
294 295 }
295 296
296 297 /* PWR management idle. */
297 298 (void) ql_idle_notification(ha);
298 299
|
↓ open down ↓ |
54 lines elided |
↑ open up ↑ |
299 300 if (rval != 0) {
300 301 /*
301 302 * Don't show failures caused by pps polling for
302 303 * non-existant virtual ports.
303 304 */
304 305 if (cmd != EXT_CC_VPORT_CMD) {
305 306 EL(ha, "failed, cmd=%d rval=%d\n", cmd, rval);
306 307 }
307 308 } else {
308 309 /*EMPTY*/
309 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
310 + QL_PRINT_9(ha, "done\n");
310 311 }
311 312 return (rval);
312 313 }
313 314
314 315 /*
315 316 * ql_busy_notification
316 317 * Adapter busy notification.
317 318 *
318 319 * Input:
319 320 * ha = adapter state pointer.
320 321 *
321 322 * Returns:
322 323 * FC_SUCCESS
323 324 * FC_FAILURE
324 325 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
325 326 * Context:
326 327 * Kernel context.
327 328 */
328 329 static int
329 330 ql_busy_notification(ql_adapter_state_t *ha)
330 331 {
331 332 if (!ha->pm_capable) {
332 333 return (FC_SUCCESS);
333 334 }
334 335
335 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
336 + QL_PRINT_9(ha, "started\n");
336 337
337 338 QL_PM_LOCK(ha);
338 - ha->busy++;
339 + ha->pm_busy++;
339 340 QL_PM_UNLOCK(ha);
340 341
341 342 if (pm_busy_component(ha->dip, 0) != DDI_SUCCESS) {
342 343 QL_PM_LOCK(ha);
343 - ha->busy--;
344 + if (ha->pm_busy) {
345 + ha->pm_busy--;
346 + }
344 347 QL_PM_UNLOCK(ha);
345 348
346 349 EL(ha, "pm_busy_component failed = %xh\n", FC_FAILURE);
347 350 return (FC_FAILURE);
348 351 }
349 352
350 353 QL_PM_LOCK(ha);
351 354 if (ha->power_level != PM_LEVEL_D0) {
352 355 QL_PM_UNLOCK(ha);
353 356 if (pm_raise_power(ha->dip, 0, 1) != DDI_SUCCESS) {
354 357 QL_PM_LOCK(ha);
355 - ha->busy--;
358 + if (ha->pm_busy) {
359 + ha->pm_busy--;
360 + }
356 361 QL_PM_UNLOCK(ha);
357 362 return (FC_FAILURE);
358 363 }
359 364 } else {
360 365 QL_PM_UNLOCK(ha);
361 366 }
362 367
363 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
368 + QL_PRINT_9(ha, "done\n");
364 369
365 370 return (FC_SUCCESS);
366 371 }
367 372
368 373 /*
369 374 * ql_idle_notification
370 375 * Adapter idle notification.
371 376 *
372 377 * Input:
373 378 * ha = adapter state pointer.
374 379 *
375 380 * Returns:
376 381 * FC_SUCCESS
377 382 * FC_FAILURE
378 383 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
379 384 * Context:
380 385 * Kernel context.
381 386 */
382 387 static int
383 388 ql_idle_notification(ql_adapter_state_t *ha)
384 389 {
385 390 if (!ha->pm_capable) {
386 391 return (FC_SUCCESS);
387 392 }
388 393
389 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
394 + QL_PRINT_9(ha, "started\n");
390 395
391 396 if (pm_idle_component(ha->dip, 0) != DDI_SUCCESS) {
392 397 EL(ha, "pm_idle_component failed = %xh\n", FC_FAILURE);
393 398 return (FC_FAILURE);
394 399 }
395 400
396 401 QL_PM_LOCK(ha);
397 - ha->busy--;
402 + if (ha->pm_busy) {
403 + ha->pm_busy--;
404 + }
398 405 QL_PM_UNLOCK(ha);
399 406
400 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
407 + QL_PRINT_9(ha, "done\n");
401 408
402 409 return (FC_SUCCESS);
403 410 }
404 411
405 412 /*
406 413 * Get adapter feature bits from NVRAM
407 414 */
408 415 static int
409 416 ql_get_feature_bits(ql_adapter_state_t *ha, uint16_t *features)
410 417 {
411 418 int count;
412 419 volatile uint16_t data;
413 420 uint32_t nv_cmd;
414 421 uint32_t start_addr;
415 422 int rval;
416 423 uint32_t offset = offsetof(nvram_t, adapter_features);
417 424
418 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
425 + QL_PRINT_9(ha, "started\n");
419 426
420 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
427 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
421 428 EL(ha, "Not supported for 24xx\n");
422 429 return (EINVAL);
423 430 }
424 431
425 432 /*
426 433 * The offset can't be greater than max of 8 bits and
427 434 * the following code breaks if the offset isn't at
428 435 * 2 byte boundary.
429 436 */
430 437 rval = ql_lock_nvram(ha, &start_addr, LNF_NVRAM_DATA);
431 438 if (rval != QL_SUCCESS) {
432 439 EL(ha, "failed, ql_lock_nvram=%xh\n", rval);
433 440 return (EIO);
434 441 }
435 442
436 443 /*
437 444 * Have the most significant 3 bits represent the read operation
438 445 * followed by the 8 bits representing the offset at which we
439 446 * are going to perform the read operation
440 447 */
441 448 offset >>= 1;
442 449 offset += start_addr;
443 450 nv_cmd = (offset << 16) | NV_READ_OP;
444 451 nv_cmd <<= 5;
445 452
446 453 /*
447 454 * Select the chip and feed the command and address
448 455 */
449 456 for (count = 0; count < 11; count++) {
450 457 if (nv_cmd & BIT_31) {
451 458 ql_nv_write(ha, NV_DATA_OUT);
452 459 } else {
453 460 ql_nv_write(ha, 0);
454 461 }
455 462 nv_cmd <<= 1;
456 463 }
457 464
458 465 *features = 0;
459 466 for (count = 0; count < 16; count++) {
460 467 WRT16_IO_REG(ha, nvram, NV_SELECT | NV_CLOCK);
461 468 ql_nv_delay();
462 469
463 470 data = RD16_IO_REG(ha, nvram);
464 471 *features <<= 1;
465 472 if (data & NV_DATA_IN) {
466 473 *features = (uint16_t)(*features | 0x1);
467 474 }
468 475
469 476 WRT16_IO_REG(ha, nvram, NV_SELECT);
|
↓ open down ↓ |
39 lines elided |
↑ open up ↑ |
470 477 ql_nv_delay();
471 478 }
472 479
473 480 /*
474 481 * Deselect the chip
475 482 */
476 483 WRT16_IO_REG(ha, nvram, NV_DESELECT);
477 484
478 485 ql_release_nvram(ha);
479 486
480 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
487 + QL_PRINT_9(ha, "done\n");
481 488
482 489 return (0);
483 490 }
484 491
485 492 /*
486 493 * Set adapter feature bits in NVRAM
487 494 */
488 495 static int
489 496 ql_set_feature_bits(ql_adapter_state_t *ha, uint16_t features)
490 497 {
491 498 int rval;
492 499 uint32_t count;
493 500 nvram_t *nv;
494 501 uint16_t *wptr;
495 502 uint8_t *bptr;
496 503 uint8_t csum;
497 504 uint32_t start_addr;
498 505
499 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
506 + QL_PRINT_9(ha, "started\n");
500 507
501 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
508 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
502 509 EL(ha, "Not supported for 24xx\n");
503 510 return (EINVAL);
504 511 }
505 512
506 513 nv = kmem_zalloc(sizeof (*nv), KM_SLEEP);
507 514 if (nv == NULL) {
508 515 EL(ha, "failed, kmem_zalloc\n");
509 516 return (ENOMEM);
510 517 }
511 518
512 519 rval = ql_lock_nvram(ha, &start_addr, LNF_NVRAM_DATA);
513 520 if (rval != QL_SUCCESS) {
514 521 EL(ha, "failed, ql_lock_nvram=%xh\n", rval);
515 522 kmem_free(nv, sizeof (*nv));
516 523 return (EIO);
517 524 }
518 525 rval = 0;
519 526
520 527 /*
521 528 * Read off the whole NVRAM
522 529 */
523 530 wptr = (uint16_t *)nv;
524 531 csum = 0;
525 532 for (count = 0; count < sizeof (nvram_t) / 2; count++) {
526 533 *wptr = (uint16_t)ql_get_nvram_word(ha, count + start_addr);
527 534 csum = (uint8_t)(csum + (uint8_t)*wptr);
528 535 csum = (uint8_t)(csum + (uint8_t)(*wptr >> 8));
529 536 wptr++;
530 537 }
531 538
532 539 /*
533 540 * If the checksum is BAD then fail it right here.
534 541 */
535 542 if (csum) {
536 543 kmem_free(nv, sizeof (*nv));
537 544 ql_release_nvram(ha);
538 545 return (EBADF);
539 546 }
540 547
541 548 nv->adapter_features[0] = (uint8_t)((features & 0xFF00) >> 8);
542 549 nv->adapter_features[1] = (uint8_t)(features & 0xFF);
543 550
544 551 /*
545 552 * Recompute the chesksum now
546 553 */
547 554 bptr = (uint8_t *)nv;
548 555 for (count = 0; count < sizeof (nvram_t) - 1; count++) {
549 556 csum = (uint8_t)(csum + *bptr++);
550 557 }
551 558 csum = (uint8_t)(~csum + 1);
552 559 nv->checksum = csum;
553 560
554 561 /*
555 562 * Now load the NVRAM
556 563 */
557 564 wptr = (uint16_t *)nv;
558 565 for (count = 0; count < sizeof (nvram_t) / 2; count++) {
559 566 ql_load_nvram(ha, (uint8_t)(count + start_addr), *wptr++);
560 567 }
561 568
562 569 /*
563 570 * Read NVRAM and verify the contents
564 571 */
565 572 wptr = (uint16_t *)nv;
566 573 csum = 0;
567 574 for (count = 0; count < sizeof (nvram_t) / 2; count++) {
568 575 if (ql_get_nvram_word(ha, count + start_addr) != *wptr) {
569 576 rval = EIO;
570 577 break;
571 578 }
572 579 csum = (uint8_t)(csum + (uint8_t)*wptr);
573 580 csum = (uint8_t)(csum + (uint8_t)(*wptr >> 8));
|
↓ open down ↓ |
62 lines elided |
↑ open up ↑ |
574 581 wptr++;
575 582 }
576 583
577 584 if (csum) {
578 585 rval = EINVAL;
579 586 }
580 587
581 588 kmem_free(nv, sizeof (*nv));
582 589 ql_release_nvram(ha);
583 590
584 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
591 + QL_PRINT_9(ha, "done\n");
585 592
586 593 return (rval);
587 594 }
588 595
589 596 /*
590 597 * Fix this function to update just feature bits and checksum in NVRAM
591 598 */
592 599 static int
593 600 ql_set_nvram_adapter_defaults(ql_adapter_state_t *ha)
594 601 {
595 602 int rval;
596 603 uint32_t count;
597 604 uint32_t start_addr;
598 605
599 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
606 + QL_PRINT_9(ha, "started\n");
600 607
601 608 rval = ql_lock_nvram(ha, &start_addr, LNF_NVRAM_DATA);
602 609 if (rval != QL_SUCCESS) {
603 610 EL(ha, "failed, ql_lock_nvram=%xh\n", rval);
604 611 return (EIO);
605 612 }
606 613 rval = 0;
607 614
608 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
615 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
609 616 nvram_24xx_t *nv;
610 617 uint32_t *longptr;
611 618 uint32_t csum = 0;
612 619
613 620 nv = kmem_zalloc(sizeof (*nv), KM_SLEEP);
614 621 if (nv == NULL) {
615 622 EL(ha, "failed, kmem_zalloc\n");
616 623 return (ENOMEM);
617 624 }
618 625
619 626 nv->nvram_version[0] = LSB(ICB_24XX_VERSION);
620 627 nv->nvram_version[1] = MSB(ICB_24XX_VERSION);
621 628
622 629 nv->version[0] = 1;
623 630 nv->max_frame_length[1] = 8;
624 631 nv->execution_throttle[0] = 16;
625 632 nv->login_retry_count[0] = 8;
626 633
627 634 nv->firmware_options_1[0] = BIT_2 | BIT_1;
628 635 nv->firmware_options_1[1] = BIT_5;
629 636 nv->firmware_options_2[0] = BIT_5;
630 637 nv->firmware_options_2[1] = BIT_4;
631 638 nv->firmware_options_3[1] = BIT_6;
632 639
633 640 /*
634 641 * Set default host adapter parameters
635 642 */
636 643 nv->host_p[0] = BIT_4 | BIT_1;
637 644 nv->host_p[1] = BIT_3 | BIT_2;
|
↓ open down ↓ |
19 lines elided |
↑ open up ↑ |
638 645 nv->reset_delay = 5;
639 646 nv->max_luns_per_target[0] = 128;
640 647 nv->port_down_retry_count[0] = 30;
641 648 nv->link_down_timeout[0] = 30;
642 649
643 650 /*
644 651 * compute the chesksum now
645 652 */
646 653 longptr = (uint32_t *)nv;
647 654 csum = 0;
648 - for (count = 0; count < (sizeof (nvram_24xx_t)/4)-1; count++) {
655 + for (count = 0; count < (sizeof (nvram_24xx_t) / 4) - 1;
656 + count++) {
649 657 csum += *longptr;
650 658 longptr++;
651 659 }
652 660 csum = (uint32_t)(~csum + 1);
653 661 LITTLE_ENDIAN_32((long)csum);
654 662 *longptr = csum;
655 663
656 664 /*
657 665 * Now load the NVRAM
658 666 */
659 667 longptr = (uint32_t *)nv;
660 668 for (count = 0; count < sizeof (nvram_24xx_t) / 4; count++) {
661 669 (void) ql_24xx_load_nvram(ha,
662 670 (uint32_t)(count + start_addr), *longptr++);
663 671 }
664 672
665 673 /*
666 674 * Read NVRAM and verify the contents
667 675 */
668 676 csum = 0;
669 677 longptr = (uint32_t *)nv;
670 678 for (count = 0; count < sizeof (nvram_24xx_t) / 4; count++) {
671 679 rval = ql_24xx_read_flash(ha, count + start_addr,
672 680 longptr);
673 681 if (rval != QL_SUCCESS) {
674 682 EL(ha, "24xx_read_flash failed=%xh\n", rval);
675 683 break;
676 684 }
677 685 csum += *longptr;
678 686 }
679 687
680 688 if (csum) {
681 689 rval = EINVAL;
682 690 }
683 691 kmem_free(nv, sizeof (nvram_24xx_t));
684 692 } else {
685 693 nvram_t *nv;
686 694 uint16_t *wptr;
687 695 uint8_t *bptr;
688 696 uint8_t csum;
689 697
690 698 nv = kmem_zalloc(sizeof (*nv), KM_SLEEP);
691 699 if (nv == NULL) {
692 700 EL(ha, "failed, kmem_zalloc\n");
693 701 return (ENOMEM);
694 702 }
695 703 /*
696 704 * Set default initialization control block.
697 705 */
698 706 nv->parameter_block_version = ICB_VERSION;
699 707 nv->firmware_options[0] = BIT_4 | BIT_3 | BIT_2 | BIT_1;
700 708 nv->firmware_options[1] = BIT_7 | BIT_5 | BIT_2;
701 709
702 710 nv->max_frame_length[1] = 4;
703 711 nv->max_iocb_allocation[1] = 1;
704 712 nv->execution_throttle[0] = 16;
705 713 nv->login_retry_count = 8;
706 714 nv->port_name[0] = 33;
707 715 nv->port_name[3] = 224;
708 716 nv->port_name[4] = 139;
709 717 nv->login_timeout = 4;
710 718
711 719 /*
712 720 * Set default host adapter parameters
713 721 */
714 722 nv->host_p[0] = BIT_1;
715 723 nv->host_p[1] = BIT_2;
716 724 nv->reset_delay = 5;
717 725 nv->port_down_retry_count = 8;
718 726 nv->maximum_luns_per_target[0] = 8;
719 727
720 728 /*
721 729 * compute the chesksum now
722 730 */
723 731 bptr = (uint8_t *)nv;
724 732 csum = 0;
725 733 for (count = 0; count < sizeof (nvram_t) - 1; count++) {
726 734 csum = (uint8_t)(csum + *bptr++);
727 735 }
728 736 csum = (uint8_t)(~csum + 1);
729 737 nv->checksum = csum;
730 738
731 739 /*
732 740 * Now load the NVRAM
733 741 */
734 742 wptr = (uint16_t *)nv;
735 743 for (count = 0; count < sizeof (nvram_t) / 2; count++) {
736 744 ql_load_nvram(ha, (uint8_t)(count + start_addr),
737 745 *wptr++);
738 746 }
739 747
740 748 /*
741 749 * Read NVRAM and verify the contents
742 750 */
743 751 wptr = (uint16_t *)nv;
744 752 csum = 0;
745 753 for (count = 0; count < sizeof (nvram_t) / 2; count++) {
746 754 if (ql_get_nvram_word(ha, count + start_addr) !=
747 755 *wptr) {
748 756 rval = EIO;
749 757 break;
750 758 }
751 759 csum = (uint8_t)(csum + (uint8_t)*wptr);
|
↓ open down ↓ |
93 lines elided |
↑ open up ↑ |
752 760 csum = (uint8_t)(csum + (uint8_t)(*wptr >> 8));
753 761 wptr++;
754 762 }
755 763 if (csum) {
756 764 rval = EINVAL;
757 765 }
758 766 kmem_free(nv, sizeof (*nv));
759 767 }
760 768 ql_release_nvram(ha);
761 769
762 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
770 + QL_PRINT_9(ha, "done\n");
763 771
764 772 return (rval);
765 773 }
766 774
767 775 static void
768 776 ql_load_nvram(ql_adapter_state_t *ha, uint8_t addr, uint16_t value)
769 777 {
770 778 int count;
771 779 volatile uint16_t word;
772 780 volatile uint32_t nv_cmd;
773 781
774 782 ql_nv_write(ha, NV_DATA_OUT);
775 783 ql_nv_write(ha, 0);
776 784 ql_nv_write(ha, 0);
777 785
778 786 for (word = 0; word < 8; word++) {
779 787 ql_nv_write(ha, NV_DATA_OUT);
780 788 }
781 789
782 790 /*
783 791 * Deselect the chip
784 792 */
785 793 WRT16_IO_REG(ha, nvram, NV_DESELECT);
786 794 ql_nv_delay();
787 795
788 796 /*
789 797 * Erase Location
790 798 */
791 799 nv_cmd = (addr << 16) | NV_ERASE_OP;
792 800 nv_cmd <<= 5;
793 801 for (count = 0; count < 11; count++) {
794 802 if (nv_cmd & BIT_31) {
795 803 ql_nv_write(ha, NV_DATA_OUT);
796 804 } else {
797 805 ql_nv_write(ha, 0);
798 806 }
799 807 nv_cmd <<= 1;
800 808 }
801 809
802 810 /*
803 811 * Wait for Erase to Finish
804 812 */
805 813 WRT16_IO_REG(ha, nvram, NV_DESELECT);
806 814 ql_nv_delay();
807 815 WRT16_IO_REG(ha, nvram, NV_SELECT);
808 816 word = 0;
809 817 while ((word & NV_DATA_IN) == 0) {
810 818 ql_nv_delay();
811 819 word = RD16_IO_REG(ha, nvram);
812 820 }
813 821 WRT16_IO_REG(ha, nvram, NV_DESELECT);
814 822 ql_nv_delay();
815 823
816 824 /*
817 825 * Write data now
818 826 */
819 827 nv_cmd = (addr << 16) | NV_WRITE_OP;
820 828 nv_cmd |= value;
821 829 nv_cmd <<= 5;
822 830 for (count = 0; count < 27; count++) {
823 831 if (nv_cmd & BIT_31) {
824 832 ql_nv_write(ha, NV_DATA_OUT);
825 833 } else {
826 834 ql_nv_write(ha, 0);
827 835 }
828 836 nv_cmd <<= 1;
829 837 }
830 838
831 839 /*
832 840 * Wait for NVRAM to become ready
833 841 */
834 842 WRT16_IO_REG(ha, nvram, NV_DESELECT);
835 843 ql_nv_delay();
836 844 WRT16_IO_REG(ha, nvram, NV_SELECT);
837 845 word = 0;
838 846 while ((word & NV_DATA_IN) == 0) {
839 847 ql_nv_delay();
840 848 word = RD16_IO_REG(ha, nvram);
841 849 }
842 850 WRT16_IO_REG(ha, nvram, NV_DESELECT);
843 851 ql_nv_delay();
844 852
845 853 /*
846 854 * Disable writes
847 855 */
848 856 ql_nv_write(ha, NV_DATA_OUT);
849 857 for (count = 0; count < 10; count++) {
850 858 ql_nv_write(ha, 0);
851 859 }
852 860
853 861 /*
854 862 * Deselect the chip now
855 863 */
856 864 WRT16_IO_REG(ha, nvram, NV_DESELECT);
857 865 }
858 866
859 867 /*
860 868 * ql_24xx_load_nvram
861 869 * Enable NVRAM and writes a 32bit word to ISP24xx NVRAM.
862 870 *
863 871 * Input:
864 872 * ha: adapter state pointer.
865 873 * addr: NVRAM address.
866 874 * value: data.
867 875 *
868 876 * Returns:
869 877 * ql local function return status code.
|
↓ open down ↓ |
97 lines elided |
↑ open up ↑ |
870 878 *
871 879 * Context:
872 880 * Kernel context.
873 881 */
874 882 static int
875 883 ql_24xx_load_nvram(ql_adapter_state_t *ha, uint32_t addr, uint32_t value)
876 884 {
877 885 int rval;
878 886
879 887 /* Enable flash write. */
880 - if (!(CFG_IST(ha, CFG_CTRL_8081))) {
888 + if (!(CFG_IST(ha, CFG_FCOE_SUPPORT))) {
881 889 WRT32_IO_REG(ha, ctrl_status,
882 890 RD32_IO_REG(ha, ctrl_status) | ISP_FLASH_ENABLE);
883 891 RD32_IO_REG(ha, ctrl_status); /* PCI Posting. */
884 892 }
885 893
886 894 /* Disable NVRAM write-protection. */
887 - if (CFG_IST(ha, CFG_CTRL_2422)) {
895 + if (CFG_IST(ha, CFG_CTRL_24XX)) {
888 896 (void) ql_24xx_write_flash(ha, NVRAM_CONF_ADDR | 0x101, 0);
889 897 } else {
890 898 if ((rval = ql_24xx_unprotect_flash(ha)) != QL_SUCCESS) {
891 899 EL(ha, "unprotect_flash failed, rval=%xh\n", rval);
892 900 return (rval);
893 901 }
894 902 }
895 903
896 904 /* Write to flash. */
897 905 rval = ql_24xx_write_flash(ha, addr, value);
898 906
899 907 /* Enable NVRAM write-protection. */
900 - if (CFG_IST(ha, CFG_CTRL_2422)) {
908 + if (CFG_IST(ha, CFG_CTRL_24XX)) {
901 909 /* TODO: Check if 0x8c is correct -- sb: 0x9c ? */
902 910 (void) ql_24xx_write_flash(ha, NVRAM_CONF_ADDR | 0x101, 0x8c);
903 911 } else {
904 912 ql_24xx_protect_flash(ha);
905 913 }
906 914
907 915 /* Disable flash write. */
908 916 if (!(CFG_IST(ha, CFG_CTRL_81XX))) {
909 917 WRT32_IO_REG(ha, ctrl_status,
910 918 RD32_IO_REG(ha, ctrl_status) & ~ISP_FLASH_ENABLE);
911 919 RD32_IO_REG(ha, ctrl_status); /* PCI Posting. */
912 920 }
913 921
914 922 return (rval);
915 923 }
916 924
917 925 /*
918 926 * ql_nv_util_load
919 927 * Loads NVRAM from application.
920 928 *
921 929 * Input:
922 930 * ha = adapter state pointer.
923 931 * bp = user buffer address.
924 932 *
925 933 * Returns:
926 934 *
927 935 * Context:
928 936 * Kernel context.
929 937 */
930 938 int
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
931 939 ql_nv_util_load(ql_adapter_state_t *ha, void *bp, int mode)
932 940 {
933 941 uint8_t cnt;
934 942 void *nv;
935 943 uint16_t *wptr;
936 944 uint16_t data;
937 945 uint32_t start_addr, *lptr, data32;
938 946 nvram_t *nptr;
939 947 int rval;
940 948
941 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
949 + QL_PRINT_9(ha, "started\n");
942 950
943 951 if ((nv = kmem_zalloc(ha->nvram_cache->size, KM_SLEEP)) == NULL) {
944 952 EL(ha, "failed, kmem_zalloc\n");
945 953 return (ENOMEM);
946 954 }
947 955
948 956 if (ddi_copyin(bp, nv, ha->nvram_cache->size, mode) != 0) {
949 957 EL(ha, "Buffer copy failed\n");
950 958 kmem_free(nv, ha->nvram_cache->size);
951 959 return (EFAULT);
952 960 }
953 961
954 962 /* See if the buffer passed to us looks sane */
955 963 nptr = (nvram_t *)nv;
956 964 if (nptr->id[0] != 'I' || nptr->id[1] != 'S' || nptr->id[2] != 'P' ||
957 965 nptr->id[3] != ' ') {
958 966 EL(ha, "failed, buffer sanity check\n");
959 967 kmem_free(nv, ha->nvram_cache->size);
960 968 return (EINVAL);
961 969 }
962 970
963 971 /* Quiesce I/O */
964 972 if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
965 973 EL(ha, "ql_stall_driver failed\n");
966 974 kmem_free(nv, ha->nvram_cache->size);
967 975 return (EBUSY);
968 976 }
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
969 977
970 978 rval = ql_lock_nvram(ha, &start_addr, LNF_NVRAM_DATA);
971 979 if (rval != QL_SUCCESS) {
972 980 EL(ha, "failed, ql_lock_nvram=%xh\n", rval);
973 981 kmem_free(nv, ha->nvram_cache->size);
974 982 ql_restart_driver(ha);
975 983 return (EIO);
976 984 }
977 985
978 986 /* Load NVRAM. */
979 - if (CFG_IST(ha, CFG_CTRL_258081)) {
987 + if (CFG_IST(ha, CFG_CTRL_252780818283)) {
980 988 GLOBAL_HW_UNLOCK();
981 989 start_addr &= ~ha->flash_data_addr;
982 990 start_addr <<= 2;
983 991 if ((rval = ql_r_m_w_flash(ha, bp, ha->nvram_cache->size,
984 992 start_addr, mode)) != QL_SUCCESS) {
985 993 EL(ha, "nvram load failed, rval = %0xh\n", rval);
986 994 }
987 995 GLOBAL_HW_LOCK();
988 - } else if (CFG_IST(ha, CFG_CTRL_2422)) {
996 + } else if (CFG_IST(ha, CFG_CTRL_24XX)) {
989 997 lptr = (uint32_t *)nv;
990 998 for (cnt = 0; cnt < ha->nvram_cache->size / 4; cnt++) {
991 999 data32 = *lptr++;
992 1000 LITTLE_ENDIAN_32(&data32);
993 1001 rval = ql_24xx_load_nvram(ha, cnt + start_addr,
994 1002 data32);
995 1003 if (rval != QL_SUCCESS) {
996 1004 EL(ha, "failed, 24xx_load_nvram=%xh\n", rval);
997 1005 break;
998 1006 }
999 1007 }
1000 1008 } else {
1001 1009 wptr = (uint16_t *)nv;
1002 1010 for (cnt = 0; cnt < ha->nvram_cache->size / 2; cnt++) {
1003 1011 data = *wptr++;
1004 1012 LITTLE_ENDIAN_16(&data);
1005 1013 ql_load_nvram(ha, (uint8_t)(cnt + start_addr), data);
1006 1014 }
1007 1015 }
1008 1016 /* switch to the new one */
1009 - NVRAM_CACHE_LOCK(ha);
1010 -
1011 1017 kmem_free(ha->nvram_cache->cache, ha->nvram_cache->size);
1012 1018 ha->nvram_cache->cache = (void *)nptr;
1013 1019
1014 - NVRAM_CACHE_UNLOCK(ha);
1015 -
1016 1020 ql_release_nvram(ha);
1017 1021 ql_restart_driver(ha);
1018 1022
1019 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1023 + QL_PRINT_9(ha, "done\n");
1020 1024
1021 1025 if (rval == QL_SUCCESS) {
1022 1026 return (0);
1023 1027 }
1024 1028
1025 1029 return (EFAULT);
1026 1030 }
1027 1031
1028 1032 /*
1029 1033 * ql_nv_util_dump
1030 1034 * Dumps NVRAM to application.
1031 1035 *
1032 1036 * Input:
1033 1037 * ha = adapter state pointer.
1034 1038 * bp = user buffer address.
1035 1039 *
1036 1040 * Returns:
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
1037 1041 *
1038 1042 * Context:
1039 1043 * Kernel context.
1040 1044 */
1041 1045 int
1042 1046 ql_nv_util_dump(ql_adapter_state_t *ha, void *bp, int mode)
1043 1047 {
1044 1048 uint32_t start_addr;
1045 1049 int rval2, rval = 0;
1046 1050
1047 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1051 + QL_PRINT_9(ha, "started\n");
1048 1052
1049 1053 if (ha->nvram_cache == NULL ||
1050 1054 ha->nvram_cache->size == NULL ||
1051 1055 ha->nvram_cache->cache == NULL) {
1052 1056 EL(ha, "failed, kmem_zalloc\n");
1053 1057 return (ENOMEM);
1054 1058 } else if (ha->nvram_cache->valid != 1) {
1055 1059
1056 1060 /* Quiesce I/O */
1057 1061 if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
1058 1062 EL(ha, "ql_stall_driver failed\n");
1059 1063 return (EBUSY);
1060 1064 }
1061 1065
1062 1066 rval2 = ql_lock_nvram(ha, &start_addr, LNF_NVRAM_DATA);
1063 1067 if (rval2 != QL_SUCCESS) {
1064 1068 EL(ha, "failed, ql_lock_nvram=%xh\n", rval2);
1065 1069 ql_restart_driver(ha);
1066 1070 return (EIO);
1067 1071 }
1068 - NVRAM_CACHE_LOCK(ha);
1069 -
1070 1072 rval2 = ql_get_nvram(ha, ha->nvram_cache->cache,
1071 1073 start_addr, ha->nvram_cache->size);
1072 1074 if (rval2 != QL_SUCCESS) {
1073 1075 rval = rval2;
1074 1076 } else {
1075 1077 ha->nvram_cache->valid = 1;
1076 1078 EL(ha, "nvram cache now valid.");
1077 1079 }
1078 1080
1079 - NVRAM_CACHE_UNLOCK(ha);
1080 -
1081 1081 ql_release_nvram(ha);
1082 1082 ql_restart_driver(ha);
1083 1083
1084 1084 if (rval != 0) {
1085 1085 EL(ha, "failed to dump nvram, rval=%x\n", rval);
1086 1086 return (rval);
1087 1087 }
1088 1088 }
1089 1089
1090 1090 if (ddi_copyout(ha->nvram_cache->cache, bp,
1091 1091 ha->nvram_cache->size, mode) != 0) {
1092 1092 EL(ha, "Buffer copy failed\n");
1093 1093 return (EFAULT);
1094 1094 }
1095 1095
1096 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1096 + QL_PRINT_9(ha, "done\n");
1097 1097
1098 1098 return (0);
1099 1099 }
1100 1100
1101 1101 int
1102 1102 ql_get_nvram(ql_adapter_state_t *ha, void *dest_addr, uint32_t src_addr,
1103 1103 uint32_t size)
1104 1104 {
1105 1105 int rval = QL_SUCCESS;
1106 1106 int cnt;
1107 1107 /* Dump NVRAM. */
1108 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1108 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1109 1109 uint32_t *lptr = (uint32_t *)dest_addr;
1110 1110
1111 1111 for (cnt = 0; cnt < size / 4; cnt++) {
1112 1112 rval = ql_24xx_read_flash(ha, src_addr++, lptr);
1113 1113 if (rval != QL_SUCCESS) {
1114 1114 EL(ha, "read_flash failed=%xh\n", rval);
1115 1115 rval = EAGAIN;
1116 1116 break;
1117 1117 }
1118 1118 LITTLE_ENDIAN_32(lptr);
1119 1119 lptr++;
1120 1120 }
1121 1121 } else {
1122 1122 uint16_t data;
1123 1123 uint16_t *wptr = (uint16_t *)dest_addr;
1124 1124
1125 1125 for (cnt = 0; cnt < size / 2; cnt++) {
1126 1126 data = (uint16_t)ql_get_nvram_word(ha, cnt +
1127 1127 src_addr);
1128 1128 LITTLE_ENDIAN_16(&data);
1129 1129 *wptr++ = data;
1130 1130 }
1131 1131 }
1132 1132 return (rval);
1133 1133 }
1134 1134
1135 1135 /*
1136 1136 * ql_vpd_load
1137 1137 * Loads VPD from application.
1138 1138 *
1139 1139 * Input:
1140 1140 * ha = adapter state pointer.
1141 1141 * bp = user buffer address.
1142 1142 *
1143 1143 * Returns:
1144 1144 *
1145 1145 * Context:
|
↓ open down ↓ |
27 lines elided |
↑ open up ↑ |
1146 1146 * Kernel context.
1147 1147 */
1148 1148 int
1149 1149 ql_vpd_load(ql_adapter_state_t *ha, void *bp, int mode)
1150 1150 {
1151 1151 uint8_t cnt;
1152 1152 uint8_t *vpd, *vpdptr, *vbuf;
1153 1153 uint32_t start_addr, vpd_size, *lptr, data32;
1154 1154 int rval;
1155 1155
1156 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1156 + QL_PRINT_9(ha, "started\n");
1157 1157
1158 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
1158 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
1159 1159 EL(ha, "unsupported adapter feature\n");
1160 1160 return (ENOTSUP);
1161 1161 }
1162 1162
1163 1163 vpd_size = QL_24XX_VPD_SIZE;
1164 1164
1165 1165 if ((vpd = kmem_zalloc(vpd_size, KM_SLEEP)) == NULL) {
1166 1166 EL(ha, "failed, kmem_zalloc\n");
1167 1167 return (ENOMEM);
1168 1168 }
1169 1169
1170 1170 if (ddi_copyin(bp, vpd, vpd_size, mode) != 0) {
1171 1171 EL(ha, "Buffer copy failed\n");
1172 1172 kmem_free(vpd, vpd_size);
1173 1173 return (EFAULT);
1174 1174 }
1175 1175
1176 1176 /* Sanity check the user supplied data via checksum */
1177 1177 if ((vpdptr = ql_vpd_findtag(ha, vpd, "RV")) == NULL) {
1178 1178 EL(ha, "vpd RV tag missing\n");
1179 1179 kmem_free(vpd, vpd_size);
1180 1180 return (EINVAL);
1181 1181 }
1182 1182
1183 1183 vpdptr += 3;
1184 1184 cnt = 0;
1185 1185 vbuf = vpd;
1186 1186 while (vbuf <= vpdptr) {
1187 1187 cnt += *vbuf++;
1188 1188 }
1189 1189 if (cnt != 0) {
1190 1190 EL(ha, "mismatched checksum, cal=%xh, passed=%xh\n",
1191 1191 (uint8_t)cnt, (uintptr_t)vpdptr);
1192 1192 kmem_free(vpd, vpd_size);
1193 1193 return (EINVAL);
1194 1194 }
1195 1195
1196 1196 /* Quiesce I/O */
1197 1197 if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
1198 1198 EL(ha, "ql_stall_driver failed\n");
1199 1199 kmem_free(vpd, vpd_size);
1200 1200 return (EBUSY);
1201 1201 }
|
↓ open down ↓ |
33 lines elided |
↑ open up ↑ |
1202 1202
1203 1203 rval = ql_lock_nvram(ha, &start_addr, LNF_VPD_DATA);
1204 1204 if (rval != QL_SUCCESS) {
1205 1205 EL(ha, "failed, ql_lock_nvram=%xh\n", rval);
1206 1206 kmem_free(vpd, vpd_size);
1207 1207 ql_restart_driver(ha);
1208 1208 return (EIO);
1209 1209 }
1210 1210
1211 1211 /* Load VPD. */
1212 - if (CFG_IST(ha, CFG_CTRL_258081)) {
1212 + if (CFG_IST(ha, CFG_CTRL_252780818283)) {
1213 1213 GLOBAL_HW_UNLOCK();
1214 1214 start_addr &= ~ha->flash_data_addr;
1215 1215 start_addr <<= 2;
1216 1216 if ((rval = ql_r_m_w_flash(ha, bp, vpd_size, start_addr,
1217 1217 mode)) != QL_SUCCESS) {
1218 1218 EL(ha, "vpd load error: %xh\n", rval);
1219 1219 }
1220 1220 GLOBAL_HW_LOCK();
1221 1221 } else {
1222 1222 lptr = (uint32_t *)vpd;
1223 1223 for (cnt = 0; cnt < vpd_size / 4; cnt++) {
1224 1224 data32 = *lptr++;
1225 1225 LITTLE_ENDIAN_32(&data32);
1226 1226 rval = ql_24xx_load_nvram(ha, cnt + start_addr,
1227 1227 data32);
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
1228 1228 if (rval != QL_SUCCESS) {
1229 1229 EL(ha, "failed, 24xx_load_nvram=%xh\n", rval);
1230 1230 break;
1231 1231 }
1232 1232 }
1233 1233 }
1234 1234
1235 1235 kmem_free(vpd, vpd_size);
1236 1236
1237 1237 /* Update the vcache */
1238 - CACHE_LOCK(ha);
1239 -
1240 1238 if (rval != QL_SUCCESS) {
1241 1239 EL(ha, "failed, load\n");
1242 1240 } else if ((ha->vcache == NULL) && ((ha->vcache =
1243 1241 kmem_zalloc(vpd_size, KM_SLEEP)) == NULL)) {
1244 1242 EL(ha, "failed, kmem_zalloc2\n");
1245 1243 } else if (ddi_copyin(bp, ha->vcache, vpd_size, mode) != 0) {
1246 1244 EL(ha, "Buffer copy2 failed\n");
1247 1245 kmem_free(ha->vcache, vpd_size);
1248 1246 ha->vcache = NULL;
1249 1247 }
1250 1248
1251 - CACHE_UNLOCK(ha);
1252 -
1253 1249 ql_release_nvram(ha);
1254 1250 ql_restart_driver(ha);
1255 1251
1256 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1252 + QL_PRINT_9(ha, "done\n");
1257 1253
1258 1254 if (rval == QL_SUCCESS) {
1259 1255 return (0);
1260 1256 }
1261 1257
1262 1258 return (EFAULT);
1263 1259 }
1264 1260
1265 1261 /*
1266 1262 * ql_vpd_dump
1267 1263 * Dumps VPD to application buffer.
1268 1264 *
1269 1265 * Input:
1270 1266 * ha = adapter state pointer.
1271 1267 * bp = user buffer address.
1272 1268 *
1273 1269 * Returns:
1274 1270 *
1275 1271 * Context:
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
1276 1272 * Kernel context.
1277 1273 */
1278 1274 int
1279 1275 ql_vpd_dump(ql_adapter_state_t *ha, void *bp, int mode)
1280 1276 {
1281 1277 uint8_t cnt;
1282 1278 void *vpd;
1283 1279 uint32_t start_addr, vpd_size, *lptr;
1284 1280 int rval = 0;
1285 1281
1286 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1282 + QL_PRINT_3(ha, "started\n");
1287 1283
1288 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
1284 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
1289 1285 EL(ha, "unsupported adapter feature\n");
1290 1286 return (EACCES);
1291 1287 }
1292 1288
1293 1289 vpd_size = QL_24XX_VPD_SIZE;
1294 1290
1295 - CACHE_LOCK(ha);
1296 -
1297 1291 if (ha->vcache != NULL) {
1298 1292 /* copy back the vpd cache data */
1299 1293 if (ddi_copyout(ha->vcache, bp, vpd_size, mode) != 0) {
1300 1294 EL(ha, "Buffer copy failed\n");
1301 1295 rval = EFAULT;
1302 1296 }
1303 - CACHE_UNLOCK(ha);
1304 1297 return (rval);
1305 1298 }
1306 1299
1307 1300 if ((vpd = kmem_zalloc(vpd_size, KM_SLEEP)) == NULL) {
1308 - CACHE_UNLOCK(ha);
1309 1301 EL(ha, "failed, kmem_zalloc\n");
1310 1302 return (ENOMEM);
1311 1303 }
1312 1304
1313 1305 /* Quiesce I/O */
1314 1306 if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
1315 - CACHE_UNLOCK(ha);
1316 1307 EL(ha, "ql_stall_driver failed\n");
1317 1308 kmem_free(vpd, vpd_size);
1318 1309 return (EBUSY);
1319 1310 }
1320 1311
1321 1312 rval = ql_lock_nvram(ha, &start_addr, LNF_VPD_DATA);
1322 1313 if (rval != QL_SUCCESS) {
1323 - CACHE_UNLOCK(ha);
1324 1314 EL(ha, "failed, ql_lock_nvram=%xh\n", rval);
1325 1315 kmem_free(vpd, vpd_size);
1326 1316 ql_restart_driver(ha);
1327 1317 return (EIO);
1328 1318 }
1329 1319
1330 1320 /* Dump VPD. */
1331 1321 lptr = (uint32_t *)vpd;
1332 1322
1333 1323 for (cnt = 0; cnt < vpd_size / 4; cnt++) {
1334 1324 rval = ql_24xx_read_flash(ha, start_addr++, lptr);
1335 1325 if (rval != QL_SUCCESS) {
1336 1326 EL(ha, "read_flash failed=%xh\n", rval);
1337 1327 rval = EAGAIN;
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
1338 1328 break;
1339 1329 }
1340 1330 LITTLE_ENDIAN_32(lptr);
1341 1331 lptr++;
1342 1332 }
1343 1333
1344 1334 ql_release_nvram(ha);
1345 1335 ql_restart_driver(ha);
1346 1336
1347 1337 if (ddi_copyout(vpd, bp, vpd_size, mode) != 0) {
1348 - CACHE_UNLOCK(ha);
1349 1338 EL(ha, "Buffer copy failed\n");
1350 1339 kmem_free(vpd, vpd_size);
1351 1340 return (EFAULT);
1352 1341 }
1353 1342
1354 1343 ha->vcache = vpd;
1355 1344
1356 - CACHE_UNLOCK(ha);
1345 + QL_PRINT_3(ha, "done\n");
1357 1346
1358 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1359 -
1360 1347 if (rval != QL_SUCCESS) {
1361 1348 return (EFAULT);
1362 1349 } else {
1363 1350 return (0);
1364 1351 }
1365 1352 }
1366 1353
1367 1354 /*
1368 1355 * ql_vpd_findtag
1369 1356 * Search the passed vpd buffer for the requested VPD tag type.
1370 1357 *
1371 1358 * Input:
1372 1359 * ha = adapter state pointer.
1373 1360 * vpdbuf = Pointer to start of the buffer to search
1374 1361 * op = VPD opcode to find (must be NULL terminated).
1375 1362 *
1376 1363 * Returns:
1377 1364 * Pointer to the opcode in the buffer if opcode found.
1378 1365 * NULL if opcode is not found.
1379 1366 *
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
1380 1367 * Context:
1381 1368 * Kernel context.
1382 1369 */
1383 1370 static uint8_t *
1384 1371 ql_vpd_findtag(ql_adapter_state_t *ha, uint8_t *vpdbuf, int8_t *opcode)
1385 1372 {
1386 1373 uint8_t *vpd = vpdbuf;
1387 1374 uint8_t *end = vpdbuf + QL_24XX_VPD_SIZE;
1388 1375 uint32_t found = 0;
1389 1376
1390 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1377 + QL_PRINT_3(ha, "started\n");
1391 1378
1392 1379 if (vpdbuf == NULL || opcode == NULL) {
1393 1380 EL(ha, "null parameter passed!\n");
1394 1381 return (NULL);
1395 1382 }
1396 1383
1397 1384 while (vpd < end) {
1398 1385
1399 1386 /* check for end of vpd */
1400 1387 if (vpd[0] == VPD_TAG_END) {
1401 1388 if (opcode[0] == VPD_TAG_END) {
1402 1389 found = 1;
1403 1390 } else {
1404 1391 found = 0;
1405 1392 }
1406 1393 break;
1407 1394 }
1408 1395
1409 1396 /* check opcode */
1410 1397 if (bcmp(opcode, vpd, strlen(opcode)) == 0) {
1411 1398 /* found opcode requested */
1412 1399 found = 1;
1413 1400 break;
1414 1401 }
1415 1402
1416 1403 /*
1417 1404 * Didn't find the opcode, so calculate start of
1418 1405 * next tag. Depending on the current tag type,
1419 1406 * the length field can be 1 or 2 bytes
|
↓ open down ↓ |
19 lines elided |
↑ open up ↑ |
1420 1407 */
1421 1408 if (!(strncmp((char *)vpd, (char *)VPD_TAG_PRODID, 1))) {
1422 1409 vpd += (vpd[2] << 8) + vpd[1] + 3;
1423 1410 } else if (*vpd == VPD_TAG_LRT || *vpd == VPD_TAG_LRTC) {
1424 1411 vpd += 3;
1425 1412 } else {
1426 1413 vpd += vpd[2] +3;
1427 1414 }
1428 1415 }
1429 1416
1430 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1417 + QL_PRINT_3(ha, "done\n");
1431 1418
1432 1419 return (found == 1 ? vpd : NULL);
1433 1420 }
1434 1421
1435 1422 /*
1436 1423 * ql_vpd_lookup
1437 1424 * Return the VPD data for the request VPD tag
1438 1425 *
1439 1426 * Input:
1440 1427 * ha = adapter state pointer.
1441 1428 * opcode = VPD opcode to find (must be NULL terminated).
1442 1429 * bp = Pointer to returned data buffer.
1443 1430 * bplen = Length of returned data buffer.
1444 1431 *
1445 1432 * Returns:
1446 1433 * Length of data copied into returned data buffer.
1447 1434 * >0 = VPD data field (NULL terminated)
1448 1435 * 0 = no data.
1449 1436 * -1 = Could not find opcode in vpd buffer / error.
1450 1437 *
1451 1438 * Context:
1452 1439 * Kernel context.
1453 1440 *
1454 1441 * NB: The opcode buffer and the bp buffer *could* be the same buffer!
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
1455 1442 *
1456 1443 */
1457 1444 int32_t
1458 1445 ql_vpd_lookup(ql_adapter_state_t *ha, uint8_t *opcode, uint8_t *bp,
1459 1446 int32_t bplen)
1460 1447 {
1461 1448 uint8_t *vpd;
1462 1449 uint8_t *vpdbuf;
1463 1450 int32_t len = -1;
1464 1451
1465 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1452 + QL_PRINT_3(ha, "started\n");
1466 1453
1467 1454 if (opcode == NULL || bp == NULL || bplen < 1) {
1468 1455 EL(ha, "invalid parameter passed: opcode=%ph, "
1469 1456 "bp=%ph, bplen=%xh\n", opcode, bp, bplen);
1470 1457 return (len);
1471 1458 }
1472 1459
1473 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
1460 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
1474 1461 return (len);
1475 1462 }
1476 1463
1477 1464 if ((vpdbuf = (uint8_t *)kmem_zalloc(QL_24XX_VPD_SIZE,
1478 1465 KM_SLEEP)) == NULL) {
1479 1466 EL(ha, "unable to allocate vpd memory\n");
1480 1467 return (len);
1481 1468 }
1482 1469
1483 1470 if ((ql_vpd_dump(ha, vpdbuf, (int)FKIOCTL)) != 0) {
1484 1471 kmem_free(vpdbuf, QL_24XX_VPD_SIZE);
1485 1472 EL(ha, "unable to retrieve VPD data\n");
1486 1473 return (len);
1487 1474 }
1488 1475
1489 1476 if ((vpd = ql_vpd_findtag(ha, vpdbuf, (int8_t *)opcode)) != NULL) {
1490 1477 /*
1491 1478 * Found the tag
1492 1479 */
1493 1480 if (*opcode == VPD_TAG_END || *opcode == VPD_TAG_LRT ||
1494 1481 *opcode == VPD_TAG_LRTC) {
1495 1482 /*
1496 1483 * we found it, but the tag doesn't have a data
1497 1484 * field.
1498 1485 */
1499 1486 len = 0;
1500 1487 } else if (!(strncmp((char *)vpd, (char *)
1501 1488 VPD_TAG_PRODID, 1))) {
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
1502 1489 len = vpd[2] << 8;
1503 1490 len += vpd[1];
1504 1491 } else {
1505 1492 len = vpd[2];
1506 1493 }
1507 1494
1508 1495 /*
1509 1496 * make sure that the vpd len doesn't exceed the
1510 1497 * vpd end
1511 1498 */
1512 - if (vpd+len > vpdbuf + QL_24XX_VPD_SIZE) {
1499 + if (vpd + len > vpdbuf + QL_24XX_VPD_SIZE) {
1513 1500 EL(ha, "vpd tag len (%xh) exceeds vpd buffer "
1514 1501 "length\n", len);
1515 1502 len = -1;
1516 1503 }
1517 1504 }
1518 1505
1519 1506 if (len >= 0) {
1520 1507 /*
1521 1508 * make sure we don't exceed callers buffer space len
1522 1509 */
1523 1510 if (len > bplen) {
1524 - len = bplen-1;
1511 + len = bplen - 1;
1525 1512 }
1526 1513
1527 1514 /* copy the data back */
1528 - (void) strncpy((int8_t *)bp, (int8_t *)(vpd+3), (int64_t)len);
1515 + (void) strncpy((int8_t *)bp, (int8_t *)(vpd + 3), (int64_t)len);
1529 1516 bp[len] = NULL;
1530 1517 } else {
1531 1518 /* error -- couldn't find tag */
1532 1519 bp[0] = NULL;
1533 1520 if (opcode[1] != NULL) {
1534 1521 EL(ha, "unable to find tag '%s'\n", opcode);
1535 1522 } else {
1536 1523 EL(ha, "unable to find tag '%xh'\n", opcode[0]);
1537 1524 }
1538 1525 }
1539 1526
1540 1527 kmem_free(vpdbuf, QL_24XX_VPD_SIZE);
1541 1528
1542 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1529 + QL_PRINT_3(ha, "done\n");
1543 1530
1544 1531 return (len);
1545 1532 }
1546 1533
1547 1534 /*
1548 1535 * ql_r_m_w_flash
1549 1536 * Read modify write from user space to flash.
1550 1537 *
1551 1538 * Input:
1552 1539 * ha: adapter state pointer.
1553 1540 * dp: source byte pointer.
1554 1541 * bc: byte count.
1555 1542 * faddr: flash byte address.
1556 1543 * mode: flags.
1557 1544 *
1558 1545 * Returns:
1559 1546 * ql local function return status code.
1560 1547 *
1561 1548 * Context:
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
1562 1549 * Kernel context.
1563 1550 */
1564 1551 int
1565 1552 ql_r_m_w_flash(ql_adapter_state_t *ha, caddr_t dp, uint32_t bc, uint32_t faddr,
1566 1553 int mode)
1567 1554 {
1568 1555 uint8_t *bp;
1569 1556 uint32_t xfer, bsize, saddr, ofst;
1570 1557 int rval = 0;
1571 1558
1572 - QL_PRINT_9(CE_CONT, "(%d): started, dp=%ph, faddr=%xh, bc=%xh\n",
1573 - ha->instance, (void *)dp, faddr, bc);
1559 + QL_PRINT_9(ha, "started, dp=%ph, faddr=%xh, bc=%xh\n",
1560 + (void *)dp, faddr, bc);
1574 1561
1575 1562 bsize = ha->xioctl->fdesc.block_size;
1576 1563 saddr = faddr & ~(bsize - 1);
1577 1564 ofst = faddr & (bsize - 1);
1578 1565
1579 1566 if ((bp = kmem_zalloc(bsize, KM_SLEEP)) == NULL) {
1580 1567 EL(ha, "kmem_zalloc=null\n");
1581 1568 return (QL_MEMORY_ALLOC_FAILED);
1582 1569 }
1583 1570
1584 1571 while (bc) {
1585 1572 xfer = bc > bsize ? bsize : bc;
1586 1573 if (ofst + xfer > bsize) {
1587 1574 xfer = bsize - ofst;
1588 1575 }
1589 - QL_PRINT_9(CE_CONT, "(%d): dp=%ph, saddr=%xh, bc=%xh, "
1590 - "ofst=%xh, xfer=%xh\n", ha->instance, (void *)dp, saddr,
1576 + QL_PRINT_9(ha, "dp=%ph, saddr=%xh, bc=%xh, "
1577 + "ofst=%xh, xfer=%xh\n", (void *)dp, saddr,
1591 1578 bc, ofst, xfer);
1592 1579
1593 1580 if (ofst || xfer < bsize) {
1594 1581 /* Dump Flash sector. */
1595 1582 if ((rval = ql_dump_fcode(ha, bp, bsize, saddr)) !=
1596 1583 QL_SUCCESS) {
1597 1584 EL(ha, "dump_flash status=%x\n", rval);
1598 1585 break;
1599 1586 }
1600 1587 }
1601 1588
1602 1589 /* Set new data. */
1603 1590 if ((rval = ddi_copyin(dp, (caddr_t)(bp + ofst), xfer,
1604 1591 mode)) != 0) {
1605 1592 EL(ha, "ddi_copyin status=%xh, dp=%ph, ofst=%xh, "
1606 1593 "xfer=%xh\n", rval, (void *)dp, ofst, xfer);
1607 1594 rval = QL_FUNCTION_FAILED;
1608 1595 break;
1609 1596 }
1610 1597
1611 1598 /* Write to flash. */
1612 1599 if ((rval = ql_load_fcode(ha, bp, bsize, saddr)) !=
1613 1600 QL_SUCCESS) {
1614 1601 EL(ha, "load_flash status=%x\n", rval);
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
1615 1602 break;
1616 1603 }
1617 1604 bc -= xfer;
1618 1605 dp += xfer;
1619 1606 saddr += bsize;
1620 1607 ofst = 0;
1621 1608 }
1622 1609
1623 1610 kmem_free(bp, bsize);
1624 1611
1625 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1612 + QL_PRINT_9(ha, "done\n");
1626 1613
1627 1614 return (rval);
1628 1615 }
1629 1616
1630 1617 /*
1631 1618 * ql_adm_op
1632 1619 * Performs qladm utility operations
1633 1620 *
1634 1621 * Input:
1635 1622 * ha: adapter state pointer.
1636 1623 * arg: driver_op_t structure pointer.
1637 1624 * mode: flags.
1638 1625 *
1639 1626 * Returns:
1640 1627 *
1641 1628 * Context:
1642 1629 * Kernel context.
1643 1630 */
1644 1631 static int
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
1645 1632 ql_adm_op(ql_adapter_state_t *ha, void *arg, int mode)
1646 1633 {
1647 1634 ql_adm_op_t dop;
1648 1635 int rval = 0;
1649 1636
1650 1637 if (ddi_copyin(arg, &dop, sizeof (ql_adm_op_t), mode) != 0) {
1651 1638 EL(ha, "failed, driver_op_t ddi_copyin\n");
1652 1639 return (EFAULT);
1653 1640 }
1654 1641
1655 - QL_PRINT_9(CE_CONT, "(%d): started, cmd=%xh, buffer=%llx,"
1656 - " length=%xh, option=%xh\n", ha->instance, dop.cmd, dop.buffer,
1642 + QL_PRINT_9(ha, "started, cmd=%xh, buffer=%llx,"
1643 + " length=%xh, option=%xh\n", dop.cmd, dop.buffer,
1657 1644 dop.length, dop.option);
1658 1645
1659 1646 switch (dop.cmd) {
1660 1647 case QL_ADAPTER_INFO:
1661 1648 rval = ql_adm_adapter_info(ha, &dop, mode);
1662 1649 break;
1663 1650
1664 1651 case QL_EXTENDED_LOGGING:
1665 1652 rval = ql_adm_extended_logging(ha, &dop);
1666 1653 break;
1667 1654
1668 1655 case QL_LOOP_RESET:
1669 1656 rval = ql_adm_loop_reset(ha);
1670 1657 break;
1671 1658
1672 1659 case QL_DEVICE_LIST:
1673 1660 rval = ql_adm_device_list(ha, &dop, mode);
1674 1661 break;
1675 1662
1676 1663 case QL_PROP_UPDATE_INT:
1677 1664 rval = ql_adm_prop_update_int(ha, &dop, mode);
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
1678 1665 break;
1679 1666
1680 1667 case QL_UPDATE_PROPERTIES:
1681 1668 rval = ql_adm_update_properties(ha);
1682 1669 break;
1683 1670
1684 1671 case QL_FW_DUMP:
1685 1672 rval = ql_adm_fw_dump(ha, &dop, arg, mode);
1686 1673 break;
1687 1674
1675 + case QL_FW_DUMP_TRIGGER:
1676 + rval = ql_adm_fw_t_dump(ha);
1677 + break;
1678 +
1679 + case QL_BEACON_ENABLE:
1680 + case QL_BEACON_DISABLE:
1681 + rval = ql_adm_beacon(ha, &dop);
1682 + break;
1683 +
1688 1684 case QL_NVRAM_LOAD:
1689 1685 rval = ql_adm_nvram_load(ha, &dop, mode);
1690 1686 break;
1691 1687
1692 1688 case QL_NVRAM_DUMP:
1693 1689 rval = ql_adm_nvram_dump(ha, &dop, mode);
1694 1690 break;
1695 1691
1696 1692 case QL_FLASH_LOAD:
1697 1693 rval = ql_adm_flash_load(ha, &dop, mode);
1698 1694 break;
1699 1695
1700 1696 case QL_VPD_LOAD:
1701 1697 rval = ql_adm_vpd_load(ha, &dop, mode);
1702 1698 break;
1703 1699
1704 1700 case QL_VPD_DUMP:
1705 1701 rval = ql_adm_vpd_dump(ha, &dop, mode);
1706 1702 break;
1707 1703
1708 1704 case QL_VPD_GETTAG:
1709 1705 rval = ql_adm_vpd_gettag(ha, &dop, mode);
1710 1706 break;
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
1711 1707
1712 1708 case QL_UPD_FWMODULE:
1713 1709 rval = ql_adm_updfwmodule(ha, &dop, mode);
1714 1710 break;
1715 1711
1716 1712 default:
1717 1713 EL(ha, "unsupported driver op cmd: %x\n", dop.cmd);
1718 1714 return (EINVAL);
1719 1715 }
1720 1716
1721 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1717 + QL_PRINT_9(ha, "done\n");
1722 1718
1723 1719 return (rval);
1724 1720 }
1725 1721
1726 1722 /*
1727 1723 * ql_adm_adapter_info
1728 1724 * Performs qladm QL_ADAPTER_INFO command
1729 1725 *
1730 1726 * Input:
1731 1727 * ha: adapter state pointer.
1732 1728 * dop: ql_adm_op_t structure pointer.
1733 1729 * mode: flags.
1734 1730 *
1735 1731 * Returns:
1736 1732 *
1737 1733 * Context:
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
1738 1734 * Kernel context.
1739 1735 */
1740 1736 static int
1741 1737 ql_adm_adapter_info(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
1742 1738 {
1743 1739 ql_adapter_info_t hba;
1744 1740 uint8_t *dp;
1745 1741 uint32_t length;
1746 1742 int rval, i;
1747 1743
1748 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1744 + QL_PRINT_9(ha, "started\n");
1749 1745
1750 1746 hba.device_id = ha->device_id;
1751 1747
1752 - dp = CFG_IST(ha, CFG_CTRL_24258081) ?
1753 - &ha->init_ctrl_blk.cb24.port_name[0] :
1754 - &ha->init_ctrl_blk.cb.port_name[0];
1748 + dp = ha->loginparams.nport_ww_name.raw_wwn;
1755 1749 bcopy(dp, hba.wwpn, 8);
1756 1750
1757 1751 hba.d_id = ha->d_id.b24;
1758 1752
1759 1753 if (ha->xioctl->fdesc.flash_size == 0 &&
1760 - !(CFG_IST(ha, CFG_CTRL_2200) && !ha->subven_id)) {
1754 + !(CFG_IST(ha, CFG_CTRL_22XX) && !ha->subven_id)) {
1761 1755 if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
1762 1756 EL(ha, "ql_stall_driver failed\n");
1763 1757 return (EBUSY);
1764 1758 }
1765 1759
1766 1760 if ((rval = ql_setup_fcache(ha)) != QL_SUCCESS) {
1767 1761 EL(ha, "ql_setup_flash failed=%xh\n", rval);
1768 1762 if (rval == QL_FUNCTION_TIMEOUT) {
1769 1763 return (EBUSY);
1770 1764 }
1771 1765 return (EIO);
1772 1766 }
1773 1767
1774 1768 /* Resume I/O */
1775 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1769 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1776 1770 ql_restart_driver(ha);
1777 1771 } else {
1778 1772 EL(ha, "isp_abort_needed for restart\n");
1779 1773 ql_awaken_task_daemon(ha, NULL, ISP_ABORT_NEEDED,
1780 1774 DRIVER_STALL);
1781 1775 }
1782 1776 }
1783 1777 hba.flash_size = ha->xioctl->fdesc.flash_size;
1784 1778
1785 1779 (void) strcpy(hba.driver_ver, QL_VERSION);
1786 1780
1787 1781 (void) sprintf(hba.fw_ver, "%d.%d.%d", ha->fw_major_version,
1788 1782 ha->fw_minor_version, ha->fw_subminor_version);
1789 1783
1790 1784 bzero(hba.fcode_ver, sizeof (hba.fcode_ver));
1791 1785
1792 1786 /*LINTED [Solaris DDI_DEV_T_ANY Lint warning]*/
1793 1787 rval = ddi_getlongprop(DDI_DEV_T_ANY, ha->dip,
1794 1788 DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "version", (caddr_t)&dp, &i);
1795 1789 length = i;
1796 1790 if (rval != DDI_PROP_SUCCESS) {
1797 1791 EL(ha, "failed, ddi_getlongprop=%xh\n", rval);
1798 1792 } else {
1799 1793 if (length > (uint32_t)sizeof (hba.fcode_ver)) {
1800 1794 length = sizeof (hba.fcode_ver) - 1;
1801 1795 }
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
1802 1796 bcopy((void *)dp, (void *)hba.fcode_ver, length);
1803 1797 kmem_free(dp, length);
1804 1798 }
1805 1799
1806 1800 if (ddi_copyout((void *)&hba, (void *)(uintptr_t)dop->buffer,
1807 1801 dop->length, mode) != 0) {
1808 1802 EL(ha, "failed, ddi_copyout\n");
1809 1803 return (EFAULT);
1810 1804 }
1811 1805
1812 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1806 + QL_PRINT_9(ha, "done\n");
1813 1807
1814 1808 return (0);
1815 1809 }
1816 1810
1817 1811 /*
1818 1812 * ql_adm_extended_logging
1819 1813 * Performs qladm QL_EXTENDED_LOGGING command
1820 1814 *
1821 1815 * Input:
1822 1816 * ha: adapter state pointer.
1823 1817 * dop: ql_adm_op_t structure pointer.
1824 1818 *
1825 1819 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
1826 1820 *
1827 1821 * Context:
1828 1822 * Kernel context.
1829 1823 */
1830 1824 static int
1831 1825 ql_adm_extended_logging(ql_adapter_state_t *ha, ql_adm_op_t *dop)
1832 1826 {
1833 1827 char prop_name[MAX_PROP_LENGTH];
1834 1828 int rval;
1835 1829
1836 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1830 + QL_PRINT_9(ha, "started\n");
1837 1831
1838 1832 (void) sprintf(prop_name, "hba%d-extended-logging", ha->instance);
1839 1833
1840 1834 /*LINTED [Solaris DDI_DEV_T_NONE Lint warning]*/
1841 1835 rval = ddi_prop_update_int(DDI_DEV_T_NONE, ha->dip, prop_name,
1842 1836 (int)dop->option);
1843 1837 if (rval != DDI_PROP_SUCCESS) {
1844 1838 EL(ha, "failed, prop_update = %xh\n", rval);
1845 1839 return (EINVAL);
1846 1840 } else {
1847 1841 dop->option ?
1848 1842 (ha->cfg_flags |= CFG_ENABLE_EXTENDED_LOGGING) :
1849 1843 (ha->cfg_flags &= ~CFG_ENABLE_EXTENDED_LOGGING);
1850 1844 }
1851 1845
1852 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1846 + QL_PRINT_9(ha, "done\n");
1853 1847
1854 1848 return (0);
1855 1849 }
1856 1850
1857 1851 /*
1858 1852 * ql_adm_loop_reset
1859 1853 * Performs qladm QL_LOOP_RESET command
1860 1854 *
1861 1855 * Input:
1862 1856 * ha: adapter state pointer.
1863 1857 *
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
1864 1858 * Returns:
1865 1859 *
1866 1860 * Context:
1867 1861 * Kernel context.
1868 1862 */
1869 1863 static int
1870 1864 ql_adm_loop_reset(ql_adapter_state_t *ha)
1871 1865 {
1872 1866 int rval;
1873 1867
1874 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1868 + QL_PRINT_9(ha, "started\n");
1875 1869
1876 - if (ha->task_daemon_flags & LOOP_DOWN) {
1877 - (void) ql_full_login_lip(ha);
1878 - } else if ((rval = ql_full_login_lip(ha)) != QL_SUCCESS) {
1879 - EL(ha, "failed, ql_initiate_lip=%xh\n", rval);
1880 - return (EIO);
1870 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
1871 + rval = ql_8021_fw_reload(ha);
1872 + ql_awaken_task_daemon(ha, NULL, ISP_ABORT_NEEDED, 0);
1873 + if (rval != QL_SUCCESS) {
1874 + EL(ha, "failed, ql_8021_fw_reload=%xh\n", rval);
1875 + return (EIO);
1876 + }
1877 + } else {
1878 + if (ha->task_daemon_flags & LOOP_DOWN) {
1879 + (void) ql_full_login_lip(ha);
1880 + } else if ((rval = ql_full_login_lip(ha)) != QL_SUCCESS) {
1881 + EL(ha, "failed, ql_initiate_lip=%xh\n", rval);
1882 + return (EIO);
1883 + }
1881 1884 }
1882 1885
1883 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1886 + QL_PRINT_9(ha, "done\n");
1884 1887
1885 1888 return (0);
1886 1889 }
1887 1890
1888 1891 /*
1889 1892 * ql_adm_device_list
1890 1893 * Performs qladm QL_DEVICE_LIST command
1891 1894 *
1892 1895 * Input:
1893 1896 * ha: adapter state pointer.
1894 1897 * dop: ql_adm_op_t structure pointer.
1895 1898 * mode: flags.
1896 1899 *
1897 1900 * Returns:
1898 1901 *
1899 1902 * Context:
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
1900 1903 * Kernel context.
1901 1904 */
1902 1905 static int
1903 1906 ql_adm_device_list(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
1904 1907 {
1905 1908 ql_device_info_t dev;
1906 1909 ql_link_t *link;
1907 1910 ql_tgt_t *tq;
1908 1911 uint32_t index, cnt;
1909 1912
1910 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1913 + QL_PRINT_9(ha, "started\n");
1911 1914
1912 1915 cnt = 0;
1913 1916 dev.address = 0xffffffff;
1914 1917
1915 1918 /* Scan port list for requested target and fill in the values */
1916 1919 for (link = NULL, index = 0;
1917 1920 index < DEVICE_HEAD_LIST_SIZE && link == NULL; index++) {
1918 1921 for (link = ha->dev[index].first; link != NULL;
1919 1922 link = link->next) {
1920 1923 tq = link->base_address;
1921 1924
1922 1925 if (!VALID_TARGET_ID(ha, tq->loop_id)) {
1923 1926 continue;
1924 1927 }
1925 1928 if (cnt != dop->option) {
1926 1929 cnt++;
1927 1930 continue;
1928 1931 }
1929 1932 /* fill in the values */
1930 1933 bcopy(tq->port_name, dev.wwpn, 8);
1931 1934 dev.address = tq->d_id.b24;
1932 1935 dev.loop_id = tq->loop_id;
1933 1936 if (tq->flags & TQF_TAPE_DEVICE) {
1934 1937 dev.type = FCT_TAPE;
1935 1938 } else if (tq->flags & TQF_INITIATOR_DEVICE) {
1936 1939 dev.type = FCT_INITIATOR;
1937 1940 } else {
1938 1941 dev.type = FCT_TARGET;
1939 1942 }
|
↓ open down ↓ |
19 lines elided |
↑ open up ↑ |
1940 1943 break;
1941 1944 }
1942 1945 }
1943 1946
1944 1947 if (ddi_copyout((void *)&dev, (void *)(uintptr_t)dop->buffer,
1945 1948 dop->length, mode) != 0) {
1946 1949 EL(ha, "failed, ddi_copyout\n");
1947 1950 return (EFAULT);
1948 1951 }
1949 1952
1950 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1953 + QL_PRINT_9(ha, "done\n");
1951 1954
1952 1955 return (0);
1953 1956 }
1954 1957
1955 1958 /*
1956 1959 * ql_adm_update_properties
1957 1960 * Performs qladm QL_UPDATE_PROPERTIES command
1958 1961 *
1959 1962 * Input:
1960 1963 * ha: adapter state pointer.
1961 1964 *
1962 1965 * Returns:
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
1963 1966 *
1964 1967 * Context:
1965 1968 * Kernel context.
1966 1969 */
1967 1970 static int
1968 1971 ql_adm_update_properties(ql_adapter_state_t *ha)
1969 1972 {
1970 1973 ql_comb_init_cb_t init_ctrl_blk;
1971 1974 ql_comb_ip_init_cb_t ip_init_ctrl_blk;
1972 1975
1973 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1976 + QL_PRINT_9(ha, "started\n");
1974 1977
1975 1978 /* Stall driver instance. */
1976 1979 (void) ql_stall_driver(ha, 0);
1977 1980
1978 1981 /* Save init control blocks. */
1979 1982 bcopy(&ha->init_ctrl_blk, &init_ctrl_blk, sizeof (ql_comb_init_cb_t));
1980 1983 bcopy(&ha->ip_init_ctrl_blk, &ip_init_ctrl_blk,
1981 1984 sizeof (ql_comb_ip_init_cb_t));
1982 1985
1983 1986 /* Update PCI configration. */
1984 1987 (void) ql_pci_sbus_config(ha);
1985 1988
1986 1989 /* Get configuration properties. */
1987 1990 (void) ql_nvram_config(ha);
1988 1991
1989 1992 /* Check for init firmware required. */
1990 1993 if (bcmp(&ha->init_ctrl_blk, &init_ctrl_blk,
1991 1994 sizeof (ql_comb_init_cb_t)) != 0 ||
1992 1995 bcmp(&ha->ip_init_ctrl_blk, &ip_init_ctrl_blk,
1993 1996 sizeof (ql_comb_ip_init_cb_t)) != 0) {
1994 1997
1995 1998 EL(ha, "isp_abort_needed\n");
1996 1999 ha->loop_down_timer = LOOP_DOWN_TIMER_START;
1997 2000 TASK_DAEMON_LOCK(ha);
1998 2001 ha->task_daemon_flags |= LOOP_DOWN | ISP_ABORT_NEEDED;
1999 2002 TASK_DAEMON_UNLOCK(ha);
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
2000 2003 }
2001 2004
2002 2005 /* Update AEN queue. */
2003 2006 if (ha->xioctl->flags & QL_AEN_TRACKING_ENABLE) {
2004 2007 ql_enqueue_aen(ha, MBA_PORT_UPDATE, NULL);
2005 2008 }
2006 2009
2007 2010 /* Restart driver instance. */
2008 2011 ql_restart_driver(ha);
2009 2012
2010 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2013 + QL_PRINT_9(ha, "done\n");
2011 2014
2012 2015 return (0);
2013 2016 }
2014 2017
2015 2018 /*
2016 2019 * ql_adm_prop_update_int
2017 2020 * Performs qladm QL_PROP_UPDATE_INT command
2018 2021 *
2019 2022 * Input:
2020 2023 * ha: adapter state pointer.
2021 2024 * dop: ql_adm_op_t structure pointer.
2022 2025 * mode: flags.
2023 2026 *
2024 2027 * Returns:
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
2025 2028 *
2026 2029 * Context:
2027 2030 * Kernel context.
2028 2031 */
2029 2032 static int
2030 2033 ql_adm_prop_update_int(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2031 2034 {
2032 2035 char *prop_name;
2033 2036 int rval;
2034 2037
2035 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2038 + QL_PRINT_9(ha, "started\n");
2036 2039
2037 2040 prop_name = kmem_zalloc(dop->length, KM_SLEEP);
2038 2041 if (prop_name == NULL) {
2039 2042 EL(ha, "failed, kmem_zalloc\n");
2040 2043 return (ENOMEM);
2041 2044 }
2042 2045
2043 2046 if (ddi_copyin((void *)(uintptr_t)dop->buffer, prop_name, dop->length,
2044 2047 mode) != 0) {
2045 2048 EL(ha, "failed, prop_name ddi_copyin\n");
2046 2049 kmem_free(prop_name, dop->length);
2047 2050 return (EFAULT);
2048 2051 }
2049 2052
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
2050 2053 /*LINTED [Solaris DDI_DEV_T_ANY Lint warning]*/
2051 2054 if ((rval = ddi_prop_update_int(DDI_DEV_T_NONE, ha->dip, prop_name,
2052 2055 (int)dop->option)) != DDI_PROP_SUCCESS) {
2053 2056 EL(ha, "failed, prop_update=%xh\n", rval);
2054 2057 kmem_free(prop_name, dop->length);
2055 2058 return (EINVAL);
2056 2059 }
2057 2060
2058 2061 kmem_free(prop_name, dop->length);
2059 2062
2060 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2063 + QL_PRINT_9(ha, "done\n");
2061 2064
2062 2065 return (0);
2063 2066 }
2064 2067
2065 2068 /*
2066 2069 * ql_adm_fw_dump
2067 2070 * Performs qladm QL_FW_DUMP command
2068 2071 *
2069 2072 * Input:
2070 2073 * ha: adapter state pointer.
2071 2074 * dop: ql_adm_op_t structure pointer.
2072 2075 * udop: user space ql_adm_op_t structure pointer.
2073 2076 * mode: flags.
2074 2077 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
2075 2078 * Returns:
2076 2079 *
2077 2080 * Context:
2078 2081 * Kernel context.
2079 2082 */
2080 2083 static int
2081 2084 ql_adm_fw_dump(ql_adapter_state_t *ha, ql_adm_op_t *dop, void *udop, int mode)
2082 2085 {
2083 2086 caddr_t dmp;
2084 2087
2085 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2088 + QL_PRINT_9(ha, "started\n");
2086 2089
2087 2090 if (dop->length < ha->risc_dump_size) {
2088 2091 EL(ha, "failed, incorrect length=%xh, size=%xh\n",
2089 2092 dop->length, ha->risc_dump_size);
2090 2093 return (EINVAL);
2091 2094 }
2092 2095
2093 2096 if (ha->ql_dump_state & QL_DUMP_VALID) {
2094 2097 dmp = kmem_zalloc(ha->risc_dump_size, KM_SLEEP);
2095 2098 if (dmp == NULL) {
2096 2099 EL(ha, "failed, kmem_zalloc\n");
2097 2100 return (ENOMEM);
2098 2101 }
2099 2102
2100 2103 dop->length = (uint32_t)ql_ascii_fw_dump(ha, dmp);
2101 2104 if (ddi_copyout((void *)dmp, (void *)(uintptr_t)dop->buffer,
2102 2105 dop->length, mode) != 0) {
2103 2106 EL(ha, "failed, ddi_copyout\n");
2104 2107 kmem_free(dmp, ha->risc_dump_size);
2105 2108 return (EFAULT);
2106 2109 }
2107 2110
2108 2111 kmem_free(dmp, ha->risc_dump_size);
2109 2112 ha->ql_dump_state |= QL_DUMP_UPLOADED;
2110 2113
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
2111 2114 } else {
2112 2115 EL(ha, "failed, no dump file\n");
2113 2116 dop->length = 0;
2114 2117 }
2115 2118
2116 2119 if (ddi_copyout(dop, udop, sizeof (ql_adm_op_t), mode) != 0) {
2117 2120 EL(ha, "failed, driver_op_t ddi_copyout\n");
2118 2121 return (EFAULT);
2119 2122 }
2120 2123
2121 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2124 + QL_PRINT_9(ha, "done\n");
2122 2125
2123 2126 return (0);
2124 2127 }
2125 2128
2126 2129 /*
2130 + * ql_adm_fw_t_dump
2131 + * Performs qladm QL_FW_DUMP_TRIGGER command
2132 + *
2133 + * Input:
2134 + * ha: adapter state pointer.
2135 + *
2136 + * Returns:
2137 + *
2138 + * Context:
2139 + * Kernel context.
2140 + */
2141 +static int
2142 +ql_adm_fw_t_dump(ql_adapter_state_t *ha)
2143 +{
2144 + int rval;
2145 +
2146 + QL_PRINT_9(ha, "started\n");
2147 +
2148 + if (ha->ql_dump_state & QL_DUMP_VALID) {
2149 + EL(ha, "Already contains a dump file\n");
2150 + return (EINVAL);
2151 + }
2152 + rval = ql_dump_firmware(ha);
2153 +
2154 + QL_PRINT_9(ha, "done\n");
2155 +
2156 + if (rval == QL_SUCCESS || rval == QL_DATA_EXISTS) {
2157 + return (0);
2158 + }
2159 + return (EFAULT);
2160 +}
2161 +
2162 +/*
2163 + * ql_adm_beacon
2164 + * Performs qladm QL_BEACON_ENABLE/DISABLE command
2165 + *
2166 + * Input:
2167 + * ha: adapter state pointer.
2168 + * dop: ql_adm_op_t structure pointer.
2169 + *
2170 + * Returns:
2171 + *
2172 + * Context:
2173 + * Kernel context.
2174 + */
2175 +static int
2176 +ql_adm_beacon(ql_adapter_state_t *ha, ql_adm_op_t *dop)
2177 +{
2178 + int rval;
2179 + ql_mbx_data_t mr;
2180 +
2181 + if (!CFG_IST(ha, CFG_CTRL_82XX)) {
2182 + return (EIO);
2183 + }
2184 +
2185 + rval = ql_diag_beacon(ha, dop->cmd, &mr);
2186 +
2187 + if (rval == QL_SUCCESS) {
2188 + return (0);
2189 + }
2190 +
2191 + return (rval);
2192 +}
2193 +
2194 +
2195 +/*
2127 2196 * ql_adm_nvram_dump
2128 2197 * Performs qladm QL_NVRAM_DUMP command
2129 2198 *
2130 2199 * Input:
2131 2200 * ha: adapter state pointer.
2132 2201 * dop: ql_adm_op_t structure pointer.
2133 2202 * mode: flags.
2134 2203 *
2135 2204 * Returns:
2136 2205 *
2137 2206 * Context:
2138 2207 * Kernel context.
2139 2208 */
2140 2209 static int
2141 2210 ql_adm_nvram_dump(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2142 2211 {
2143 2212 int rval;
2144 2213
2145 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2214 + QL_PRINT_9(ha, "started\n");
2146 2215
2147 2216 if (dop->length < ha->nvram_cache->size) {
2148 2217 EL(ha, "failed, length=%xh, size=%xh\n", dop->length,
2149 2218 ha->nvram_cache->size);
2150 2219 return (EINVAL);
2151 2220 }
2152 2221
2153 2222 if ((rval = ql_nv_util_dump(ha, (void *)(uintptr_t)dop->buffer,
2154 2223 mode)) != 0) {
2155 2224 EL(ha, "failed, ql_nv_util_dump\n");
2156 2225 } else {
2157 2226 /*EMPTY*/
2158 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2227 + QL_PRINT_9(ha, "done\n");
2159 2228 }
2160 2229
2161 2230 return (rval);
2162 2231 }
2163 2232
2164 2233 /*
2165 2234 * ql_adm_nvram_load
2166 2235 * Performs qladm QL_NVRAM_LOAD command
2167 2236 *
2168 2237 * Input:
2169 2238 * ha: adapter state pointer.
2170 2239 * dop: ql_adm_op_t structure pointer.
2171 2240 * mode: flags.
2172 2241 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
2173 2242 * Returns:
2174 2243 *
2175 2244 * Context:
2176 2245 * Kernel context.
2177 2246 */
2178 2247 static int
2179 2248 ql_adm_nvram_load(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2180 2249 {
2181 2250 int rval;
2182 2251
2183 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2252 + QL_PRINT_9(ha, "started\n");
2184 2253
2185 2254 if (dop->length < ha->nvram_cache->size) {
2186 2255 EL(ha, "failed, length=%xh, size=%xh\n", dop->length,
2187 2256 ha->nvram_cache->size);
2188 2257 return (EINVAL);
2189 2258 }
2190 2259
2191 2260 if ((rval = ql_nv_util_load(ha, (void *)(uintptr_t)dop->buffer,
2192 2261 mode)) != 0) {
2193 2262 EL(ha, "failed, ql_nv_util_dump\n");
2194 2263 } else {
2195 2264 /*EMPTY*/
2196 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2265 + QL_PRINT_9(ha, "done\n");
2197 2266 }
2198 2267
2199 2268 return (rval);
2200 2269 }
2201 2270
2202 2271 /*
2203 2272 * ql_adm_flash_load
2204 2273 * Performs qladm QL_FLASH_LOAD command
2205 2274 *
2206 2275 * Input:
2207 2276 * ha: adapter state pointer.
2208 2277 * dop: ql_adm_op_t structure pointer.
2209 2278 * mode: flags.
2210 2279 *
2211 2280 * Returns:
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
2212 2281 *
2213 2282 * Context:
2214 2283 * Kernel context.
2215 2284 */
2216 2285 static int
2217 2286 ql_adm_flash_load(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2218 2287 {
2219 2288 uint8_t *dp;
2220 2289 int rval;
2221 2290
2222 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2291 + QL_PRINT_9(ha, "started\n");
2223 2292
2224 2293 if ((dp = kmem_zalloc(dop->length, KM_SLEEP)) == NULL) {
2225 2294 EL(ha, "failed, kmem_zalloc\n");
2226 2295 return (ENOMEM);
2227 2296 }
2228 2297
2229 2298 if (ddi_copyin((void *)(uintptr_t)dop->buffer, dp, dop->length,
2230 2299 mode) != 0) {
2231 2300 EL(ha, "ddi_copyin failed\n");
2232 2301 kmem_free(dp, dop->length);
2233 2302 return (EFAULT);
2234 2303 }
2235 2304
2236 2305 if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
2237 2306 EL(ha, "ql_stall_driver failed\n");
2238 2307 kmem_free(dp, dop->length);
2239 2308 return (EBUSY);
2240 2309 }
2241 2310
2242 - rval = (CFG_IST(ha, CFG_CTRL_24258081) ?
2311 + rval = (CFG_IST(ha, CFG_ISP_FW_TYPE_2) ?
2243 2312 ql_24xx_load_flash(ha, dp, dop->length, dop->option) :
2244 2313 ql_load_flash(ha, dp, dop->length));
2245 2314
2246 2315 ql_restart_driver(ha);
2247 2316
2248 2317 kmem_free(dp, dop->length);
2249 2318
2250 2319 if (rval != QL_SUCCESS) {
2251 2320 EL(ha, "failed\n");
2252 2321 return (EIO);
2253 2322 }
2254 2323
2255 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2324 + QL_PRINT_9(ha, "done\n");
2256 2325
2257 2326 return (0);
2258 2327 }
2259 2328
2260 2329 /*
2261 2330 * ql_adm_vpd_dump
2262 2331 * Performs qladm QL_VPD_DUMP command
2263 2332 *
2264 2333 * Input:
2265 2334 * ha: adapter state pointer.
2266 2335 * dop: ql_adm_op_t structure pointer.
2267 2336 * mode: flags.
2268 2337 *
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
2269 2338 * Returns:
2270 2339 *
2271 2340 * Context:
2272 2341 * Kernel context.
2273 2342 */
2274 2343 static int
2275 2344 ql_adm_vpd_dump(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2276 2345 {
2277 2346 int rval;
2278 2347
2279 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2348 + QL_PRINT_9(ha, "started\n");
2280 2349
2281 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
2350 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
2282 2351 EL(ha, "hba does not support VPD\n");
2283 2352 return (EINVAL);
2284 2353 }
2285 2354
2286 2355 if (dop->length < QL_24XX_VPD_SIZE) {
2287 2356 EL(ha, "failed, length=%xh, size=%xh\n", dop->length,
2288 2357 QL_24XX_VPD_SIZE);
2289 2358 return (EINVAL);
2290 2359 }
2291 2360
2292 2361 if ((rval = ql_vpd_dump(ha, (void *)(uintptr_t)dop->buffer, mode))
2293 2362 != 0) {
2294 2363 EL(ha, "failed, ql_vpd_dump\n");
2295 2364 } else {
2296 2365 /*EMPTY*/
2297 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2366 + QL_PRINT_9(ha, "done\n");
2298 2367 }
2299 2368
2300 2369 return (rval);
2301 2370 }
2302 2371
2303 2372 /*
2304 2373 * ql_adm_vpd_load
2305 2374 * Performs qladm QL_VPD_LOAD command
2306 2375 *
2307 2376 * Input:
2308 2377 * ha: adapter state pointer.
2309 2378 * dop: ql_adm_op_t structure pointer.
2310 2379 * mode: flags.
2311 2380 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
2312 2381 * Returns:
2313 2382 *
2314 2383 * Context:
2315 2384 * Kernel context.
2316 2385 */
2317 2386 static int
2318 2387 ql_adm_vpd_load(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2319 2388 {
2320 2389 int rval;
2321 2390
2322 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2391 + QL_PRINT_9(ha, "started\n");
2323 2392
2324 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
2393 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
2325 2394 EL(ha, "hba does not support VPD\n");
2326 2395 return (EINVAL);
2327 2396 }
2328 2397
2329 2398 if (dop->length < QL_24XX_VPD_SIZE) {
2330 2399 EL(ha, "failed, length=%xh, size=%xh\n", dop->length,
2331 2400 QL_24XX_VPD_SIZE);
2332 2401 return (EINVAL);
2333 2402 }
2334 2403
2335 2404 if ((rval = ql_vpd_load(ha, (void *)(uintptr_t)dop->buffer, mode))
2336 2405 != 0) {
2337 2406 EL(ha, "failed, ql_vpd_dump\n");
2338 2407 } else {
2339 2408 /*EMPTY*/
2340 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2409 + QL_PRINT_9(ha, "done\n");
2341 2410 }
2342 2411
2343 2412 return (rval);
2344 2413 }
2345 2414
2346 2415 /*
2347 2416 * ql_adm_vpd_gettag
2348 2417 * Performs qladm QL_VPD_GETTAG command
2349 2418 *
2350 2419 * Input:
2351 2420 * ha: adapter state pointer.
2352 2421 * dop: ql_adm_op_t structure pointer.
2353 2422 * mode: flags.
2354 2423 *
2355 2424 * Returns:
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
2356 2425 *
2357 2426 * Context:
2358 2427 * Kernel context.
2359 2428 */
2360 2429 static int
2361 2430 ql_adm_vpd_gettag(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2362 2431 {
2363 2432 int rval = 0;
2364 2433 uint8_t *lbuf;
2365 2434
2366 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2435 + QL_PRINT_9(ha, "started\n");
2367 2436
2368 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
2437 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
2369 2438 EL(ha, "hba does not support VPD\n");
2370 2439 return (EINVAL);
2371 2440 }
2372 2441
2373 2442 if ((lbuf = (uint8_t *)kmem_zalloc(dop->length, KM_SLEEP)) == NULL) {
2374 2443 EL(ha, "mem alloc failure of %xh bytes\n", dop->length);
2375 2444 rval = EFAULT;
2376 2445 } else {
2377 2446 if (ddi_copyin((void *)(uintptr_t)dop->buffer, lbuf,
2378 2447 dop->length, mode) != 0) {
2379 2448 EL(ha, "ddi_copyin failed\n");
2380 2449 kmem_free(lbuf, dop->length);
2381 2450 return (EFAULT);
2382 2451 }
2383 2452
2384 2453 if ((rval = ql_vpd_lookup(ha, lbuf, lbuf, (int32_t)
2385 2454 dop->length)) < 0) {
2386 2455 EL(ha, "failed vpd_lookup\n");
2387 2456 } else {
2388 2457 if (ddi_copyout(lbuf, (void *)(uintptr_t)dop->buffer,
2389 - strlen((int8_t *)lbuf)+1, mode) != 0) {
2458 + strlen((int8_t *)lbuf) + 1, mode) != 0) {
2390 2459 EL(ha, "failed, ddi_copyout\n");
2391 2460 rval = EFAULT;
2392 2461 } else {
2393 2462 rval = 0;
2394 2463 }
2395 2464 }
2396 2465 kmem_free(lbuf, dop->length);
2397 2466 }
2398 2467
2399 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2468 + QL_PRINT_9(ha, "done\n");
2400 2469
2401 2470 return (rval);
2402 2471 }
2403 2472
2404 2473 /*
2405 2474 * ql_adm_updfwmodule
2406 2475 * Performs qladm QL_UPD_FWMODULE command
2407 2476 *
2408 2477 * Input:
2409 2478 * ha: adapter state pointer.
2410 2479 * dop: ql_adm_op_t structure pointer.
2411 2480 * mode: flags.
2412 2481 *
2413 2482 * Returns:
2414 2483 *
2415 2484 * Context:
2416 2485 * Kernel context.
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
2417 2486 */
2418 2487 /* ARGSUSED */
2419 2488 static int
2420 2489 ql_adm_updfwmodule(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2421 2490 {
2422 2491 int rval = DDI_SUCCESS;
2423 2492 ql_link_t *link;
2424 2493 ql_adapter_state_t *ha2 = NULL;
2425 2494 uint16_t fw_class = (uint16_t)dop->option;
2426 2495
2427 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2496 + QL_PRINT_9(ha, "started\n");
2428 2497
2429 2498 /* zero the firmware module reference count */
2430 2499 for (link = ql_hba.first; link != NULL; link = link->next) {
2431 2500 ha2 = link->base_address;
2432 2501 if (fw_class == ha2->fw_class) {
2433 2502 if ((rval = ddi_modclose(ha2->fw_module)) !=
2434 2503 DDI_SUCCESS) {
2435 2504 EL(ha2, "modclose rval=%xh\n", rval);
2436 2505 break;
2437 2506 }
2438 2507 ha2->fw_module = NULL;
2439 2508 }
2440 2509 }
2441 2510
2442 2511 /* reload the f/w modules */
2443 2512 for (link = ql_hba.first; link != NULL; link = link->next) {
2444 2513 ha2 = link->base_address;
2445 2514
2446 2515 if ((fw_class == ha2->fw_class) && (ha2->fw_class == NULL)) {
2447 2516 if ((rval = (int32_t)ql_fwmodule_resolve(ha2)) !=
2448 2517 QL_SUCCESS) {
2449 2518 EL(ha2, "unable to load f/w module: '%x' "
2450 2519 "(rval=%xh)\n", ha2->fw_class, rval);
2451 2520 rval = EFAULT;
2452 2521 } else {
2453 2522 EL(ha2, "f/w module updated: '%x'\n",
2454 2523 ha2->fw_class);
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
2455 2524 }
2456 2525
2457 2526 EL(ha2, "isp abort needed (%d)\n", ha->instance);
2458 2527
2459 2528 ql_awaken_task_daemon(ha2, NULL, ISP_ABORT_NEEDED, 0);
2460 2529
2461 2530 rval = 0;
2462 2531 }
2463 2532 }
2464 2533
2465 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2534 + QL_PRINT_9(ha, "done\n");
2466 2535
2467 2536 return (rval);
2468 2537 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX