Print this page
NEX-5733 cleanup qlt/qlc
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Reviewed by: Alek Pinchuk <alek.pinchuk@nexenta.com>
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_mbx.c
+++ new/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_mbx.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_mbx.c"
28 +#pragma ident "Copyright 2015 QLogic Corporation; ql_mbx.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 #include <ql_apps.h>
44 44 #include <ql_api.h>
45 45 #include <ql_debug.h>
46 46 #include <ql_iocb.h>
47 47 #include <ql_isr.h>
48 48 #include <ql_mbx.h>
49 +#include <ql_nx.h>
49 50 #include <ql_xioctl.h>
50 51
51 52 /*
52 53 * Local data
53 54 */
54 55
55 56 /*
56 57 * Local prototypes
57 58 */
58 59 static int ql_mailbox_command(ql_adapter_state_t *, mbx_cmd_t *);
59 -static int ql_task_mgmt_iocb(ql_adapter_state_t *, ql_tgt_t *, uint16_t,
60 +static int ql_task_mgmt_iocb(ql_adapter_state_t *, ql_tgt_t *, uint64_t,
60 61 uint32_t, uint16_t);
61 62 static int ql_abort_cmd_iocb(ql_adapter_state_t *, ql_srb_t *);
62 63 static int ql_setup_mbox_dma_transfer(ql_adapter_state_t *, dma_mem_t *,
63 64 caddr_t, uint32_t);
64 65 static int ql_setup_mbox_dma_resources(ql_adapter_state_t *, dma_mem_t *,
65 66 uint32_t);
66 67 static void ql_setup_mbox_dma_data(dma_mem_t *, caddr_t);
67 68 static void ql_get_mbox_dma_data(dma_mem_t *, caddr_t);
68 -
69 +static int ql_init_req_q(ql_adapter_state_t *, ql_request_q_t *, uint16_t);
70 +static int ql_init_rsp_q(ql_adapter_state_t *, ql_response_q_t *, uint16_t);
69 71 /*
70 72 * ql_mailbox_command
71 73 * Issue mailbox command and waits for completion.
72 74 *
73 75 * Input:
74 76 * ha = adapter state pointer.
75 77 * mcp = mailbox command parameter structure pointer.
76 78 *
77 79 * Returns:
78 80 * ql local function return status code.
79 81 *
80 82 * Context:
81 83 * Kernel context.
82 84 */
83 85 static int
84 86 ql_mailbox_command(ql_adapter_state_t *vha, mbx_cmd_t *mcp)
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
85 87 {
86 88 uint16_t cnt;
87 89 uint32_t data;
88 90 clock_t timer, cv_stat;
89 91 int rval;
90 92 uint32_t set_flags = 0;
91 93 uint32_t reset_flags = 0;
92 94 ql_adapter_state_t *ha = vha->pha;
93 95 int mbx_cmd = mcp->mb[0];
94 96
95 - QL_PRINT_3(CE_CONT, "(%d): started, cmd=%xh\n", ha->instance, mbx_cmd);
97 + QL_PRINT_3(ha, "started, cmd=%xh\n", mbx_cmd);
96 98
97 99 /* Acquire mailbox register lock. */
98 100 MBX_REGISTER_LOCK(ha);
99 101
100 102 /* Check for mailbox available, if not wait for signal. */
101 - while (ha->mailbox_flags & MBX_BUSY_FLG ||
102 - (CFG_IST(ha, CFG_CTRL_8021) &&
103 - RD32_IO_REG(ha, nx_host_int) & NX_MBX_CMD)) {
104 - ha->mailbox_flags = (uint8_t)
105 - (ha->mailbox_flags | MBX_WANT_FLG);
106 -
103 + while (ha->mailbox_flags & MBX_BUSY_FLG) {
107 104 if (ha->task_daemon_flags & TASK_DAEMON_POWERING_DOWN) {
108 - EL(vha, "failed availability cmd=%xh\n", mcp->mb[0]);
105 + EL(vha, "powerdown availability cmd=%xh\n", mcp->mb[0]);
109 106 MBX_REGISTER_UNLOCK(ha);
110 107 return (QL_LOCK_TIMEOUT);
111 108 }
109 + ha->mailbox_flags = (uint8_t)
110 + (ha->mailbox_flags | MBX_WANT_FLG);
112 111
113 112 /* Set timeout after command that is running. */
114 - timer = (mcp->timeout + 20) * drv_usectohz(1000000);
113 + timer = ha->mailbox_flags & MBX_BUSY_FLG ?
114 + (mcp->timeout + 20) : 2;
115 + timer = timer * drv_usectohz(1000000);
115 116 cv_stat = cv_reltimedwait_sig(&ha->cv_mbx_wait,
116 117 &ha->pha->mbx_mutex, timer, TR_CLOCK_TICK);
117 118 if (cv_stat == -1 || cv_stat == 0) {
118 119 /*
119 120 * The timeout time 'timer' was
120 121 * reached without the condition
121 122 * being signaled.
122 123 */
123 124 ha->mailbox_flags = (uint8_t)(ha->mailbox_flags &
124 125 ~MBX_WANT_FLG);
125 126 cv_broadcast(&ha->cv_mbx_wait);
126 127
127 128 /* Release mailbox register lock. */
128 129 MBX_REGISTER_UNLOCK(ha);
129 130
130 131 if (cv_stat == 0) {
131 132 EL(vha, "waiting for availability aborted, "
132 133 "cmd=%xh\n", mcp->mb[0]);
133 134 return (QL_ABORTED);
134 135 }
135 136 EL(vha, "failed availability cmd=%xh\n", mcp->mb[0]);
136 137 return (QL_LOCK_TIMEOUT);
137 138 }
138 139 }
139 140
140 141 ha->mailbox_flags = (uint8_t)(ha->mailbox_flags | MBX_BUSY_FLG);
141 142
142 143 /* Structure pointer for return mailbox registers. */
143 144 ha->mcp = mcp;
144 145
145 146 /* Load mailbox registers. */
|
↓ open down ↓ |
21 lines elided |
↑ open up ↑ |
146 147 data = mcp->out_mb;
147 148 for (cnt = 0; cnt < ha->reg_off->mbox_cnt && data; cnt++) {
148 149 if (data & MBX_0) {
149 150 WRT16_IO_REG(ha, mailbox_in[cnt], mcp->mb[cnt]);
150 151 }
151 152 data >>= 1;
152 153 }
153 154
154 155 /* Issue set host interrupt command. */
155 156 ha->mailbox_flags = (uint8_t)(ha->mailbox_flags & ~MBX_INTERRUPT);
156 - if (CFG_IST(ha, CFG_CTRL_8021)) {
157 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
157 158 WRT32_IO_REG(ha, nx_host_int, NX_MBX_CMD);
158 - } else if (CFG_IST(ha, CFG_CTRL_242581)) {
159 + } else if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
159 160 WRT32_IO_REG(ha, hccr, HC24_SET_HOST_INT);
160 161 } else {
161 162 WRT16_IO_REG(ha, hccr, HC_SET_HOST_INT);
162 163 }
163 164
164 165 /* Wait for command to complete. */
165 166 if (ha->flags & INTERRUPTS_ENABLED &&
166 - !(ha->task_daemon_flags & (TASK_THREAD_CALLED |
167 - TASK_DAEMON_POWERING_DOWN)) &&
167 + !(ha->task_daemon_flags & TASK_DAEMON_POWERING_DOWN) &&
168 168 !ddi_in_panic()) {
169 169 timer = mcp->timeout * drv_usectohz(1000000);
170 170 while (!(ha->mailbox_flags & (MBX_INTERRUPT | MBX_ABORT)) &&
171 171 !(ha->task_daemon_flags & ISP_ABORT_NEEDED)) {
172 172
173 173 if (cv_reltimedwait(&ha->cv_mbx_intr,
174 174 &ha->pha->mbx_mutex, timer, TR_CLOCK_TICK) == -1) {
175 175 /*
176 176 * The timeout time 'timer' was
177 177 * reached without the condition
178 178 * being signaled.
179 179 */
180 + EL(vha, "reltimedwait expired cmd=%xh\n",
181 + mcp->mb[0]);
180 182 MBX_REGISTER_UNLOCK(ha);
181 183 while (INTERRUPT_PENDING(ha)) {
182 184 (void) ql_isr((caddr_t)ha);
183 185 INTR_LOCK(ha);
184 186 ha->intr_claimed = B_TRUE;
185 187 INTR_UNLOCK(ha);
186 188 }
187 189 MBX_REGISTER_LOCK(ha);
188 190 break;
189 191 }
190 192 }
191 193 } else {
192 194 /* Release mailbox register lock. */
193 195 MBX_REGISTER_UNLOCK(ha);
194 196
195 197 /* Acquire interrupt lock. */
196 198 for (timer = mcp->timeout * 100; timer; timer--) {
197 199 /* Check for pending interrupts. */
198 200 while (INTERRUPT_PENDING(ha)) {
199 201 (void) ql_isr((caddr_t)ha);
200 202 INTR_LOCK(ha);
201 203 ha->intr_claimed = B_TRUE;
202 204 INTR_UNLOCK(ha);
203 205 if (ha->mailbox_flags &
204 206 (MBX_INTERRUPT | MBX_ABORT) ||
205 207 ha->task_daemon_flags & ISP_ABORT_NEEDED) {
206 208 break;
207 209 }
208 210 }
209 211 if (ha->mailbox_flags & (MBX_INTERRUPT | MBX_ABORT) ||
210 212 ha->task_daemon_flags & ISP_ABORT_NEEDED) {
211 213 break;
212 214 } else if (!ddi_in_panic() && timer % 101 == 0) {
213 215 delay(drv_usectohz(10000));
214 216 } else {
215 217 drv_usecwait(10000);
216 218 }
217 219 }
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
218 220
219 221 /* Acquire mailbox register lock. */
220 222 MBX_REGISTER_LOCK(ha);
221 223 }
222 224
223 225 /* Mailbox command timeout? */
224 226 if (ha->task_daemon_flags & ISP_ABORT_NEEDED ||
225 227 ha->mailbox_flags & MBX_ABORT) {
226 228 rval = QL_ABORTED;
227 229 } else if ((ha->mailbox_flags & MBX_INTERRUPT) == 0) {
228 - if (!CFG_IST(ha, CFG_CTRL_8021)) {
230 + if (!CFG_IST(ha, CFG_CTRL_82XX)) {
229 231 if (CFG_IST(ha, CFG_DUMP_MAILBOX_TIMEOUT)) {
230 232 (void) ql_binary_fw_dump(ha, FALSE);
231 233 }
232 234 EL(vha, "command timeout, isp_abort_needed\n");
233 235 set_flags |= ISP_ABORT_NEEDED;
234 236 }
235 237 rval = QL_FUNCTION_TIMEOUT;
236 238 } else {
237 239 ha->mailbox_flags = (uint8_t)
238 240 (ha->mailbox_flags & ~MBX_INTERRUPT);
239 241 /*
240 242 * This is the expected completion path so
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
241 243 * return the actual mbx cmd completion status.
242 244 */
243 245 rval = mcp->mb[0];
244 246 }
245 247
246 248 /*
247 249 * Clear outbound to risc mailbox registers per spec. The exception
248 250 * is on 2200 mailbox 4 and 5 affect the req and resp que indexes
249 251 * so avoid writing them.
250 252 */
251 - if (ha->cfg_flags & CFG_CTRL_2200) {
253 + if (CFG_IST(ha, CFG_CTRL_22XX)) {
252 254 data = ((mcp->out_mb & ~(MBX_4 | MBX_5)) >> 1);
253 255 } else {
254 256 data = (mcp->out_mb >> 1);
255 257 }
256 258 for (cnt = 1; cnt < ha->reg_off->mbox_cnt && data; cnt++) {
257 259 if (data & MBX_0) {
258 260 WRT16_IO_REG(ha, mailbox_in[cnt], (uint16_t)0);
259 261 }
260 262 data >>= 1;
261 263 }
262 264
263 265 /* Reset busy status. */
264 266 ha->mailbox_flags = (uint8_t)(ha->mailbox_flags &
265 267 ~(MBX_BUSY_FLG | MBX_ABORT));
266 268 ha->mcp = NULL;
267 269
268 270 /* If thread is waiting for mailbox go signal it to start. */
269 271 if (ha->mailbox_flags & MBX_WANT_FLG) {
270 272 ha->mailbox_flags = (uint8_t)(ha->mailbox_flags &
271 273 ~MBX_WANT_FLG);
272 274 cv_broadcast(&ha->cv_mbx_wait);
273 275 }
274 276
275 277 /* Release mailbox register lock. */
276 278 MBX_REGISTER_UNLOCK(ha);
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
277 279
278 280 if (set_flags != 0 || reset_flags != 0) {
279 281 ql_awaken_task_daemon(ha, NULL, set_flags, reset_flags);
280 282 }
281 283
282 284 if (rval != QL_SUCCESS) {
283 285 EL(vha, "%s failed, rval=%xh, mcp->mb[0]=%xh\n",
284 286 mbx_cmd_text(mbx_cmd), rval, mcp->mb[0]);
285 287 } else {
286 288 /*EMPTY*/
287 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
289 + QL_PRINT_3(ha, "done\n");
288 290 }
289 291
290 292 return (rval);
291 293 }
292 294
293 295 /*
294 296 * ql_setup_mbox_dma_resources
295 297 * Prepare the data for a mailbox dma transfer.
296 298 *
297 299 * Input:
298 300 * ha = adapter state pointer.
299 301 * mem_desc = descriptor to contain the dma resource information.
300 302 * data = pointer to the data.
301 303 * size = size of the data in bytes.
302 304 *
303 305 * Returns:
304 306 * ql local function return status code.
305 307 *
306 308 * Context:
307 309 * Kernel context.
308 310 */
309 311 static int
310 312 ql_setup_mbox_dma_transfer(ql_adapter_state_t *ha, dma_mem_t *mem_desc,
311 313 caddr_t data, uint32_t size)
312 314 {
313 315 int rval = QL_SUCCESS;
314 316
315 317 if ((rval = ql_setup_mbox_dma_resources(ha, mem_desc, size)) ==
316 318 QL_SUCCESS) {
317 319 ql_setup_mbox_dma_data(mem_desc, data);
318 320 } else {
319 321 EL(ha, "failed, setup_mbox_dma_transfer: %xh\n", rval);
320 322 }
321 323
322 324 return (rval);
323 325 }
324 326
325 327 /*
326 328 * ql_setup_mbox_dma_resources
327 329 * Prepare a dma buffer.
328 330 *
329 331 * Input:
330 332 * ha = adapter state pointer.
331 333 * mem_desc = descriptor to contain the dma resource information.
332 334 * data = pointer to the data.
333 335 * size = size of the data in bytes.
334 336 *
335 337 * Returns:
336 338 * ql local function return status code.
337 339 *
338 340 * Context:
339 341 * Kernel context.
340 342 */
341 343 static int
342 344 ql_setup_mbox_dma_resources(ql_adapter_state_t *ha, dma_mem_t *mem_desc,
343 345 uint32_t size)
344 346 {
345 347 int rval = QL_SUCCESS;
346 348
347 349 if ((rval = ql_get_dma_mem(ha, mem_desc, size, LITTLE_ENDIAN_DMA,
348 350 QL_DMA_RING_ALIGN)) != QL_SUCCESS) {
349 351 EL(ha, "failed, ql_get_dma_mem FC_NOMEM\n");
350 352 rval = QL_MEMORY_ALLOC_FAILED;
351 353 }
352 354
353 355 return (rval);
354 356 }
355 357
356 358 /*
357 359 * ql_setup_mbox_dma_data
358 360 * Move data to the dma buffer.
359 361 *
360 362 * Input:
361 363 * mem_desc = descriptor to contain the dma resource information.
362 364 * data = pointer to the data.
363 365 *
364 366 * Returns:
365 367 *
366 368 * Context:
367 369 * Kernel context.
368 370 */
369 371 static void
370 372 ql_setup_mbox_dma_data(dma_mem_t *mem_desc, caddr_t data)
371 373 {
372 374 /* Copy out going data to DMA buffer. */
373 375 ddi_rep_put8(mem_desc->acc_handle, (uint8_t *)data,
374 376 (uint8_t *)mem_desc->bp, mem_desc->size, DDI_DEV_AUTOINCR);
375 377
376 378 /* Sync DMA buffer. */
377 379 (void) ddi_dma_sync(mem_desc->dma_handle, 0, mem_desc->size,
378 380 DDI_DMA_SYNC_FORDEV);
379 381 }
380 382
381 383 /*
382 384 * ql_get_mbox_dma_data
383 385 * Recover data from the dma buffer.
384 386 *
385 387 * Input:
386 388 * mem_desc = descriptor to contain the dma resource information.
387 389 * data = pointer to the data.
388 390 *
389 391 * Returns:
390 392 *
391 393 * Context:
392 394 * Kernel context.
393 395 */
394 396 static void
395 397 ql_get_mbox_dma_data(dma_mem_t *mem_desc, caddr_t data)
396 398 {
397 399 /* Sync in coming DMA buffer. */
398 400 (void) ddi_dma_sync(mem_desc->dma_handle, 0, mem_desc->size,
399 401 DDI_DMA_SYNC_FORKERNEL);
400 402 /* Copy in coming DMA data. */
401 403 ddi_rep_get8(mem_desc->acc_handle, (uint8_t *)data,
402 404 (uint8_t *)mem_desc->bp, mem_desc->size, DDI_DEV_AUTOINCR);
403 405 }
404 406
405 407 /*
406 408 * ql_initialize_ip
407 409 * Initialize IP receive buffer queue.
408 410 *
409 411 * Input:
410 412 * ha = adapter state pointer.
411 413 * ha->ip_init_ctrl_blk = setup for transmit.
412 414 *
413 415 * Returns:
414 416 * ql local function return status code.
415 417 *
416 418 * Context:
417 419 * Kernel context.
418 420 */
419 421 int
|
↓ open down ↓ |
122 lines elided |
↑ open up ↑ |
420 422 ql_initialize_ip(ql_adapter_state_t *ha)
421 423 {
422 424 ql_link_t *link;
423 425 ql_tgt_t *tq;
424 426 uint16_t index;
425 427 int rval;
426 428 dma_mem_t mem_desc;
427 429 mbx_cmd_t mc = {0};
428 430 mbx_cmd_t *mcp = &mc;
429 431
430 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
432 + QL_PRINT_3(ha, "started\n");
431 433
432 - if (CFG_IST(ha, (CFG_CTRL_6322 | CFG_CTRL_258081)) ||
433 - ha->vp_index != 0) {
434 + if (!CFG_IST(ha, CFG_FCIP_SUPPORT) || ha->vp_index != 0) {
434 435 ha->flags &= ~IP_INITIALIZED;
435 436 EL(ha, "HBA does not support IP\n");
436 437 return (QL_FUNCTION_FAILED);
437 438 }
438 439
439 - ha->rcvbuf_ring_ptr = ha->rcvbuf_ring_bp;
440 + ha->rcvbuf_ring_ptr = ha->rcv_ring.bp;
440 441 ha->rcvbuf_ring_index = 0;
441 442
442 443 /* Reset all sequence counts. */
443 444 for (index = 0; index < DEVICE_HEAD_LIST_SIZE; index++) {
444 445 for (link = ha->dev[index].first; link != NULL;
445 446 link = link->next) {
446 447 tq = link->base_address;
447 448 tq->ub_total_seg_cnt = 0;
448 449 }
449 450 }
450 451
451 452 rval = ql_setup_mbox_dma_transfer(ha, &mem_desc,
452 453 (caddr_t)&ha->ip_init_ctrl_blk, sizeof (ql_comb_ip_init_cb_t));
453 454 if (rval != QL_SUCCESS) {
454 455 EL(ha, "failed, setup_mbox_dma_transfer: %xh\n", rval);
455 456 return (rval);
456 457 }
457 458
458 459 mcp->mb[0] = MBC_INITIALIZE_IP;
459 460 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
460 461 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
461 462 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
462 463 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
463 464 mcp->mb[8] = 0;
464 465 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
465 466 mcp->in_mb = MBX_8|MBX_0;
466 467 mcp->timeout = MAILBOX_TOV;
467 468 rval = ql_mailbox_command(ha, mcp);
468 469
469 470 ql_free_dma_resource(ha, &mem_desc);
470 471
471 472 if (rval == QL_SUCCESS) {
472 473 ADAPTER_STATE_LOCK(ha);
473 474 ha->flags |= IP_INITIALIZED;
474 475 ADAPTER_STATE_UNLOCK(ha);
475 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
476 + QL_PRINT_3(ha, "done\n");
476 477 } else {
477 478 ha->flags &= ~IP_INITIALIZED;
478 479 EL(ha, "failed, rval = %xh\n", rval);
479 480 }
480 481 return (rval);
481 482 }
482 483
483 484 /*
484 485 * ql_shutdown_ip
485 486 * Disconnects firmware IP from system buffers.
486 487 *
487 488 * Input:
488 489 * ha = adapter state pointer.
489 490 *
490 491 * Returns:
491 492 * ql local function return status code.
492 493 *
493 494 * Context:
494 495 * Kernel context.
495 496 */
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
496 497 int
497 498 ql_shutdown_ip(ql_adapter_state_t *ha)
498 499 {
499 500 int rval;
500 501 mbx_cmd_t mc = {0};
501 502 mbx_cmd_t *mcp = &mc;
502 503 fc_unsol_buf_t *ubp;
503 504 ql_srb_t *sp;
504 505 uint16_t index;
505 506
506 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
507 + QL_PRINT_3(ha, "started\n");
507 508
508 509 mcp->mb[0] = MBC_UNLOAD_IP;
509 510 mcp->out_mb = MBX_0;
510 511 mcp->in_mb = MBX_0;
511 512 mcp->timeout = MAILBOX_TOV;
512 513 rval = ql_mailbox_command(ha, mcp);
513 514
514 515 ADAPTER_STATE_LOCK(ha);
515 516 QL_UB_LOCK(ha);
516 517 /* Return all unsolicited buffers that ISP-IP has. */
517 518 for (index = 0; index < QL_UB_LIMIT; index++) {
518 519 ubp = ha->ub_array[index];
519 520 if (ubp != NULL) {
520 521 sp = ubp->ub_fca_private;
521 522 sp->flags &= ~SRB_UB_IN_ISP;
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
522 523 }
523 524 }
524 525
525 526 ha->ub_outcnt = 0;
526 527 QL_UB_UNLOCK(ha);
527 528 ha->flags &= ~IP_INITIALIZED;
528 529 ADAPTER_STATE_UNLOCK(ha);
529 530
530 531 if (rval == QL_SUCCESS) {
531 532 /* EMPTY - no need to check return value of MBC_SHUTDOWN_IP */
532 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
533 + QL_PRINT_3(ha, "done\n");
533 534 } else {
534 535 EL(ha, "failed, rval = %xh\n", rval);
535 536 }
536 537 return (rval);
537 538 }
538 539
539 540 /*
540 541 * ql_online_selftest
541 542 * Issue online self test mailbox command.
542 543 *
543 544 * Input:
544 545 * ha = adapter state pointer.
545 546 *
546 547 * Returns:
547 548 * ql local function return status code.
548 549 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
549 550 * Context:
550 551 * Kernel context.
551 552 */
552 553 int
553 554 ql_online_selftest(ql_adapter_state_t *ha)
554 555 {
555 556 int rval;
556 557 mbx_cmd_t mc = {0};
557 558 mbx_cmd_t *mcp = &mc;
558 559
559 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
560 + QL_PRINT_3(ha, "started\n");
560 561
561 562 mcp->mb[0] = MBC_ONLINE_SELF_TEST;
562 563 mcp->out_mb = MBX_0;
563 564 mcp->in_mb = MBX_0 | MBX_1 | MBX_2 | MBX_3;
564 565 mcp->timeout = MAILBOX_TOV;
565 566 rval = ql_mailbox_command(ha, mcp);
566 567
567 568 if (rval != QL_SUCCESS) {
568 569 EL(ha, "failed, rval = %xh, mb1=%xh, mb2=%xh, mb3=%xh\n",
569 570 rval, mcp->mb[1], mcp->mb[2], mcp->mb[3]);
570 571 } else {
571 572 /*EMPTY*/
572 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
573 + QL_PRINT_3(ha, "done\n");
573 574 }
574 575 return (rval);
575 576 }
576 577
577 578 /*
578 579 * ql_loop_back
579 580 * Issue diagnostic loop back frame mailbox command.
580 581 *
581 582 * Input:
582 583 * ha: adapter state pointer.
583 584 * findex: FCF index.
584 585 * lb: loop back parameter structure pointer.
585 586 *
586 587 * Returns:
587 588 * ql local function return status code.
588 589 *
589 590 * Context:
590 591 * Kernel context.
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
591 592 */
592 593 #ifndef apps_64bit
593 594 int
594 595 ql_loop_back(ql_adapter_state_t *ha, uint16_t findex, lbp_t *lb,
595 596 uint32_t h_xmit, uint32_t h_rcv)
596 597 {
597 598 int rval;
598 599 mbx_cmd_t mc = {0};
599 600 mbx_cmd_t *mcp = &mc;
600 601
601 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
602 + QL_PRINT_3(ha, "started\n");
602 603
603 604 mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
604 605 mcp->mb[1] = lb->options;
605 606 mcp->mb[2] = findex;
606 607 mcp->mb[6] = LSW(h_rcv);
607 608 mcp->mb[7] = MSW(h_rcv);
608 609 mcp->mb[10] = LSW(lb->transfer_count);
609 610 mcp->mb[11] = MSW(lb->transfer_count);
610 611 mcp->mb[12] = lb->transfer_segment_count;
611 612 mcp->mb[13] = lb->receive_segment_count;
612 613 mcp->mb[14] = LSW(lb->transfer_data_address);
613 614 mcp->mb[15] = MSW(lb->transfer_data_address);
614 615 mcp->mb[16] = LSW(lb->receive_data_address);
615 616 mcp->mb[17] = MSW(lb->receive_data_address);
616 617 mcp->mb[18] = LSW(lb->iteration_count);
617 618 mcp->mb[19] = MSW(lb->iteration_count);
618 619 mcp->mb[20] = LSW(h_xmit);
619 620 mcp->mb[21] = MSW(h_xmit);
620 621 mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
621 622 MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
622 623 mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
623 624 mcp->timeout = lb->iteration_count / 300;
624 625
625 626 if (mcp->timeout < MAILBOX_TOV) {
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
626 627 mcp->timeout = MAILBOX_TOV;
627 628 }
628 629
629 630 rval = ql_mailbox_command(ha, mcp);
630 631
631 632 if (rval != QL_SUCCESS) {
632 633 EL(ha, "failed, rval = %xh, mb1=%xh, mb2=%xh, mb3=%xh\n",
633 634 rval, mcp->mb[1], mcp->mb[2], mcp->mb[3]);
634 635 } else {
635 636 /*EMPTY*/
636 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
637 + QL_PRINT_3(ha, "done\n");
637 638 }
638 639 return (rval);
639 640 }
640 641 #else
641 642 int
642 643 ql_loop_back(ql_adapter_state_t *ha, uint16_t findex, lbp_t *lb)
643 644 {
644 645 int rval;
645 646 mbx_cmd_t mc = {0};
646 647 mbx_cmd_t *mcp = &mc;
647 648
648 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
649 + QL_PRINT_3(ha, "started\n");
649 650
650 651 mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
651 652 mcp->mb[1] = lb->options;
652 653 mcp->mb[2] = findex;
653 654 mcp->mb[6] = LSW(h_rcv);
654 655 mcp->mb[7] = MSW(h_rcv);
655 656 mcp->mb[6] = LSW(MSD(lb->receive_data_address));
656 657 mcp->mb[7] = MSW(MSD(lb->receive_data_address));
657 658 mcp->mb[10] = LSW(lb->transfer_count);
658 659 mcp->mb[11] = MSW(lb->transfer_count);
659 660 mcp->mb[12] = lb->transfer_segment_count;
660 661 mcp->mb[13] = lb->receive_segment_count;
661 662 mcp->mb[14] = LSW(lb->transfer_data_address);
662 663 mcp->mb[15] = MSW(lb->transfer_data_address);
663 664 mcp->mb[14] = LSW(LSD(lb->transfer_data_address));
664 665 mcp->mb[15] = MSW(LSD(lb->transfer_data_address));
665 666 mcp->mb[16] = LSW(lb->receive_data_address);
666 667 mcp->mb[17] = MSW(lb->receive_data_address);
667 668 mcp->mb[16] = LSW(LSD(lb->receive_data_address));
668 669 mcp->mb[17] = MSW(LSD(lb->receive_data_address));
669 670 mcp->mb[18] = LSW(lb->iteration_count);
670 671 mcp->mb[19] = MSW(lb->iteration_count);
671 672 mcp->mb[20] = LSW(h_xmit);
672 673 mcp->mb[21] = MSW(h_xmit);
673 674 mcp->mb[20] = LSW(MSD(lb->transfer_data_address));
674 675 mcp->mb[21] = MSW(MSD(lb->transfer_data_address));
675 676 mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
676 677 MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
677 678 mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
678 679 mcp->timeout = lb->iteration_count / 300;
679 680
|
↓ open down ↓ |
21 lines elided |
↑ open up ↑ |
680 681 if (mcp->timeout < MAILBOX_TOV) {
681 682 mcp->timeout = MAILBOX_TOV;
682 683 }
683 684
684 685 rval = ql_mailbox_command(ha, mcp);
685 686
686 687 if (rval != QL_SUCCESS) {
687 688 EL(ha, "failed, rval = %xh\n", rval);
688 689 } else {
689 690 /*EMPTY*/
690 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
691 + QL_PRINT_3(ha, "done\n");
691 692 }
692 693 return (rval);
693 694 }
694 695 #endif
695 696
696 697 /*
697 698 * ql_echo
698 699 * Issue an ELS echo using the user specified data to a user specified
699 700 * destination
700 701 *
701 702 * Input:
702 703 * ha: adapter state pointer.
703 704 * findex: FCF index.
704 705 * echo_pt: echo parameter structure pointer.
705 706 *
706 707 * Returns:
707 708 * ql local function return status code.
708 709 *
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
709 710 * Context:
710 711 * Kernel context.
711 712 */
712 713 int
713 714 ql_echo(ql_adapter_state_t *ha, uint16_t findex, echo_t *echo_pt)
714 715 {
715 716 int rval;
716 717 mbx_cmd_t mc = {0};
717 718 mbx_cmd_t *mcp = &mc;
718 719
719 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
720 + QL_PRINT_3(ha, "started\n");
720 721
721 722 mcp->mb[0] = MBC_ECHO; /* ECHO command */
722 723 mcp->mb[1] = echo_pt->options; /* command options; 64 bit */
723 724 /* addressing (bit 6) and */
724 725 /* real echo (bit 15 */
725 726 mcp->mb[2] = findex;
726 727
727 728 /*
728 729 * I know this looks strange, using a field labled "not used"
729 730 * The way the ddi_dma_cookie_t structure/union is defined
730 731 * is a union of one 64 bit entity with an array of two 32
731 732 * bit enititys. Since we have routines to convert 32 bit
732 733 * entities into 16 bit entities it is easier to use
733 734 * both 32 bit union members then the one 64 bit union
734 735 * member
735 736 */
736 737 if (echo_pt->options & BIT_6) {
737 738 /* 64 bit addressing */
738 739 /* Receive data dest add in system memory bits 47-32 */
739 740 mcp->mb[6] = LSW(echo_pt->receive_data_address.dmac_notused);
740 741
741 742 /* Receive data dest add in system memory bits 63-48 */
742 743 mcp->mb[7] = MSW(echo_pt->receive_data_address.dmac_notused);
743 744
744 745 /* Transmit data source address in system memory bits 47-32 */
745 746 mcp->mb[20] = LSW(echo_pt->transfer_data_address.dmac_notused);
746 747
747 748 /* Transmit data source address in system memory bits 63-48 */
748 749 mcp->mb[21] = MSW(echo_pt->transfer_data_address.dmac_notused);
749 750 }
750 751
751 752 /* transfer count bits 15-0 */
752 753 mcp->mb[10] = LSW(echo_pt->transfer_count);
753 754
754 755 /* Transmit data source address in system memory bits 15-0 */
755 756 mcp->mb[14] = LSW(echo_pt->transfer_data_address.dmac_address);
756 757
757 758 /* Transmit data source address in system memory bits 31-16 */
758 759 mcp->mb[15] = MSW(echo_pt->transfer_data_address.dmac_address);
759 760
760 761 /* Receive data destination address in system memory bits 15-0 */
761 762 mcp->mb[16] = LSW(echo_pt->receive_data_address.dmac_address);
762 763
763 764 /* Receive data destination address in system memory bits 31-16 */
764 765 mcp->mb[17] = MSW(echo_pt->receive_data_address.dmac_address);
765 766
766 767 mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|MBX_14|MBX_10|
|
↓ open down ↓ |
37 lines elided |
↑ open up ↑ |
767 768 MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
768 769 mcp->in_mb = MBX_3|MBX_1|MBX_0;
769 770 mcp->timeout = MAILBOX_TOV;
770 771
771 772 rval = ql_mailbox_command(ha, mcp);
772 773
773 774 if (rval != QL_SUCCESS) {
774 775 EL(ha, "failed, rval = %xh\n", rval);
775 776 } else {
776 777 /*EMPTY*/
777 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
778 + QL_PRINT_3(ha, "done\n");
778 779 }
779 780 return (rval);
780 781 }
781 782
782 783 /*
783 784 * ql_send_change_request
784 785 * Issue send change request mailbox command.
785 786 *
786 787 * Input:
787 788 * ha: adapter state pointer.
788 789 * fmt: Registration format.
789 790 *
790 791 * Returns:
791 792 * ql local function return status code.
792 793 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
793 794 * Context:
794 795 * Kernel context.
795 796 */
796 797 int
797 798 ql_send_change_request(ql_adapter_state_t *ha, uint16_t fmt)
798 799 {
799 800 int rval;
800 801 mbx_cmd_t mc = {0};
801 802 mbx_cmd_t *mcp = &mc;
802 803
803 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
804 + QL_PRINT_3(ha, "started\n");
804 805
805 806 mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
806 807 mcp->mb[1] = fmt;
807 808 mcp->out_mb = MBX_1|MBX_0;
808 809 if (ha->flags & VP_ENABLED) {
809 810 mcp->mb[9] = ha->vp_index;
810 811 mcp->out_mb |= MBX_9;
811 812 }
812 813 mcp->in_mb = MBX_0;
813 814 mcp->timeout = MAILBOX_TOV;
814 815 rval = ql_mailbox_command(ha, mcp);
815 816
816 817 if (rval != QL_SUCCESS) {
817 818 EL(ha, "failed=%xh\n", rval);
818 819 } else {
819 820 /*EMPTY*/
820 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
821 + QL_PRINT_3(ha, "done\n");
821 822 }
822 823 return (rval);
823 824 }
824 825
825 826 /*
826 827 * ql_send_lfa
827 828 * Send a Loop Fabric Address mailbox command.
828 829 *
829 830 * Input:
830 831 * ha: adapter state pointer.
831 832 * lfa: LFA command structure pointer.
832 833 *
833 834 * Returns:
834 835 * ql local function return status code.
835 836 *
836 837 * Context:
837 838 * Kernel context.
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
838 839 */
839 840 int
840 841 ql_send_lfa(ql_adapter_state_t *ha, lfa_cmd_t *lfa)
841 842 {
842 843 int rval;
843 844 uint16_t size;
844 845 dma_mem_t mem_desc;
845 846 mbx_cmd_t mc = {0};
846 847 mbx_cmd_t *mcp = &mc;
847 848
848 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
849 + QL_PRINT_3(ha, "started\n");
849 850
850 851 /* LFA_CB sz = 4 16bit words subcommand + 10 16bit words header. */
851 852 size = (uint16_t)((lfa->subcommand_length[0] + 10) << 1);
852 853
853 854 rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, (caddr_t)lfa, size);
854 855 if (rval != QL_SUCCESS) {
855 856 EL(ha, "failed, setup_mbox_dma_transfer: %xh\n", rval);
856 857 return (rval);
857 858 }
858 859
859 860 mcp->mb[0] = MBC_SEND_LFA_COMMAND;
860 861 mcp->mb[1] = (uint16_t)(size >> 1);
861 862 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
862 863 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
863 864 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
864 865 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
865 866 mcp->in_mb = MBX_0;
866 867 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
867 868 if (ha->flags & VP_ENABLED) {
868 869 mcp->mb[9] = ha->vp_index;
869 870 mcp->out_mb |= MBX_9;
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
870 871 }
871 872 mcp->timeout = MAILBOX_TOV;
872 873 rval = ql_mailbox_command(ha, mcp);
873 874
874 875 ql_free_dma_resource(ha, &mem_desc);
875 876
876 877 if (rval != QL_SUCCESS) {
877 878 EL(ha, "failed, rval = %xh\n", rval);
878 879 } else {
879 880 /*EMPTY*/
880 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
881 + QL_PRINT_3(ha, "done\n");
881 882 }
882 883
883 884 return (rval);
884 885 }
885 886
886 887 /*
887 888 * ql_clear_aca
888 889 * Issue clear ACA mailbox command.
889 890 *
890 891 * Input:
891 892 * ha: adapter state pointer.
892 893 * tq: target queue pointer.
893 - * lun: LUN.
894 + * lq: LUN queue pointer.
894 895 *
895 896 * Returns:
896 897 * ql local function return status code.
897 898 *
898 899 * Context:
899 900 * Kernel context.
900 901 */
901 902 int
902 -ql_clear_aca(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t lun)
903 +ql_clear_aca(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
903 904 {
904 905 int rval;
905 906 mbx_cmd_t mc = {0};
906 907 mbx_cmd_t *mcp = &mc;
907 908
908 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
909 + QL_PRINT_3(ha, "started\n");
909 910
910 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
911 - rval = ql_task_mgmt_iocb(ha, tq, lun, CF_CLEAR_ACA, 0);
911 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
912 + rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
913 + CF_CLEAR_ACA, 0);
912 914 } else {
913 915 mcp->mb[0] = MBC_CLEAR_ACA;
914 916 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
915 917 mcp->mb[1] = tq->loop_id;
916 918 } else {
917 919 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
918 920 }
919 - mcp->mb[2] = lun;
921 + mcp->mb[2] = lq->lun_no;
920 922 mcp->out_mb = MBX_2|MBX_1|MBX_0;
921 923 mcp->in_mb = MBX_0;
922 924 mcp->timeout = MAILBOX_TOV;
923 925 rval = ql_mailbox_command(ha, mcp);
924 926 }
925 927
926 - (void) ql_marker(ha, tq->loop_id, lun, MK_SYNC_ID);
928 + (void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);
927 929
928 930 if (rval != QL_SUCCESS) {
929 931 EL(ha, "failed, rval = %xh\n", rval);
930 932 } else {
931 933 /*EMPTY*/
932 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
934 + QL_PRINT_3(ha, "done\n");
933 935 }
934 936
935 937 return (rval);
936 938 }
937 939
938 940 /*
939 941 * ql_target_reset
940 942 * Issue target reset mailbox command.
941 943 *
942 944 * Input:
943 945 * ha: adapter state pointer.
944 946 * tq: target queue pointer.
945 947 * delay: seconds.
946 948 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
947 949 * Returns:
948 950 * ql local function return status code.
949 951 *
950 952 * Context:
951 953 * Kernel context.
952 954 */
953 955 int
954 956 ql_target_reset(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t delay)
955 957 {
956 958 ql_link_t *link;
959 + ql_srb_t *sp;
957 960 uint16_t index;
958 - int rval;
961 + int rval = QL_SUCCESS;
959 962 mbx_cmd_t mc = {0};
960 963 mbx_cmd_t *mcp = &mc;
961 964
962 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
965 + QL_PRINT_3(ha, "started\n");
963 966
964 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
967 + ql_requeue_pending_cmds(ha, tq);
968 + INTR_LOCK(ha);
969 + for (index = 1; index < ha->pha->osc_max_cnt; index++) {
970 + if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
971 + sp->lun_queue != NULL &&
972 + sp->lun_queue->target_queue == tq) {
973 + sp->flags |= SRB_ABORTING;
974 + }
975 + }
976 + INTR_UNLOCK(ha);
977 +
978 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
965 979 /* queue = NULL, all targets. */
966 980 if (tq == NULL) {
967 981 for (index = 0; index < DEVICE_HEAD_LIST_SIZE;
968 982 index++) {
969 983 for (link = ha->dev[index].first; link !=
970 984 NULL; link = link->next) {
971 985 tq = link->base_address;
972 986 if (!VALID_DEVICE_ID(ha,
973 987 tq->loop_id)) {
974 988 continue;
975 989 }
976 990
977 991 if (CFG_IST(ha, CFG_FAST_TIMEOUT)) {
978 992 rval = ql_task_mgmt_iocb(ha,
979 993 tq, 0, CF_DO_NOT_SEND |
980 994 CF_TARGET_RESET, delay);
981 995 } else {
982 996 rval = ql_task_mgmt_iocb(ha,
983 997 tq, 0, CF_TARGET_RESET,
984 998 delay);
985 999 }
986 1000
987 1001 if (rval != QL_SUCCESS) {
988 1002 break;
989 1003 }
990 1004 }
991 1005
992 1006 if (link != NULL) {
993 1007 break;
994 1008 }
995 1009 }
996 1010 tq = NULL;
997 1011 } else {
998 1012
999 1013 if (CFG_IST(ha, CFG_FAST_TIMEOUT)) {
1000 1014 rval = ql_task_mgmt_iocb(ha, tq, 0,
1001 1015 CF_TARGET_RESET | CF_DO_NOT_SEND, delay);
1002 1016 } else {
1003 1017 rval = ql_task_mgmt_iocb(ha, tq, 0,
1004 1018 CF_TARGET_RESET, delay);
1005 1019 }
1006 1020 }
1007 1021 } else {
1008 1022 /* queue = NULL, all targets. */
1009 1023 if (tq == NULL) {
1010 1024 mcp->mb[0] = MBC_RESET;
1011 1025 mcp->mb[1] = delay;
1012 1026 mcp->out_mb = MBX_1|MBX_0;
1013 1027 } else {
1014 1028 mcp->mb[0] = MBC_TARGET_RESET;
1015 1029 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1016 1030 mcp->mb[1] = tq->loop_id;
1017 1031 } else {
1018 1032 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
1019 1033 }
1020 1034 mcp->mb[2] = delay;
1021 1035 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1022 1036 }
1023 1037 mcp->in_mb = MBX_0;
1024 1038 mcp->timeout = MAILBOX_TOV;
|
↓ open down ↓ |
50 lines elided |
↑ open up ↑ |
1025 1039 rval = ql_mailbox_command(ha, mcp);
1026 1040 }
1027 1041
1028 1042 tq == NULL ? (void) ql_marker(ha, 0, 0, MK_SYNC_ALL) :
1029 1043 (void) ql_marker(ha, tq->loop_id, 0, MK_SYNC_ID);
1030 1044
1031 1045 if (rval != QL_SUCCESS) {
1032 1046 EL(ha, "failed, rval = %xh\n", rval);
1033 1047 } else {
1034 1048 /*EMPTY*/
1035 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1049 + QL_PRINT_3(ha, "done\n");
1036 1050 }
1037 1051
1038 1052 return (rval);
1039 1053 }
1040 1054
1041 1055 /*
1042 1056 * ql_abort_target
1043 1057 * Issue abort target mailbox command.
1044 1058 *
1045 1059 * Input:
1046 1060 * ha: adapter state pointer.
1047 1061 * tq: target queue pointer.
1048 1062 * delay: in seconds.
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
1049 1063 *
1050 1064 * Returns:
1051 1065 * ql local function return status code.
1052 1066 *
1053 1067 * Context:
1054 1068 * Kernel context.
1055 1069 */
1056 1070 int
1057 1071 ql_abort_target(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t delay)
1058 1072 {
1073 + ql_srb_t *sp;
1074 + uint16_t index;
1059 1075 int rval;
1060 1076 mbx_cmd_t mc = {0};
1061 1077 mbx_cmd_t *mcp = &mc;
1062 1078
1063 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1079 + QL_PRINT_3(ha, "started\n");
1064 1080
1065 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1081 + ql_requeue_pending_cmds(ha, tq);
1082 + INTR_LOCK(ha);
1083 + for (index = 1; index < ha->pha->osc_max_cnt; index++) {
1084 + if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
1085 + sp->lun_queue != NULL &&
1086 + sp->lun_queue->target_queue == tq) {
1087 + sp->flags |= SRB_ABORTING;
1088 + }
1089 + }
1090 + INTR_UNLOCK(ha);
1091 +
1092 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1066 1093 rval = ql_task_mgmt_iocb(ha, tq, 0,
1067 1094 CF_DO_NOT_SEND | CF_TARGET_RESET, delay);
1068 1095 } else {
1069 1096 mcp->mb[0] = MBC_ABORT_TARGET;
1070 1097 /* Don't send Task Mgt */
1071 1098 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1072 1099 mcp->mb[1] = tq->loop_id;
1073 1100 mcp->mb[10] = BIT_0;
1074 1101 mcp->out_mb = MBX_10|MBX_2|MBX_1|MBX_0;
1075 1102 } else {
1076 1103 mcp->mb[1] = (uint16_t)(tq->loop_id << 8 | BIT_0);
1077 1104 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1078 1105 }
1079 1106 mcp->mb[2] = delay;
1080 1107 mcp->in_mb = MBX_0;
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
1081 1108 mcp->timeout = MAILBOX_TOV;
1082 1109 rval = ql_mailbox_command(ha, mcp);
1083 1110 }
1084 1111
1085 1112 (void) ql_marker(ha, tq->loop_id, 0, MK_SYNC_ID);
1086 1113
1087 1114 if (rval != QL_SUCCESS) {
1088 1115 EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
1089 1116 } else {
1090 1117 /*EMPTY*/
1091 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1118 + QL_PRINT_3(ha, "done\n");
1092 1119 }
1093 1120 return (rval);
1094 1121 }
1095 1122
1096 1123 /*
1097 1124 * ql_lun_reset
1098 1125 * Issue LUN reset task management mailbox command.
1099 1126 *
1100 1127 * Input:
1101 1128 * ha: adapter state pointer.
1102 1129 * tq: target queue pointer.
1103 - * lun: LUN.
1130 + * lq: LUN queue pointer.
1104 1131 *
1105 1132 * Returns:
1106 1133 * ql local function return status code.
1107 1134 *
1108 1135 * Context:
1109 1136 * Kernel context.
1110 1137 */
1111 1138 int
1112 -ql_lun_reset(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t lun)
1139 +ql_lun_reset(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
1113 1140 {
1141 + ql_srb_t *sp;
1142 + uint16_t index;
1114 1143 int rval;
1115 1144 mbx_cmd_t mc = {0};
1116 1145 mbx_cmd_t *mcp = &mc;
1117 1146
1118 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1147 + QL_PRINT_3(ha, "started\n");
1119 1148
1120 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1121 - rval = ql_task_mgmt_iocb(ha, tq, lun, CF_LUN_RESET, 0);
1149 + ql_requeue_pending_cmds(ha, tq);
1150 + INTR_LOCK(ha);
1151 + for (index = 1; index < ha->pha->osc_max_cnt; index++) {
1152 + if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
1153 + sp->lun_queue != NULL &&
1154 + sp->lun_queue->target_queue == tq &&
1155 + sp->lun_queue == lq) {
1156 + sp->flags |= SRB_ABORTING;
1157 + }
1158 + }
1159 + INTR_UNLOCK(ha);
1160 +
1161 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1162 + rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
1163 + CF_LUN_RESET, 0);
1122 1164 } else {
1123 1165 mcp->mb[0] = MBC_LUN_RESET;
1124 1166 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1125 1167 mcp->mb[1] = tq->loop_id;
1126 1168 } else {
1127 1169 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
1128 1170 }
1129 - mcp->mb[2] = lun;
1171 + mcp->mb[2] = lq->lun_no;
1130 1172 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1131 1173 mcp->in_mb = MBX_0;
1132 1174 mcp->timeout = MAILBOX_TOV;
1133 1175 rval = ql_mailbox_command(ha, mcp);
1134 1176 }
1135 1177
1136 - (void) ql_marker(ha, tq->loop_id, lun, MK_SYNC_ID);
1178 + (void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);
1137 1179
1138 1180 if (rval != QL_SUCCESS) {
1139 1181 EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
1140 1182 } else {
1141 1183 /*EMPTY*/
1142 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1184 + QL_PRINT_3(ha, "done\n");
1143 1185 }
1144 1186 return (rval);
1145 1187 }
1146 1188
1147 1189 /*
1148 1190 * ql_clear_task_set
1149 1191 * Issue clear task set mailbox command.
1150 1192 *
1151 1193 * Input:
1152 1194 * ha: adapter state pointer.
1153 1195 * tq: target queue pointer.
1154 - * lun: LUN.
1196 + * lq: LUN queue pointer.
1155 1197 *
1156 1198 * Returns:
1157 1199 * ql local function return status code.
1158 1200 *
1159 1201 * Context:
1160 1202 * Kernel context.
1161 1203 */
1162 1204 int
1163 -ql_clear_task_set(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t lun)
1205 +ql_clear_task_set(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
1164 1206 {
1207 + ql_srb_t *sp;
1208 + uint16_t index;
1165 1209 int rval;
1166 1210 mbx_cmd_t mc = {0};
1167 1211 mbx_cmd_t *mcp = &mc;
1168 1212
1169 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1213 + QL_PRINT_3(ha, "started\n");
1170 1214
1171 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1172 - rval = ql_task_mgmt_iocb(ha, tq, lun, CF_CLEAR_TASK_SET, 0);
1215 + ql_requeue_pending_cmds(ha, tq);
1216 + INTR_LOCK(ha);
1217 + for (index = 1; index < ha->pha->osc_max_cnt; index++) {
1218 + if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
1219 + sp->lun_queue != NULL &&
1220 + sp->lun_queue->target_queue == tq &&
1221 + sp->lun_queue == lq) {
1222 + sp->flags |= SRB_ABORTING;
1223 + }
1224 + }
1225 + INTR_UNLOCK(ha);
1226 +
1227 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1228 + rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
1229 + CF_CLEAR_TASK_SET, 0);
1173 1230 } else {
1174 1231 mcp->mb[0] = MBC_CLEAR_TASK_SET;
1175 1232 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1176 1233 mcp->mb[1] = tq->loop_id;
1177 1234 } else {
1178 1235 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
1179 1236 }
1180 - mcp->mb[2] = lun;
1237 + mcp->mb[2] = lq->lun_no;
1181 1238 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1182 1239 mcp->in_mb = MBX_0;
1183 1240 mcp->timeout = MAILBOX_TOV;
1184 1241 rval = ql_mailbox_command(ha, mcp);
1185 1242 }
1186 1243
1187 - (void) ql_marker(ha, tq->loop_id, lun, MK_SYNC_ID);
1244 + (void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);
1188 1245
1189 1246 if (rval != QL_SUCCESS) {
1190 1247 EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
1191 1248 } else {
1192 1249 /*EMPTY*/
1193 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1250 + QL_PRINT_3(ha, "done\n");
1194 1251 }
1195 1252
1196 1253 return (rval);
1197 1254 }
1198 1255
1199 1256 /*
1200 1257 * ql_abort_task_set
1201 1258 * Issue abort task set mailbox command.
1202 1259 *
1203 1260 * Input:
1204 1261 * ha: adapter state pointer.
1205 1262 * tq: target queue pointer.
1206 - * lun: LUN.
1263 + * lq: LUN queue pointer.
1207 1264 *
1208 1265 * Returns:
1209 1266 * ql local function return status code.
1210 1267 *
1211 1268 * Context:
1212 1269 * Kernel context.
1213 1270 */
1214 1271 int
1215 -ql_abort_task_set(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t lun)
1272 +ql_abort_task_set(ql_adapter_state_t *ha, ql_tgt_t *tq, ql_lun_t *lq)
1216 1273 {
1274 + ql_srb_t *sp;
1275 + uint16_t index;
1217 1276 int rval;
1218 1277 mbx_cmd_t mc = {0};
1219 1278 mbx_cmd_t *mcp = &mc;
1220 1279
1221 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1280 + QL_PRINT_3(ha, "started\n");
1222 1281
1223 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1224 - rval = ql_task_mgmt_iocb(ha, tq, lun, CF_ABORT_TASK_SET, 0);
1282 + ql_requeue_pending_cmds(ha, tq);
1283 + INTR_LOCK(ha);
1284 + for (index = 1; index < ha->pha->osc_max_cnt; index++) {
1285 + if ((sp = ha->pha->outstanding_cmds[index]) != NULL &&
1286 + sp->lun_queue != NULL &&
1287 + sp->lun_queue->target_queue == tq &&
1288 + sp->lun_queue == lq) {
1289 + sp->flags |= SRB_ABORTING;
1290 + }
1291 + }
1292 + INTR_UNLOCK(ha);
1293 +
1294 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1295 + rval = ql_task_mgmt_iocb(ha, tq, lq->lun_addr,
1296 + CF_ABORT_TASK_SET, 0);
1225 1297 } else {
1226 1298 mcp->mb[0] = MBC_ABORT_TASK_SET;
1227 1299 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1228 1300 mcp->mb[1] = tq->loop_id;
1229 1301 } else {
1230 1302 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
1231 1303 }
1232 - mcp->mb[2] = lun;
1304 + mcp->mb[2] = lq->lun_no;
1233 1305 mcp->out_mb = MBX_2|MBX_1|MBX_0;
1234 1306 mcp->in_mb = MBX_0;
1235 1307 mcp->timeout = MAILBOX_TOV;
1236 1308 rval = ql_mailbox_command(ha, mcp);
1237 1309 }
1238 1310
1239 - (void) ql_marker(ha, tq->loop_id, lun, MK_SYNC_ID);
1311 + (void) ql_marker(ha, tq->loop_id, lq, MK_SYNC_ID);
1240 1312
1241 1313 if (rval != QL_SUCCESS) {
1242 1314 EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
1243 1315 } else {
1244 1316 /*EMPTY*/
1245 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1317 + QL_PRINT_3(ha, "done\n");
1246 1318 }
1247 1319
1248 1320 return (rval);
1249 1321 }
1250 1322
1251 1323 /*
1252 1324 * ql_task_mgmt_iocb
1253 1325 * Function issues task management IOCB.
1254 1326 *
1255 1327 * Input:
1256 - * ha: adapter state pointer.
1257 - * tq: target queue pointer.
1258 - * lun: LUN.
1259 - * flags: control flags.
1260 - * delay: seconds.
1328 + * ha: adapter state pointer.
1329 + * tq: target queue pointer.
1330 + * lun_addr: LUN.
1331 + * flags: control flags.
1332 + * delay: seconds.
1261 1333 *
1262 1334 * Returns:
1263 1335 * ql local function return status code.
1264 1336 *
1265 1337 * Context:
1266 1338 * Kernel context
1267 1339 */
1268 1340 static int
1269 -ql_task_mgmt_iocb(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t lun,
1341 +ql_task_mgmt_iocb(ql_adapter_state_t *ha, ql_tgt_t *tq, uint64_t lun_addr,
1270 1342 uint32_t flags, uint16_t delay)
1271 1343 {
1272 1344 ql_mbx_iocb_t *pkt;
1273 1345 int rval;
1274 1346 uint32_t pkt_size;
1347 + fcp_ent_addr_t *fcp_ent_addr;
1275 1348
1276 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1349 + QL_PRINT_3(ha, "started\n");
1277 1350
1278 1351 pkt_size = sizeof (ql_mbx_iocb_t);
1279 1352 pkt = kmem_zalloc(pkt_size, KM_SLEEP);
1280 1353 if (pkt == NULL) {
1281 1354 EL(ha, "failed, kmem_zalloc\n");
1282 1355 return (QL_MEMORY_ALLOC_FAILED);
1283 1356 }
1284 1357
1285 1358 pkt->mgmt.entry_type = TASK_MGMT_TYPE;
1286 1359 pkt->mgmt.entry_count = 1;
1287 1360
1288 1361 pkt->mgmt.n_port_hdl = (uint16_t)LE_16(tq->loop_id);
1289 1362 pkt->mgmt.delay = (uint16_t)LE_16(delay);
1290 1363 pkt->mgmt.timeout = LE_16(MAILBOX_TOV);
1291 - pkt->mgmt.fcp_lun[2] = LSB(lun);
1292 - pkt->mgmt.fcp_lun[3] = MSB(lun);
1364 +
1365 + fcp_ent_addr = (fcp_ent_addr_t *)&lun_addr;
1366 + pkt->mgmt.fcp_lun[2] = lobyte(fcp_ent_addr->ent_addr_0);
1367 + pkt->mgmt.fcp_lun[3] = hibyte(fcp_ent_addr->ent_addr_0);
1368 + pkt->mgmt.fcp_lun[0] = lobyte(fcp_ent_addr->ent_addr_1);
1369 + pkt->mgmt.fcp_lun[1] = hibyte(fcp_ent_addr->ent_addr_1);
1370 + pkt->mgmt.fcp_lun[6] = lobyte(fcp_ent_addr->ent_addr_2);
1371 + pkt->mgmt.fcp_lun[7] = hibyte(fcp_ent_addr->ent_addr_2);
1372 + pkt->mgmt.fcp_lun[4] = lobyte(fcp_ent_addr->ent_addr_3);
1373 + pkt->mgmt.fcp_lun[5] = hibyte(fcp_ent_addr->ent_addr_3);
1374 +
1293 1375 pkt->mgmt.control_flags = LE_32(flags);
1294 1376 pkt->mgmt.target_id[0] = tq->d_id.b.al_pa;
1295 1377 pkt->mgmt.target_id[1] = tq->d_id.b.area;
1296 1378 pkt->mgmt.target_id[2] = tq->d_id.b.domain;
1297 1379 pkt->mgmt.vp_index = ha->vp_index;
1298 1380
1299 1381 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size);
1300 1382 if (rval == QL_SUCCESS && (pkt->sts24.entry_status & 0x3c) != 0) {
1301 1383 EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
1302 1384 pkt->sts24.entry_status, tq->d_id.b24);
1303 1385 rval = QL_FUNCTION_PARAMETER_ERROR;
1304 1386 }
1305 1387
1306 1388 LITTLE_ENDIAN_16(&pkt->sts24.comp_status);
1307 1389
1308 1390 if (rval == QL_SUCCESS && pkt->sts24.comp_status != CS_COMPLETE) {
1309 1391 EL(ha, "failed, comp_status=%xh, d_id=%xh\n",
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
1310 1392 pkt->sts24.comp_status, tq->d_id.b24);
1311 1393 rval = QL_FUNCTION_FAILED;
1312 1394 }
1313 1395
1314 1396 kmem_free(pkt, pkt_size);
1315 1397
1316 1398 if (rval != QL_SUCCESS) {
1317 1399 EL(ha, "failed, rval = %xh\n", rval);
1318 1400 } else {
1319 1401 /*EMPTY*/
1320 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1402 + QL_PRINT_3(ha, "done\n");
1321 1403 }
1322 1404
1323 1405 return (rval);
1324 1406 }
1325 1407
1326 1408 /*
1327 1409 * ql_loop_port_bypass
1328 1410 * Issue loop port bypass mailbox command.
1329 1411 *
1330 1412 * Input:
1331 1413 * ha: adapter state pointer.
1332 1414 * tq: target queue pointer.
1333 1415 *
1334 1416 * Returns:
1335 1417 * ql local function return status code.
1336 1418 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
1337 1419 * Context:
1338 1420 * Kernel context.
1339 1421 */
1340 1422 int
1341 1423 ql_loop_port_bypass(ql_adapter_state_t *ha, ql_tgt_t *tq)
1342 1424 {
1343 1425 int rval;
1344 1426 mbx_cmd_t mc = {0};
1345 1427 mbx_cmd_t *mcp = &mc;
1346 1428
1347 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1429 + QL_PRINT_3(ha, "started\n");
1348 1430
1349 1431 mcp->mb[0] = MBC_LOOP_PORT_BYPASS;
1350 1432
1351 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1433 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1352 1434 mcp->mb[1] = tq->d_id.b.al_pa;
1353 1435 } else if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1354 1436 mcp->mb[1] = tq->loop_id;
1355 1437 } else {
1356 1438 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
1357 1439 }
1358 1440
1359 1441 mcp->out_mb = MBX_1|MBX_0;
1360 1442 mcp->in_mb = MBX_0;
1361 1443 mcp->timeout = MAILBOX_TOV;
1362 1444 rval = ql_mailbox_command(ha, mcp);
1363 1445
1364 1446 if (rval != QL_SUCCESS) {
1365 1447 EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
1366 1448 } else {
1367 1449 /*EMPTY*/
1368 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1450 + QL_PRINT_3(ha, "done\n");
1369 1451 }
1370 1452
1371 1453 return (rval);
1372 1454 }
1373 1455
1374 1456 /*
1375 1457 * ql_loop_port_enable
1376 1458 * Issue loop port enable mailbox command.
1377 1459 *
1378 1460 * Input:
1379 1461 * ha: adapter state pointer.
1380 1462 * tq: target queue pointer.
1381 1463 *
1382 1464 * Returns:
1383 1465 * ql local function return status code.
1384 1466 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
1385 1467 * Context:
1386 1468 * Kernel context.
1387 1469 */
1388 1470 int
1389 1471 ql_loop_port_enable(ql_adapter_state_t *ha, ql_tgt_t *tq)
1390 1472 {
1391 1473 int rval;
1392 1474 mbx_cmd_t mc = {0};
1393 1475 mbx_cmd_t *mcp = &mc;
1394 1476
1395 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1477 + QL_PRINT_3(ha, "started\n");
1396 1478
1397 1479 mcp->mb[0] = MBC_LOOP_PORT_ENABLE;
1398 1480
1399 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1481 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1400 1482 mcp->mb[1] = tq->d_id.b.al_pa;
1401 1483 } else if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1402 1484 mcp->mb[1] = tq->loop_id;
1403 1485 } else {
1404 1486 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
1405 1487 }
1406 1488 mcp->out_mb = MBX_1|MBX_0;
1407 1489 mcp->in_mb = MBX_0;
1408 1490 mcp->timeout = MAILBOX_TOV;
1409 1491 rval = ql_mailbox_command(ha, mcp);
1410 1492
1411 1493 if (rval != QL_SUCCESS) {
1412 1494 EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
1413 1495 } else {
1414 1496 /*EMPTY*/
1415 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1497 + QL_PRINT_3(ha, "done\n");
1416 1498 }
1417 1499
1418 1500 return (rval);
1419 1501 }
1420 1502
1421 1503 /*
1422 1504 * ql_login_lport
1423 1505 * Issue login loop port mailbox command.
1424 1506 *
1425 1507 * Input:
1426 1508 * ha: adapter state pointer.
1427 1509 * tq: target queue pointer.
1428 1510 * loop_id: FC loop id.
1429 1511 * opt: options.
1430 1512 * LLF_NONE, LLF_PLOGI
1431 1513 *
1432 1514 * Returns:
1433 1515 * ql local function return status code.
1434 1516 *
1435 1517 * Context:
1436 1518 * Kernel context.
1437 1519 */
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
1438 1520 int
1439 1521 ql_login_lport(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t loop_id,
1440 1522 uint16_t opt)
1441 1523 {
1442 1524 int rval;
1443 1525 uint16_t flags;
1444 1526 ql_mbx_data_t mr;
1445 1527 mbx_cmd_t mc = {0};
1446 1528 mbx_cmd_t *mcp = &mc;
1447 1529
1448 - QL_PRINT_3(CE_CONT, "(%d): started, d_id=%xh, loop_id=%xh\n",
1530 + QL_PRINT_3(ha, "started, d_id=%xh, loop_id=%xh\n",
1449 1531 ha->instance, tq->d_id.b24, loop_id);
1450 1532
1451 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1533 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1452 1534 flags = CF_CMD_PLOGI;
1453 1535 if ((opt & LLF_PLOGI) == 0) {
1454 1536 flags = (uint16_t)(flags | CFO_COND_PLOGI);
1455 1537 }
1456 1538 rval = ql_log_iocb(ha, tq, loop_id, flags, &mr);
1457 1539 } else {
1458 1540 mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
1459 1541 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1460 1542 mcp->mb[1] = loop_id;
1461 1543 } else {
1462 1544 mcp->mb[1] = (uint16_t)(loop_id << 8);
1463 1545 }
1464 1546 mcp->mb[2] = opt;
1465 1547 mcp->out_mb = MBX_2|MBX_1|MBX_0;
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
1466 1548 mcp->in_mb = MBX_0;
1467 1549 mcp->timeout = MAILBOX_TOV;
1468 1550 rval = ql_mailbox_command(ha, mcp);
1469 1551 }
1470 1552
1471 1553 if (rval != QL_SUCCESS) {
1472 1554 EL(ha, "d_id=%xh, loop_id=%xh, failed=%xh\n", tq->d_id.b24,
1473 1555 loop_id, rval);
1474 1556 } else {
1475 1557 /*EMPTY*/
1476 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1558 + QL_PRINT_3(ha, "done\n");
1477 1559 }
1478 1560
1479 1561 return (rval);
1480 1562 }
1481 1563
1482 1564 /*
1483 1565 * ql_login_fport
1484 1566 * Issue login fabric port mailbox command.
1485 1567 *
1486 1568 * Input:
1487 1569 * ha: adapter state pointer.
1488 1570 * tq: target queue pointer.
1489 1571 * loop_id: FC loop id.
1490 1572 * opt: options.
1491 1573 * LFF_NONE, LFF_NO_PLOGI, LFF_NO_PRLI
1492 1574 * mr: pointer for mailbox data.
1493 1575 *
1494 1576 * Returns:
1495 1577 * ql local function return status code.
1496 1578 *
1497 1579 * Context:
1498 1580 * Kernel context.
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
1499 1581 */
1500 1582 int
1501 1583 ql_login_fport(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t loop_id,
1502 1584 uint16_t opt, ql_mbx_data_t *mr)
1503 1585 {
1504 1586 int rval;
1505 1587 uint16_t flags;
1506 1588 mbx_cmd_t mc = {0};
1507 1589 mbx_cmd_t *mcp = &mc;
1508 1590
1509 - QL_PRINT_3(CE_CONT, "(%d): started, d_id=%xh, loop_id=%xh\n",
1591 + QL_PRINT_3(ha, "started, d_id=%xh, loop_id=%xh\n",
1510 1592 ha->instance, tq->d_id.b24, loop_id);
1511 1593
1512 - if ((tq->d_id.b24 & 0xffffff) == 0xfffffa) {
1594 + if ((tq->d_id.b24 & QL_PORT_ID_MASK) == FS_MANAGEMENT_SERVER) {
1513 1595 opt = (uint16_t)(opt | LFF_NO_PRLI);
1514 1596 }
1515 1597
1516 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1598 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1517 1599 flags = CF_CMD_PLOGI;
1518 1600 if (opt & LFF_NO_PLOGI) {
1519 1601 flags = (uint16_t)(flags | CFO_COND_PLOGI);
1520 1602 }
1521 1603 if (opt & LFF_NO_PRLI) {
1522 1604 flags = (uint16_t)(flags | CFO_SKIP_PRLI);
1523 1605 }
1524 1606 rval = ql_log_iocb(ha, tq, loop_id, flags, mr);
1525 1607 } else {
1526 1608 mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
1527 1609 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1528 1610 mcp->mb[1] = loop_id;
1529 1611 mcp->mb[10] = opt;
1530 1612 mcp->out_mb = MBX_10|MBX_3|MBX_2|MBX_1|MBX_0;
1531 1613 } else {
1532 1614 mcp->mb[1] = (uint16_t)(loop_id << 8 | opt);
1533 1615 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1534 1616 }
1535 1617 mcp->mb[2] = MSW(tq->d_id.b24);
1536 1618 mcp->mb[3] = LSW(tq->d_id.b24);
1537 1619 mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
1538 1620 mcp->timeout = MAILBOX_TOV;
1539 1621 rval = ql_mailbox_command(ha, mcp);
1540 1622
1541 1623 /* Return mailbox data. */
1542 1624 if (mr != NULL) {
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
1543 1625 mr->mb[0] = mcp->mb[0];
1544 1626 mr->mb[1] = mcp->mb[1];
1545 1627 mr->mb[2] = mcp->mb[2];
1546 1628 mr->mb[6] = mcp->mb[6];
1547 1629 mr->mb[7] = mcp->mb[7];
1548 1630 }
1549 1631 }
1550 1632
1551 1633 if (rval != QL_SUCCESS) {
1552 1634 EL(ha, "d_id=%xh, loop_id=%xh, failed=%xh, mb1=%02xh, "
1553 - "mb2=%04x\n", tq->d_id.b24, loop_id, rval, mr->mb[1],
1554 - mr->mb[2]);
1635 + "mb2=%04x\n", tq->d_id.b24, loop_id, rval,
1636 + mr != NULL ? mr->mb[1] : mcp->mb[1],
1637 + mr != NULL ? mr->mb[2] : mcp->mb[2]);
1555 1638 } else {
1556 1639 /*EMPTY*/
1557 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1640 + QL_PRINT_3(ha, "done\n");
1558 1641 }
1559 1642
1560 1643 return (rval);
1561 1644 }
1562 1645
1563 1646 /*
1564 1647 * ql_logout_fabric_port
1565 1648 * Issue logout fabric port mailbox command.
1566 1649 *
1567 1650 * Input:
1568 1651 * ha: adapter state pointer.
1569 1652 * tq: target queue pointer.
1570 1653 *
1571 1654 * Returns:
1572 1655 * ql local function return status code.
1573 1656 *
1574 1657 * Context:
1575 1658 * Kernel context.
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
1576 1659 */
1577 1660 int
1578 1661 ql_logout_fabric_port(ql_adapter_state_t *ha, ql_tgt_t *tq)
1579 1662 {
1580 1663 int rval;
1581 1664 uint16_t flag;
1582 1665 ql_mbx_data_t mr;
1583 1666 mbx_cmd_t mc = {0};
1584 1667 mbx_cmd_t *mcp = &mc;
1585 1668
1586 - QL_PRINT_3(CE_CONT, "(%d): started, loop_id=%xh d_id=%xh\n",
1587 - ha->instance, tq->loop_id, tq->d_id.b24);
1669 + QL_PRINT_3(ha, "started, loop_id=%xh d_id=%xh\n",
1670 + tq->loop_id, tq->d_id.b24);
1588 1671
1589 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1590 - flag = (uint16_t)(RESERVED_LOOP_ID(ha, tq->loop_id) ?
1591 - CFO_EXPLICIT_LOGO |CF_CMD_LOGO | CFO_FREE_N_PORT_HANDLE :
1592 - CFO_IMPLICIT_LOGO |CF_CMD_LOGO | CFO_FREE_N_PORT_HANDLE);
1593 - rval = ql_log_iocb(ha, tq, tq->loop_id, flag, &mr);
1672 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1673 + if ((ha->topology & QL_N_PORT) &&
1674 + (tq->loop_id != 0x7fe) &&
1675 + (tq->loop_id != 0x7ff)) {
1676 + flag = (uint16_t)(CFO_IMPLICIT_LOGO |
1677 + CF_CMD_LOGO | CFO_FREE_N_PORT_HANDLE);
1678 +
1679 + rval = ql_log_iocb(ha, tq, tq->loop_id, flag, &mr);
1680 + } else {
1681 + flag = (uint16_t)(RESERVED_LOOP_ID(ha, tq->loop_id) ?
1682 + CFO_EXPLICIT_LOGO | CF_CMD_LOGO |
1683 + CFO_FREE_N_PORT_HANDLE :
1684 + CFO_IMPLICIT_LOGO | CF_CMD_LOGO |
1685 + CFO_FREE_N_PORT_HANDLE);
1686 +
1687 + rval = ql_log_iocb(ha, tq, tq->loop_id, flag, &mr);
1688 + }
1689 +
1690 + if (rval == QL_SUCCESS) {
1691 + EL(ha, "tq=%ph, loop_id=%xh, d_id=%xh, flag=%xh\n",
1692 + tq, tq->loop_id, tq->d_id.b24, flag);
1693 + }
1594 1694 } else {
1595 - flag = (uint16_t)(RESERVED_LOOP_ID(ha, tq->loop_id) ? 1 : 0);
1695 + flag = (uint16_t)(RESERVED_LOOP_ID(ha, tq->loop_id) ? 1 : 0);
1596 1696 mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
1597 1697 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1598 1698 mcp->mb[1] = tq->loop_id;
1599 1699 mcp->mb[10] = flag;
1600 1700 mcp->out_mb = MBX_10|MBX_1|MBX_0;
1601 1701 } else {
1602 1702 mcp->mb[1] = (uint16_t)(tq->loop_id << 8 | flag);
1603 1703 mcp->out_mb = MBX_1|MBX_0;
1604 1704 }
1605 1705 mcp->in_mb = MBX_0;
1606 1706 mcp->timeout = MAILBOX_TOV;
1607 1707 rval = ql_mailbox_command(ha, mcp);
1608 1708 }
1609 1709
1610 1710 if (rval != QL_SUCCESS) {
1611 - EL(ha, "d_id=%xh, loop_id=%xh, failed=%xh\n", rval,
1711 + EL(ha, "failed, rval=%xh, d_id=%xh, loop_id=%xh\n", rval,
1612 1712 tq->d_id.b24, tq->loop_id);
1613 1713 } else {
1614 1714 /*EMPTY*/
1615 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1715 + QL_PRINT_3(ha, "done\n");
1616 1716 }
1617 1717
1618 1718 return (rval);
1619 1719 }
1620 1720
1621 1721 /*
1622 1722 * ql_log_iocb
1623 1723 * Function issues login/logout IOCB.
1624 1724 *
1625 1725 * Input:
1626 1726 * ha: adapter state pointer.
1627 1727 * tq: target queue pointer.
1628 1728 * loop_id: FC Loop ID.
1629 1729 * flags: control flags.
1630 1730 * mr: pointer for mailbox data.
1631 1731 *
1632 1732 * Returns:
1633 1733 * ql local function return status code.
1634 1734 *
1635 1735 * Context:
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
1636 1736 * Kernel context.
1637 1737 */
1638 1738 int
1639 1739 ql_log_iocb(ql_adapter_state_t *ha, ql_tgt_t *tq, uint16_t loop_id,
1640 1740 uint16_t flags, ql_mbx_data_t *mr)
1641 1741 {
1642 1742 ql_mbx_iocb_t *pkt;
1643 1743 int rval;
1644 1744 uint32_t pkt_size;
1645 1745
1646 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1746 + QL_PRINT_3(ha, "started\n");
1647 1747
1648 1748 pkt_size = sizeof (ql_mbx_iocb_t);
1649 1749 pkt = kmem_zalloc(pkt_size, KM_SLEEP);
1650 1750 if (pkt == NULL) {
1651 1751 EL(ha, "failed, kmem_zalloc\n");
1652 1752 return (QL_MEMORY_ALLOC_FAILED);
1653 1753 }
1654 1754
1655 1755 pkt->log.entry_type = LOG_TYPE;
1656 1756 pkt->log.entry_count = 1;
1657 1757 pkt->log.n_port_hdl = (uint16_t)LE_16(loop_id);
1658 1758 pkt->log.control_flags = (uint16_t)LE_16(flags);
1659 1759 pkt->log.port_id[0] = tq->d_id.b.al_pa;
1660 1760 pkt->log.port_id[1] = tq->d_id.b.area;
1661 1761 pkt->log.port_id[2] = tq->d_id.b.domain;
1662 1762 pkt->log.vp_index = ha->vp_index;
1663 1763
1664 1764 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size);
1665 1765 if (rval == QL_SUCCESS && (pkt->log.entry_status & 0x3c) != 0) {
1666 1766 EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
1667 1767 pkt->log.entry_status, tq->d_id.b24);
1668 1768 rval = QL_FUNCTION_PARAMETER_ERROR;
1669 1769 }
1670 1770
1671 1771 if (rval == QL_SUCCESS) {
1672 1772 if (pkt->log.rsp_size == 0xB) {
1673 1773 LITTLE_ENDIAN_32(&pkt->log.io_param[5]);
1674 1774 tq->cmn_features = MSW(pkt->log.io_param[5]);
1675 1775 LITTLE_ENDIAN_32(&pkt->log.io_param[6]);
1676 1776 tq->conc_sequences = MSW(pkt->log.io_param[6]);
1677 1777 tq->relative_offset = LSW(pkt->log.io_param[6]);
1678 1778 LITTLE_ENDIAN_32(&pkt->log.io_param[9]);
1679 1779 tq->class3_recipient_ctl = MSW(pkt->log.io_param[9]);
1680 1780 tq->class3_conc_sequences = LSW(pkt->log.io_param[9]);
1681 1781 LITTLE_ENDIAN_32(&pkt->log.io_param[10]);
1682 1782 tq->class3_open_sequences_per_exch =
1683 1783 MSW(pkt->log.io_param[10]);
1684 1784 tq->prli_payload_length = 0x14;
1685 1785 }
1686 1786 if (mr != NULL) {
1687 1787 LITTLE_ENDIAN_16(&pkt->log.status);
1688 1788 LITTLE_ENDIAN_32(&pkt->log.io_param[0]);
1689 1789 LITTLE_ENDIAN_32(&pkt->log.io_param[1]);
1690 1790
1691 1791 if (pkt->log.status != CS_COMPLETE) {
1692 1792 EL(ha, "failed, status=%xh, iop0=%xh, iop1="
1693 1793 "%xh\n", pkt->log.status,
1694 1794 pkt->log.io_param[0],
1695 1795 pkt->log.io_param[1]);
1696 1796
1697 1797 switch (pkt->log.io_param[0]) {
1698 1798 case CS0_NO_LINK:
1699 1799 case CS0_FIRMWARE_NOT_READY:
1700 1800 mr->mb[0] = MBS_COMMAND_ERROR;
1701 1801 mr->mb[1] = 1;
1702 1802 break;
1703 1803 case CS0_NO_IOCB:
1704 1804 case CS0_NO_PCB_ALLOCATED:
1705 1805 mr->mb[0] = MBS_COMMAND_ERROR;
1706 1806 mr->mb[1] = 2;
1707 1807 break;
1708 1808 case CS0_NO_EXCH_CTRL_BLK:
1709 1809 mr->mb[0] = MBS_COMMAND_ERROR;
1710 1810 mr->mb[1] = 3;
1711 1811 break;
1712 1812 case CS0_COMMAND_FAILED:
1713 1813 mr->mb[0] = MBS_COMMAND_ERROR;
1714 1814 mr->mb[1] = 4;
1715 1815 switch (LSB(pkt->log.io_param[1])) {
1716 1816 case CS1_PLOGI_RESPONSE_FAILED:
1717 1817 mr->mb[2] = 3;
1718 1818 break;
1719 1819 case CS1_PRLI_FAILED:
1720 1820 mr->mb[2] = 4;
1721 1821 break;
1722 1822 case CS1_PRLI_RESPONSE_FAILED:
1723 1823 mr->mb[2] = 5;
1724 1824 break;
1725 1825 case CS1_COMMAND_LOGGED_OUT:
1726 1826 mr->mb[2] = 7;
1727 1827 break;
1728 1828 case CS1_PLOGI_FAILED:
1729 1829 default:
1730 1830 EL(ha, "log iop1 = %xh\n",
1731 1831 LSB(pkt->log.io_param[1]))
1732 1832 mr->mb[2] = 2;
1733 1833 break;
1734 1834 }
1735 1835 break;
1736 1836 case CS0_PORT_NOT_LOGGED_IN:
1737 1837 mr->mb[0] = MBS_COMMAND_ERROR;
1738 1838 mr->mb[1] = 4;
1739 1839 mr->mb[2] = 7;
1740 1840 break;
1741 1841 case CS0_NO_FLOGI_ACC:
1742 1842 case CS0_NO_FABRIC_PRESENT:
1743 1843 mr->mb[0] = MBS_COMMAND_ERROR;
1744 1844 mr->mb[1] = 5;
1745 1845 break;
1746 1846 case CS0_ELS_REJECT_RECEIVED:
1747 1847 mr->mb[0] = MBS_COMMAND_ERROR;
1748 1848 mr->mb[1] = 0xd;
1749 1849 break;
1750 1850 case CS0_PORT_ID_USED:
1751 1851 mr->mb[0] = MBS_PORT_ID_USED;
1752 1852 mr->mb[1] = LSW(pkt->log.io_param[1]);
1753 1853 break;
1754 1854 case CS0_N_PORT_HANDLE_USED:
1755 1855 mr->mb[0] = MBS_LOOP_ID_USED;
1756 1856 mr->mb[1] = MSW(pkt->log.io_param[1]);
1757 1857 mr->mb[2] = LSW(pkt->log.io_param[1]);
1758 1858 break;
1759 1859 case CS0_NO_N_PORT_HANDLE_AVAILABLE:
1760 1860 mr->mb[0] = MBS_ALL_IDS_IN_USE;
|
↓ open down ↓ |
104 lines elided |
↑ open up ↑ |
1761 1861 break;
1762 1862 case CS0_CMD_PARAMETER_ERROR:
1763 1863 default:
1764 1864 EL(ha, "pkt->log iop[0]=%xh\n",
1765 1865 pkt->log.io_param[0]);
1766 1866 mr->mb[0] =
1767 1867 MBS_COMMAND_PARAMETER_ERROR;
1768 1868 break;
1769 1869 }
1770 1870 } else {
1771 - QL_PRINT_3(CE_CONT, "(%d): status=%xh\n",
1772 - ha->instance, pkt->log.status);
1871 + QL_PRINT_3(ha, "status=%xh\n", pkt->log.status);
1773 1872
1774 1873 mr->mb[0] = MBS_COMMAND_COMPLETE;
1775 1874 mr->mb[1] = (uint16_t)
1776 1875 (pkt->log.io_param[0] & BIT_4 ? 0 : BIT_0);
1777 1876 if (pkt->log.io_param[0] & BIT_8) {
1778 1877 mr->mb[1] = (uint16_t)
1779 1878 (mr->mb[1] | BIT_1);
1780 1879 }
1781 1880 }
1782 1881 rval = mr->mb[0];
1783 1882 }
1784 1883
1785 1884 }
1786 1885
1787 1886 kmem_free(pkt, pkt_size);
1788 1887
1789 1888 if (rval != QL_SUCCESS) {
1790 - EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
1889 + EL(ha, "failed, rval=%xh, d_id=%xh loop_id=%xh\n",
1890 + rval, tq->d_id.b24, loop_id);
1791 1891 } else {
1792 1892 /*EMPTY*/
1793 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
1893 + QL_PRINT_3(ha, "done\n");
1794 1894 }
1795 1895
1796 1896 return (rval);
1797 1897 }
1798 1898
1799 1899 /*
1800 1900 * ql_get_port_database
1801 1901 * Issue get port database mailbox command
1802 1902 * and copy context to device queue.
1803 1903 *
1804 1904 * Input:
1805 1905 * ha: adapter state pointer.
1806 1906 * tq: target queue pointer.
1807 1907 * opt: options.
1808 1908 * PDF_NONE, PDF_PLOGI, PDF_ADISC
1809 1909 * Returns:
1810 1910 * ql local function return status code.
1811 1911 *
1812 1912 * Context:
1813 1913 * Kernel context.
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
1814 1914 */
1815 1915 int
1816 1916 ql_get_port_database(ql_adapter_state_t *ha, ql_tgt_t *tq, uint8_t opt)
1817 1917 {
1818 1918 int rval;
1819 1919 dma_mem_t mem_desc;
1820 1920 mbx_cmd_t mc = {0};
1821 1921 mbx_cmd_t *mcp = &mc;
1822 1922 port_database_23_t *pd23;
1823 1923
1824 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
1924 + QL_PRINT_3(ha, "started\n");
1825 1925
1826 1926 pd23 = (port_database_23_t *)kmem_zalloc(PORT_DATABASE_SIZE, KM_SLEEP);
1827 1927 if (pd23 == NULL) {
1828 1928 rval = QL_MEMORY_ALLOC_FAILED;
1829 1929 EL(ha, "failed, rval = %xh\n", rval);
1830 1930 return (rval);
1831 1931 }
1832 1932
1833 1933 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
1834 1934 PORT_DATABASE_SIZE)) != QL_SUCCESS) {
1835 1935 return (QL_MEMORY_ALLOC_FAILED);
1836 1936 }
1837 1937
1838 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1938 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1839 1939 mcp->mb[0] = MBC_GET_PORT_DATABASE;
1840 1940 mcp->mb[1] = tq->loop_id;
1841 1941 mcp->mb[4] = CHAR_TO_SHORT(tq->d_id.b.al_pa, tq->d_id.b.area);
1842 1942 mcp->mb[5] = (uint16_t)tq->d_id.b.domain;
1843 1943 mcp->mb[9] = ha->vp_index;
1844 1944 mcp->mb[10] = (uint16_t)(opt | PDF_ADISC);
1845 1945 mcp->out_mb = MBX_10|MBX_9|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|
1846 1946 MBX_2|MBX_1|MBX_0;
1847 1947 } else {
1848 1948 mcp->mb[0] = (uint16_t)(opt == PDF_NONE ?
1849 1949 MBC_GET_PORT_DATABASE : MBC_ENHANCED_GET_PORT_DATABASE);
1850 1950 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1851 1951 mcp->mb[1] = tq->loop_id;
1852 1952 mcp->mb[10] = opt;
1853 1953 mcp->out_mb = MBX_10|MBX_7|MBX_6|MBX_3|
1854 1954 MBX_2|MBX_1|MBX_0;
1855 1955 } else {
1856 1956 mcp->mb[1] = (uint16_t)(tq->loop_id << 8 | opt);
1857 1957 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1858 1958 }
1859 1959 }
1860 1960
1861 1961 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
1862 1962 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
1863 1963 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
1864 1964 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
1865 1965 mcp->in_mb = MBX_0;
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
1866 1966 mcp->timeout = MAILBOX_TOV;
1867 1967 rval = ql_mailbox_command(ha, mcp);
1868 1968
1869 1969 if (rval == QL_SUCCESS) {
1870 1970 ql_get_mbox_dma_data(&mem_desc, (caddr_t)pd23);
1871 1971 }
1872 1972
1873 1973 ql_free_dma_resource(ha, &mem_desc);
1874 1974
1875 1975 if (rval == QL_SUCCESS) {
1876 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1976 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1877 1977 port_database_24_t *pd24 = (port_database_24_t *)pd23;
1878 1978
1879 1979 tq->master_state = pd24->current_login_state;
1880 1980 tq->slave_state = pd24->last_stable_login_state;
1881 1981 if (PD_PORT_LOGIN(tq)) {
1882 1982 /* Names are big endian. */
1883 1983 bcopy((void *)&pd24->port_name[0],
1884 1984 (void *)&tq->port_name[0], 8);
1885 1985 bcopy((void *)&pd24->node_name[0],
1886 1986 (void *)&tq->node_name[0], 8);
1887 1987 tq->hard_addr.b.al_pa = pd24->hard_address[2];
1888 1988 tq->hard_addr.b.area = pd24->hard_address[1];
1889 1989 tq->hard_addr.b.domain = pd24->hard_address[0];
1890 1990 tq->class3_rcv_data_size =
1891 1991 pd24->receive_data_size;
1892 1992 LITTLE_ENDIAN_16(&tq->class3_rcv_data_size);
1893 1993 tq->prli_svc_param_word_0 =
1894 1994 pd24->PRLI_service_parameter_word_0;
1895 1995 LITTLE_ENDIAN_16(&tq->prli_svc_param_word_0);
1896 1996 tq->prli_svc_param_word_3 =
1897 1997 pd24->PRLI_service_parameter_word_3;
1898 1998 LITTLE_ENDIAN_16(&tq->prli_svc_param_word_3);
1899 1999 }
1900 2000 } else {
1901 2001 tq->master_state = pd23->master_state;
1902 2002 tq->slave_state = pd23->slave_state;
1903 2003 if (PD_PORT_LOGIN(tq)) {
1904 2004 /* Names are big endian. */
1905 2005 bcopy((void *)&pd23->port_name[0],
1906 2006 (void *)&tq->port_name[0], 8);
1907 2007 bcopy((void *)&pd23->node_name[0],
1908 2008 (void *)&tq->node_name[0], 8);
1909 2009 tq->hard_addr.b.al_pa = pd23->hard_address[2];
1910 2010 tq->hard_addr.b.area = pd23->hard_address[1];
1911 2011 tq->hard_addr.b.domain = pd23->hard_address[0];
1912 2012 tq->cmn_features = pd23->common_features;
1913 2013 LITTLE_ENDIAN_16(&tq->cmn_features);
1914 2014 tq->conc_sequences =
1915 2015 pd23->total_concurrent_sequences;
1916 2016 LITTLE_ENDIAN_16(&tq->conc_sequences);
1917 2017 tq->relative_offset =
1918 2018 pd23->RO_by_information_category;
1919 2019 LITTLE_ENDIAN_16(&tq->relative_offset);
1920 2020 tq->class3_recipient_ctl = pd23->recipient;
1921 2021 LITTLE_ENDIAN_16(&tq->class3_recipient_ctl);
1922 2022 tq->class3_rcv_data_size =
1923 2023 pd23->receive_data_size;
1924 2024 LITTLE_ENDIAN_16(&tq->class3_rcv_data_size);
1925 2025 tq->class3_conc_sequences =
1926 2026 pd23->concurrent_sequences;
1927 2027 LITTLE_ENDIAN_16(&tq->class3_conc_sequences);
1928 2028 tq->class3_open_sequences_per_exch =
1929 2029 pd23->open_sequences_per_exchange;
1930 2030 LITTLE_ENDIAN_16(
1931 2031 &tq->class3_open_sequences_per_exch);
1932 2032 tq->prli_payload_length =
1933 2033 pd23->PRLI_payload_length;
1934 2034 LITTLE_ENDIAN_16(&tq->prli_payload_length);
1935 2035 tq->prli_svc_param_word_0 =
1936 2036 pd23->PRLI_service_parameter_word_0;
1937 2037 LITTLE_ENDIAN_16(&tq->prli_svc_param_word_0);
1938 2038 tq->prli_svc_param_word_3 =
1939 2039 pd23->PRLI_service_parameter_word_3;
1940 2040 LITTLE_ENDIAN_16(&tq->prli_svc_param_word_3);
1941 2041 }
1942 2042 }
1943 2043
1944 2044 if (!PD_PORT_LOGIN(tq)) {
1945 2045 EL(ha, "d_id=%xh, loop_id=%xh, not logged in "
1946 2046 "master=%xh, slave=%xh\n", tq->d_id.b24,
1947 2047 tq->loop_id, tq->master_state, tq->slave_state);
1948 2048 rval = QL_NOT_LOGGED_IN;
1949 2049 } else {
1950 2050 tq->flags = tq->prli_svc_param_word_3 &
1951 2051 PRLI_W3_TARGET_FUNCTION ?
1952 2052 tq->flags & ~TQF_INITIATOR_DEVICE :
1953 2053 tq->flags | TQF_INITIATOR_DEVICE;
1954 2054
1955 2055 if ((tq->flags & TQF_INITIATOR_DEVICE) == 0) {
1956 2056 tq->flags = tq->prli_svc_param_word_3 &
1957 2057 PRLI_W3_RETRY ?
|
↓ open down ↓ |
71 lines elided |
↑ open up ↑ |
1958 2058 tq->flags | TQF_TAPE_DEVICE :
1959 2059 tq->flags & ~TQF_TAPE_DEVICE;
1960 2060 } else {
1961 2061 tq->flags &= ~TQF_TAPE_DEVICE;
1962 2062 }
1963 2063 }
1964 2064 }
1965 2065
1966 2066 kmem_free(pd23, PORT_DATABASE_SIZE);
1967 2067
1968 - if ((rval != QL_SUCCESS) && (rval != QL_PARAMETER_ERROR)) {
1969 - EL(ha, "d_id=%xh, loop_id=%xh, failed=%xh\n", tq->d_id.b24,
1970 - tq->loop_id, rval);
2068 + /*
2069 + * log the trace in any cases other than QL_SUCCESS.
2070 + */
2071 + if (rval != QL_SUCCESS) {
2072 + EL(ha, "failed, rval=%xh, d_id=%xh, loop_id=%xh\n",
2073 + rval, tq->d_id.b24, tq->loop_id);
1971 2074 } else {
1972 2075 /*EMPTY*/
1973 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2076 + QL_PRINT_3(ha, "done\n");
1974 2077 }
1975 2078
1976 2079 return (rval);
1977 2080 }
1978 2081
1979 2082 /*
1980 2083 * ql_get_loop_position_map
1981 2084 * Issue get loop position map mailbox command.
1982 2085 *
1983 2086 * Input:
1984 2087 * ha: adapter state pointer.
1985 2088 * size: size of data buffer.
1986 2089 * bufp: data pointer for DMA data.
1987 2090 *
1988 2091 * Returns:
1989 2092 * ql local function return status code.
1990 2093 *
1991 2094 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
1992 2095 * Kernel context.
1993 2096 */
1994 2097 int
1995 2098 ql_get_loop_position_map(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
1996 2099 {
1997 2100 int rval;
1998 2101 dma_mem_t mem_desc;
1999 2102 mbx_cmd_t mc = {0};
2000 2103 mbx_cmd_t *mcp = &mc;
2001 2104
2002 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2105 + QL_PRINT_3(ha, "started\n");
2003 2106
2004 2107 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
2005 2108 (uint32_t)size)) != QL_SUCCESS) {
2006 2109 EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
2007 2110 return (QL_MEMORY_ALLOC_FAILED);
2008 2111 }
2009 2112
2010 2113 mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
2011 2114 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2012 2115 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2013 2116 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2014 2117 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2015 2118 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2016 2119 mcp->in_mb = MBX_1|MBX_0;
2017 2120 mcp->timeout = MAILBOX_TOV;
2018 2121 rval = ql_mailbox_command(ha, mcp);
2019 2122
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
2020 2123 if (rval == QL_SUCCESS) {
2021 2124 ql_get_mbox_dma_data(&mem_desc, bufp);
2022 2125 }
2023 2126
2024 2127 ql_free_dma_resource(ha, &mem_desc);
2025 2128
2026 2129 if (rval != QL_SUCCESS) {
2027 2130 EL(ha, "failed=%xh\n", rval);
2028 2131 } else {
2029 2132 /*EMPTY*/
2030 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2133 + QL_PRINT_3(ha, "done\n");
2031 2134 }
2032 2135
2033 2136 return (rval);
2034 2137 }
2035 2138
2036 2139 /*
2037 2140 * ql_set_rnid_params
2038 2141 * Issue set RNID parameters mailbox command.
2039 2142 *
2040 2143 * Input:
2041 2144 * ha: adapter state pointer.
2042 2145 * size: size of data buffer.
2043 2146 * bufp: data pointer for DMA data.
2044 2147 *
2045 2148 * Returns:
2046 2149 * ql local function return status code.
2047 2150 *
2048 2151 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
2049 2152 * Kernel context.
2050 2153 */
2051 2154 int
2052 2155 ql_set_rnid_params(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
2053 2156 {
2054 2157 int rval;
2055 2158 dma_mem_t mem_desc;
2056 2159 mbx_cmd_t mc = {0};
2057 2160 mbx_cmd_t *mcp = &mc;
2058 2161
2059 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2162 + QL_PRINT_3(ha, "started\n");
2060 2163
2061 2164 if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bufp,
2062 2165 (uint32_t)size)) != QL_SUCCESS) {
2063 2166 EL(ha, "failed, setup_mbox_dma_transfer: %x\n", rval);
2064 2167 return (rval);
2065 2168 }
2066 2169
2067 2170 mcp->mb[0] = MBC_SET_PARAMETERS;
2068 2171 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2069 2172 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2070 2173 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2071 2174 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2072 2175 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
2073 2176 mcp->in_mb = MBX_0;
2074 2177 mcp->timeout = MAILBOX_TOV;
2075 2178 rval = ql_mailbox_command(ha, mcp);
2076 2179
2077 2180 ql_free_dma_resource(ha, &mem_desc);
2078 2181
2079 2182 if (rval != QL_SUCCESS) {
2080 2183 EL(ha, "failed, rval = %xh\n", rval);
2081 2184 } else {
2082 2185 /*EMPTY*/
2083 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2186 + QL_PRINT_3(ha, "done\n");
2084 2187 }
2085 2188
2086 2189 return (rval);
2087 2190 }
2088 2191
2089 2192 /*
2090 2193 * ql_send_rnid_els
2091 2194 * Issue a send node identfication data mailbox command.
2092 2195 *
2093 2196 * Input:
2094 2197 * ha: adapter state pointer.
2095 2198 * loop_id: FC loop id.
2096 2199 * opt: options.
2097 2200 * size: size of data buffer.
2098 2201 * bufp: data pointer for DMA data.
2099 2202 *
2100 2203 * Returns:
2101 2204 * ql local function return status code.
2102 2205 *
2103 2206 * Context:
2104 2207 * Kernel context.
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
2105 2208 */
2106 2209 int
2107 2210 ql_send_rnid_els(ql_adapter_state_t *ha, uint16_t loop_id, uint8_t opt,
2108 2211 size_t size, caddr_t bufp)
2109 2212 {
2110 2213 int rval;
2111 2214 dma_mem_t mem_desc;
2112 2215 mbx_cmd_t mc = {0};
2113 2216 mbx_cmd_t *mcp = &mc;
2114 2217
2115 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2218 + QL_PRINT_3(ha, "started\n");
2116 2219
2117 2220 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
2118 2221 (uint32_t)size)) != QL_SUCCESS) {
2119 2222 return (QL_MEMORY_ALLOC_FAILED);
2120 2223 }
2121 2224
2122 2225 mcp->mb[0] = MBC_SEND_RNID_ELS;
2123 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2226 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2124 2227 mcp->mb[1] = loop_id;
2125 2228 mcp->mb[9] = ha->vp_index;
2126 2229 mcp->mb[10] = opt;
2127 2230 mcp->out_mb = MBX_10|MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2128 2231 } else if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
2129 2232 mcp->mb[1] = loop_id;
2130 2233 mcp->mb[10] = opt;
2131 2234 mcp->out_mb = MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2132 2235 } else {
2133 2236 mcp->mb[1] = (uint16_t)(loop_id << 8 | opt);
2134 2237 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2135 2238 }
2136 2239 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2137 2240 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2138 2241 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2139 2242 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2140 2243 mcp->in_mb = MBX_0;
2141 2244 mcp->timeout = MAILBOX_TOV;
2142 2245 rval = ql_mailbox_command(ha, mcp);
2143 2246
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
2144 2247 if (rval == QL_SUCCESS) {
2145 2248 ql_get_mbox_dma_data(&mem_desc, bufp);
2146 2249 }
2147 2250
2148 2251 ql_free_dma_resource(ha, &mem_desc);
2149 2252
2150 2253 if (rval != QL_SUCCESS) {
2151 2254 EL(ha, "failed, rval = %xh\n", rval);
2152 2255 } else {
2153 2256 /*EMPTY*/
2154 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2257 + QL_PRINT_3(ha, "done\n");
2155 2258 }
2156 2259
2157 2260 return (rval);
2158 2261 }
2159 2262
2160 2263 /*
2161 2264 * ql_get_rnid_params
2162 2265 * Issue get RNID parameters mailbox command.
2163 2266 *
2164 2267 * Input:
2165 2268 * ha: adapter state pointer.
2166 2269 * size: size of data buffer.
2167 2270 * bufp: data pointer for DMA data.
2168 2271 *
2169 2272 * Returns:
2170 2273 * ql local function return status code.
2171 2274 *
2172 2275 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
2173 2276 * Kernel context.
2174 2277 */
2175 2278 int
2176 2279 ql_get_rnid_params(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
2177 2280 {
2178 2281 int rval;
2179 2282 dma_mem_t mem_desc;
2180 2283 mbx_cmd_t mc = {0};
2181 2284 mbx_cmd_t *mcp = &mc;
2182 2285
2183 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2286 + QL_PRINT_3(ha, "started\n");
2184 2287
2185 2288 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
2186 2289 (uint32_t)size)) != QL_SUCCESS) {
2187 2290 return (QL_MEMORY_ALLOC_FAILED);
2188 2291 }
2189 2292
2190 2293 mcp->mb[0] = MBC_GET_PARAMETERS;
2191 2294 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2192 2295 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2193 2296 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2194 2297 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2195 2298 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2196 2299 mcp->in_mb = MBX_0;
2197 2300 mcp->timeout = MAILBOX_TOV;
2198 2301 rval = ql_mailbox_command(ha, mcp);
2199 2302
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
2200 2303 if (rval == QL_SUCCESS) {
2201 2304 ql_get_mbox_dma_data(&mem_desc, bufp);
2202 2305 }
2203 2306
2204 2307 ql_free_dma_resource(ha, &mem_desc);
2205 2308
2206 2309 if (rval != QL_SUCCESS) {
2207 2310 EL(ha, "failed=%xh\n", rval);
2208 2311 } else {
2209 2312 /*EMPTY*/
2210 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2313 + QL_PRINT_3(ha, "done\n");
2211 2314 }
2212 2315
2213 2316 return (rval);
2214 2317 }
2215 2318
2216 2319 /*
2217 2320 * ql_get_link_status
2218 2321 * Issue get link status mailbox command.
2219 2322 *
2220 2323 * Input:
2221 2324 * ha: adapter state pointer.
2222 2325 * loop_id: FC loop id or n_port_hdl.
2223 2326 * size: size of data buffer.
2224 2327 * bufp: data pointer for DMA data.
2225 2328 * port_no: port number to query.
2226 2329 *
2227 2330 * Returns:
2228 2331 * ql local function return status code.
2229 2332 *
2230 2333 * Context:
2231 2334 * Kernel context.
2232 2335 */
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
2233 2336 int
2234 2337 ql_get_link_status(ql_adapter_state_t *ha, uint16_t loop_id, size_t size,
2235 2338 caddr_t bufp, uint8_t port_no)
2236 2339 {
2237 2340 dma_mem_t mem_desc;
2238 2341 mbx_cmd_t mc = {0};
2239 2342 mbx_cmd_t *mcp = &mc;
2240 2343 int rval = QL_SUCCESS;
2241 2344 int retry = 0;
2242 2345
2243 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2346 + QL_PRINT_3(ha, "started\n");
2244 2347
2245 2348 do {
2246 2349 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
2247 2350 (uint32_t)size)) != QL_SUCCESS) {
2248 2351 EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
2249 2352 return (QL_MEMORY_ALLOC_FAILED);
2250 2353 }
2251 2354
2252 2355 mcp->mb[0] = MBC_GET_LINK_STATUS;
2253 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2356 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2254 2357 if (loop_id == ha->loop_id) {
2255 2358 mcp->mb[0] = MBC_GET_STATUS_COUNTS;
2256 2359 mcp->mb[8] = (uint16_t)(size >> 2);
2257 2360 mcp->out_mb = MBX_10|MBX_8;
2258 2361 } else {
2259 2362 mcp->mb[1] = loop_id;
2260 2363 mcp->mb[4] = port_no;
2261 2364 mcp->mb[10] = (uint16_t)(retry ? BIT_3 : 0);
2262 2365 mcp->out_mb = MBX_10|MBX_4;
2263 2366 }
2264 2367 } else {
2265 2368 if (retry) {
2266 2369 port_no = (uint8_t)(port_no | BIT_3);
2267 2370 }
2268 2371 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
2269 2372 mcp->mb[1] = loop_id;
2270 2373 mcp->mb[10] = port_no;
2271 2374 mcp->out_mb = MBX_10;
2272 2375 } else {
2273 2376 mcp->mb[1] = (uint16_t)((loop_id << 8) |
2274 2377 port_no);
2275 2378 mcp->out_mb = 0;
2276 2379 }
2277 2380 }
2278 2381 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2279 2382 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2280 2383 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2281 2384 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2282 2385 mcp->in_mb = MBX_1|MBX_0;
2283 2386 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2284 2387 mcp->timeout = MAILBOX_TOV;
2285 2388
2286 2389 rval = ql_mailbox_command(ha, mcp);
2287 2390
2288 2391 if (rval == QL_SUCCESS) {
2289 2392 ql_get_mbox_dma_data(&mem_desc, bufp);
2290 2393 }
2291 2394
2292 2395 ql_free_dma_resource(ha, &mem_desc);
2293 2396
2294 2397 if (rval != QL_SUCCESS) {
2295 2398 EL(ha, "failed=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
2296 2399 }
2297 2400
2298 2401 /*
|
↓ open down ↓ |
35 lines elided |
↑ open up ↑ |
2299 2402 * Some of the devices want d_id in the payload,
2300 2403 * strictly as per standard. Let's retry.
2301 2404 */
2302 2405
2303 2406 } while (rval == QL_COMMAND_ERROR && !retry++);
2304 2407
2305 2408 if (rval != QL_SUCCESS) {
2306 2409 EL(ha, "failed=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
2307 2410 } else {
2308 2411 /*EMPTY*/
2309 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2412 + QL_PRINT_3(ha, "done\n");
2310 2413 }
2311 2414
2312 2415 return (rval);
2313 2416 }
2314 2417
2315 2418 /*
2316 2419 * ql_get_status_counts
2317 2420 * Issue get adapter link status counts mailbox command.
2318 2421 *
2319 2422 * Input:
2320 2423 * ha: adapter state pointer.
2321 2424 * loop_id: FC loop id or n_port_hdl.
2322 2425 * size: size of data buffer.
2323 2426 * bufp: data pointer for DMA data.
2324 2427 * port_no: port number to query.
2325 2428 *
2326 2429 * Returns:
2327 2430 * ql local function return status code.
2328 2431 *
2329 2432 * Context:
2330 2433 * Kernel context.
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
2331 2434 */
2332 2435 int
2333 2436 ql_get_status_counts(ql_adapter_state_t *ha, uint16_t loop_id, size_t size,
2334 2437 caddr_t bufp, uint8_t port_no)
2335 2438 {
2336 2439 dma_mem_t mem_desc;
2337 2440 mbx_cmd_t mc = {0};
2338 2441 mbx_cmd_t *mcp = &mc;
2339 2442 int rval = QL_SUCCESS;
2340 2443
2341 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2444 + QL_PRINT_3(ha, "started\n");
2342 2445
2343 2446 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
2344 2447 (uint32_t)size)) != QL_SUCCESS) {
2345 2448 EL(ha, "setup_mbox_dma_resources failed: %x\n", rval);
2346 2449 return (QL_MEMORY_ALLOC_FAILED);
2347 2450 }
2348 2451
2349 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2452 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2350 2453 mcp->mb[0] = MBC_GET_STATUS_COUNTS;
2351 2454 mcp->mb[8] = (uint16_t)(size / 4);
2352 2455 mcp->out_mb = MBX_10|MBX_8;
2353 2456 } else {
2354 2457 mcp->mb[0] = MBC_GET_LINK_STATUS;
2355 2458
2356 2459 /* allows reporting when link is down */
2357 - if (CFG_IST(ha, CFG_CTRL_2200) == 0) {
2460 + if (CFG_IST(ha, CFG_CTRL_22XX) == 0) {
2358 2461 port_no = (uint8_t)(port_no | BIT_6);
2359 2462 }
2360 2463
2361 2464 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
2362 2465 mcp->mb[1] = loop_id;
2363 2466 mcp->mb[10] = port_no;
2364 2467 mcp->out_mb = MBX_10|MBX_1;
2365 2468 } else {
2366 2469 mcp->mb[1] = (uint16_t)((loop_id << 8) |
2367 2470 port_no);
2368 2471 mcp->out_mb = MBX_1;
2369 2472 }
2370 2473 }
2371 2474 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2372 2475 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2373 2476 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2374 2477 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2375 2478 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2376 2479 mcp->in_mb = MBX_2|MBX_1|MBX_0;
2377 2480 mcp->timeout = MAILBOX_TOV;
2378 2481 rval = ql_mailbox_command(ha, mcp);
2379 2482
2380 2483 if (rval == QL_SUCCESS) {
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
2381 2484 ql_get_mbox_dma_data(&mem_desc, bufp);
2382 2485 }
2383 2486
2384 2487 ql_free_dma_resource(ha, &mem_desc);
2385 2488
2386 2489 if (rval != QL_SUCCESS) {
2387 2490 EL(ha, "failed=%xh, mbx1=%xh, mbx2=%xh\n", rval,
2388 2491 mcp->mb[1], mcp->mb[2]);
2389 2492 } else {
2390 2493 /*EMPTY*/
2391 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2494 + QL_PRINT_3(ha, "done\n");
2392 2495 }
2393 2496
2394 2497 return (rval);
2395 2498 }
2396 2499
2397 2500 /*
2398 2501 * ql_reset_link_status
2399 2502 * Issue Reset Link Error Status mailbox command
2400 2503 *
2401 2504 * Input:
2402 2505 * ha: adapter state pointer.
2403 2506 *
2404 2507 * Returns:
2405 2508 * ql local function return status code.
2406 2509 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
2407 2510 * Context:
2408 2511 * Kernel context.
2409 2512 */
2410 2513 int
2411 2514 ql_reset_link_status(ql_adapter_state_t *ha)
2412 2515 {
2413 2516 int rval;
2414 2517 mbx_cmd_t mc = {0};
2415 2518 mbx_cmd_t *mcp = &mc;
2416 2519
2417 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2520 + QL_PRINT_3(ha, "started\n");
2418 2521
2419 2522 mcp->mb[0] = MBC_RESET_LINK_STATUS;
2420 2523 mcp->out_mb = MBX_0;
2421 2524 mcp->in_mb = MBX_0;
2422 2525 mcp->timeout = MAILBOX_TOV;
2423 2526 rval = ql_mailbox_command(ha, mcp);
2424 2527
2425 2528 if (rval != QL_SUCCESS) {
2426 2529 EL(ha, "failed=%xh\n", rval);
2427 2530 } else {
2428 2531 /*EMPTY*/
2429 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2532 + QL_PRINT_3(ha, "done\n");
2430 2533 }
2431 2534
2432 2535 return (rval);
2433 2536 }
2434 2537
2435 2538 /*
2436 2539 * ql_loop_reset
2437 2540 * Issue loop reset.
2438 2541 *
2439 2542 * Input:
2440 2543 * ha: adapter state pointer.
2441 2544 *
2442 2545 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
2443 2546 * ql local function return status code.
2444 2547 *
2445 2548 * Context:
2446 2549 * Kernel context.
2447 2550 */
2448 2551 int
2449 2552 ql_loop_reset(ql_adapter_state_t *ha)
2450 2553 {
2451 2554 int rval;
2452 2555
2453 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2556 + QL_PRINT_3(ha, "started\n");
2454 2557
2455 2558 if (CFG_IST(ha, CFG_ENABLE_LIP_RESET)) {
2456 2559 rval = ql_lip_reset(ha, 0xff);
2457 2560 } else if (CFG_IST(ha, CFG_ENABLE_FULL_LIP_LOGIN)) {
2458 2561 rval = ql_full_login_lip(ha);
2459 2562 } else if (CFG_IST(ha, CFG_ENABLE_TARGET_RESET)) {
2460 2563 rval = ql_target_reset(ha, NULL, ha->loop_reset_delay);
2461 2564 } else {
2462 2565 rval = ql_initiate_lip(ha);
2463 2566 }
2464 2567
2465 2568 if (rval != QL_SUCCESS) {
2466 2569 EL(ha, "failed, rval = %xh\n", rval);
2467 2570 } else {
2468 2571 /*EMPTY*/
2469 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2572 + QL_PRINT_3(ha, "done\n");
2470 2573 }
2471 2574
2472 2575 return (rval);
2473 2576 }
2474 2577
2475 2578 /*
2476 2579 * ql_initiate_lip
2477 2580 * Initiate LIP mailbox command.
2478 2581 *
2479 2582 * Input:
2480 2583 * ha: adapter state pointer.
2481 2584 *
2482 2585 * Returns:
2483 2586 * ql local function return status code.
2484 2587 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
2485 2588 * Context:
2486 2589 * Kernel context.
2487 2590 */
2488 2591 int
2489 2592 ql_initiate_lip(ql_adapter_state_t *ha)
2490 2593 {
2491 2594 int rval;
2492 2595 mbx_cmd_t mc = {0};
2493 2596 mbx_cmd_t *mcp = &mc;
2494 2597
2495 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2598 + QL_PRINT_3(ha, "started\n");
2496 2599
2497 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2600 + if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
2601 + ql_toggle_loop_state(ha);
2602 + QL_PRINT_3(ha, "8081 done\n");
2603 + return (QL_SUCCESS);
2604 + }
2605 + if (CFG_IST(ha, CFG_FC_TYPE_2)) {
2498 2606 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
2499 - mcp->mb[1] = (uint16_t)(CFG_IST(ha, CFG_CTRL_8081) ?
2500 - BIT_1 : BIT_4);
2607 + mcp->mb[1] = BIT_4;
2501 2608 mcp->mb[3] = ha->loop_reset_delay;
2502 2609 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2503 2610 } else {
2504 2611 mcp->mb[0] = MBC_INITIATE_LIP;
2505 2612 mcp->out_mb = MBX_0;
2506 2613 }
2507 2614 mcp->in_mb = MBX_0;
2508 2615 mcp->timeout = MAILBOX_TOV;
2509 2616 rval = ql_mailbox_command(ha, mcp);
2510 2617
2511 2618 if (rval != QL_SUCCESS) {
2512 2619 EL(ha, "failed, rval = %xh\n", rval);
2513 2620 } else {
2514 2621 /*EMPTY*/
2515 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2622 + QL_PRINT_3(ha, "done\n");
2516 2623 }
2517 2624
2518 2625 return (rval);
2519 2626 }
2520 2627
2521 2628 /*
2522 2629 * ql_full_login_lip
2523 2630 * Issue full login LIP mailbox command.
2524 2631 *
2525 2632 * Input:
2526 2633 * ha: adapter state pointer.
2527 2634 *
2528 2635 * Returns:
2529 2636 * ql local function return status code.
2530 2637 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
2531 2638 * Context:
2532 2639 * Kernel context.
2533 2640 */
2534 2641 int
2535 2642 ql_full_login_lip(ql_adapter_state_t *ha)
2536 2643 {
2537 2644 int rval;
2538 2645 mbx_cmd_t mc = {0};
2539 2646 mbx_cmd_t *mcp = &mc;
2540 2647
2541 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2648 + QL_PRINT_3(ha, "started\n");
2542 2649
2650 + if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
2651 + ql_toggle_loop_state(ha);
2652 + QL_PRINT_3(ha, "8081 done\n");
2653 + return (QL_SUCCESS);
2654 + }
2543 2655 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
2544 - if (CFG_IST(ha, CFG_CTRL_2425)) {
2656 + if (CFG_IST(ha, CFG_FC_TYPE_2)) {
2545 2657 mcp->mb[1] = BIT_3;
2546 - } else if (CFG_IST(ha, CFG_CTRL_8081)) {
2547 - mcp->mb[1] = BIT_1;
2548 2658 }
2549 2659 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2550 2660 mcp->in_mb = MBX_0;
2551 2661 mcp->timeout = MAILBOX_TOV;
2552 2662 rval = ql_mailbox_command(ha, mcp);
2553 2663
2554 2664 if (rval != QL_SUCCESS) {
2555 2665 EL(ha, "failed, rval = %xh\n", rval);
2556 2666 } else {
2557 2667 /*EMPTY*/
2558 - QL_PRINT_3(CE_CONT, "(%d): done", ha->instance);
2668 + QL_PRINT_3(ha, "done");
2559 2669 }
2560 2670
2561 2671 return (rval);
2562 2672 }
2563 2673
2564 2674 /*
2565 2675 * ql_lip_reset
2566 2676 * Issue lip reset to a port.
2567 2677 *
2568 2678 * Input:
2569 2679 * ha: adapter state pointer.
2570 2680 * loop_id: FC loop id.
2571 2681 *
2572 2682 * Returns:
2573 2683 * ql local function return status code.
2574 2684 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
2575 2685 * Context:
2576 2686 * Kernel context.
2577 2687 */
2578 2688 int
2579 2689 ql_lip_reset(ql_adapter_state_t *ha, uint16_t loop_id)
2580 2690 {
2581 2691 int rval;
2582 2692 mbx_cmd_t mc = {0};
2583 2693 mbx_cmd_t *mcp = &mc;
2584 2694
2585 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2695 + QL_PRINT_3(ha, "started\n");
2586 2696
2587 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2697 + if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
2698 + ql_toggle_loop_state(ha);
2699 + QL_PRINT_3(ha, "8081 done\n");
2700 + return (QL_SUCCESS);
2701 + }
2702 +
2703 + if (CFG_IST(ha, CFG_FC_TYPE_2)) {
2588 2704 mcp->mb[0] = MBC_LIP_FULL_LOGIN;
2589 - mcp->mb[1] = (uint16_t)(CFG_IST(ha, CFG_CTRL_8081) ?
2590 - BIT_1 : BIT_6);
2705 + mcp->mb[1] = BIT_6;
2591 2706 mcp->mb[3] = ha->loop_reset_delay;
2592 2707 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2593 2708 } else {
2594 2709 mcp->mb[0] = MBC_LIP_RESET;
2595 2710 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
2596 2711 mcp->mb[1] = loop_id;
2597 2712 mcp->out_mb = MBX_10|MBX_3|MBX_2|MBX_1|MBX_0;
2598 2713 } else {
2599 2714 mcp->mb[1] = (uint16_t)(loop_id << 8);
2600 2715 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
2601 2716 }
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
2602 2717 mcp->mb[2] = ha->loop_reset_delay;
2603 2718 }
2604 2719 mcp->in_mb = MBX_0;
2605 2720 mcp->timeout = MAILBOX_TOV;
2606 2721 rval = ql_mailbox_command(ha, mcp);
2607 2722
2608 2723 if (rval != QL_SUCCESS) {
2609 2724 EL(ha, "failed, rval = %xh\n", rval);
2610 2725 } else {
2611 2726 /*EMPTY*/
2612 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2727 + QL_PRINT_3(ha, "done\n");
2613 2728 }
2614 2729
2615 2730 return (rval);
2616 2731 }
2617 2732
2618 2733 /*
2619 2734 * ql_abort_command
2620 2735 * Abort command aborts a specified IOCB.
2621 2736 *
2622 2737 * Input:
2623 2738 * ha: adapter state pointer.
2624 2739 * sp: SRB structure pointer.
2625 2740 *
2626 2741 * Returns:
2627 2742 * ql local function return status code.
2628 2743 *
2629 2744 * Context:
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
2630 2745 * Kernel context.
2631 2746 */
2632 2747 int
2633 2748 ql_abort_command(ql_adapter_state_t *ha, ql_srb_t *sp)
2634 2749 {
2635 2750 int rval;
2636 2751 mbx_cmd_t mc = {0};
2637 2752 mbx_cmd_t *mcp = &mc;
2638 2753 ql_tgt_t *tq = sp->lun_queue->target_queue;
2639 2754
2640 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2755 + QL_PRINT_3(ha, "started\n");
2641 2756
2642 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2757 + sp->flags |= SRB_ABORTING;
2758 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2643 2759 rval = ql_abort_cmd_iocb(ha, sp);
2644 2760 } else {
2645 2761 mcp->mb[0] = MBC_ABORT_COMMAND_IOCB;
2646 2762 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
2647 2763 mcp->mb[1] = tq->loop_id;
2648 2764 } else {
2649 2765 mcp->mb[1] = (uint16_t)(tq->loop_id << 8);
2650 2766 }
2651 2767 mcp->mb[2] = LSW(sp->handle);
2652 2768 mcp->mb[3] = MSW(sp->handle);
2653 2769 mcp->mb[6] = (uint16_t)(sp->flags & SRB_FCP_CMD_PKT ?
2654 2770 sp->lun_queue->lun_no : 0);
2655 2771 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
2656 2772 mcp->in_mb = MBX_0;
2657 2773 mcp->timeout = MAILBOX_TOV;
2658 2774 rval = ql_mailbox_command(ha, mcp);
2659 2775 }
2660 2776
2661 2777 if (rval != QL_SUCCESS) {
2662 2778 EL(ha, "failed=%xh, d_id=%xh, handle=%xh\n", rval,
2663 2779 tq->d_id.b24, sp->handle);
2664 2780 } else {
2665 2781 /*EMPTY*/
2666 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2782 + QL_PRINT_3(ha, "done\n");
2667 2783 }
2668 2784
2669 2785 return (rval);
2670 2786 }
2671 2787
2672 2788 /*
2673 2789 * ql_abort_cmd_iocb
2674 2790 * Function issues abort command IOCB.
2675 2791 *
2676 2792 * Input:
2677 2793 * ha: adapter state pointer.
2678 2794 * sp: SRB structure pointer.
2679 2795 *
2680 2796 * Returns:
2681 2797 * ql local function return status code.
2682 2798 *
2683 2799 * Context:
2684 2800 * Interrupt or Kernel context, no mailbox commands allowed.
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
2685 2801 */
2686 2802 static int
2687 2803 ql_abort_cmd_iocb(ql_adapter_state_t *ha, ql_srb_t *sp)
2688 2804 {
2689 2805 ql_mbx_iocb_t *pkt;
2690 2806 int rval;
2691 2807 uint32_t pkt_size;
2692 2808 uint16_t comp_status;
2693 2809 ql_tgt_t *tq = sp->lun_queue->target_queue;
2694 2810
2695 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2811 + QL_PRINT_3(ha, "started\n");
2696 2812
2697 2813 pkt_size = sizeof (ql_mbx_iocb_t);
2698 2814 if ((pkt = kmem_zalloc(pkt_size, KM_SLEEP)) == NULL) {
2699 2815 EL(ha, "failed, kmem_zalloc\n");
2700 2816 return (QL_MEMORY_ALLOC_FAILED);
2701 2817 }
2702 2818
2703 2819 pkt->abo.entry_type = ABORT_CMD_TYPE;
2704 2820 pkt->abo.entry_count = 1;
2705 2821 pkt->abo.n_port_hdl = (uint16_t)LE_16(tq->loop_id);
2706 - if (!CFG_IST(ha, CFG_CTRL_8021)) {
2822 + if (!CFG_IST(ha, CFG_CTRL_82XX)) {
2707 2823 pkt->abo.options = AF_NO_ABTS;
2708 2824 }
2709 2825 pkt->abo.cmd_handle = LE_32(sp->handle);
2710 2826 pkt->abo.target_id[0] = tq->d_id.b.al_pa;
2711 2827 pkt->abo.target_id[1] = tq->d_id.b.area;
2712 2828 pkt->abo.target_id[2] = tq->d_id.b.domain;
2713 2829 pkt->abo.vp_index = ha->vp_index;
2714 2830
2715 2831 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size);
2716 2832
2717 2833 if (rval == QL_SUCCESS) {
2718 - if ((pkt->abo.entry_status & 0x3c) != 0) {
2834 + if ((pkt->abo.entry_status & 0x3c) != 0) {
2719 2835 EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
2720 2836 pkt->abo.entry_status, tq->d_id.b24);
2721 2837 rval = QL_FUNCTION_PARAMETER_ERROR;
2722 2838 } else {
2723 2839 comp_status = (uint16_t)LE_16(pkt->abo.n_port_hdl);
2724 2840 if (comp_status != CS_COMPLETE) {
2725 2841 EL(ha, "failed, comp_status=%xh, d_id=%xh\n",
2726 2842 comp_status, tq->d_id.b24);
2727 2843 rval = QL_FUNCTION_FAILED;
2728 2844 }
2729 2845 }
2730 2846 }
2731 2847
2732 2848 kmem_free(pkt, pkt_size);
2733 2849
2734 2850 if (rval != QL_SUCCESS) {
2735 2851 EL(ha, "failed=%xh, d_id=%xh\n", rval, tq->d_id.b24);
2736 2852 } else {
2737 2853 /*EMPTY*/
2738 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2854 + QL_PRINT_3(ha, "done\n");
2739 2855 }
2740 2856
2741 2857 return (rval);
2742 2858 }
2743 2859
2744 2860 /*
2745 2861 * ql_verify_checksum
2746 2862 * Verify loaded RISC firmware.
2747 2863 *
2748 2864 * Input:
2749 2865 * ha = adapter state pointer.
2750 2866 *
2751 2867 * Returns:
2752 2868 * ql local function return status code.
2753 2869 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
2754 2870 * Context:
2755 2871 * Kernel context.
2756 2872 */
2757 2873 int
2758 2874 ql_verify_checksum(ql_adapter_state_t *ha)
2759 2875 {
2760 2876 int rval;
2761 2877 mbx_cmd_t mc = {0};
2762 2878 mbx_cmd_t *mcp = &mc;
2763 2879
2764 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2880 + QL_PRINT_3(ha, "started\n");
2765 2881
2766 2882 mcp->mb[0] = MBC_VERIFY_CHECKSUM;
2767 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2883 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2768 2884 mcp->mb[1] = MSW(ha->risc_fw[0].addr);
2769 2885 mcp->mb[2] = LSW(ha->risc_fw[0].addr);
2770 2886 } else {
2771 2887 mcp->mb[1] = LSW(ha->risc_fw[0].addr);
2772 2888 }
2773 2889 mcp->out_mb = MBX_2|MBX_1|MBX_0;
2774 2890 mcp->in_mb = MBX_2|MBX_1|MBX_0;
2775 2891 mcp->timeout = MAILBOX_TOV;
2776 2892 rval = ql_mailbox_command(ha, mcp);
2777 2893
2778 2894 if (rval != QL_SUCCESS) {
2779 2895 EL(ha, "failed, rval = %xh\n", rval);
2780 2896 } else {
2781 2897 /*EMPTY*/
2782 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2898 + QL_PRINT_3(ha, "done\n");
2783 2899 }
2784 2900
2785 2901 return (rval);
2786 2902 }
2787 2903
2788 2904 /*
2789 2905 * ql_get_id_list
2790 2906 * Get d_id and loop ID list.
2791 2907 *
2792 2908 * Input:
2793 2909 * ha: adapter state pointer.
2794 2910 * bp: data pointer for DMA data.
2795 2911 * size: size of data buffer.
2796 2912 * mr: pointer for mailbox data.
2797 2913 *
2798 2914 * Returns:
2799 2915 * ql local function return status code.
2800 2916 *
2801 2917 * Context:
2802 2918 * Kernel context.
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
2803 2919 */
2804 2920 int
2805 2921 ql_get_id_list(ql_adapter_state_t *ha, caddr_t bp, uint32_t size,
2806 2922 ql_mbx_data_t *mr)
2807 2923 {
2808 2924 int rval;
2809 2925 dma_mem_t mem_desc;
2810 2926 mbx_cmd_t mc = {0};
2811 2927 mbx_cmd_t *mcp = &mc;
2812 2928
2813 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
2929 + QL_PRINT_3(ha, "started\n");
2814 2930
2815 2931 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
2816 2932 (uint32_t)size)) != QL_SUCCESS) {
2817 2933 EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
2818 2934 return (QL_MEMORY_ALLOC_FAILED);
2819 2935 }
2820 2936
2821 2937 mcp->mb[0] = MBC_GET_ID_LIST;
2822 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2938 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2823 2939 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2824 2940 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2825 2941 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2826 2942 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2827 2943 mcp->mb[8] = (uint16_t)size;
2828 2944 mcp->mb[9] = ha->vp_index;
2829 2945 mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2830 2946 } else {
2831 2947 mcp->mb[1] = MSW(LSD(mem_desc.cookie.dmac_laddress));
2832 2948 mcp->mb[2] = LSW(LSD(mem_desc.cookie.dmac_laddress));
2833 2949 mcp->mb[3] = MSW(MSD(mem_desc.cookie.dmac_laddress));
2834 2950 mcp->mb[6] = LSW(MSD(mem_desc.cookie.dmac_laddress));
2835 2951 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2836 2952 }
2837 2953 mcp->in_mb = MBX_1|MBX_0;
2838 2954 mcp->timeout = MAILBOX_TOV;
2839 2955 rval = ql_mailbox_command(ha, mcp);
2840 2956
2841 2957 if (rval == QL_SUCCESS) {
2842 2958 ql_get_mbox_dma_data(&mem_desc, bp);
2843 2959 }
2844 2960
2845 2961 ql_free_dma_resource(ha, &mem_desc);
2846 2962
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
2847 2963 /* Return mailbox data. */
2848 2964 if (mr != NULL) {
2849 2965 mr->mb[0] = mcp->mb[0];
2850 2966 mr->mb[1] = mcp->mb[1];
2851 2967 }
2852 2968
2853 2969 if (rval != QL_SUCCESS) {
2854 2970 EL(ha, "failed, rval = %xh\n", rval);
2855 2971 } else {
2856 2972 /*EMPTY*/
2857 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
2973 + QL_PRINT_3(ha, "done\n");
2858 2974 }
2859 2975
2860 2976 return (rval);
2861 2977 }
2862 2978
2863 2979 /*
2864 2980 * ql_wrt_risc_ram
2865 2981 * Load RISC RAM.
2866 2982 *
2867 2983 * Input:
2868 2984 * ha: adapter state pointer.
2869 2985 * risc_address: risc ram word address.
2870 2986 * bp: DMA pointer.
2871 2987 * word_count: 16/32bit word count.
2872 2988 *
2873 2989 * Returns:
2874 2990 * ql local function return status code.
2875 2991 *
2876 2992 * Context:
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
2877 2993 * Kernel context.
2878 2994 */
2879 2995 int
2880 2996 ql_wrt_risc_ram(ql_adapter_state_t *ha, uint32_t risc_address, uint64_t bp,
2881 2997 uint32_t word_count)
2882 2998 {
2883 2999 int rval;
2884 3000 mbx_cmd_t mc = {0};
2885 3001 mbx_cmd_t *mcp = &mc;
2886 3002
2887 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3003 + QL_PRINT_3(ha, "started\n");
2888 3004
2889 - if (CFG_IST(ha, CFG_CTRL_242581)) {
3005 + mcp->mb[1] = LSW(risc_address);
3006 + mcp->mb[2] = MSW(LSD(bp));
3007 + mcp->mb[3] = LSW(LSD(bp));
3008 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2890 3009 mcp->mb[0] = MBC_LOAD_RAM_EXTENDED;
2891 3010 mcp->mb[4] = MSW(word_count);
2892 3011 mcp->mb[5] = LSW(word_count);
2893 - mcp->mb[6] = MSW(MSD(bp));
2894 - mcp->mb[7] = LSW(MSD(bp));
2895 3012 mcp->mb[8] = MSW(risc_address);
2896 - mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|
2897 - MBX_0;
3013 + mcp->out_mb = MBX_0_THRU_8;
2898 3014 } else {
2899 - mcp->mb[0] = MBC_LOAD_RAM;
3015 + mcp->mb[0] = MBC_LOAD_RISC_RAM;
2900 3016 mcp->mb[4] = LSW(word_count);
2901 - mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3017 + mcp->out_mb = MBX_7|MBX_6|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2902 3018 }
2903 - mcp->mb[1] = LSW(risc_address);
2904 - mcp->mb[2] = MSW(LSD(bp));
2905 - mcp->mb[3] = LSW(LSD(bp));
3019 + mcp->mb[6] = MSW(MSD(bp));
3020 + mcp->mb[7] = LSW(MSD(bp));
2906 3021 mcp->in_mb = MBX_0;
2907 3022 mcp->timeout = MAILBOX_TOV;
2908 -
2909 3023 rval = ql_mailbox_command(ha, mcp);
2910 3024
2911 3025 if (rval != QL_SUCCESS) {
2912 3026 EL(ha, "failed, rval = %xh\n", rval);
2913 3027 } else {
2914 3028 /*EMPTY*/
2915 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3029 + QL_PRINT_3(ha, "done\n");
2916 3030 }
2917 3031
2918 3032 return (rval);
2919 3033 }
2920 3034
2921 3035 /*
2922 3036 * ql_rd_risc_ram
2923 3037 * Get RISC RAM.
2924 3038 *
2925 3039 * Input:
2926 3040 * ha: adapter state pointer.
2927 3041 * risc_address: risc ram word address.
2928 3042 * bp: direct data pointer.
2929 3043 * word_count: 16/32bit word count.
2930 3044 *
2931 3045 * Returns:
2932 3046 * ql local function return status code.
2933 3047 *
2934 3048 * Context:
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
2935 3049 * Kernel context.
2936 3050 */
2937 3051 int
2938 3052 ql_rd_risc_ram(ql_adapter_state_t *ha, uint32_t risc_address, uint64_t bp,
2939 3053 uint32_t word_count)
2940 3054 {
2941 3055 int rval;
2942 3056 mbx_cmd_t mc = {0};
2943 3057 mbx_cmd_t *mcp = &mc;
2944 3058
2945 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3059 + QL_PRINT_3(ha, "started\n");
2946 3060
2947 - if (CFG_IST(ha, CFG_CTRL_242581)) {
3061 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2948 3062 mcp->mb[0] = MBC_DUMP_RAM_EXTENDED;
2949 3063 mcp->mb[1] = LSW(risc_address);
2950 3064 mcp->mb[2] = MSW(LSD(bp));
2951 3065 mcp->mb[3] = LSW(LSD(bp));
2952 3066 mcp->mb[4] = MSW(word_count);
2953 3067 mcp->mb[5] = LSW(word_count);
2954 3068 mcp->mb[6] = MSW(MSD(bp));
2955 3069 mcp->mb[7] = LSW(MSD(bp));
2956 3070 mcp->mb[8] = MSW(risc_address);
2957 3071 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|
2958 3072 MBX_0;
2959 3073 } else {
2960 3074 mcp->mb[0] = MBC_DUMP_RAM; /* doesn't support 64bit addr */
2961 3075 mcp->mb[1] = LSW(risc_address);
2962 3076 mcp->mb[2] = MSW(LSD(bp));
2963 3077 mcp->mb[3] = LSW(LSD(bp));
2964 3078 mcp->mb[4] = LSW(word_count);
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
2965 3079 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2966 3080 }
2967 3081 mcp->in_mb = MBX_0;
2968 3082 mcp->timeout = MAILBOX_TOV;
2969 3083 rval = ql_mailbox_command(ha, mcp);
2970 3084
2971 3085 if (rval != QL_SUCCESS) {
2972 3086 EL(ha, "failed, rval = %xh\n", rval);
2973 3087 } else {
2974 3088 /*EMPTY*/
2975 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3089 + QL_PRINT_3(ha, "done\n");
2976 3090 }
2977 3091
2978 3092 return (rval);
2979 3093 }
2980 3094
2981 3095 /*
2982 3096 * ql_wrt_risc_ram_word
2983 3097 * Write RISC RAM word.
2984 3098 *
2985 3099 * Input:
2986 3100 * ha: adapter state pointer.
2987 3101 * risc_address: risc ram word address.
2988 3102 * data: data.
2989 3103 *
2990 3104 * Returns:
2991 3105 * ql local function return status code.
2992 3106 *
2993 3107 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
2994 3108 * Kernel context.
2995 3109 */
2996 3110 int
2997 3111 ql_wrt_risc_ram_word(ql_adapter_state_t *ha, uint32_t risc_address,
2998 3112 uint32_t data)
2999 3113 {
3000 3114 int rval;
3001 3115 mbx_cmd_t mc = {0};
3002 3116 mbx_cmd_t *mcp = &mc;
3003 3117
3004 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3118 + QL_PRINT_3(ha, "started\n");
3005 3119
3006 3120 mcp->mb[0] = MBC_WRITE_RAM_EXTENDED;
3007 3121 mcp->mb[1] = LSW(risc_address);
3008 3122 mcp->mb[2] = LSW(data);
3009 3123 mcp->mb[3] = MSW(data);
3010 3124 mcp->mb[8] = MSW(risc_address);
3011 3125 mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
3012 3126 mcp->in_mb = MBX_0;
3013 3127 mcp->timeout = MAILBOX_TOV;
3014 3128
3015 3129 rval = ql_mailbox_command(ha, mcp);
3016 3130
3017 3131 if (rval != QL_SUCCESS) {
3018 3132 EL(ha, "failed, rval = %xh\n", rval);
3019 3133 } else {
3020 3134 /*EMPTY*/
3021 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3135 + QL_PRINT_3(ha, "done\n");
3022 3136 }
3023 3137
3024 3138 return (rval);
3025 3139 }
3026 3140
3027 3141 /*
3028 3142 * ql_rd_risc_ram_word
3029 3143 * Read RISC RAM word.
3030 3144 *
3031 3145 * Input:
3032 3146 * ha: adapter state pointer.
3033 3147 * risc_address: risc ram word address.
3034 3148 * data: data pointer.
3035 3149 *
3036 3150 * Returns:
3037 3151 * ql local function return status code.
3038 3152 *
3039 3153 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
3040 3154 * Kernel context.
3041 3155 */
3042 3156 int
3043 3157 ql_rd_risc_ram_word(ql_adapter_state_t *ha, uint32_t risc_address,
3044 3158 uint32_t *data)
3045 3159 {
3046 3160 int rval;
3047 3161 mbx_cmd_t mc = {0};
3048 3162 mbx_cmd_t *mcp = &mc;
3049 3163
3050 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3164 + QL_PRINT_3(ha, "started\n");
3051 3165
3052 3166 mcp->mb[0] = MBC_READ_RAM_EXTENDED;
3053 3167 mcp->mb[1] = LSW(risc_address);
3054 3168 mcp->mb[8] = MSW(risc_address);
3055 3169 mcp->out_mb = MBX_8|MBX_1|MBX_0;
3056 3170 mcp->in_mb = MBX_3|MBX_2|MBX_0;
3057 3171 mcp->timeout = MAILBOX_TOV;
3058 3172
3059 3173 rval = ql_mailbox_command(ha, mcp);
3060 3174
3061 3175 if (rval != QL_SUCCESS) {
3062 3176 EL(ha, "failed, rval = %xh\n", rval);
3063 3177 } else {
3064 3178 *data = mcp->mb[2];
3065 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
3179 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
3066 3180 *data |= mcp->mb[3] << 16;
3067 3181 }
3068 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3182 + QL_PRINT_3(ha, "done\n");
3069 3183 }
3070 3184
3071 3185 return (rval);
3072 3186 }
3073 3187
3074 3188 /*
3075 3189 * ql_issue_mbx_iocb
3076 3190 * Issue IOCB using mailbox command
3077 3191 *
3078 3192 * Input:
3079 3193 * ha: adapter state pointer.
3080 3194 * bp: buffer pointer.
3081 3195 * size: buffer size.
3082 3196 *
3083 3197 * Returns:
3084 3198 * ql local function return status code.
3085 3199 *
3086 3200 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
3087 3201 * Kernel context.
3088 3202 */
3089 3203 int
3090 3204 ql_issue_mbx_iocb(ql_adapter_state_t *ha, caddr_t bp, uint32_t size)
3091 3205 {
3092 3206 int rval;
3093 3207 dma_mem_t mem_desc;
3094 3208 mbx_cmd_t mc = {0};
3095 3209 mbx_cmd_t *mcp = &mc;
3096 3210
3097 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3211 + QL_PRINT_3(ha, "started\n");
3098 3212
3099 3213 if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bp, size)) !=
3100 3214 QL_SUCCESS) {
3101 3215 EL(ha, "setup_mbox_dma_transfer failed: %x\n", rval);
3102 3216 return (rval);
3103 3217 }
3104 3218
3105 3219 mcp->mb[0] = MBC_EXECUTE_IOCB;
3106 3220 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
3107 3221 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
3108 3222 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
3109 3223 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
3110 3224 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3111 3225 mcp->in_mb = MBX_1|MBX_0;
3112 3226 mcp->timeout = MAILBOX_TOV + 5;
3113 3227 rval = ql_mailbox_command(ha, mcp);
3114 3228
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
3115 3229 if (rval == QL_SUCCESS) {
3116 3230 ql_get_mbox_dma_data(&mem_desc, bp);
3117 3231 }
3118 3232
3119 3233 ql_free_dma_resource(ha, &mem_desc);
3120 3234
3121 3235 if (rval != QL_SUCCESS) {
3122 3236 EL(ha, "failed=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
3123 3237 } else {
3124 3238 /*EMPTY*/
3125 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3239 + QL_PRINT_3(ha, "done\n");
3126 3240 }
3127 3241
3128 3242 return (rval);
3129 3243 }
3130 3244
3131 3245 /*
3132 3246 * ql_mbx_wrap_test
3133 3247 * Mailbox register wrap test.
3134 3248 *
3135 3249 * Input:
3136 3250 * ha: adapter state pointer.
3137 3251 * mr: pointer for in/out mailbox data.
3138 3252 *
3139 3253 * Returns:
3140 3254 * ql local function return status code.
3141 3255 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3142 3256 * Context:
3143 3257 * Kernel context.
3144 3258 */
3145 3259 int
3146 3260 ql_mbx_wrap_test(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
3147 3261 {
3148 3262 int rval;
3149 3263 mbx_cmd_t mc = {0};
3150 3264 mbx_cmd_t *mcp = &mc;
3151 3265
3152 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3266 + QL_PRINT_3(ha, "started cfg=0x%llx\n", ha->cfg_flags);
3153 3267
3154 - if (mr != NULL) {
3155 - mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
3268 + mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
3269 + if (mr == NULL) {
3270 + mcp->mb[1] = 0xAAAA;
3271 + mcp->mb[2] = 0x5555;
3272 + mcp->mb[3] = 0xAA55;
3273 + mcp->mb[4] = 0x55AA;
3274 + mcp->mb[5] = 0xA5A5;
3275 + mcp->mb[6] = 0x5A5A;
3276 + mcp->mb[7] = 0x2525;
3277 + } else {
3156 3278 mcp->mb[1] = mr->mb[1];
3157 3279 mcp->mb[2] = mr->mb[2];
3158 3280 mcp->mb[3] = mr->mb[3];
3159 3281 mcp->mb[4] = mr->mb[4];
3160 3282 mcp->mb[5] = mr->mb[5];
3161 3283 mcp->mb[6] = mr->mb[6];
3162 3284 mcp->mb[7] = mr->mb[7];
3163 - mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3164 - mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3165 - mcp->timeout = MAILBOX_TOV;
3166 - rval = ql_mailbox_command(ha, mcp);
3167 - if (rval == QL_SUCCESS) {
3168 - mr->mb[1] = mcp->mb[1];
3169 - mr->mb[2] = mcp->mb[2];
3170 - mr->mb[3] = mcp->mb[3];
3171 - mr->mb[4] = mcp->mb[4];
3172 - mr->mb[5] = mcp->mb[5];
3173 - mr->mb[6] = mcp->mb[6];
3174 - mr->mb[7] = mcp->mb[7];
3285 + }
3286 + mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3287 + mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3288 + mcp->timeout = MAILBOX_TOV;
3289 + rval = ql_mailbox_command(ha, mcp);
3290 + if (rval == QL_SUCCESS) {
3291 + if (mr == NULL) {
3292 + if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
3293 + mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA) {
3294 + rval = QL_FUNCTION_FAILED;
3295 + }
3296 + if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
3297 + mcp->mb[7] != 0x2525) {
3298 + rval = QL_FUNCTION_FAILED;
3299 + }
3300 + } else {
3301 + if (mcp->mb[1] != mr->mb[1] ||
3302 + mcp->mb[2] != mr->mb[2] ||
3303 + mcp->mb[3] != mr->mb[3] ||
3304 + mcp->mb[4] != mr->mb[4]) {
3305 + rval = QL_FUNCTION_FAILED;
3306 + }
3307 + if (mcp->mb[5] != mr->mb[5] ||
3308 + mcp->mb[6] != mr->mb[6] ||
3309 + mcp->mb[7] != mr->mb[7]) {
3310 + rval = QL_FUNCTION_FAILED;
3311 + }
3175 3312 }
3176 - } else {
3177 - rval = QL_FUNCTION_PARAMETER_ERROR;
3178 3313 }
3179 3314
3180 3315 if (rval != QL_SUCCESS) {
3181 3316 EL(ha, "failed=%xh\n", rval);
3182 3317 } else {
3183 3318 /*EMPTY*/
3184 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3319 + QL_PRINT_3(ha, "done\n");
3185 3320 }
3186 3321
3187 3322 return (rval);
3188 3323 }
3189 3324
3190 3325 /*
3191 3326 * ql_execute_fw
3192 3327 * Start adapter firmware.
3193 3328 *
3194 3329 * Input:
3195 3330 * ha: adapter state pointer.
3196 3331 *
3197 3332 * Returns:
3198 3333 * ql local function return status code.
3199 3334 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
3200 3335 * Context:
3201 3336 * Kernel context.
3202 3337 */
3203 3338 int
3204 3339 ql_execute_fw(ql_adapter_state_t *ha)
3205 3340 {
3206 3341 int rval;
3207 3342 mbx_cmd_t mc = {0};
3208 3343 mbx_cmd_t *mcp = &mc;
3209 3344
3210 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3345 + QL_PRINT_3(ha, "started\n");
3211 3346
3212 - if (CFG_IST(ha, CFG_CTRL_8021)) {
3347 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
3213 3348 return (QL_SUCCESS);
3214 3349 }
3215 3350
3216 3351 mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
3217 - if (CFG_IST(ha, CFG_CTRL_242581)) {
3352 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
3218 3353 mcp->mb[1] = MSW(ha->risc_fw[0].addr);
3219 3354 mcp->mb[2] = LSW(ha->risc_fw[0].addr);
3220 3355 } else {
3221 3356 mcp->mb[1] = LSW(ha->risc_fw[0].addr);
3222 3357 }
3223 3358 if (CFG_IST(ha, CFG_LR_SUPPORT)) {
3224 3359 mcp->mb[4] = BIT_0;
3225 3360 }
3226 3361 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3227 3362 mcp->in_mb = MBX_0;
3228 3363 mcp->timeout = MAILBOX_TOV;
3229 3364 rval = ql_mailbox_command(ha, mcp);
3230 3365
3231 - if (CFG_IST(ha, CFG_CTRL_2200)) {
3366 + if (CFG_IST(ha, CFG_CTRL_22XX)) {
3232 3367 rval = QL_SUCCESS;
3233 3368 }
3234 3369
3235 3370 if (rval != QL_SUCCESS) {
3236 3371 EL(ha, "failed=%xh\n", rval);
3237 3372 } else {
3238 3373 /*EMPTY*/
3239 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3374 + QL_PRINT_3(ha, "done\n");
3240 3375 }
3241 3376
3242 3377 return (rval);
3243 3378 }
3244 3379
3245 3380 /*
3246 3381 * ql_get_firmware_option
3247 3382 * Get Firmware Options Mailbox Command.
3248 3383 *
3249 3384 * Input:
3250 3385 * ha: adapter state pointer.
3251 3386 * mr: pointer for mailbox data.
3252 3387 *
3253 3388 * Returns:
3254 3389 * ql local function return status code.
3255 3390 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3256 3391 * Context:
3257 3392 * Kernel context.
3258 3393 */
3259 3394 int
3260 3395 ql_get_firmware_option(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
3261 3396 {
3262 3397 int rval;
3263 3398 mbx_cmd_t mc = {0};
3264 3399 mbx_cmd_t *mcp = &mc;
3265 3400
3266 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3401 + QL_PRINT_3(ha, "started\n");
3267 3402
3268 3403 mcp->mb[0] = MBC_GET_FIRMWARE_OPTIONS;
3269 3404 mcp->out_mb = MBX_0;
3270 3405 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
3271 3406 mcp->timeout = MAILBOX_TOV;
3272 3407 rval = ql_mailbox_command(ha, mcp);
3273 3408
3274 3409 /* Return mailbox data. */
3275 3410 if (mr != NULL) {
3276 3411 mr->mb[0] = mcp->mb[0];
3277 3412 mr->mb[1] = mcp->mb[1];
3278 3413 mr->mb[2] = mcp->mb[2];
3279 3414 mr->mb[3] = mcp->mb[3];
3280 3415 }
3281 3416
3282 3417 if (rval != QL_SUCCESS) {
3283 3418 EL(ha, "failed=%xh\n", rval);
3284 3419 } else {
3285 3420 /*EMPTY*/
3286 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3421 + QL_PRINT_9(ha, "done\n");
3287 3422 }
3288 3423
3289 3424 return (rval);
3290 3425 }
3291 3426
3292 3427 /*
3293 3428 * ql_set_firmware_option
3294 3429 * Set Firmware Options Mailbox Command.
3295 3430 *
3296 3431 * Input:
3297 3432 * ha: adapter state pointer.
3298 3433 * mr: pointer for mailbox data.
3299 3434 *
3300 3435 * Returns:
3301 3436 * ql local function return status code.
3302 3437 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3303 3438 * Context:
3304 3439 * Kernel context.
3305 3440 */
3306 3441 int
3307 3442 ql_set_firmware_option(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
3308 3443 {
3309 3444 int rval;
3310 3445 mbx_cmd_t mc = {0};
3311 3446 mbx_cmd_t *mcp = &mc;
3312 3447
3313 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3448 + QL_PRINT_3(ha, "started\n");
3314 3449
3315 3450 if (mr != NULL) {
3316 3451 mcp->mb[0] = MBC_SET_FIRMWARE_OPTIONS;
3317 3452 mcp->mb[1] = mr->mb[1];
3318 3453 mcp->mb[2] = mr->mb[2];
3319 3454 mcp->mb[3] = mr->mb[3];
3320 3455 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
3321 3456 mcp->in_mb = MBX_0;
3322 3457 mcp->timeout = MAILBOX_TOV;
3323 3458 rval = ql_mailbox_command(ha, mcp);
3324 3459 } else {
3325 3460 rval = QL_FUNCTION_PARAMETER_ERROR;
3326 3461 }
3327 3462
3328 3463 if (rval != QL_SUCCESS) {
3329 3464 EL(ha, "failed=%xh\n", rval);
3330 3465 } else {
3331 3466 /*EMPTY*/
3332 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3467 + QL_PRINT_3(ha, "done\n");
3333 3468 }
3334 3469
3335 3470 return (rval);
3336 3471 }
3337 3472
3338 3473 /*
3339 3474 * ql_init_firmware
3340 3475 * Initialize firmware mailbox command.
3341 3476 *
3342 3477 * Input:
3343 3478 * ha: adapter state pointer.
3344 3479 * ha->init_ctrl_blk = setup for transmit.
3345 3480 *
3346 3481 * Returns:
3347 3482 * ql local function return status code.
3348 3483 *
3349 3484 * Context:
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
3350 3485 * Kernel context.
3351 3486 */
3352 3487 int
3353 3488 ql_init_firmware(ql_adapter_state_t *ha)
3354 3489 {
3355 3490 int rval;
3356 3491 dma_mem_t mem_desc;
3357 3492 mbx_cmd_t mc = {0};
3358 3493 mbx_cmd_t *mcp = &mc;
3359 3494
3360 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3495 + QL_PRINT_3(ha, "started\n");
3361 3496
3362 - if (CFG_IST(ha, CFG_CTRL_8021)) {
3497 + if (ha->flags & MULTI_QUEUE) {
3498 + WR32_MBAR_REG(ha, ha->req_q[0]->mbar_req_in, 0);
3499 + WR32_MBAR_REG(ha, ha->rsp_queues[0]->mbar_rsp_out, 0);
3500 + } else if (CFG_IST(ha, CFG_CTRL_82XX)) {
3501 + ql_8021_wr_req_in(ha, 0);
3363 3502 WRT32_IO_REG(ha, req_out, 0);
3364 3503 WRT32_IO_REG(ha, resp_in, 0);
3365 3504 WRT32_IO_REG(ha, resp_out, 0);
3366 - } else if (CFG_IST(ha, CFG_CTRL_242581)) {
3505 + } else if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
3367 3506 WRT32_IO_REG(ha, req_in, 0);
3368 3507 WRT32_IO_REG(ha, resp_out, 0);
3369 3508 WRT32_IO_REG(ha, pri_req_in, 0);
3370 3509 WRT32_IO_REG(ha, atio_req_out, 0);
3371 3510 } else {
3372 3511 WRT16_IO_REG(ha, req_in, 0);
3373 3512 WRT16_IO_REG(ha, resp_out, 0);
3374 3513 }
3514 + if (ha->req_q[0]->req_out_shadow_ptr) {
3515 + *ha->req_q[0]->req_out_shadow_ptr = 0;
3516 + }
3517 + if (ha->rsp_queues[0]->rsp_in_shadow_ptr) {
3518 + *ha->rsp_queues[0]->rsp_in_shadow_ptr = 0;
3519 + }
3375 3520
3376 3521 if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc,
3377 3522 (caddr_t)&ha->init_ctrl_blk, sizeof (ql_comb_init_cb_t))) !=
3378 3523 QL_SUCCESS) {
3379 3524 EL(ha, "dma setup failed=%xh\n", rval);
3380 3525 return (rval);
3381 3526 }
3382 3527
3383 3528 mcp->mb[0] = (uint16_t)(ha->flags & VP_ENABLED ?
3384 3529 MBC_INITIALIZE_MULTI_ID_FW : MBC_INITIALIZE_FIRMWARE);
3385 3530
3386 3531 if (CFG_IST(ha, CFG_SBUS_CARD)) {
3387 - mcp->mb[1] = (uint16_t)(CFG_IST(ha, CFG_CTRL_2200) ?
3532 + mcp->mb[1] = (uint16_t)(CFG_IST(ha, CFG_CTRL_22XX) ?
3388 3533 0x204c : 0x52);
3389 3534 }
3390 3535
3391 3536 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
3392 3537 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
3393 3538 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
3394 3539 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
3395 - if (CFG_IST(ha, CFG_CTRL_8081)) {
3540 + if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
3396 3541 uint64_t ofst, addr;
3397 3542 ql_init_24xx_cb_t *icb = (ql_init_24xx_cb_t *)
3398 3543 &ha->init_ctrl_blk.cb24;
3399 3544
3400 3545 mcp->mb[0] = MBC_INITIALIZE_MULTI_ID_FW;
3401 3546 if (icb->ext_blk.version[0] | icb->ext_blk.version[1]) {
3402 3547 ofst = (uintptr_t)&icb->ext_blk - (uintptr_t)icb;
3403 3548 addr = mem_desc.cookie.dmac_laddress + ofst;
3404 3549 mcp->mb[10] = MSW(LSD(addr));
3405 3550 mcp->mb[11] = LSW(LSD(addr));
3406 3551 mcp->mb[12] = MSW(MSD(addr));
3407 3552 mcp->mb[13] = LSW(MSD(addr));
3408 3553 mcp->mb[14] = sizeof (ql_ext_icb_8100_t);
3409 3554 mcp->mb[1] = BIT_0;
3410 3555 }
3411 3556 mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3412 3557 MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3413 3558 } else {
3414 3559 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3415 3560 }
3416 3561 mcp->in_mb = MBX_5|MBX_4|MBX_2|MBX_0;
3417 3562 mcp->timeout = MAILBOX_TOV;
3418 3563 rval = ql_mailbox_command(ha, mcp);
3419 3564
3420 3565 if (rval == QL_SUCCESS) {
3421 3566 ha->sfp_stat = mcp->mb[2];
3567 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
3568 + (void) ql_8021_get_md_template(ha);
3569 + } else {
3570 + uint16_t i, opt;
3571 +
3572 + opt = ha->flags & NO_INTR_HANDSHAKE ?
3573 + IMO_NONE : IMO_INTERRUPT_HANDSHAKE;
3574 + if (ha->flags & QUEUE_SHADOW_PTRS) {
3575 + opt |= IMO_QUEUE_POINTER_SHADOWING;
3576 + }
3577 + /* Initialize ha multi-response-queue request queue */
3578 + if (ha->rsp_queues_cnt > 1) {
3579 + rval = ql_init_req_q(ha, ha->req_q[1], opt);
3580 + if (rval != QL_SUCCESS) {
3581 + EL(ha, "ql_init_req_q=%xh\n", rval);
3582 + return (rval);
3583 + }
3584 + }
3585 + /* Initialize multi-response queues */
3586 + for (i = 1; i < ha->rsp_queues_cnt; i++) {
3587 + rval = ql_init_rsp_q(ha, ha->rsp_queues[i],
3588 + opt);
3589 + if (rval != QL_SUCCESS) {
3590 + EL(ha, "ql_init_rsp_q=%xh\n", rval);
3591 + return (rval);
3592 + }
3593 + }
3594 + }
3422 3595 }
3423 3596 ql_free_dma_resource(ha, &mem_desc);
3424 3597
3425 3598 if (rval != QL_SUCCESS) {
3426 3599 EL(ha, "failed=%xh\n", rval);
3427 3600 } else {
3428 3601 /*EMPTY*/
3429 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3602 + QL_PRINT_3(ha, "done\n");
3430 3603 }
3431 3604
3432 3605 return (rval);
3433 3606 }
3434 3607
3435 3608 /*
3436 3609 * ql_get_firmware_state
3437 3610 * Get adapter firmware state.
3438 3611 *
3439 3612 * Input:
3440 3613 * ha: adapter state pointer.
3441 3614 * mr: pointer for mailbox data.
3442 3615 *
3443 3616 * Returns:
3444 3617 * ql local function return status code.
3445 3618 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3446 3619 * Context:
3447 3620 * Kernel context.
3448 3621 */
3449 3622 int
3450 3623 ql_get_firmware_state(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
3451 3624 {
3452 3625 int rval;
3453 3626 mbx_cmd_t mc = {0};
3454 3627 mbx_cmd_t *mcp = &mc;
3455 3628
3456 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3629 + QL_PRINT_3(ha, "started\n");
3457 3630
3458 3631 mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
3459 3632 mcp->out_mb = MBX_0;
3460 - mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3633 + mcp->in_mb = MBX_0_THRU_6;
3461 3634 mcp->timeout = MAILBOX_TOV;
3462 3635 rval = ql_mailbox_command(ha, mcp);
3463 3636
3637 + ha->fw_state[0] = mcp->mb[0];
3638 + ha->fw_state[1] = mcp->mb[1];
3639 + ha->fw_state[2] = mcp->mb[2];
3640 + ha->fw_state[3] = mcp->mb[3];
3641 + ha->fw_state[4] = mcp->mb[4];
3642 + ha->fw_state[5] = mcp->mb[5];
3643 + ha->fw_state[6] = mcp->mb[6];
3644 +
3464 3645 /* Return mailbox data. */
3465 3646 if (mr != NULL) {
3466 3647 mr->mb[1] = mcp->mb[1];
3467 3648 mr->mb[2] = mcp->mb[2];
3468 3649 mr->mb[3] = mcp->mb[3];
3469 3650 mr->mb[4] = mcp->mb[4];
3470 3651 mr->mb[5] = mcp->mb[5];
3652 + mr->mb[6] = mcp->mb[6];
3471 3653 }
3472 3654
3473 3655 ha->sfp_stat = mcp->mb[2];
3474 3656
3475 3657 if (rval != QL_SUCCESS) {
3476 3658 EL(ha, "failed=%xh\n", rval);
3477 3659 } else {
3478 3660 /*EMPTY*/
3479 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3661 + QL_PRINT_3(ha, "done\n");
3480 3662 }
3481 3663
3482 3664 return (rval);
3483 3665 }
3484 3666
3485 3667 /*
3486 3668 * ql_get_adapter_id
3487 3669 * Get adapter ID and topology.
3488 3670 *
3489 3671 * Input:
3490 3672 * ha: adapter state pointer.
3491 3673 * mr: pointer for mailbox data.
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
3492 3674 *
3493 3675 * Returns:
3494 3676 * ql local function return status code.
3495 3677 *
3496 3678 * Context:
3497 3679 * Kernel context.
3498 3680 */
3499 3681 int
3500 3682 ql_get_adapter_id(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
3501 3683 {
3502 - int rval;
3684 + int i, rval;
3503 3685 mbx_cmd_t mc = {0};
3504 3686 mbx_cmd_t *mcp = &mc;
3505 3687
3506 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3688 + QL_PRINT_3(ha, "started\n");
3507 3689
3508 3690 mcp->mb[0] = MBC_GET_ID;
3509 3691 if (ha->flags & VP_ENABLED) {
3510 3692 mcp->mb[9] = ha->vp_index;
3511 3693 }
3512 3694 mcp->out_mb = MBX_9|MBX_0;
3513 - mcp->in_mb = MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|
3514 - MBX_3|MBX_2|MBX_1|MBX_0;
3695 + mcp->in_mb = MBX_0_THRU_19;
3515 3696 mcp->timeout = MAILBOX_TOV;
3516 3697
3517 3698 rval = ql_mailbox_command(ha, mcp);
3518 3699
3519 3700 /* Return mailbox data. */
3520 3701 if (mr != NULL) {
3521 - mr->mb[1] = mcp->mb[1];
3522 - mr->mb[1] = (uint16_t)(CFG_IST(ha, CFG_CTRL_24258081) ?
3523 - 0xffff : mcp->mb[1]);
3524 - mr->mb[2] = mcp->mb[2];
3525 - mr->mb[3] = mcp->mb[3];
3526 - mr->mb[6] = mcp->mb[6];
3527 - mr->mb[7] = mcp->mb[7];
3528 - mr->mb[8] = mcp->mb[8];
3529 - mr->mb[9] = mcp->mb[9];
3530 - mr->mb[10] = mcp->mb[10];
3531 - mr->mb[11] = mcp->mb[11];
3532 - mr->mb[12] = mcp->mb[12];
3533 - mr->mb[13] = mcp->mb[13];
3702 + for (i = 0; i < 20; i++) {
3703 + mr->mb[i] = mcp->mb[i];
3704 + }
3534 3705 }
3535 3706
3536 3707 if (rval != QL_SUCCESS) {
3537 3708 EL(ha, "failed=%xh\n", rval);
3538 3709 } else {
3539 3710 /*EMPTY*/
3540 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3711 + QL_PRINT_3(ha, "done\n");
3541 3712 }
3542 3713
3543 3714 return (rval);
3544 3715 }
3545 3716
3546 3717 /*
3547 3718 * ql_get_fw_version
3548 3719 * Get firmware version.
3549 3720 *
3550 3721 * Input:
3551 3722 * ha: adapter state pointer.
3552 3723 * mr: pointer for mailbox data.
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
3553 3724 *
3554 3725 * Returns:
3555 3726 * ql local function return status code.
3556 3727 *
3557 3728 * Context:
3558 3729 * Kernel context.
3559 3730 */
3560 3731 int
3561 3732 ql_get_fw_version(ql_adapter_state_t *ha, ql_mbx_data_t *mr, uint16_t timeout)
3562 3733 {
3563 - int rval;
3734 + int rval, i;
3564 3735 mbx_cmd_t mc = {0};
3565 3736 mbx_cmd_t *mcp = &mc;
3566 3737
3567 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3738 + QL_PRINT_3(ha, "started\n");
3568 3739
3569 3740 mcp->mb[0] = MBC_ABOUT_FIRMWARE;
3570 3741 mcp->out_mb = MBX_0;
3571 - mcp->in_mb = MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_6|MBX_5|
3572 - MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3742 + if (CFG_IST(ha, CFG_CTRL_83XX)) {
3743 + mcp->in_mb = MBX_0_THRU_17;
3744 + } else if (CFG_IST(ha, CFG_CTRL_27XX)) {
3745 + mcp->in_mb = MBX_0_THRU_25;
3746 + } else {
3747 + mcp->in_mb = MBX_0_THRU_13;
3748 + }
3573 3749 mcp->timeout = timeout;
3574 3750 rval = ql_mailbox_command(ha, mcp);
3575 3751
3576 3752 /* Return mailbox data. */
3577 3753 if (mr != NULL) {
3578 - mr->mb[1] = mcp->mb[1];
3579 - mr->mb[2] = mcp->mb[2];
3580 - mr->mb[3] = mcp->mb[3];
3581 - mr->mb[4] = mcp->mb[4];
3582 - mr->mb[5] = mcp->mb[5];
3583 - mr->mb[6] = mcp->mb[6];
3584 - mr->mb[8] = mcp->mb[8];
3585 - mr->mb[9] = mcp->mb[9];
3586 - mr->mb[10] = mcp->mb[10];
3587 - mr->mb[11] = mcp->mb[11];
3588 - mr->mb[12] = mcp->mb[12];
3589 - mr->mb[13] = mcp->mb[13];
3754 + for (i = 0; i < ha->reg_off->mbox_cnt && mcp->in_mb; i++) {
3755 + if (mcp->in_mb & MBX_0) {
3756 + mr->mb[i] = mcp->mb[i];
3757 + }
3758 + mcp->in_mb >>= 1;
3759 + }
3590 3760 }
3591 3761
3592 3762 if (rval != QL_SUCCESS) {
3593 3763 EL(ha, "failed=%xh\n", rval);
3594 3764 } else {
3595 3765 /*EMPTY*/
3596 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3766 + QL_PRINT_3(ha, "done\n");
3597 3767 }
3598 3768
3599 3769 return (rval);
3600 3770 }
3601 3771
3602 3772 /*
3603 3773 * ql_data_rate
3604 3774 * Issue data rate Mailbox Command.
3605 3775 *
3606 3776 * Input:
3607 3777 * ha: adapter state pointer.
3608 3778 * mr: pointer for mailbox data.
3609 3779 *
3610 3780 * Returns:
3611 3781 * ql local function return status code.
3612 3782 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3613 3783 * Context:
3614 3784 * Kernel context.
3615 3785 */
3616 3786 int
3617 3787 ql_data_rate(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
3618 3788 {
3619 3789 int rval;
3620 3790 mbx_cmd_t mc = {0};
3621 3791 mbx_cmd_t *mcp = &mc;
3622 3792
3623 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3793 + QL_PRINT_3(ha, "started\n");
3624 3794
3625 3795 if (mr != NULL) {
3626 3796 mcp->mb[0] = MBC_DATA_RATE;
3627 3797 mcp->mb[1] = mr->mb[1];
3628 3798 mcp->mb[2] = mr->mb[2];
3629 3799 mcp->out_mb = MBX_2|MBX_1|MBX_0;
3630 - mcp->in_mb = MBX_2|MBX_1|MBX_0;
3800 + mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
3631 3801 mcp->timeout = MAILBOX_TOV;
3632 3802 rval = ql_mailbox_command(ha, mcp);
3633 3803
3634 3804 /* Return mailbox data. */
3635 3805 mr->mb[1] = mcp->mb[1];
3636 3806 mr->mb[2] = mcp->mb[2];
3807 + mr->mb[3] = mcp->mb[3];
3637 3808 } else {
3638 3809 rval = QL_FUNCTION_PARAMETER_ERROR;
3639 3810 }
3640 3811
3641 3812 ha->sfp_stat = mcp->mb[2];
3642 3813
3643 3814 if (rval != QL_SUCCESS) {
3644 3815 EL(ha, "failed=%xh\n", rval);
3645 3816 } else {
3646 3817 /*EMPTY*/
3647 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3818 + QL_PRINT_3(ha, "done\n");
3648 3819 }
3649 3820
3650 3821 return (rval);
3651 3822 }
3652 3823
3653 3824 /*
3654 3825 * ql_Diag_Loopback
3655 3826 * Issue Reset Link Status mailbox command
3656 3827 *
3657 3828 * Input:
3658 3829 * ha: adapter state pointer.
3659 - * findex: FCF index.
3660 3830 * bp: buffer pointer.
3661 3831 * size: buffer size.
3662 3832 * opt: command options.
3663 3833 * it_cnt: iteration count.
3664 3834 * mr: pointer for mailbox data.
3665 3835 *
3666 3836 * Returns:
3667 3837 * ql local function return status code.
3668 3838 *
3669 3839 * Context:
3670 3840 * Kernel context.
3671 3841 */
3672 3842 int
3673 -ql_diag_loopback(ql_adapter_state_t *ha, uint16_t findex, caddr_t bp,
3674 - uint32_t size, uint16_t opt, uint32_t it_cnt, ql_mbx_data_t *mr)
3843 +ql_diag_loopback(ql_adapter_state_t *ha, caddr_t bp, uint32_t size,
3844 + uint16_t opt, uint32_t it_cnt, ql_mbx_data_t *mr)
3675 3845 {
3676 3846 int rval;
3677 3847 dma_mem_t mem_desc;
3678 3848 mbx_cmd_t mc = {0};
3679 3849 mbx_cmd_t *mcp = &mc;
3680 3850
3681 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3851 + QL_PRINT_3(ha, "started\n");
3682 3852
3683 3853 if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bp, size)) !=
3684 3854 QL_SUCCESS) {
3685 3855 EL(ha, "setup_mbox_dma_transfer failed: %x\n", rval);
3686 3856 return (rval);
3687 3857 }
3688 3858
3689 3859 mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
3690 3860 mcp->mb[1] = opt;
3691 - mcp->mb[2] = findex;
3861 + mcp->mb[2] = ha->fcoe_fcf_idx;
3692 3862 mcp->mb[6] = LSW(MSD(mem_desc.cookie.dmac_laddress));
3693 3863 mcp->mb[7] = MSW(MSD(mem_desc.cookie.dmac_laddress));
3694 3864 mcp->mb[10] = LSW(size);
3695 3865 mcp->mb[11] = MSW(size);
3696 3866 mcp->mb[14] = LSW(LSD(mem_desc.cookie.dmac_laddress));
3697 3867 mcp->mb[15] = MSW(LSD(mem_desc.cookie.dmac_laddress));
3698 3868 mcp->mb[16] = LSW(LSD(mem_desc.cookie.dmac_laddress));
3699 3869 mcp->mb[17] = MSW(LSD(mem_desc.cookie.dmac_laddress));
3700 3870 mcp->mb[18] = LSW(it_cnt);
3701 3871 mcp->mb[19] = MSW(it_cnt);
3702 3872 mcp->mb[20] = LSW(MSD(mem_desc.cookie.dmac_laddress));
3703 3873 mcp->mb[21] = MSW(MSD(mem_desc.cookie.dmac_laddress));
3704 3874 mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
3705 3875 MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
3706 3876 mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
3707 3877 mcp->timeout = it_cnt / 300;
3708 3878 if (mcp->timeout < MAILBOX_TOV) {
3709 3879 mcp->timeout = MAILBOX_TOV;
3710 3880 }
3711 3881 rval = ql_mailbox_command(ha, mcp);
3712 3882
3713 3883 if (rval == QL_SUCCESS) {
3714 3884 ql_get_mbox_dma_data(&mem_desc, bp);
3715 3885 }
3716 3886
3717 3887 ql_free_dma_resource(ha, &mem_desc);
3718 3888
3719 3889 /* Return mailbox data. */
3720 3890 if (mr != NULL) {
3721 3891 mr->mb[0] = mcp->mb[0];
3722 3892 mr->mb[1] = mcp->mb[1];
|
↓ open down ↓ |
21 lines elided |
↑ open up ↑ |
3723 3893 mr->mb[2] = mcp->mb[2];
3724 3894 mr->mb[3] = mcp->mb[3];
3725 3895 mr->mb[18] = mcp->mb[18];
3726 3896 mr->mb[19] = mcp->mb[19];
3727 3897 }
3728 3898
3729 3899 if (rval != QL_SUCCESS) {
3730 3900 EL(ha, "failed=%xh, mb1=%xh\n", rval, mcp->mb[1]);
3731 3901 } else {
3732 3902 /*EMPTY*/
3733 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3903 + QL_PRINT_3(ha, "done\n");
3734 3904 }
3735 3905
3736 3906 return (rval);
3737 3907 }
3738 3908
3739 3909 /*
3740 3910 * ql_diag_echo
3741 3911 * Issue Diag echo mailbox command. Valid for qla23xx HBA's.
3742 3912 *
3743 3913 * Input:
3744 3914 * ha: adapter state pointer.
3745 - * findex: FCF index.
3746 3915 * bp: buffer pointer.
3747 3916 * size: buffer size.
3748 3917 * opt: command options.
3749 3918 * mr: pointer to mailbox status.
3750 3919 *
3751 3920 * Returns:
3752 3921 * ql local function return status code.
3753 3922 *
3754 3923 * Context:
3755 3924 * Kernel context.
3756 3925 */
3757 3926 int
3758 -ql_diag_echo(ql_adapter_state_t *ha, uint16_t findex, caddr_t bp,
3759 - uint32_t size, uint16_t opt, ql_mbx_data_t *mr)
3927 +ql_diag_echo(ql_adapter_state_t *ha, caddr_t bp, uint32_t size, uint16_t opt,
3928 + ql_mbx_data_t *mr)
3760 3929 {
3761 3930 int rval;
3762 3931 dma_mem_t mem_desc;
3763 3932 mbx_cmd_t mc = {0};
3764 3933 mbx_cmd_t *mcp = &mc;
3765 3934
3766 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
3935 + QL_PRINT_3(ha, "started\n");
3767 3936
3768 3937 if ((rval = ql_setup_mbox_dma_transfer(ha, &mem_desc, bp, size)) !=
3769 3938 QL_SUCCESS) {
3770 3939 EL(ha, "setup_mbox_dma_transfer failed: %x\n", rval);
3771 3940 return (rval);
3772 3941 }
3773 3942
3774 3943 mcp->mb[0] = MBC_ECHO;
3775 3944 mcp->mb[1] = opt;
3776 - mcp->mb[2] = findex;
3945 + mcp->mb[2] = ha->fcoe_fcf_idx;
3777 3946 mcp->mb[6] = LSW(MSD(mem_desc.cookie.dmac_laddress));
3778 3947 mcp->mb[7] = MSW(MSD(mem_desc.cookie.dmac_laddress));
3779 3948 mcp->mb[10] = LSW(size);
3780 3949 mcp->mb[14] = LSW(LSD(mem_desc.cookie.dmac_laddress));
3781 3950 mcp->mb[15] = MSW(LSD(mem_desc.cookie.dmac_laddress));
3782 3951 mcp->mb[16] = LSW(LSD(mem_desc.cookie.dmac_laddress));
3783 3952 mcp->mb[17] = MSW(LSD(mem_desc.cookie.dmac_laddress));
3784 3953 mcp->mb[20] = LSW(MSD(mem_desc.cookie.dmac_laddress));
3785 3954 mcp->mb[21] = MSW(MSD(mem_desc.cookie.dmac_laddress));
3786 3955 mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
3787 3956 MBX_14|MBX_10|MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
3788 3957 mcp->in_mb = MBX_1|MBX_0;
3789 3958 mcp->timeout = MAILBOX_TOV;
3790 3959 rval = ql_mailbox_command(ha, mcp);
3791 3960
3792 3961 if (rval == QL_SUCCESS) {
3793 3962 ql_get_mbox_dma_data(&mem_desc, bp);
3794 3963 }
3795 3964
3796 3965 ql_free_dma_resource(ha, &mem_desc);
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
3797 3966
3798 3967 if (mr != NULL) {
3799 3968 mr->mb[0] = mcp->mb[0];
3800 3969 }
3801 3970
3802 3971 if (rval != QL_SUCCESS) {
3803 3972 EL(ha, "failed=%xh, mb1=%xh\n", rval,
3804 3973 mcp->mb[1]);
3805 3974 } else {
3806 3975 /*EMPTY*/
3807 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
3976 + QL_PRINT_3(ha, "done\n");
3808 3977 }
3809 3978
3810 3979 return (rval);
3811 3980 }
3812 3981
3813 3982 /*
3983 + * ql_diag_beacon
3984 + * Enable/Disable beaconing via mailbox command.
3985 + *
3986 + * Input:
3987 + * ha: adapter state pointer.
3988 + * mr: pointer to mailbox in/out parameters.
3989 + *
3990 + * Returns:
3991 + * ql local function return status code.
3992 + *
3993 + * Context:
3994 + * Kernel context.
3995 + */
3996 +int
3997 +ql_diag_beacon(ql_adapter_state_t *ha, int cmd, ql_mbx_data_t *mr)
3998 +{
3999 + int rval;
4000 + mbx_cmd_t mc = {0};
4001 + mbx_cmd_t *mcp = &mc;
4002 +
4003 + mcp->mb[0] = MBC_SET_LED_CONFIG;
4004 + if (cmd == QL_BEACON_ENABLE) {
4005 + mcp->mb[7] = 0xE;
4006 + } else if (cmd == QL_BEACON_DISABLE) {
4007 + mcp->mb[7] = 0xD;
4008 + } else {
4009 + return (EIO);
4010 + }
4011 + mcp->out_mb = MBX_7|MBX_0;
4012 + mcp->in_mb = MBX_0;
4013 + mcp->timeout = MAILBOX_TOV;
4014 +
4015 + rval = ql_mailbox_command(ha, mcp);
4016 +
4017 + /* Return mailbox data. */
4018 + if (mr != NULL) {
4019 + mr->mb[0] = mcp->mb[0];
4020 + }
4021 +
4022 + if (rval != QL_SUCCESS) {
4023 + EL(ha, "failed=%xh\n", rval);
4024 + }
4025 +
4026 + return (rval);
4027 +}
4028 +
4029 +
4030 +/*
3814 4031 * ql_serdes_param
3815 4032 * Set/Get serdes transmit parameters mailbox command.
3816 4033 *
3817 4034 * Input:
3818 4035 * ha: adapter state pointer.
3819 4036 * mr: pointer to mailbox in/out parameters.
3820 4037 *
3821 4038 * Returns:
3822 4039 * ql local function return status code.
3823 4040 *
3824 4041 * Context:
3825 4042 * Kernel context.
3826 4043 */
3827 4044 int
3828 4045 ql_serdes_param(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
3829 4046 {
3830 4047 int rval;
3831 4048 mbx_cmd_t mc = {0};
3832 4049 mbx_cmd_t *mcp = &mc;
3833 4050
3834 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4051 + QL_PRINT_3(ha, "started\n");
3835 4052
3836 4053 mcp->mb[0] = MBC_SERDES_TRANSMIT_PARAMETERS;
3837 4054 mcp->mb[1] = mr->mb[1];
3838 4055 mcp->mb[2] = mr->mb[2];
3839 4056 mcp->mb[3] = mr->mb[3];
3840 4057 mcp->mb[4] = mr->mb[4];
3841 4058 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
3842 4059 mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_0;
3843 4060 mcp->timeout = MAILBOX_TOV;
3844 4061 rval = ql_mailbox_command(ha, mcp);
3845 4062
3846 4063 /* Return mailbox data. */
3847 - if (mr != NULL) {
3848 - mr->mb[0] = mcp->mb[0];
3849 - mr->mb[2] = mcp->mb[2];
3850 - mr->mb[3] = mcp->mb[3];
3851 - mr->mb[4] = mcp->mb[4];
3852 - }
4064 + mr->mb[0] = mcp->mb[0];
4065 + mr->mb[2] = mcp->mb[2];
4066 + mr->mb[3] = mcp->mb[3];
4067 + mr->mb[4] = mcp->mb[4];
3853 4068
3854 4069 if (rval != QL_SUCCESS) {
3855 4070 EL(ha, "failed=%xh\n", rval);
3856 4071 } else {
3857 4072 /*EMPTY*/
3858 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4073 + QL_PRINT_3(ha, "done\n");
3859 4074 }
3860 4075
3861 4076 return (rval);
3862 4077 }
3863 4078
3864 4079 /*
3865 4080 * ql_get_timeout_parameters
3866 4081 * Issue get timeout parameters mailbox command.
3867 4082 *
3868 4083 * Input:
3869 4084 * ha: adapter state pointer.
3870 4085 * mr: pointer to mailbox in/out parameters.
3871 4086 *
3872 4087 * Returns:
3873 4088 * ql local function return status code.
3874 4089 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3875 4090 * Context:
3876 4091 * Kernel context.
3877 4092 */
3878 4093 int
3879 4094 ql_get_timeout_parameters(ql_adapter_state_t *ha, uint16_t *tov)
3880 4095 {
3881 4096 int rval;
3882 4097 mbx_cmd_t mc = {0};
3883 4098 mbx_cmd_t *mcp = &mc;
3884 4099
3885 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4100 + QL_PRINT_3(ha, "started\n");
3886 4101
3887 4102 mcp->mb[0] = MBC_GET_TIMEOUT_PARAMETERS;
3888 - mcp->out_mb = MBX_0;
4103 + mcp->mb[1] = ha->fcoe_fcf_idx;
4104 + mcp->out_mb = MBX_1|MBX_0;
3889 4105 mcp->in_mb = MBX_3|MBX_0;
3890 4106 mcp->timeout = MAILBOX_TOV;
3891 4107 rval = ql_mailbox_command(ha, mcp);
3892 4108 if (rval == QL_SUCCESS) {
3893 4109 /* Get 2 * R_A_TOV in seconds */
3894 - if (CFG_IST(ha, CFG_CTRL_2200) || mcp->mb[3] == 0) {
4110 + if (CFG_IST(ha, CFG_CTRL_22XX) || mcp->mb[3] == 0) {
3895 4111 *tov = R_A_TOV_DEFAULT;
3896 4112 } else {
3897 4113 *tov = (uint16_t)(mcp->mb[3] / 10);
3898 4114 if (mcp->mb[3] % 10 != 0) {
3899 4115 *tov = (uint16_t)(*tov + 1);
3900 4116 }
3901 4117 /*
3902 4118 * Adjust value to prevent driver timeout at the same
3903 4119 * time as device.
3904 4120 */
3905 4121 *tov = (uint16_t)(*tov + 5);
3906 4122 }
3907 4123 } else {
3908 4124 *tov = R_A_TOV_DEFAULT;
3909 4125 }
3910 4126
3911 4127 if (rval != QL_SUCCESS) {
3912 4128 EL(ha, "failed=%xh\n", rval);
3913 4129 } else {
3914 4130 /*EMPTY*/
3915 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4131 + QL_PRINT_3(ha, "done\n");
3916 4132 }
3917 4133
3918 4134 return (rval);
3919 4135 }
3920 4136
3921 4137 /*
3922 4138 * ql_stop_firmware
3923 4139 * Issue stop firmware Mailbox Command.
3924 4140 *
3925 4141 * Input:
3926 4142 * ha: adapter state pointer.
3927 4143 *
3928 4144 * Returns:
3929 4145 * ql local function return status code.
3930 4146 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
3931 4147 * Context:
3932 4148 * Kernel context.
3933 4149 */
3934 4150 int
3935 4151 ql_stop_firmware(ql_adapter_state_t *ha)
3936 4152 {
3937 4153 int rval;
3938 4154 mbx_cmd_t mc = {0};
3939 4155 mbx_cmd_t *mcp = &mc;
3940 4156
3941 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4157 + QL_PRINT_3(ha, "started\n");
3942 4158
3943 4159 mcp->mb[0] = MBC_STOP_FIRMWARE;
3944 4160 mcp->out_mb = MBX_1|MBX_0;
3945 4161 mcp->in_mb = MBX_0;
3946 4162 mcp->timeout = 2;
3947 4163 rval = ql_mailbox_command(ha, mcp);
3948 4164
3949 4165 if (rval != QL_SUCCESS) {
3950 4166 EL(ha, "failed=%xh\n", rval);
3951 4167 } else {
3952 4168 /*EMPTY*/
3953 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4169 + QL_PRINT_3(ha, "done\n");
3954 4170 }
3955 4171
3956 4172 return (rval);
3957 4173 }
3958 4174
3959 4175 /*
3960 4176 * ql_read_sfp
3961 4177 * Issue Read SFP Mailbox command
3962 4178 *
3963 4179 * Input:
3964 4180 * ha: adapter state pointer.
3965 4181 * mem: pointer to dma memory object for command.
3966 4182 * dev: Device address (A0h or A2h).
3967 - * addr: Data address on SFP EEPROM (0–255).
4183 + * addr: Data address on SFP EEPROM (0-255).
3968 4184 *
3969 4185 * Returns:
3970 4186 * ql local function return status code.
3971 4187 *
3972 4188 * Context:
3973 4189 * Kernel context.
3974 4190 */
3975 4191 int
3976 4192 ql_read_sfp(ql_adapter_state_t *ha, dma_mem_t *mem, uint16_t dev,
3977 4193 uint16_t addr)
3978 4194 {
3979 4195 int rval;
3980 4196 mbx_cmd_t mc = {0};
3981 4197 mbx_cmd_t *mcp = &mc;
3982 4198
3983 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4199 + QL_PRINT_3(ha, "started\n");
3984 4200
3985 4201 mcp->mb[0] = MBC_READ_SFP;
3986 4202 mcp->mb[1] = dev;
3987 4203 mcp->mb[2] = MSW(mem->cookies->dmac_address);
3988 4204 mcp->mb[3] = LSW(mem->cookies->dmac_address);
3989 4205 mcp->mb[6] = MSW(mem->cookies->dmac_notused);
3990 4206 mcp->mb[7] = LSW(mem->cookies->dmac_notused);
3991 4207 mcp->mb[8] = LSW(mem->size);
3992 4208 mcp->mb[9] = addr;
3993 4209 mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
3994 4210 mcp->in_mb = MBX_1|MBX_0;
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
3995 4211 mcp->timeout = MAILBOX_TOV;
3996 4212 rval = ql_mailbox_command(ha, mcp);
3997 4213
3998 4214 (void) ddi_dma_sync(mem->dma_handle, 0, mem->size,
3999 4215 DDI_DMA_SYNC_FORKERNEL);
4000 4216
4001 4217 if (rval != QL_SUCCESS) {
4002 4218 EL(ha, "failed=%xh\n", rval);
4003 4219 } else {
4004 4220 /*EMPTY*/
4005 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4221 + QL_PRINT_3(ha, "done\n");
4006 4222 }
4007 4223
4008 4224 return (rval);
4009 4225 }
4010 4226
4011 4227 /*
4012 4228 * ql_iidma_rate
4013 4229 * Issue get/set iidma rate command
4014 4230 *
4015 4231 * Input:
4016 4232 * ha: adapter state pointer.
4017 4233 * loop_id: n-port handle to set/get iidma rate.
4018 4234 * idma_rate: Pointer to iidma rate.
4019 4235 * option: iidma firmware option (set or get data).
4020 4236 * 0 --> Get iidma rate
4021 4237 * 1 --> Set iidma rate
4022 4238 *
4023 4239 * Returns:
4024 4240 * ql local function return status code.
4025 4241 *
4026 4242 * Context:
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
4027 4243 * Kernel context.
4028 4244 */
4029 4245 int
4030 4246 ql_iidma_rate(ql_adapter_state_t *ha, uint16_t loop_id, uint32_t *idma_rate,
4031 4247 uint32_t option)
4032 4248 {
4033 4249 int rval;
4034 4250 mbx_cmd_t mc = {0};
4035 4251 mbx_cmd_t *mcp = &mc;
4036 4252
4037 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4253 + QL_PRINT_3(ha, "started\n");
4038 4254
4039 4255 mcp->mb[0] = MBC_PORT_PARAM;
4040 4256 mcp->mb[1] = loop_id;
4041 4257 mcp->mb[2] = (uint16_t)option;
4042 4258 mcp->out_mb = MBX_0|MBX_1|MBX_2;
4043 4259 mcp->in_mb = MBX_0|MBX_1;
4044 4260
4045 4261 if (option & BIT_0) {
4046 4262 mcp->mb[3] = (uint16_t)*idma_rate;
4047 4263 mcp->out_mb |= MBX_3;
4048 4264 } else {
4049 4265 mcp->in_mb |= MBX_3;
4050 4266 }
4051 4267
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
4052 4268 mcp->timeout = MAILBOX_TOV;
4053 4269 rval = ql_mailbox_command(ha, mcp);
4054 4270
4055 4271 if (rval != QL_SUCCESS) {
4056 4272 EL(ha, "failed=%xh, mb1=%xh\n", rval, mcp->mb[1]);
4057 4273 } else {
4058 4274 if (option == 0) {
4059 4275 *idma_rate = mcp->mb[3];
4060 4276 }
4061 4277
4062 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4278 + QL_PRINT_3(ha, "done\n");
4063 4279 }
4064 4280
4065 4281 return (rval);
4066 4282 }
4067 4283
4068 4284 /*
4069 4285 * ql_set_xmit_parms
4070 4286 * Set transmit parameters
4071 4287 *
4072 4288 * Input:
4073 4289 * ha: adapter state pointer.
4074 4290 *
4075 4291 * Returns:
4076 4292 * ql local function return status code.
4077 4293 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
4078 4294 * Context:
4079 4295 * Kernel context.
4080 4296 */
4081 4297 int
4082 4298 ql_set_xmit_parms(ql_adapter_state_t *ha)
4083 4299 {
4084 4300 int rval;
4085 4301 mbx_cmd_t mc = {0};
4086 4302 mbx_cmd_t *mcp = &mc;
4087 4303
4088 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4304 + QL_PRINT_3(ha, "started\n");
4089 4305
4090 4306 mcp->mb[0] = MBC_XMIT_PARM;
4091 4307 mcp->mb[1] = BIT_1;
4092 4308 mcp->out_mb = MBX_1|MBX_0;
4093 4309 mcp->in_mb = MBX_0;
4094 4310 mcp->timeout = MAILBOX_TOV;
4095 4311 rval = ql_mailbox_command(ha, mcp);
4096 4312
4097 4313 if (rval != QL_SUCCESS) {
4098 4314 EL(ha, "failed=%xh\n", rval);
4099 4315 } else {
4100 4316 /*EMPTY*/
4101 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4317 + QL_PRINT_3(ha, "done\n");
4102 4318 }
4103 4319 return (rval);
4104 4320 }
4105 4321
4106 4322 /*
4107 4323 * ql_fw_etrace
4108 4324 * Firmware extended tracing.
4109 4325 *
4110 4326 * Input:
4111 4327 * ha: adapter state pointer.
4112 4328 * mem: pointer to dma memory object for command.
4113 4329 * opt: options and opcode.
4330 + * mr: pointer to mailbox in/out parameters.
4114 4331 *
4115 4332 * Returns:
4116 4333 * ql local function return status code.
4117 4334 *
4118 4335 * Context:
4119 4336 * Kernel context.
4120 4337 */
4121 4338 int
4122 -ql_fw_etrace(ql_adapter_state_t *ha, dma_mem_t *mem, uint16_t opt)
4339 +ql_fw_etrace(ql_adapter_state_t *ha, dma_mem_t *mem, uint16_t opt,
4340 + ql_mbx_data_t *mr)
4123 4341 {
4124 4342 int rval = QL_SUCCESS;
4125 4343 mbx_cmd_t mc = {0};
4126 4344 mbx_cmd_t *mcp = &mc;
4127 4345 uint16_t op_code;
4128 4346 uint64_t time;
4129 4347
4130 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4348 + QL_PRINT_3(ha, "started\n");
4131 4349
4132 4350 /* currently no supported options */
4133 4351 op_code = (uint16_t)(opt & ~0xFF00);
4134 4352
4135 4353 mcp->mb[0] = MBC_TRACE_CONTROL;
4136 4354 mcp->mb[1] = op_code;
4137 4355 mcp->in_mb = MBX_0;
4138 4356 mcp->timeout = MAILBOX_TOV;
4139 4357
4140 4358 switch (op_code) {
4141 4359 case FTO_INSERT_TIME_STAMP:
4142 4360
4143 4361 (void) drv_getparm(TIME, &time);
4144 4362
4145 4363 EL(ha, "insert time: %x %xh\n", MSD(time), LSD(time));
4146 4364
4147 4365 mcp->mb[2] = LSW(LSD(time));
4148 4366 mcp->mb[3] = MSW(LSD(time));
4149 4367 mcp->mb[4] = LSW(MSD(time));
4150 4368 mcp->mb[5] = MSW(MSD(time));
4151 4369 mcp->out_mb = MBX_0_THRU_5;
4152 4370 break;
4153 4371
4154 4372 case FTO_FCE_TRACE_ENABLE:
4155 4373 /* Firmware Fibre Channel Event Trace Buffer */
4156 4374 mcp->mb[2] = LSW(mem->cookies->dmac_address);
4157 4375 mcp->mb[3] = MSW(mem->cookies->dmac_address);
4158 4376 mcp->mb[4] = LSW(mem->cookies->dmac_notused);
4159 4377 mcp->mb[5] = MSW(mem->cookies->dmac_notused);
4160 4378 mcp->mb[6] = (uint16_t)(mem->size / 0x4000); /* 16kb blks */
4161 4379 mcp->mb[8] = (uint16_t)ha->fwfcetraceopt;
4162 4380 mcp->mb[9] = FTO_FCEMAXTRACEBUF;
4163 4381 mcp->mb[10] = FTO_FCEMAXTRACEBUF;
4164 4382 mcp->out_mb = MBX_0_THRU_10;
4165 4383 break;
4166 4384
4167 4385 case FTO_EXT_TRACE_ENABLE:
4168 4386 /* Firmware Extended Trace Buffer */
4169 4387 mcp->mb[2] = LSW(mem->cookies->dmac_address);
4170 4388 mcp->mb[3] = MSW(mem->cookies->dmac_address);
4171 4389 mcp->mb[4] = LSW(mem->cookies->dmac_notused);
4172 4390 mcp->mb[5] = MSW(mem->cookies->dmac_notused);
4173 4391 mcp->mb[6] = (uint16_t)(mem->size / 0x4000); /* 16kb blks */
4174 4392 mcp->out_mb = MBX_0_THRU_7;
4175 4393 break;
4176 4394
4177 4395 case FTO_FCE_TRACE_DISABLE:
4178 4396 /* also causes ISP25xx to flush its internal FCE buffer. */
4179 4397 mcp->mb[2] = BIT_0;
4180 4398 mcp->out_mb = MBX_0_THRU_2;
4181 4399 break;
4182 4400
4183 4401 case FTO_EXT_TRACE_DISABLE:
4184 4402 /* just sending the opcode disables it */
4185 4403 break;
4186 4404
|
↓ open down ↓ |
46 lines elided |
↑ open up ↑ |
4187 4405 default:
4188 4406 EL(ha, "invalid option: %xh\n", opt);
4189 4407 rval = QL_PARAMETER_ERROR;
4190 4408 break;
4191 4409 }
4192 4410
4193 4411 if (rval == QL_SUCCESS) {
4194 4412 rval = ql_mailbox_command(ha, mcp);
4195 4413 }
4196 4414
4415 + /* Return mailbox data. */
4416 + if (mr != NULL) {
4417 + mr->mb[0] = mcp->mb[0];
4418 + mr->mb[1] = mcp->mb[1];
4419 + mr->mb[2] = mcp->mb[2];
4420 + mr->mb[3] = mcp->mb[3];
4421 + mr->mb[4] = mcp->mb[4];
4422 + mr->mb[5] = mcp->mb[5];
4423 + mr->mb[6] = mcp->mb[6];
4424 + mr->mb[7] = mcp->mb[7];
4425 + mr->mb[8] = mcp->mb[8];
4426 + mr->mb[9] = mcp->mb[9];
4427 + }
4428 +
4197 4429 if (rval != QL_SUCCESS) {
4198 4430 EL(ha, "failed=%xh\n", rval);
4199 4431 } else {
4200 4432 /*EMPTY*/
4201 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4433 + QL_PRINT_3(ha, "done\n");
4202 4434 }
4203 4435
4204 4436 return (rval);
4205 4437 }
4206 4438
4207 4439 /*
4208 4440 * ql_reset_menlo
4209 4441 * Reset Menlo Mailbox Command.
4210 4442 *
4211 4443 * Input:
4212 4444 * ha: adapter state pointer.
4213 4445 * mr: pointer to mailbox in/out parameters.
4214 4446 * opt: options.
4215 4447 *
4216 4448 * Returns:
4217 4449 * ql local function return status code.
4218 4450 *
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
4219 4451 * Context:
4220 4452 * Kernel context.
4221 4453 */
4222 4454 int
4223 4455 ql_reset_menlo(ql_adapter_state_t *ha, ql_mbx_data_t *mr, uint16_t opt)
4224 4456 {
4225 4457 int rval;
4226 4458 mbx_cmd_t mc = {0};
4227 4459 mbx_cmd_t *mcp = &mc;
4228 4460
4229 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4461 + QL_PRINT_3(ha, "started\n");
4230 4462
4231 4463 mcp->mb[0] = MBC_RESET_MENLO;
4232 4464 mcp->mb[1] = opt;
4233 4465 mcp->out_mb = MBX_1|MBX_0;
4234 4466 mcp->in_mb = MBX_1|MBX_0;
4235 4467 mcp->timeout = MAILBOX_TOV;
4236 4468 rval = ql_mailbox_command(ha, mcp);
4237 4469
4238 4470 /* Return mailbox data. */
4239 4471 if (mr != NULL) {
4240 4472 mr->mb[0] = mcp->mb[0];
4241 4473 mr->mb[1] = mcp->mb[1];
4242 4474 }
4243 4475
4244 4476 if (rval != QL_SUCCESS) {
4245 4477 EL(ha, "failed=%xh\n", rval);
4246 4478 } else {
4247 4479 /*EMPTY*/
4248 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4480 + QL_PRINT_3(ha, "done\n");
4249 4481 }
4250 4482
4251 4483 return (rval);
4252 4484 }
4253 4485
4254 4486 /*
4255 4487 * ql_restart_mpi
4256 4488 * The Restart MPI Firmware Mailbox Command will reset the MPI RISC,
4257 4489 * reload MPI firmware from Flash, and execute the firmware.
4258 4490 *
4259 4491 * Input:
4260 4492 * ha: adapter state pointer.
4261 4493 *
4262 4494 * Returns:
4263 4495 * ql local function return status code.
4264 4496 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
4265 4497 * Context:
4266 4498 * Kernel context.
4267 4499 */
4268 4500 int
4269 4501 ql_restart_mpi(ql_adapter_state_t *ha)
4270 4502 {
4271 4503 int rval;
4272 4504 mbx_cmd_t mc = {0};
4273 4505 mbx_cmd_t *mcp = &mc;
4274 4506
4275 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4507 + QL_PRINT_3(ha, "started\n");
4276 4508
4277 4509 mcp->mb[0] = MBC_RESTART_MPI;
4278 4510 mcp->out_mb = MBX_0;
4279 4511 mcp->in_mb = MBX_1|MBX_0;
4280 4512 mcp->timeout = MAILBOX_TOV;
4281 4513 rval = ql_mailbox_command(ha, mcp);
4282 4514
4283 4515 /* Return mailbox data. */
4284 4516 if (rval != QL_SUCCESS) {
4285 4517 EL(ha, "status=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
4286 4518 } else {
4287 4519 /*EMPTY*/
4288 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4520 + QL_PRINT_3(ha, "done\n");
4289 4521 }
4290 4522
4291 4523 return (rval);
4292 4524 }
4293 4525
4294 4526 /*
4295 4527 * ql_idc_request
4296 4528 * Inter-Driver Communication Request.
4297 4529 *
4298 4530 * Input:
4299 4531 * ha: adapter state pointer.
4300 4532 * mr: pointer for mailbox data.
4301 4533 *
4302 4534 * Returns:
4303 4535 * ql local function return status code.
4304 4536 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
4305 4537 * Context:
4306 4538 * Kernel context.
4307 4539 */
4308 4540 int
4309 4541 ql_idc_request(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
4310 4542 {
4311 4543 int rval;
4312 4544 mbx_cmd_t mc = {0};
4313 4545 mbx_cmd_t *mcp = &mc;
4314 4546
4315 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4547 + QL_PRINT_3(ha, "started\n");
4316 4548
4317 4549 mcp->mb[0] = MBC_IDC_REQUEST;
4318 4550 mcp->mb[1] = mr->mb[1];
4319 4551 mcp->mb[2] = mr->mb[2];
4320 4552 mcp->mb[3] = mr->mb[3];
4321 4553 mcp->mb[4] = mr->mb[4];
4322 4554 mcp->mb[5] = mr->mb[5];
4323 4555 mcp->mb[6] = mr->mb[6];
4324 4556 mcp->mb[7] = mr->mb[7];
4325 4557 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4326 4558 mcp->in_mb = MBX_2|MBX_0;
4327 4559 mcp->timeout = MAILBOX_TOV;
4328 4560 rval = ql_mailbox_command(ha, mcp);
4329 4561
4330 4562 if (rval == QL_SUCCESS) {
4331 - if (mr != NULL) {
4332 - mr->mb[2] = mcp->mb[2];
4333 - }
4334 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4563 + mr->mb[2] = mcp->mb[2];
4564 + QL_PRINT_3(ha, "done\n");
4335 4565 } else {
4336 4566 EL(ha, "status=%xh, mbx2=%xh\n", rval, mcp->mb[2]);
4337 4567 }
4338 4568
4339 4569 return (rval);
4340 4570 }
4341 4571
4342 4572 /*
4343 4573 * ql_idc_ack
4344 4574 * Inter-Driver Communication Acknowledgement.
4345 4575 *
4346 4576 * Input:
4347 4577 * ha: adapter state pointer.
4348 4578 *
4349 4579 * Returns:
4350 4580 * ql local function return status code.
4351 4581 *
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
4352 4582 * Context:
4353 4583 * Kernel context.
4354 4584 */
4355 4585 int
4356 4586 ql_idc_ack(ql_adapter_state_t *ha)
4357 4587 {
4358 4588 int rval;
4359 4589 mbx_cmd_t mc = {0};
4360 4590 mbx_cmd_t *mcp = &mc;
4361 4591
4362 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4592 + QL_PRINT_3(ha, "started\n");
4363 4593
4364 4594 mcp->mb[0] = MBC_IDC_ACK;
4365 4595 mcp->mb[1] = ha->idc_mb[1];
4366 4596 mcp->mb[2] = ha->idc_mb[2];
4367 4597 mcp->mb[3] = ha->idc_mb[3];
4368 4598 mcp->mb[4] = ha->idc_mb[4];
4369 4599 mcp->mb[5] = ha->idc_mb[5];
4370 4600 mcp->mb[6] = ha->idc_mb[6];
4371 4601 mcp->mb[7] = ha->idc_mb[7];
4372 4602 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4373 4603 mcp->in_mb = MBX_0;
4374 4604 mcp->timeout = MAILBOX_TOV;
4375 4605 rval = ql_mailbox_command(ha, mcp);
4376 4606
4377 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4607 + QL_PRINT_3(ha, "done\n");
4378 4608
4379 4609 return (rval);
4380 4610 }
4381 4611
4382 4612 /*
4383 4613 * ql_idc_time_extend
4384 4614 * Inter-Driver Communication Time Extend
4385 4615 *
4386 4616 * Input:
4387 4617 * ha: adapter state pointer.
4388 - * mr: pointer for mailbox data.
4389 4618 *
4390 4619 * Returns:
4391 4620 * ql local function return status code.
4392 4621 *
4393 4622 * Context:
4394 4623 * Kernel context.
4395 4624 */
4396 4625 int
4397 -ql_idc_time_extend(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
4626 +ql_idc_time_extend(ql_adapter_state_t *ha)
4398 4627 {
4399 4628 int rval;
4400 4629 mbx_cmd_t mc = {0};
4401 4630 mbx_cmd_t *mcp = &mc;
4402 4631
4403 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4632 + QL_PRINT_3(ha, "started\n");
4404 4633
4405 4634 mcp->mb[0] = MBC_IDC_TIME_EXTEND;
4406 - mcp->mb[1] = mr->mb[1];
4407 - mcp->mb[2] = mr->mb[2];
4408 - mcp->out_mb = MBX_2|MBX_1|MBX_0;
4635 + mcp->mb[1] = ha->idc_mb[1];
4636 + mcp->mb[2] = ha->idc_mb[2];
4637 + mcp->mb[3] = ha->idc_mb[3];
4638 + mcp->mb[4] = ha->idc_mb[4];
4639 + mcp->mb[5] = ha->idc_mb[5];
4640 + mcp->mb[6] = ha->idc_mb[6];
4641 + mcp->mb[7] = ha->idc_mb[7];
4642 + mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4409 4643 mcp->in_mb = MBX_0;
4410 4644 mcp->timeout = MAILBOX_TOV;
4411 4645 rval = ql_mailbox_command(ha, mcp);
4412 4646
4413 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4647 + QL_PRINT_3(ha, "done\n");
4414 4648
4415 4649 return (rval);
4416 4650 }
4417 4651
4418 4652 /*
4419 4653 * ql_port_reset
4420 4654 * The Port Reset for the external 10G port associated with this function.
4421 4655 *
4422 4656 * Input:
4423 4657 * ha: adapter state pointer.
4424 4658 *
4425 4659 * Returns:
4426 4660 * ql local function return status code.
4427 4661 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
4428 4662 * Context:
4429 4663 * Kernel context.
4430 4664 */
4431 4665 int
4432 4666 ql_port_reset(ql_adapter_state_t *ha)
4433 4667 {
4434 4668 int rval;
4435 4669 mbx_cmd_t mc = {0};
4436 4670 mbx_cmd_t *mcp = &mc;
4437 4671
4438 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4672 + QL_PRINT_3(ha, "started\n");
4439 4673
4440 4674 mcp->mb[0] = MBC_PORT_RESET;
4441 4675 mcp->out_mb = MBX_0;
4442 4676 mcp->in_mb = MBX_0;
4443 4677 mcp->timeout = MAILBOX_TOV;
4444 4678 rval = ql_mailbox_command(ha, mcp);
4445 4679
4446 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4680 + QL_PRINT_3(ha, "done\n");
4447 4681
4448 4682 return (rval);
4449 4683 }
4450 4684
4451 4685 /*
4452 4686 * ql_set_port_config
4453 4687 * The Set Port Configuration command sets the configuration for the
4454 4688 * external 10G port associated with this function.
4455 4689 *
4456 4690 * Input:
4457 4691 * ha: adapter state pointer.
4458 4692 * mr: pointer for mailbox data.
4459 4693 *
4460 4694 * Returns:
4461 4695 * ql local function return status code.
4462 4696 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
4463 4697 * Context:
4464 4698 * Kernel context.
4465 4699 */
4466 4700 int
4467 4701 ql_set_port_config(ql_adapter_state_t *ha, ql_mbx_data_t *mrp)
4468 4702 {
4469 4703 int rval;
4470 4704 mbx_cmd_t mc = {0};
4471 4705 mbx_cmd_t *mcp = &mc;
4472 4706
4473 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4707 + QL_PRINT_3(ha, "started\n");
4474 4708
4475 4709 mcp->mb[0] = MBC_SET_PORT_CONFIG;
4476 4710 mcp->mb[1] = mrp->mb[1];
4477 4711 mcp->mb[2] = mrp->mb[2];
4478 4712 mcp->mb[3] = mrp->mb[3];
4479 4713 mcp->mb[4] = mrp->mb[4];
4480 4714 mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4481 4715 mcp->in_mb = MBX_0;
4482 4716 mcp->timeout = MAILBOX_TOV;
4483 4717 rval = ql_mailbox_command(ha, mcp);
4484 4718
4485 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4719 + QL_PRINT_3(ha, "done\n");
4486 4720
4487 4721 return (rval);
4488 4722 }
4489 4723
4490 4724 /*
4491 4725 * ql_get_port_config
4492 4726 * The Get Port Configuration command retrieves the current configuration
4493 4727 * for the external 10G port associated with this function.
4494 4728 *
4495 4729 * Input:
4496 4730 * ha: adapter state pointer.
4497 4731 * mr: pointer for mailbox data.
4498 4732 *
4499 4733 * Returns:
4500 4734 * ql local function return status code.
4501 4735 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
4502 4736 * Context:
4503 4737 * Kernel context.
4504 4738 */
4505 4739 int
4506 4740 ql_get_port_config(ql_adapter_state_t *ha, ql_mbx_data_t *mrp)
4507 4741 {
4508 4742 int rval;
4509 4743 mbx_cmd_t mc = {0};
4510 4744 mbx_cmd_t *mcp = &mc;
4511 4745
4512 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4746 + QL_PRINT_3(ha, "started\n");
4513 4747
4514 4748 mcp->mb[0] = MBC_GET_PORT_CONFIG;
4515 4749 mcp->out_mb = MBX_0;
4516 4750 mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4517 4751 mcp->timeout = MAILBOX_TOV;
4518 4752 rval = ql_mailbox_command(ha, mcp);
4519 4753
4520 4754 if (rval == QL_SUCCESS) {
4521 4755 if (mrp != NULL) {
4522 4756 mrp->mb[1] = mcp->mb[1];
4523 4757 mrp->mb[2] = mcp->mb[2];
4524 4758 mrp->mb[3] = mcp->mb[3];
4525 4759 mrp->mb[4] = mcp->mb[4];
4526 4760 }
4527 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4761 + QL_PRINT_3(ha, "done\n");
4528 4762 } else {
4529 4763 EL(ha, "status=%xh, mbx1=%xh, mbx2=%xh, mbx3=%xh, mbx4=%xh\n",
4530 4764 rval, mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[4]);
4531 4765 }
4532 4766
4533 4767 return (rval);
4534 4768 }
4535 4769
4536 4770 /*
4537 4771 * ql_flash_access
4538 4772 * The Get Port Configuration command retrieves the current configuration
4539 4773 * for the external 10G port associated with this function
4540 4774 *
4541 4775 * Input:
4542 4776 * ha: adapter state pointer.
4543 4777 * cmd: command.
4544 4778 * start: 32bit word address.
4545 4779 * end: 32bit word address.
4546 4780 * dp: 32bit word pointer.
4547 4781 *
4548 4782 * Returns:
4549 4783 * ql local function return status code.
4550 4784 *
4551 4785 * Context:
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
4552 4786 * Kernel context.
4553 4787 */
4554 4788 int
4555 4789 ql_flash_access(ql_adapter_state_t *ha, uint16_t cmd, uint32_t start,
4556 4790 uint32_t end, uint32_t *dp)
4557 4791 {
4558 4792 int rval;
4559 4793 mbx_cmd_t mc = {0};
4560 4794 mbx_cmd_t *mcp = &mc;
4561 4795
4562 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4796 + QL_PRINT_3(ha, "started, cmd=%xh\n", cmd);
4563 4797
4564 4798 mcp->mb[0] = MBC_FLASH_ACCESS;
4565 - if (cmd > 0 && cmd < 4) {
4566 - mcp->mb[1] = (uint16_t)(FAC_FORCE_SEMA_LOCK | cmd);
4567 - } else {
4568 - mcp->mb[1] = cmd;
4569 - }
4799 + mcp->mb[1] = cmd;
4570 4800 mcp->mb[2] = LSW(start);
4571 4801 mcp->mb[3] = MSW(start);
4572 4802 mcp->mb[4] = LSW(end);
4573 4803 mcp->mb[5] = MSW(end);
4574 4804
4575 4805 mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
4576 - mcp->in_mb = MBX_2|MBX_1|MBX_0;
4806 + mcp->in_mb = MBX_0_THRU_4;
4577 4807 mcp->timeout = MAILBOX_TOV;
4578 4808 rval = ql_mailbox_command(ha, mcp);
4579 4809
4580 4810 if (rval != QL_SUCCESS) {
4581 - EL(ha, "status=%xh, mbx1=%xh, mbx2=%xh\n", rval, mcp->mb[1],
4582 - mcp->mb[2]);
4811 + EL(ha, "cmd=%xh, status=%xh, mbx1=%xh, mbx2=%xh, mbx3=%xh, "
4812 + "mbx4=%xh\n", cmd, rval, mcp->mb[1], mcp->mb[2],
4813 + mcp->mb[3], mcp->mb[4]);
4583 4814 } else {
4584 4815 if (dp != NULL) {
4585 4816 *dp = (uint32_t)mcp->mb[1];
4586 4817 }
4587 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4818 + QL_PRINT_3(ha, "done\n");
4588 4819 }
4589 4820
4590 4821 return (rval);
4591 4822 }
4592 4823
4593 4824 /*
4594 4825 * ql_get_xgmac_stats
4595 4826 * Issue et XGMAC Statistics Mailbox command
4596 4827 *
4597 4828 * Input:
4598 4829 * ha: adapter state pointer.
4599 4830 * size: size of data buffer.
4600 4831 * bufp: data pointer for DMA data.
4601 4832 *
4602 4833 * Returns:
4603 4834 * ql local function return status code.
4604 4835 *
4605 4836 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
4606 4837 * Kernel context.
4607 4838 */
4608 4839 int
4609 4840 ql_get_xgmac_stats(ql_adapter_state_t *ha, size_t size, caddr_t bufp)
4610 4841 {
4611 4842 int rval;
4612 4843 dma_mem_t mem_desc;
4613 4844 mbx_cmd_t mc = {0};
4614 4845 mbx_cmd_t *mcp = &mc;
4615 4846
4616 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4847 + QL_PRINT_3(ha, "started\n");
4617 4848
4618 4849 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
4619 4850 (uint32_t)size)) != QL_SUCCESS) {
4620 4851 EL(ha, "setup_mbox_dma_resources failed: %xh\n", rval);
4621 4852 return (QL_MEMORY_ALLOC_FAILED);
4622 4853 }
4623 4854
4624 4855 mcp->mb[0] = MBC_GET_XGMAC_STATS;
4625 4856 mcp->mb[2] = MSW(mem_desc.cookie.dmac_address);
4626 4857 mcp->mb[3] = LSW(mem_desc.cookie.dmac_address);
4627 4858 mcp->mb[6] = MSW(mem_desc.cookie.dmac_notused);
4628 4859 mcp->mb[7] = LSW(mem_desc.cookie.dmac_notused);
4629 4860 mcp->mb[8] = (uint16_t)(size >> 2);
4630 4861 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
4631 4862 mcp->in_mb = MBX_2|MBX_1|MBX_0;
4632 4863 mcp->timeout = MAILBOX_TOV;
4633 4864 rval = ql_mailbox_command(ha, mcp);
4634 4865
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
4635 4866 if (rval == QL_SUCCESS) {
4636 4867 ql_get_mbox_dma_data(&mem_desc, bufp);
4637 4868 }
4638 4869 ql_free_dma_resource(ha, &mem_desc);
4639 4870
4640 4871 if (rval != QL_SUCCESS) {
4641 4872 EL(ha, "status=%xh, mbx1=%xh, mbx2=%xh\n", rval, mcp->mb[1],
4642 4873 mcp->mb[2]);
4643 4874 } else {
4644 4875 /*EMPTY*/
4645 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4876 + QL_PRINT_3(ha, "done\n");
4646 4877 }
4647 4878
4648 4879 return (rval);
4649 4880 }
4650 4881
4651 4882 /*
4652 4883 * ql_get_dcbx_params
4653 4884 * Issue get DCBX parameters mailbox command.
4654 4885 *
4655 4886 * Input:
4656 4887 * ha: adapter state pointer.
4657 4888 * size: size of data buffer.
4658 4889 * bufp: data pointer for DMA data.
4659 4890 *
4660 4891 * Returns:
4661 4892 * ql local function return status code.
4662 4893 *
4663 4894 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
4664 4895 * Kernel context.
4665 4896 */
4666 4897 int
4667 4898 ql_get_dcbx_params(ql_adapter_state_t *ha, uint32_t size, caddr_t bufp)
4668 4899 {
4669 4900 int rval;
4670 4901 dma_mem_t mem_desc;
4671 4902 mbx_cmd_t mc = {0};
4672 4903 mbx_cmd_t *mcp = &mc;
4673 4904
4674 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4905 + QL_PRINT_3(ha, "started\n");
4675 4906
4676 4907 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc, size)) !=
4677 4908 QL_SUCCESS) {
4678 4909 EL(ha, "failed=%xh\n", QL_MEMORY_ALLOC_FAILED);
4679 4910 return (QL_MEMORY_ALLOC_FAILED);
4680 4911 }
4681 4912
4682 4913 mcp->mb[0] = MBC_GET_DCBX_PARAMS;
4683 4914 mcp->mb[1] = 0; /* Return all DCBX paramters */
4684 4915 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
4685 4916 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
4686 4917 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
4687 4918 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
4688 4919 mcp->mb[8] = (uint16_t)size;
4689 4920 mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
4690 4921 mcp->in_mb = MBX_2|MBX_1|MBX_0;
4691 4922 mcp->timeout = MAILBOX_TOV;
4692 4923 rval = ql_mailbox_command(ha, mcp);
4693 4924
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
4694 4925 if (rval == QL_SUCCESS) {
4695 4926 ql_get_mbox_dma_data(&mem_desc, bufp);
4696 4927 }
4697 4928
4698 4929 ql_free_dma_resource(ha, &mem_desc);
4699 4930
4700 4931 if (rval != QL_SUCCESS) {
4701 4932 EL(ha, "failed=%xh\n", rval);
4702 4933 } else {
4703 4934 /*EMPTY*/
4704 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4935 + QL_PRINT_3(ha, "done\n");
4705 4936 }
4706 4937
4707 4938 return (rval);
4708 4939 }
4709 4940 /*
4710 4941 * ql_get_fcf_list
4711 4942 * Issue get FCF list mailbox command.
4712 4943 *
4713 4944 * Input:
4714 4945 * ha: adapter state pointer.
4715 4946 * fcf_list: pointer to ql_fcf_list_desc_t
4716 4947 * bufp: data pointer for DMA data.
4717 4948 *
4718 4949 * Returns:
4719 4950 * ql local function return status code.
4720 4951 *
4721 4952 * Context:
4722 4953 * Kernel context.
4723 4954 */
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
4724 4955
4725 4956 int
4726 4957 ql_get_fcf_list_mbx(ql_adapter_state_t *ha, ql_fcf_list_desc_t *fcf_list,
4727 4958 caddr_t bufp)
4728 4959 {
4729 4960 int rval;
4730 4961 dma_mem_t mem_desc;
4731 4962 mbx_cmd_t mc = {0};
4732 4963 mbx_cmd_t *mcp = &mc;
4733 4964
4734 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
4965 + QL_PRINT_3(ha, "started\n");
4735 4966
4736 4967 if ((rval = ql_setup_mbox_dma_resources(ha, &mem_desc,
4737 4968 fcf_list->buffer_size)) !=
4738 4969 QL_SUCCESS) {
4739 4970 EL(ha, "failed=%xh\n", QL_MEMORY_ALLOC_FAILED);
4740 4971 return (QL_MEMORY_ALLOC_FAILED);
4741 4972 }
4742 4973
4743 4974 mcp->mb[0] = MBC_GET_FCF_LIST;
4744 4975 mcp->mb[1] = fcf_list->options;
4745 4976 mcp->mb[2] = MSW(LSD(mem_desc.cookie.dmac_laddress));
4746 4977 mcp->mb[3] = LSW(LSD(mem_desc.cookie.dmac_laddress));
4747 4978 mcp->mb[6] = MSW(MSD(mem_desc.cookie.dmac_laddress));
4748 4979 mcp->mb[7] = LSW(MSD(mem_desc.cookie.dmac_laddress));
4749 4980 mcp->mb[8] = (uint16_t)fcf_list->buffer_size;
4750 4981 mcp->mb[9] = fcf_list->fcf_index;
4751 4982 mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
4752 4983 mcp->in_mb = MBX_2|MBX_1|MBX_0;
4753 4984 mcp->timeout = MAILBOX_TOV;
4754 4985 rval = ql_mailbox_command(ha, mcp);
4755 4986
4756 4987 if (rval == QL_SUCCESS) {
4757 4988 ql_get_mbox_dma_data(&mem_desc, bufp);
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
4758 4989 fcf_list->buffer_size = (uint16_t)mcp->mb[1];
4759 4990 }
4760 4991
4761 4992 ql_free_dma_resource(ha, &mem_desc);
4762 4993
4763 4994 if (rval != QL_SUCCESS) {
4764 4995 EL(ha, "status=%xh, mbx1=%xh, mbx2=%xh\n", rval, mcp->mb[1],
4765 4996 mcp->mb[2]);
4766 4997 } else {
4767 4998 /*EMPTY*/
4768 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
4999 + QL_PRINT_3(ha, "done\n");
4769 5000 }
4770 5001
4771 5002 return (rval);
4772 5003 }
4773 5004
4774 5005 /*
4775 5006 * ql_get_resource_cnts
4776 5007 * Issue get Resourse Count mailbox command.
4777 5008 *
4778 5009 * Input:
4779 5010 * ha: adapter state pointer.
4780 5011 * mr: pointer for mailbox data.
4781 5012 *
4782 5013 * Returns:
4783 5014 * ql local function return status code.
4784 5015 *
4785 5016 * Context:
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
4786 5017 * Kernel context.
4787 5018 */
4788 5019
4789 5020 int
4790 5021 ql_get_resource_cnts(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
4791 5022 {
4792 5023 int rval;
4793 5024 mbx_cmd_t mc = {0};
4794 5025 mbx_cmd_t *mcp = &mc;
4795 5026
4796 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
5027 + QL_PRINT_3(ha, "started\n");
4797 5028
4798 5029 mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
4799 - mcp->out_mb = MBX_0;
5030 + mcp->out_mb = MBX_9|MBX_1|MBX_0;
4800 5031 mcp->in_mb = MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|
4801 5032 MBX_3|MBX_2|MBX_1|MBX_0;
4802 5033 mcp->timeout = MAILBOX_TOV;
4803 5034 rval = ql_mailbox_command(ha, mcp);
4804 5035
4805 5036 /* Return mailbox data. */
4806 5037 if (mr != NULL) {
4807 5038 mr->mb[1] = mcp->mb[1];
4808 5039 mr->mb[2] = mcp->mb[2];
4809 5040 mr->mb[3] = mcp->mb[3];
4810 5041 mr->mb[6] = mcp->mb[6];
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
4811 5042 mr->mb[7] = mcp->mb[7];
4812 5043 mr->mb[10] = mcp->mb[10];
4813 5044 mr->mb[11] = mcp->mb[11];
4814 5045 mr->mb[12] = mcp->mb[12];
4815 5046 }
4816 5047
4817 5048 if (rval != QL_SUCCESS) {
4818 5049 EL(ha, "failed=%xh\n", rval);
4819 5050 } else {
4820 5051 /*EMPTY*/
4821 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
5052 + QL_PRINT_3(ha, "done\n");
4822 5053 }
4823 5054
4824 5055 return (rval);
4825 5056 }
4826 5057
4827 5058 /*
4828 5059 * ql_toggle_interrupt
4829 5060 * Issue Toggle Interrupt Mailbox Command.
4830 5061 *
4831 5062 * Input:
4832 5063 * ha: adapter state pointer.
4833 5064 * opt: 0 = disable, 1 = enable.
4834 5065 *
4835 5066 * Returns:
4836 5067 * ql local function return status code.
4837 5068 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
4838 5069 * Context:
4839 5070 * Kernel context.
4840 5071 */
4841 5072 int
4842 5073 ql_toggle_interrupt(ql_adapter_state_t *ha, uint16_t opt)
4843 5074 {
4844 5075 int rval;
4845 5076 mbx_cmd_t mc = {0};
4846 5077 mbx_cmd_t *mcp = &mc;
4847 5078
4848 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
5079 + QL_PRINT_3(ha, "started\n");
4849 5080
4850 5081 mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
4851 5082 mcp->mb[1] = opt;
4852 5083 mcp->out_mb = MBX_1|MBX_0;
4853 5084 mcp->in_mb = MBX_0;
4854 5085 mcp->timeout = 2;
4855 5086 rval = ql_mailbox_command(ha, mcp);
4856 5087
4857 5088 if (rval != QL_SUCCESS) {
4858 5089 EL(ha, "failed=%xh\n", rval);
4859 5090 } else {
4860 5091 /*EMPTY*/
4861 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
5092 + QL_PRINT_3(ha, "done\n");
4862 5093 }
4863 5094
5095 + return (rval);
5096 +}
5097 +
5098 +/*
5099 + * ql_get_md_template
5100 + * Issue request mini-dump template Mailbox command
5101 + *
5102 + * Input:
5103 + * ha: adapter state pointer.
5104 + * mem: pointer to dma memory object for command.
5105 + * mr: pointer for return mailboxes.
5106 + * ofst: template offset.
5107 + * opt: request command code.
5108 + * GTO_TEMPLATE_SIZE = Request Template Size.
5109 + * GTO_TEMPLATE = Request Template.
5110 + *
5111 + * Returns:
5112 + * ql local function return status code.
5113 + *
5114 + * Context:
5115 + * Kernel context.
5116 + */
5117 +int
5118 +ql_get_md_template(ql_adapter_state_t *ha, dma_mem_t *mem, ql_mbx_data_t *mr,
5119 + uint32_t ofst, uint16_t opt)
5120 +{
5121 + int rval;
5122 + mbx_cmd_t mc = {0};
5123 + mbx_cmd_t *mcp = &mc;
5124 +
5125 + QL_PRINT_3(ha, "started\n");
5126 +
5127 + mcp->mb[0] = MBC_GET_MD_TEMPLATE;
5128 + mcp->mb[2] = opt;
5129 + if (mem != NULL) {
5130 + mcp->mb[4] = LSW(mem->cookies->dmac_address);
5131 + mcp->mb[5] = MSW(mem->cookies->dmac_address);
5132 + mcp->mb[6] = LSW(mem->cookies->dmac_notused);
5133 + mcp->mb[7] = MSW(mem->cookies->dmac_notused);
5134 + mcp->mb[8] = LSW(mem->size);
5135 + mcp->mb[9] = MSW(mem->size);
5136 + }
5137 + if (ofst != 0) {
5138 + mcp->mb[10] = LSW(ofst);
5139 + mcp->mb[11] = MSW(ofst);
5140 + }
5141 + mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|
5142 + MBX_2|MBX_1|MBX_0;
5143 + mcp->in_mb = MBX_15|MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|
5144 + MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
5145 + mcp->timeout = MAILBOX_TOV;
5146 + rval = ql_mailbox_command(ha, mcp);
5147 +
5148 + /* Return mailbox data. */
5149 + if (mr != NULL) {
5150 + mr->mb[0] = mcp->mb[0];
5151 + mr->mb[1] = mcp->mb[1];
5152 + mr->mb[2] = mcp->mb[2];
5153 + mr->mb[3] = mcp->mb[3];
5154 + mr->mb[4] = mcp->mb[4];
5155 + mr->mb[5] = mcp->mb[5];
5156 + mr->mb[6] = mcp->mb[6];
5157 + mr->mb[7] = mcp->mb[7];
5158 + mr->mb[8] = mcp->mb[8];
5159 + mr->mb[9] = mcp->mb[9];
5160 + mr->mb[10] = mcp->mb[10];
5161 + mr->mb[11] = mcp->mb[11];
5162 + mr->mb[12] = mcp->mb[12];
5163 + mr->mb[13] = mcp->mb[13];
5164 + mr->mb[12] = mcp->mb[14];
5165 + mr->mb[13] = mcp->mb[15];
5166 + }
5167 +
5168 + if (rval != QL_SUCCESS) {
5169 + EL(ha, "failed=%xh\n", rval);
5170 + } else {
5171 + /*EMPTY*/
5172 + QL_PRINT_3(ha, "done\n");
5173 + }
5174 + return (rval);
5175 +}
5176 +
5177 +/*
5178 + * ql_init_req_q
5179 + * Initialize request queue.
5180 + *
5181 + * Input:
5182 + * ha: adapter state pointer.
5183 + * req_q: request queue structure pointer.
5184 + * opt: Initialize Multiple Queue mailbox command options.
5185 + *
5186 + * Returns:
5187 + * ql driver local function return status codes
5188 + *
5189 + * Context:
5190 + * Kernel context.
5191 + */
5192 +static int
5193 +ql_init_req_q(ql_adapter_state_t *ha, ql_request_q_t *req_q, uint16_t opt)
5194 +{
5195 + int rval;
5196 + mbx_cmd_t mc = {0};
5197 + mbx_cmd_t *mcp = &mc;
5198 +
5199 + QL_PRINT_3(ha, "started, req_q_number=%d\n", req_q->req_q_number);
5200 +
5201 + if (!(opt & IMO_QOS_UPDATE)) {
5202 + req_q->req_ring_ptr = req_q->req_ring.bp;
5203 + req_q->req_ring_index = 0;
5204 + req_q->req_q_cnt = (uint16_t)(req_q->req_entry_cnt - 1);
5205 + WR32_MBAR_REG(ha, req_q->mbar_req_in, 0);
5206 + if (req_q->req_out_shadow_ptr) {
5207 + *req_q->req_out_shadow_ptr = 0;
5208 + }
5209 + }
5210 +
5211 + mcp->mb[0] = MBC_INIT_MULTIPLE_QUEUE;
5212 + mcp->mb[1] = (uint16_t)(opt | IMO_QUEUE_NOT_ASSOCIATED);
5213 + mcp->mb[2] = MSW(LSD(req_q->req_ring.cookie.dmac_laddress));
5214 + mcp->mb[3] = LSW(LSD(req_q->req_ring.cookie.dmac_laddress));
5215 + mcp->mb[4] = req_q->req_q_number;
5216 + mcp->mb[5] = req_q->req_entry_cnt;
5217 + mcp->mb[6] = MSW(MSD(req_q->req_ring.cookie.dmac_laddress));
5218 + mcp->mb[7] = LSW(MSD(req_q->req_ring.cookie.dmac_laddress));
5219 + mcp->mb[11] = ha->vp_index;
5220 + mcp->mb[12] = 0;
5221 + mcp->mb[14] = 1;
5222 + mcp->out_mb = MBX_0_THRU_14;
5223 + mcp->in_mb = MBX_0_THRU_1;
5224 + mcp->timeout = MAILBOX_TOV;
5225 + rval = ql_mailbox_command(ha, mcp);
5226 +
5227 + if (rval != QL_SUCCESS) {
5228 + EL(ha, "status=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
5229 + } else {
5230 + /*EMPTY*/
5231 + QL_PRINT_3(ha, "done\n");
5232 + }
5233 + return (rval);
5234 +}
5235 +
5236 +/*
5237 + * ql_init_rsp_q
5238 + * Initialize response queue.
5239 + *
5240 + * Input:
5241 + * ha: adapter state pointer.
5242 + * rsp_q: response queue structure pointer.
5243 + * opt: Initialize Multiple Queue mailbox command options.
5244 + *
5245 + * Returns:
5246 + * ql driver local function return status codes
5247 + *
5248 + * Context:
5249 + * Kernel context.
5250 + */
5251 +static int
5252 +ql_init_rsp_q(ql_adapter_state_t *ha, ql_response_q_t *rsp_q, uint16_t opt)
5253 +{
5254 + int rval;
5255 + mbx_cmd_t mc = {0};
5256 + mbx_cmd_t *mcp = &mc;
5257 +
5258 + QL_PRINT_3(ha, "started, rsp_q_number=%d\n", rsp_q->rsp_q_number);
5259 +
5260 + if (!(opt & IMO_DELETE_Q)) {
5261 + rsp_q->rsp_ring_ptr = rsp_q->rsp_ring.bp;
5262 + rsp_q->rsp_ring_index = 0;
5263 + WR32_MBAR_REG(ha, rsp_q->mbar_rsp_out, 0);
5264 + if (rsp_q->rsp_in_shadow_ptr) {
5265 + *rsp_q->rsp_in_shadow_ptr = 0;
5266 + }
5267 + }
5268 +
5269 + mcp->mb[0] = MBC_INIT_MULTIPLE_QUEUE;
5270 + mcp->mb[1] = (uint16_t)(opt | IMO_QUEUE_NOT_ASSOCIATED |
5271 + IMO_RESPONSE_Q_SERVICE);
5272 + mcp->mb[2] = MSW(LSD(rsp_q->rsp_ring.cookie.dmac_laddress));
5273 + mcp->mb[3] = LSW(LSD(rsp_q->rsp_ring.cookie.dmac_laddress));
5274 + mcp->mb[4] = rsp_q->rsp_q_number;
5275 + mcp->mb[5] = rsp_q->rsp_entry_cnt;
5276 + mcp->mb[6] = MSW(MSD(rsp_q->rsp_ring.cookie.dmac_laddress));
5277 + mcp->mb[7] = LSW(MSD(rsp_q->rsp_ring.cookie.dmac_laddress));
5278 + mcp->mb[14] = rsp_q->msi_x_vector;
5279 + mcp->out_mb = MBX_0_THRU_14;
5280 + mcp->in_mb = MBX_0_THRU_1;
5281 + mcp->timeout = MAILBOX_TOV;
5282 + rval = ql_mailbox_command(ha, mcp);
5283 +
5284 + if (rval != QL_SUCCESS) {
5285 + EL(ha, "status=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
5286 + } else {
5287 + /*EMPTY*/
5288 + QL_PRINT_3(ha, "done\n");
5289 + }
5290 + return (rval);
5291 +}
5292 +
5293 +/*
5294 + * ql_load_flash_image
5295 + * Load Flash Firmware.
5296 + *
5297 + * Input:
5298 + * ha: adapter state pointer.
5299 + *
5300 + * Returns:
5301 + * ql local function return status code.
5302 + *
5303 + * Context:
5304 + * Kernel context.
5305 + */
5306 +int
5307 +ql_load_flash_image(ql_adapter_state_t *ha)
5308 +{
5309 + int rval;
5310 + mbx_cmd_t mc = {0};
5311 + mbx_cmd_t *mcp = &mc;
5312 +
5313 + QL_PRINT_3(ha, "started\n");
5314 +
5315 + mcp->mb[0] = MBC_LOAD_FLASH_IMAGE;
5316 + mcp->out_mb = MBX_0;
5317 + mcp->in_mb = MBX_2|MBX_1|MBX_0;
5318 + mcp->timeout = MAILBOX_TOV;
5319 + rval = ql_mailbox_command(ha, mcp);
5320 +
5321 + if (rval != QL_SUCCESS) {
5322 + EL(ha, "failed, rval=%xh, mbx1=%xh, mbx2=%xh\n",
5323 + rval, mcp->mb[1], mcp->mb[2]);
5324 + } else {
5325 + /*EMPTY*/
5326 + QL_PRINT_3(ha, "done\n");
5327 + }
5328 + return (rval);
5329 +}
5330 +
5331 +/*
5332 + * ql_set_led_config
5333 + * Set LED Configuration.
5334 + *
5335 + * Input:
5336 + * ha: adapter state pointer.
5337 + * mr: pointer for mailbox data.
5338 + *
5339 + * Returns:
5340 + * ql local function return status code.
5341 + *
5342 + * Context:
5343 + * Kernel context.
5344 + */
5345 +int
5346 +ql_set_led_config(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
5347 +{
5348 + int rval;
5349 + mbx_cmd_t mc = {0};
5350 + mbx_cmd_t *mcp = &mc;
5351 +
5352 + QL_PRINT_3(ha, "started\n");
5353 +
5354 + mcp->mb[0] = MBC_SET_LED_CONFIG;
5355 + mcp->mb[1] = mr->mb[1];
5356 + mcp->mb[2] = mr->mb[2];
5357 + mcp->mb[3] = mr->mb[3];
5358 + mcp->mb[4] = mr->mb[4];
5359 + mcp->mb[5] = mr->mb[5];
5360 + mcp->mb[6] = mr->mb[6];
5361 + mcp->out_mb = MBX_0_THRU_6;
5362 + mcp->in_mb = MBX_0;
5363 + mcp->timeout = MAILBOX_TOV;
5364 + rval = ql_mailbox_command(ha, mcp);
5365 +
5366 + if (rval != QL_SUCCESS) {
5367 + EL(ha, "failed=%xh\n", rval);
5368 + } else {
5369 + /*EMPTY*/
5370 + QL_PRINT_3(ha, "done\n");
5371 + }
5372 +
5373 + return (rval);
5374 +}
5375 +/*
5376 + * ql_get_led_config
5377 + * Get LED Configuration.
5378 + *
5379 + * Input:
5380 + * ha: adapter state pointer.
5381 + * mr: pointer for mailbox data.
5382 + *
5383 + * Returns:
5384 + * ql local function return status code.
5385 + *
5386 + * Context:
5387 + * Kernel context.
5388 + */
5389 +int
5390 +ql_get_led_config(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
5391 +{
5392 + int rval;
5393 + mbx_cmd_t mc = {0};
5394 + mbx_cmd_t *mcp = &mc;
5395 +
5396 + QL_PRINT_3(ha, "started\n");
5397 +
5398 + mcp->mb[0] = MBC_GET_LED_CONFIG;
5399 + mcp->out_mb = MBX_0;
5400 + mcp->in_mb = MBX_0_THRU_6;
5401 + mcp->timeout = MAILBOX_TOV;
5402 + rval = ql_mailbox_command(ha, mcp);
5403 +
5404 + /* Return config data. */
5405 + if (mr != NULL) {
5406 + mr->mb[1] = mcp->mb[1];
5407 + mr->mb[2] = mcp->mb[2];
5408 + mr->mb[3] = mcp->mb[3];
5409 + mr->mb[4] = mcp->mb[4];
5410 + mr->mb[5] = mcp->mb[5];
5411 + mr->mb[6] = mcp->mb[6];
5412 + }
5413 +
5414 + if (rval != QL_SUCCESS) {
5415 + EL(ha, "failed=%xh\n", rval);
5416 + } else {
5417 + /*EMPTY*/
5418 + QL_PRINT_3(ha, "done\n");
5419 + }
5420 +
5421 + return (rval);
5422 +}
5423 +
5424 +/*
5425 + * ql_led_config
5426 + * Set/Get Fibre Channel LED Configuration command.
5427 + *
5428 + * Input:
5429 + * ha: adapter state pointer.
5430 + * opt: Options.
5431 + * led0: LED 0 configuration.
5432 + * led1: LED 1 configuration.
5433 + * led2: LED 2 configuration.
5434 + * mr: pointer for mailbox data.
5435 + *
5436 + * Returns:
5437 + * qlc local function return status code.
5438 + *
5439 + * Context:
5440 + * Kernel context.
5441 + */
5442 +int
5443 +ql_led_config(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
5444 +{
5445 + int rval = QL_SUCCESS;
5446 + mbx_cmd_t mc = {0};
5447 + mbx_cmd_t *mcp = &mc;
5448 +
5449 + QL_PRINT_3(ha, "started\n");
5450 +
5451 + mcp->mb[0] = MBC_FC_LED_CONFIG;
5452 + mcp->mb[1] = mr->mb[1];
5453 + mcp->mb[2] = mr->mb[2];
5454 + mcp->mb[3] = mr->mb[3];
5455 + mcp->mb[4] = mr->mb[4];
5456 + mcp->out_mb = MBX_0_THRU_4;
5457 + mcp->in_mb = MBX_0_THRU_4;
5458 + mcp->timeout = MAILBOX_TOV;
5459 + rval = ql_mailbox_command(ha, mcp);
5460 +
5461 + /* Return mailbox data. */
5462 + mr->mb[0] = mcp->mb[0];
5463 + mr->mb[1] = mcp->mb[1];
5464 + mr->mb[2] = mcp->mb[2];
5465 + mr->mb[3] = mcp->mb[3];
5466 + mr->mb[4] = mcp->mb[4];
5467 +
5468 + if (rval != QL_SUCCESS) {
5469 + EL(ha, "failed, rval=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
5470 + } else {
5471 + /*EMPTY*/
5472 + QL_PRINT_3(ha, "done\n");
5473 + }
5474 + return (rval);
5475 +}
5476 +
5477 +/*
5478 + * ql_write_remote_reg
5479 + * Writes a register within another function.
5480 + *
5481 + * Input:
5482 + * ha: adapter state pointer.
5483 + * addr: address.
5484 + * data: data.
5485 + *
5486 + * Returns:
5487 + * ql local function return status code.
5488 + *
5489 + * Context:
5490 + * Kernel context.
5491 + */
5492 +int
5493 +ql_write_remote_reg(ql_adapter_state_t *ha, uint32_t addr, uint32_t data)
5494 +{
5495 + int rval;
5496 + mbx_cmd_t mc = {0};
5497 + mbx_cmd_t *mcp = &mc;
5498 +
5499 + QL_PRINT_10(ha, "started, addr=%xh, data=%xh\n", addr, data);
5500 +
5501 + mcp->mb[0] = MBC_WRITE_REMOTE_REG;
5502 + mcp->mb[1] = LSW(addr);
5503 + mcp->mb[2] = MSW(addr);
5504 + mcp->mb[3] = LSW(data);
5505 + mcp->mb[4] = MSW(data);
5506 + mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
5507 + mcp->in_mb = MBX_1|MBX_0;
5508 + mcp->timeout = MAILBOX_TOV;
5509 + rval = ql_mailbox_command(ha, mcp);
5510 +
5511 + if (rval != QL_SUCCESS) {
5512 + EL(ha, "failed=%xh, mbx1=%xh, addr=%xh, data=%xh\n", rval,
5513 + mcp->mb[1], addr, data);
5514 + } else {
5515 + /*EMPTY*/
5516 + QL_PRINT_10(ha, "done\n");
5517 + }
5518 + return (rval);
5519 +}
5520 +
5521 +/*
5522 + * ql_read_remote_reg
5523 + * Read a register within another function.
5524 + *
5525 + * Input:
5526 + * ha: adapter state pointer.
5527 + * addr: address.
5528 + * data: data pointer.
5529 + *
5530 + * Returns:
5531 + * qlc local function return status code.
5532 + *
5533 + * Context:
5534 + * Kernel context.
5535 + */
5536 +int
5537 +ql_read_remote_reg(ql_adapter_state_t *ha, uint32_t addr, uint32_t *dp)
5538 +{
5539 + int rval;
5540 + mbx_cmd_t mc = {0};
5541 + mbx_cmd_t *mcp = &mc;
5542 +
5543 + QL_PRINT_10(ha, "started, addr=%xh\n", addr);
5544 +
5545 + mcp->mb[0] = MBC_READ_REMOTE_REG;
5546 + mcp->mb[1] = LSW(addr);
5547 + mcp->mb[2] = MSW(addr);
5548 + mcp->out_mb = MBX_2|MBX_1|MBX_0;
5549 + mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
5550 + mcp->timeout = MAILBOX_TOV;
5551 + rval = ql_mailbox_command(ha, mcp);
5552 +
5553 + if (rval != QL_SUCCESS) {
5554 + EL(ha, "failed=%xh, mbx1=%xh, addr=%xh\n", rval, mcp->mb[1],
5555 + addr);
5556 + } else {
5557 + *dp = SHORT_TO_LONG(mcp->mb[3], mcp->mb[4]);
5558 + QL_PRINT_10(ha, "done, addr=%xh, data=%xh\n", addr, *dp);
5559 + }
5560 + return (rval);
5561 +}
5562 +
5563 +/*
5564 + * ql_get_temp
5565 + * Issue get temperature mailbox command.
5566 + *
5567 + * Input:
5568 + * ha: adapter state pointer.
5569 + * mr: pointer for mailbox data.
5570 + *
5571 + * Returns:
5572 + * ql local function return status code.
5573 + *
5574 + * Context:
5575 + * Kernel context.
5576 + */
5577 +int
5578 +ql_get_temp(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
5579 +{
5580 + int rval;
5581 + mbx_cmd_t mc = {0};
5582 + mbx_cmd_t *mcp = &mc;
5583 +
5584 + QL_PRINT_3(ha, "started\n");
5585 +
5586 + mcp->mb[0] = MBC_GET_PARAMETERS;
5587 + mcp->mb[1] = READ_ASIC_TEMP << 8;
5588 + mcp->out_mb = MBX_0_THRU_1;
5589 + mcp->in_mb = MBX_0_THRU_1;
5590 + mcp->timeout = MAILBOX_TOV;
5591 + rval = ql_mailbox_command(ha, mcp);
5592 +
5593 + /* Return config data. */
5594 + if (mr != NULL) {
5595 + mr->mb[1] = mcp->mb[1];
5596 + }
5597 +
5598 + if (rval != QL_SUCCESS) {
5599 + EL(ha, "failed, rval=%xh, mbx1=%xh\n", rval, mcp->mb[1]);
5600 + } else {
5601 + /*EMPTY*/
5602 + QL_PRINT_3(ha, "done\n");
5603 + }
5604 + return (rval);
5605 +}
5606 +
5607 +/*
5608 + * ql_write_serdes
5609 + * Issue write FC serdes register mailbox command.
5610 + *
5611 + * Input:
5612 + * ha: adapter state pointer.
5613 + * mr: pointer for mailbox data.
5614 + *
5615 + * Returns:
5616 + * ql local function return status code.
5617 + *
5618 + * Context:
5619 + * Kernel context.
5620 + */
5621 +int
5622 +ql_write_serdes(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
5623 +{
5624 + int rval;
5625 + mbx_cmd_t mc = {0};
5626 + mbx_cmd_t *mcp = &mc;
5627 +
5628 + QL_PRINT_3(ha, "started\n");
5629 +
5630 + mcp->mb[0] = MBC_WRITE_SERDES_REG;
5631 + mcp->mb[1] = mr->mb[1];
5632 + mcp->mb[2] = mr->mb[2];
5633 + mcp->mb[3] = mr->mb[3];
5634 + mcp->mb[4] = mr->mb[4];
5635 + mcp->mb[5] = mr->mb[5];
5636 + mcp->mb[6] = mr->mb[6];
5637 + mcp->out_mb = MBX_0_THRU_6;
5638 + mcp->in_mb = MBX_0;
5639 + mcp->timeout = MAILBOX_TOV;
5640 + rval = ql_mailbox_command(ha, mcp);
5641 +
5642 + if (rval != QL_SUCCESS) {
5643 + EL(ha, "failed, rval=%xh\n", rval);
5644 + } else {
5645 + /*EMPTY*/
5646 + QL_PRINT_3(ha, "done\n");
5647 + }
5648 +
5649 + return (rval);
5650 +}
5651 +
5652 +/*
5653 + * ql_read_serdes
5654 + * Issue read FC serdes register mailbox command.
5655 + *
5656 + * Input:
5657 + * ha: adapter state pointer.
5658 + * mr: pointer for mailbox data.
5659 + *
5660 + * Returns:
5661 + * ql local function return status code.
5662 + *
5663 + * Context:
5664 + * Kernel context.
5665 + */
5666 +int
5667 +ql_read_serdes(ql_adapter_state_t *ha, ql_mbx_data_t *mr)
5668 +{
5669 + int rval;
5670 + mbx_cmd_t mc = {0};
5671 + mbx_cmd_t *mcp = &mc;
5672 +
5673 + QL_PRINT_3(ha, "started\n");
5674 +
5675 + mcp->mb[0] = MBC_READ_SERDES_REG;
5676 + mcp->mb[1] = mr->mb[1];
5677 + mcp->mb[2] = mr->mb[2];
5678 + mcp->mb[3] = mr->mb[3];
5679 + mcp->mb[4] = mr->mb[4];
5680 + mcp->mb[5] = mr->mb[5];
5681 + mcp->mb[6] = mr->mb[6];
5682 + mcp->out_mb = MBX_0_THRU_6;
5683 + mcp->in_mb = MBX_0_THRU_6;
5684 + mcp->timeout = MAILBOX_TOV;
5685 + rval = ql_mailbox_command(ha, mcp);
5686 +
5687 + /* Return mailbox data. */
5688 + mr->mb[0] = mcp->mb[0];
5689 + mr->mb[1] = mcp->mb[1];
5690 + mr->mb[2] = mcp->mb[2];
5691 + mr->mb[3] = mcp->mb[3];
5692 + mr->mb[4] = mcp->mb[4];
5693 + mr->mb[4] = mcp->mb[5];
5694 + mr->mb[4] = mcp->mb[6];
5695 +
5696 + if (rval != QL_SUCCESS) {
5697 + EL(ha, "failed, rval=%xh", rval);
5698 + } else {
5699 + /*EMPTY*/
5700 + QL_PRINT_3(ha, "done\n");
5701 + }
5702 +
4864 5703 return (rval);
4865 5704 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX