Print this page
NEX-5979 QLogic 2322 flash bug
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Reviewed by: Marcel Telka <marcel.telka@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_xioctl.c
+++ new/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_xioctl.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 28 /*
29 29 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
30 30 */
31 31
32 -#pragma ident "Copyright 2010 QLogic Corporation; ql_xioctl.c"
32 +#pragma ident "Copyright 2015 QLogic Corporation; ql_xioctl.c"
33 33
34 34 /*
35 35 * ISP2xxx Solaris Fibre Channel Adapter (FCA) driver source file.
36 36 *
37 37 * ***********************************************************************
38 38 * * **
39 39 * * NOTICE **
40 - * * COPYRIGHT (C) 1996-2010 QLOGIC CORPORATION **
40 + * * COPYRIGHT (C) 1996-2015 QLOGIC CORPORATION **
41 41 * * ALL RIGHTS RESERVED **
42 42 * * **
43 43 * ***********************************************************************
44 44 *
45 45 */
46 46
47 47 #include <ql_apps.h>
48 48 #include <ql_api.h>
49 49 #include <ql_debug.h>
50 50 #include <ql_init.h>
51 51 #include <ql_iocb.h>
52 52 #include <ql_ioctl.h>
53 53 #include <ql_mbx.h>
54 +#include <ql_nx.h>
54 55 #include <ql_xioctl.h>
55 56
56 57 /*
57 58 * Local data
58 59 */
59 60
60 61 /*
61 62 * Local prototypes
62 63 */
63 64 static int ql_sdm_ioctl(ql_adapter_state_t *, int, void *, int);
64 65 static int ql_sdm_setup(ql_adapter_state_t *, EXT_IOCTL **, void *, int,
65 66 boolean_t (*)(EXT_IOCTL *));
66 67 static boolean_t ql_validate_signature(EXT_IOCTL *);
67 68 static int ql_sdm_return(ql_adapter_state_t *, EXT_IOCTL *, void *, int);
68 69 static void ql_query(ql_adapter_state_t *, EXT_IOCTL *, int);
69 70 static void ql_qry_hba_node(ql_adapter_state_t *, EXT_IOCTL *, int);
70 71 static void ql_qry_hba_port(ql_adapter_state_t *, EXT_IOCTL *, int);
71 72 static void ql_qry_disc_port(ql_adapter_state_t *, EXT_IOCTL *, int);
72 73 static void ql_qry_disc_tgt(ql_adapter_state_t *, EXT_IOCTL *, int);
73 74 static void ql_qry_fw(ql_adapter_state_t *, EXT_IOCTL *, int);
74 75 static void ql_qry_chip(ql_adapter_state_t *, EXT_IOCTL *, int);
75 76 static void ql_qry_driver(ql_adapter_state_t *, EXT_IOCTL *, int);
76 77 static void ql_fcct(ql_adapter_state_t *, EXT_IOCTL *, int);
77 78 static void ql_aen_reg(ql_adapter_state_t *, EXT_IOCTL *, int);
78 79 static void ql_aen_get(ql_adapter_state_t *, EXT_IOCTL *, int);
79 80 static void ql_scsi_passthru(ql_adapter_state_t *, EXT_IOCTL *, int);
80 81 static void ql_wwpn_to_scsiaddr(ql_adapter_state_t *, EXT_IOCTL *, int);
81 82 static void ql_host_idx(ql_adapter_state_t *, EXT_IOCTL *, int);
82 83 static void ql_host_drvname(ql_adapter_state_t *, EXT_IOCTL *, int);
83 84 static void ql_read_nvram(ql_adapter_state_t *, EXT_IOCTL *, int);
84 85 static void ql_write_nvram(ql_adapter_state_t *, EXT_IOCTL *, int);
85 86 static void ql_read_flash(ql_adapter_state_t *, EXT_IOCTL *, int);
86 87 static void ql_write_flash(ql_adapter_state_t *, EXT_IOCTL *, int);
87 88 static void ql_write_vpd(ql_adapter_state_t *, EXT_IOCTL *, int);
88 89 static void ql_read_vpd(ql_adapter_state_t *, EXT_IOCTL *, int);
|
↓ open down ↓ |
25 lines elided |
↑ open up ↑ |
89 90 static void ql_diagnostic_loopback(ql_adapter_state_t *, EXT_IOCTL *, int);
90 91 static void ql_send_els_rnid(ql_adapter_state_t *, EXT_IOCTL *, int);
91 92 static void ql_set_host_data(ql_adapter_state_t *, EXT_IOCTL *, int);
92 93 static void ql_get_host_data(ql_adapter_state_t *, EXT_IOCTL *, int);
93 94 static void ql_qry_cna_port(ql_adapter_state_t *, EXT_IOCTL *, int);
94 95
95 96 static int ql_lun_count(ql_adapter_state_t *, ql_tgt_t *);
96 97 static int ql_report_lun(ql_adapter_state_t *, ql_tgt_t *);
97 98 static int ql_inq_scan(ql_adapter_state_t *, ql_tgt_t *, int);
98 99 static int ql_inq(ql_adapter_state_t *, ql_tgt_t *, int, ql_mbx_iocb_t *,
99 - uint8_t);
100 + uint32_t);
100 101 static uint32_t ql_get_buffer_data(caddr_t, caddr_t, uint32_t, int);
101 102 static uint32_t ql_send_buffer_data(caddr_t, caddr_t, uint32_t, int);
102 103 static int ql_24xx_flash_desc(ql_adapter_state_t *);
103 104 static int ql_setup_flash(ql_adapter_state_t *);
104 105 static ql_tgt_t *ql_find_port(ql_adapter_state_t *, uint8_t *, uint16_t);
105 106 static int ql_flash_fcode_load(ql_adapter_state_t *, void *, uint32_t, int);
106 107 static int ql_flash_fcode_dump(ql_adapter_state_t *, void *, uint32_t,
107 108 uint32_t, int);
108 109 static int ql_program_flash_address(ql_adapter_state_t *, uint32_t,
109 110 uint8_t);
110 111 static void ql_set_rnid_parameters(ql_adapter_state_t *, EXT_IOCTL *, int);
111 112 static void ql_get_rnid_parameters(ql_adapter_state_t *, EXT_IOCTL *, int);
112 113 static int ql_reset_statistics(ql_adapter_state_t *, EXT_IOCTL *);
113 114 static void ql_get_statistics(ql_adapter_state_t *, EXT_IOCTL *, int);
114 115 static void ql_get_statistics_fc(ql_adapter_state_t *, EXT_IOCTL *, int);
115 116 static void ql_get_statistics_fc4(ql_adapter_state_t *, EXT_IOCTL *, int);
116 117 static void ql_set_led_state(ql_adapter_state_t *, EXT_IOCTL *, int);
117 118 static void ql_get_led_state(ql_adapter_state_t *, EXT_IOCTL *, int);
118 119 static void ql_drive_led(ql_adapter_state_t *, uint32_t);
119 -static uint32_t ql_setup_led(ql_adapter_state_t *);
120 -static uint32_t ql_wrapup_led(ql_adapter_state_t *);
120 +static int ql_setup_led(ql_adapter_state_t *);
121 +static int ql_wrapup_led(ql_adapter_state_t *);
121 122 static void ql_get_port_summary(ql_adapter_state_t *, EXT_IOCTL *, int);
122 123 static void ql_get_target_id(ql_adapter_state_t *, EXT_IOCTL *, int);
123 124 static void ql_get_sfp(ql_adapter_state_t *, EXT_IOCTL *, int);
124 125 static int ql_dump_sfp(ql_adapter_state_t *, void *, int);
125 126 static ql_fcache_t *ql_setup_fnode(ql_adapter_state_t *);
126 127 static void ql_get_fcache(ql_adapter_state_t *, EXT_IOCTL *, int);
127 128 static void ql_get_fcache_ex(ql_adapter_state_t *, EXT_IOCTL *, int);
128 129 void ql_update_fcache(ql_adapter_state_t *, uint8_t *, uint32_t);
129 130 static int ql_check_pci(ql_adapter_state_t *, ql_fcache_t *, uint32_t *);
130 131 static void ql_flash_layout_table(ql_adapter_state_t *, uint32_t);
131 132 static void ql_process_flt(ql_adapter_state_t *, uint32_t);
132 133 static void ql_flash_nvram_defaults(ql_adapter_state_t *);
133 134 static void ql_port_param(ql_adapter_state_t *, EXT_IOCTL *, int);
134 135 static int ql_check_pci(ql_adapter_state_t *, ql_fcache_t *, uint32_t *);
135 136 static void ql_get_pci_data(ql_adapter_state_t *, EXT_IOCTL *, int);
136 137 static void ql_get_fwfcetrace(ql_adapter_state_t *, EXT_IOCTL *, int);
137 138 static void ql_get_fwexttrace(ql_adapter_state_t *, EXT_IOCTL *, int);
138 139 static void ql_menlo_reset(ql_adapter_state_t *, EXT_IOCTL *, int);
139 140 static void ql_menlo_get_fw_version(ql_adapter_state_t *, EXT_IOCTL *, int);
140 141 static void ql_menlo_update_fw(ql_adapter_state_t *, EXT_IOCTL *, int);
141 142 static void ql_menlo_manage_info(ql_adapter_state_t *, EXT_IOCTL *, int);
142 143 static int ql_suspend_hba(ql_adapter_state_t *, uint32_t);
143 144 static void ql_restart_hba(ql_adapter_state_t *);
144 145 static void ql_get_vp_cnt_id(ql_adapter_state_t *, EXT_IOCTL *, int);
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
145 146 static void ql_vp_ioctl(ql_adapter_state_t *, EXT_IOCTL *, int);
146 147 static void ql_qry_vport(ql_adapter_state_t *, EXT_IOCTL *, int);
147 148 static void ql_access_flash(ql_adapter_state_t *, EXT_IOCTL *, int);
148 149 static void ql_reset_cmd(ql_adapter_state_t *, EXT_IOCTL *);
149 150 static void ql_update_flash_caches(ql_adapter_state_t *);
150 151 static void ql_get_dcbx_parameters(ql_adapter_state_t *, EXT_IOCTL *, int);
151 152 static void ql_get_xgmac_statistics(ql_adapter_state_t *, EXT_IOCTL *, int);
152 153 static void ql_get_fcf_list(ql_adapter_state_t *, EXT_IOCTL *, int);
153 154 static void ql_get_resource_counts(ql_adapter_state_t *, EXT_IOCTL *, int);
154 155 static void ql_qry_adapter_versions(ql_adapter_state_t *, EXT_IOCTL *, int);
155 -static int ql_set_loop_point(ql_adapter_state_t *, uint16_t);
156 +static void ql_get_temperature(ql_adapter_state_t *, EXT_IOCTL *, int);
157 +static void ql_dump_cmd(ql_adapter_state_t *, EXT_IOCTL *, int);
158 +static void ql_serdes_reg(ql_adapter_state_t *, EXT_IOCTL *, int);
159 +static void ql_serdes_reg_ex(ql_adapter_state_t *, EXT_IOCTL *, int);
160 +static void ql_els_passthru(ql_adapter_state_t *, EXT_IOCTL *, int);
161 +static void ql_flash_update_caps(ql_adapter_state_t *, EXT_IOCTL *, int);
162 +static void ql_get_bbcr_data(ql_adapter_state_t *, EXT_IOCTL *, int);
163 +static void ql_get_priv_stats(ql_adapter_state_t *, EXT_IOCTL *, int);
156 164
157 165 /* ******************************************************************** */
158 166 /* External IOCTL support. */
159 167 /* ******************************************************************** */
160 168
161 169 /*
162 170 * ql_alloc_xioctl_resource
163 171 * Allocates resources needed by module code.
164 172 *
165 173 * Input:
166 174 * ha: adapter state pointer.
167 175 *
168 176 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
169 177 * SYS_ERRNO
170 178 *
171 179 * Context:
172 180 * Kernel context.
173 181 */
174 182 int
175 183 ql_alloc_xioctl_resource(ql_adapter_state_t *ha)
176 184 {
177 185 ql_xioctl_t *xp;
178 186
179 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
187 + QL_PRINT_9(ha, "started\n");
180 188
181 189 if (ha->xioctl != NULL) {
182 - QL_PRINT_9(CE_CONT, "(%d): already allocated done\n",
190 + QL_PRINT_9(ha, "already allocated done\n",
183 191 ha->instance);
184 192 return (0);
185 193 }
186 194
187 195 xp = kmem_zalloc(sizeof (ql_xioctl_t), KM_SLEEP);
188 196 if (xp == NULL) {
189 197 EL(ha, "failed, kmem_zalloc\n");
190 198 return (ENOMEM);
191 199 }
192 200 ha->xioctl = xp;
193 201
194 202 /* Allocate AEN tracking buffer */
195 203 xp->aen_tracking_queue = kmem_zalloc(EXT_DEF_MAX_AEN_QUEUE *
196 204 sizeof (EXT_ASYNC_EVENT), KM_SLEEP);
197 205 if (xp->aen_tracking_queue == NULL) {
198 206 EL(ha, "failed, kmem_zalloc-2\n");
199 207 ql_free_xioctl_resource(ha);
200 208 return (ENOMEM);
201 209 }
202 210
203 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
211 + QL_PRINT_9(ha, "done\n");
204 212
205 213 return (0);
206 214 }
207 215
208 216 /*
209 217 * ql_free_xioctl_resource
210 218 * Frees resources used by module code.
211 219 *
212 220 * Input:
213 221 * ha: adapter state pointer.
214 222 *
215 223 * Context:
216 224 * Kernel context.
217 225 */
218 226 void
219 227 ql_free_xioctl_resource(ql_adapter_state_t *ha)
220 228 {
221 229 ql_xioctl_t *xp = ha->xioctl;
222 230
223 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
231 + QL_PRINT_9(ha, "started\n");
224 232
225 233 if (xp == NULL) {
226 - QL_PRINT_9(CE_CONT, "(%d): already freed\n", ha->instance);
234 + QL_PRINT_9(ha, "already freed\n");
227 235 return;
228 236 }
229 237
230 238 if (xp->aen_tracking_queue != NULL) {
231 239 kmem_free(xp->aen_tracking_queue, EXT_DEF_MAX_AEN_QUEUE *
232 240 sizeof (EXT_ASYNC_EVENT));
233 241 xp->aen_tracking_queue = NULL;
234 242 }
235 243
236 244 kmem_free(xp, sizeof (ql_xioctl_t));
237 245 ha->xioctl = NULL;
238 246
239 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
247 + QL_PRINT_9(ha, "done\n");
240 248 }
241 249
242 250 /*
243 251 * ql_xioctl
244 252 * External IOCTL processing.
245 253 *
246 254 * Input:
247 255 * ha: adapter state pointer.
248 256 * cmd: function to perform
249 257 * arg: data type varies with request
250 258 * mode: flags
251 259 * cred_p: credentials pointer
252 260 * rval_p: pointer to result value
253 261 *
254 262 * Returns:
255 263 * 0: success
256 264 * ENXIO: No such device or address
257 265 * ENOPROTOOPT: Protocol not available
258 266 *
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
259 267 * Context:
260 268 * Kernel context.
261 269 */
262 270 /* ARGSUSED */
263 271 int
264 272 ql_xioctl(ql_adapter_state_t *ha, int cmd, intptr_t arg, int mode,
265 273 cred_t *cred_p, int *rval_p)
266 274 {
267 275 int rval;
268 276
269 - QL_PRINT_9(CE_CONT, "(%d): started, cmd=%d\n", ha->instance, cmd);
277 + QL_PRINT_9(ha, "started, cmd=%d\n", cmd);
270 278
271 279 if (ha->xioctl == NULL) {
272 - QL_PRINT_9(CE_CONT, "(%d): no context\n", ha->instance);
280 + QL_PRINT_9(ha, "no context\n");
273 281 return (ENXIO);
274 282 }
275 283
276 284 switch (cmd) {
277 285 case EXT_CC_QUERY:
278 286 case EXT_CC_SEND_FCCT_PASSTHRU:
279 287 case EXT_CC_REG_AEN:
280 288 case EXT_CC_GET_AEN:
281 289 case EXT_CC_SEND_SCSI_PASSTHRU:
282 290 case EXT_CC_WWPN_TO_SCSIADDR:
283 291 case EXT_CC_SEND_ELS_RNID:
284 292 case EXT_CC_SET_DATA:
285 293 case EXT_CC_GET_DATA:
286 294 case EXT_CC_HOST_IDX:
287 295 case EXT_CC_READ_NVRAM:
288 296 case EXT_CC_UPDATE_NVRAM:
289 297 case EXT_CC_READ_OPTION_ROM:
290 298 case EXT_CC_READ_OPTION_ROM_EX:
291 299 case EXT_CC_UPDATE_OPTION_ROM:
292 300 case EXT_CC_UPDATE_OPTION_ROM_EX:
293 301 case EXT_CC_GET_VPD:
294 302 case EXT_CC_SET_VPD:
295 303 case EXT_CC_LOOPBACK:
296 304 case EXT_CC_GET_FCACHE:
297 305 case EXT_CC_GET_FCACHE_EX:
298 306 case EXT_CC_HOST_DRVNAME:
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
299 307 case EXT_CC_GET_SFP_DATA:
300 308 case EXT_CC_PORT_PARAM:
301 309 case EXT_CC_GET_PCI_DATA:
302 310 case EXT_CC_GET_FWEXTTRACE:
303 311 case EXT_CC_GET_FWFCETRACE:
304 312 case EXT_CC_GET_VP_CNT_ID:
305 313 case EXT_CC_VPORT_CMD:
306 314 case EXT_CC_ACCESS_FLASH:
307 315 case EXT_CC_RESET_FW:
308 316 case EXT_CC_MENLO_MANAGE_INFO:
317 + case EXT_CC_I2C_DATA:
318 + case EXT_CC_DUMP:
319 + case EXT_CC_SERDES_REG_OP:
320 + case EXT_CC_VF_STATE:
321 + case EXT_CC_SERDES_REG_OP_EX:
322 + case EXT_CC_ELS_PASSTHRU_OS:
323 + case EXT_CC_FLASH_UPDATE_CAPS_OS:
324 + case EXT_CC_GET_BBCR_DATA_OS:
309 325 rval = ql_sdm_ioctl(ha, cmd, (void *)arg, mode);
310 326 break;
311 327 default:
312 328 /* function not supported. */
313 329 EL(ha, "function=%d not supported\n", cmd);
314 330 rval = ENOPROTOOPT;
315 331 }
316 332
317 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
333 + QL_PRINT_9(ha, "done\n");
318 334
319 335 return (rval);
320 336 }
321 337
322 338 /*
323 339 * ql_sdm_ioctl
324 340 * Provides ioctl functions for SAN/Device Management functions
325 341 * AKA External Ioctl functions.
326 342 *
327 343 * Input:
328 344 * ha: adapter state pointer.
329 345 * ioctl_code: ioctl function to perform
330 346 * arg: Pointer to EXT_IOCTL cmd data in application land.
331 347 * mode: flags
332 348 *
333 349 * Returns:
334 350 * 0: success
335 351 * ENOMEM: Alloc of local EXT_IOCTL struct failed.
336 352 * EFAULT: Copyin of caller's EXT_IOCTL struct failed or
337 353 * copyout of EXT_IOCTL status info failed.
338 354 * EINVAL: Signature or version of caller's EXT_IOCTL invalid.
339 355 * EBUSY: Device busy
340 356 *
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
341 357 * Context:
342 358 * Kernel context.
343 359 */
344 360 static int
345 361 ql_sdm_ioctl(ql_adapter_state_t *ha, int ioctl_code, void *arg, int mode)
346 362 {
347 363 EXT_IOCTL *cmd;
348 364 int rval;
349 365 ql_adapter_state_t *vha;
350 366
351 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
367 + QL_PRINT_9(ha, "started\n");
352 368
353 369 /* Copy argument structure (EXT_IOCTL) from application land. */
354 370 if ((rval = ql_sdm_setup(ha, &cmd, arg, mode,
355 371 ql_validate_signature)) != 0) {
356 372 /*
357 373 * a non-zero value at this time means a problem getting
358 374 * the requested information from application land, just
359 375 * return the error code and hope for the best.
360 376 */
361 377 EL(ha, "failed, sdm_setup\n");
362 378 return (rval);
363 379 }
364 380
365 381 /*
366 382 * Map the physical ha ptr (which the ioctl is called with)
367 383 * to the virtual ha that the caller is addressing.
368 384 */
369 385 if (ha->flags & VP_ENABLED) {
370 386 /* Check that it is within range. */
371 - if (cmd->HbaSelect > (CFG_IST(ha, CFG_CTRL_2422) ?
372 - MAX_24_VIRTUAL_PORTS : MAX_25_VIRTUAL_PORTS)) {
387 + if (cmd->HbaSelect > ha->max_vports) {
373 388 EL(ha, "Invalid HbaSelect vp index: %xh\n",
374 389 cmd->HbaSelect);
375 390 cmd->Status = EXT_STATUS_INVALID_VPINDEX;
376 391 cmd->ResponseLen = 0;
377 392 return (EFAULT);
378 393 }
379 394 /*
380 395 * Special case: HbaSelect == 0 is physical ha
381 396 */
382 397 if (cmd->HbaSelect != 0) {
383 398 vha = ha->vp_next;
384 399 while (vha != NULL) {
385 400 if (vha->vp_index == cmd->HbaSelect) {
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
386 401 ha = vha;
387 402 break;
388 403 }
389 404 vha = vha->vp_next;
390 405 }
391 406 /*
392 407 * The specified vp index may be valid(within range)
393 408 * but it's not in the list. Currently this is all
394 409 * we can say.
395 410 */
396 - if (vha == NULL) {
411 + if (vha == NULL || !(vha->flags & VP_ENABLED)) {
397 412 cmd->Status = EXT_STATUS_INVALID_VPINDEX;
398 413 cmd->ResponseLen = 0;
399 414 return (EFAULT);
400 415 }
401 416 }
402 417 }
403 418
404 419 /*
405 420 * If driver is suspended, stalled, or powered down rtn BUSY
406 421 */
407 422 if (ha->flags & ADAPTER_SUSPENDED ||
408 - ha->task_daemon_flags & DRIVER_STALL ||
423 + (ha->task_daemon_flags & (DRIVER_STALL | ISP_ABORT_NEEDED |
424 + ABORT_ISP_ACTIVE | LOOP_RESYNC_NEEDED | LOOP_RESYNC_ACTIVE)) ||
409 425 ha->power_level != PM_LEVEL_D0) {
410 426 EL(ha, " %s\n", ha->flags & ADAPTER_SUSPENDED ?
411 427 "driver suspended" :
412 - (ha->task_daemon_flags & DRIVER_STALL ? "driver stalled" :
428 + (ha->task_daemon_flags & (DRIVER_STALL | ISP_ABORT_NEEDED |
429 + ABORT_ISP_ACTIVE | LOOP_RESYNC_NEEDED |
430 + LOOP_RESYNC_ACTIVE) ? "driver stalled" :
413 431 "FCA powered down"));
414 432 cmd->Status = EXT_STATUS_BUSY;
415 433 cmd->ResponseLen = 0;
416 434 rval = EBUSY;
417 435
418 436 /* Return results to caller */
419 437 if ((ql_sdm_return(ha, cmd, arg, mode)) == -1) {
420 438 EL(ha, "failed, sdm_return\n");
421 439 rval = EFAULT;
422 440 }
423 441 return (rval);
424 442 }
425 443
426 444 switch (ioctl_code) {
427 445 case EXT_CC_QUERY_OS:
428 446 ql_query(ha, cmd, mode);
429 447 break;
430 448 case EXT_CC_SEND_FCCT_PASSTHRU_OS:
431 449 ql_fcct(ha, cmd, mode);
432 450 break;
433 451 case EXT_CC_REG_AEN_OS:
434 452 ql_aen_reg(ha, cmd, mode);
435 453 break;
436 454 case EXT_CC_GET_AEN_OS:
437 455 ql_aen_get(ha, cmd, mode);
438 456 break;
439 457 case EXT_CC_GET_DATA_OS:
440 458 ql_get_host_data(ha, cmd, mode);
441 459 break;
442 460 case EXT_CC_SET_DATA_OS:
443 461 ql_set_host_data(ha, cmd, mode);
444 462 break;
445 463 case EXT_CC_SEND_ELS_RNID_OS:
446 464 ql_send_els_rnid(ha, cmd, mode);
447 465 break;
448 466 case EXT_CC_SCSI_PASSTHRU_OS:
449 467 ql_scsi_passthru(ha, cmd, mode);
450 468 break;
451 469 case EXT_CC_WWPN_TO_SCSIADDR_OS:
452 470 ql_wwpn_to_scsiaddr(ha, cmd, mode);
453 471 break;
454 472 case EXT_CC_HOST_IDX_OS:
455 473 ql_host_idx(ha, cmd, mode);
456 474 break;
457 475 case EXT_CC_HOST_DRVNAME_OS:
458 476 ql_host_drvname(ha, cmd, mode);
459 477 break;
460 478 case EXT_CC_READ_NVRAM_OS:
461 479 ql_read_nvram(ha, cmd, mode);
462 480 break;
463 481 case EXT_CC_UPDATE_NVRAM_OS:
464 482 ql_write_nvram(ha, cmd, mode);
465 483 break;
466 484 case EXT_CC_READ_OPTION_ROM_OS:
467 485 case EXT_CC_READ_OPTION_ROM_EX_OS:
468 486 ql_read_flash(ha, cmd, mode);
469 487 break;
470 488 case EXT_CC_UPDATE_OPTION_ROM_OS:
471 489 case EXT_CC_UPDATE_OPTION_ROM_EX_OS:
472 490 ql_write_flash(ha, cmd, mode);
473 491 break;
474 492 case EXT_CC_LOOPBACK_OS:
475 493 ql_diagnostic_loopback(ha, cmd, mode);
476 494 break;
477 495 case EXT_CC_GET_VPD_OS:
478 496 ql_read_vpd(ha, cmd, mode);
479 497 break;
480 498 case EXT_CC_SET_VPD_OS:
481 499 ql_write_vpd(ha, cmd, mode);
482 500 break;
483 501 case EXT_CC_GET_FCACHE_OS:
484 502 ql_get_fcache(ha, cmd, mode);
485 503 break;
486 504 case EXT_CC_GET_FCACHE_EX_OS:
487 505 ql_get_fcache_ex(ha, cmd, mode);
488 506 break;
489 507 case EXT_CC_GET_SFP_DATA_OS:
490 508 ql_get_sfp(ha, cmd, mode);
491 509 break;
492 510 case EXT_CC_PORT_PARAM_OS:
493 511 ql_port_param(ha, cmd, mode);
494 512 break;
495 513 case EXT_CC_GET_PCI_DATA_OS:
496 514 ql_get_pci_data(ha, cmd, mode);
497 515 break;
498 516 case EXT_CC_GET_FWEXTTRACE_OS:
499 517 ql_get_fwexttrace(ha, cmd, mode);
500 518 break;
501 519 case EXT_CC_GET_FWFCETRACE_OS:
502 520 ql_get_fwfcetrace(ha, cmd, mode);
503 521 break;
504 522 case EXT_CC_MENLO_RESET:
505 523 ql_menlo_reset(ha, cmd, mode);
506 524 break;
507 525 case EXT_CC_MENLO_GET_FW_VERSION:
508 526 ql_menlo_get_fw_version(ha, cmd, mode);
509 527 break;
510 528 case EXT_CC_MENLO_UPDATE_FW:
511 529 ql_menlo_update_fw(ha, cmd, mode);
512 530 break;
513 531 case EXT_CC_MENLO_MANAGE_INFO:
514 532 ql_menlo_manage_info(ha, cmd, mode);
515 533 break;
516 534 case EXT_CC_GET_VP_CNT_ID_OS:
517 535 ql_get_vp_cnt_id(ha, cmd, mode);
|
↓ open down ↓ |
95 lines elided |
↑ open up ↑ |
518 536 break;
519 537 case EXT_CC_VPORT_CMD_OS:
520 538 ql_vp_ioctl(ha, cmd, mode);
521 539 break;
522 540 case EXT_CC_ACCESS_FLASH_OS:
523 541 ql_access_flash(ha, cmd, mode);
524 542 break;
525 543 case EXT_CC_RESET_FW_OS:
526 544 ql_reset_cmd(ha, cmd);
527 545 break;
546 + case EXT_CC_I2C_DATA:
547 + ql_get_temperature(ha, cmd, mode);
548 + break;
549 + case EXT_CC_DUMP_OS:
550 + ql_dump_cmd(ha, cmd, mode);
551 + break;
552 + case EXT_CC_SERDES_REG_OP:
553 + ql_serdes_reg(ha, cmd, mode);
554 + break;
555 + case EXT_CC_SERDES_REG_OP_EX:
556 + ql_serdes_reg_ex(ha, cmd, mode);
557 + break;
558 + case EXT_CC_ELS_PASSTHRU_OS:
559 + ql_els_passthru(ha, cmd, mode);
560 + break;
561 + case EXT_CC_FLASH_UPDATE_CAPS_OS:
562 + ql_flash_update_caps(ha, cmd, mode);
563 + break;
564 + case EXT_CC_GET_BBCR_DATA_OS:
565 + ql_get_bbcr_data(ha, cmd, mode);
566 + break;
528 567 default:
529 568 /* function not supported. */
530 569 EL(ha, "failed, function not supported=%d\n", ioctl_code);
531 570
532 571 cmd->Status = EXT_STATUS_INVALID_REQUEST;
533 572 cmd->ResponseLen = 0;
534 573 break;
535 574 }
536 575
537 576 /* Return results to caller */
538 577 if (ql_sdm_return(ha, cmd, arg, mode) == -1) {
539 578 EL(ha, "failed, sdm_return\n");
540 579 return (EFAULT);
541 580 }
542 581
543 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
582 + QL_PRINT_9(ha, "done\n");
544 583
545 584 return (0);
546 585 }
547 586
548 587 /*
549 588 * ql_sdm_setup
550 589 * Make a local copy of the EXT_IOCTL struct and validate it.
551 590 *
552 591 * Input:
553 592 * ha: adapter state pointer.
554 593 * cmd_struct: Pointer to location to store local adrs of EXT_IOCTL.
555 594 * arg: Address of application EXT_IOCTL cmd data
556 595 * mode: flags
557 596 * val_sig: Pointer to a function to validate the ioctl signature.
558 597 *
559 598 * Returns:
560 599 * 0: success
561 600 * EFAULT: Copy in error of application EXT_IOCTL struct.
562 601 * EINVAL: Invalid version, signature.
563 602 * ENOMEM: Local allocation of EXT_IOCTL failed.
564 603 *
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
565 604 * Context:
566 605 * Kernel context.
567 606 */
568 607 static int
569 608 ql_sdm_setup(ql_adapter_state_t *ha, EXT_IOCTL **cmd_struct, void *arg,
570 609 int mode, boolean_t (*val_sig)(EXT_IOCTL *))
571 610 {
572 611 int rval;
573 612 EXT_IOCTL *cmd;
574 613
575 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
614 + QL_PRINT_9(ha, "started\n");
576 615
577 616 /* Allocate local memory for EXT_IOCTL. */
578 617 *cmd_struct = NULL;
579 618 cmd = (EXT_IOCTL *)kmem_zalloc(sizeof (EXT_IOCTL), KM_SLEEP);
580 619 if (cmd == NULL) {
581 620 EL(ha, "failed, kmem_zalloc\n");
582 621 return (ENOMEM);
583 622 }
584 623 /* Get argument structure. */
585 624 rval = ddi_copyin(arg, (void *)cmd, sizeof (EXT_IOCTL), mode);
586 625 if (rval != 0) {
587 626 EL(ha, "failed, ddi_copyin\n");
588 627 rval = EFAULT;
589 628 } else {
590 629 /*
591 630 * Check signature and the version.
592 631 * If either are not valid then neither is the
593 632 * structure so don't attempt to return any error status
594 633 * because we can't trust what caller's arg points to.
595 634 * Just return the errno.
596 635 */
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
597 636 if (val_sig(cmd) == 0) {
598 637 EL(ha, "failed, signature\n");
599 638 rval = EINVAL;
600 639 } else if (cmd->Version > EXT_VERSION) {
601 640 EL(ha, "failed, version\n");
602 641 rval = EINVAL;
603 642 }
604 643 }
605 644
606 645 if (rval == 0) {
607 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
646 + QL_PRINT_9(ha, "done\n");
608 647 *cmd_struct = cmd;
609 648 cmd->Status = EXT_STATUS_OK;
610 649 cmd->DetailStatus = 0;
611 650 } else {
612 651 kmem_free((void *)cmd, sizeof (EXT_IOCTL));
613 652 }
614 653
615 654 return (rval);
616 655 }
617 656
618 657 /*
619 658 * ql_validate_signature
620 659 * Validate the signature string for an external ioctl call.
621 660 *
622 661 * Input:
623 662 * sg: Pointer to EXT_IOCTL signature to validate.
624 663 *
625 664 * Returns:
626 665 * B_TRUE: Signature is valid.
627 666 * B_FALSE: Signature is NOT valid.
628 667 *
629 668 * Context:
630 669 * Kernel context.
631 670 */
632 671 static boolean_t
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
633 672 ql_validate_signature(EXT_IOCTL *cmd_struct)
634 673 {
635 674 /*
636 675 * Check signature.
637 676 *
638 677 * If signature is not valid then neither is the rest of
639 678 * the structure (e.g., can't trust it), so don't attempt
640 679 * to return any error status other than the errno.
641 680 */
642 681 if (bcmp(&cmd_struct->Signature, "QLOGIC", 6) != 0) {
643 - QL_PRINT_2(CE_CONT, "failed,\n");
682 + QL_PRINT_2(NULL, "failed,\n");
644 683 return (B_FALSE);
645 684 }
646 685
647 686 return (B_TRUE);
648 687 }
649 688
650 689 /*
651 690 * ql_sdm_return
652 691 * Copies return data/status to application land for
653 692 * ioctl call using the SAN/Device Management EXT_IOCTL call interface.
654 693 *
655 694 * Input:
656 695 * ha: adapter state pointer.
657 696 * cmd: Pointer to kernel copy of requestor's EXT_IOCTL struct.
658 697 * ioctl_code: ioctl function to perform
659 698 * arg: EXT_IOCTL cmd data in application land.
660 699 * mode: flags
661 700 *
662 701 * Returns:
663 702 * 0: success
664 703 * EFAULT: Copy out error.
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
665 704 *
666 705 * Context:
667 706 * Kernel context.
668 707 */
669 708 /* ARGSUSED */
670 709 static int
671 710 ql_sdm_return(ql_adapter_state_t *ha, EXT_IOCTL *cmd, void *arg, int mode)
672 711 {
673 712 int rval = 0;
674 713
675 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
714 + QL_PRINT_9(ha, "started\n");
676 715
677 716 rval |= ddi_copyout((void *)&cmd->ResponseLen,
678 717 (void *)&(((EXT_IOCTL*)arg)->ResponseLen), sizeof (uint32_t),
679 718 mode);
680 719
681 720 rval |= ddi_copyout((void *)&cmd->Status,
682 721 (void *)&(((EXT_IOCTL*)arg)->Status),
683 722 sizeof (cmd->Status), mode);
684 723 rval |= ddi_copyout((void *)&cmd->DetailStatus,
685 724 (void *)&(((EXT_IOCTL*)arg)->DetailStatus),
686 725 sizeof (cmd->DetailStatus), mode);
687 726
688 727 kmem_free((void *)cmd, sizeof (EXT_IOCTL));
689 728
690 729 if (rval != 0) {
691 730 /* Some copyout operation failed */
692 731 EL(ha, "failed, ddi_copyout\n");
693 732 return (EFAULT);
694 733 }
695 734
696 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
735 + QL_PRINT_9(ha, "done\n");
697 736
698 737 return (0);
699 738 }
700 739
701 740 /*
702 741 * ql_query
703 742 * Performs all EXT_CC_QUERY functions.
704 743 *
705 744 * Input:
706 745 * ha: adapter state pointer.
707 746 * cmd: Local EXT_IOCTL cmd struct pointer.
708 747 * mode: flags.
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
709 748 *
710 749 * Returns:
711 750 * None, request status indicated in cmd->Status.
712 751 *
713 752 * Context:
714 753 * Kernel context.
715 754 */
716 755 static void
717 756 ql_query(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
718 757 {
719 - QL_PRINT_9(CE_CONT, "(%d): started, cmd=%d\n", ha->instance,
758 + QL_PRINT_9(ha, "started, cmd=%d\n",
720 759 cmd->SubCode);
721 760
722 761 /* case off on command subcode */
723 762 switch (cmd->SubCode) {
724 763 case EXT_SC_QUERY_HBA_NODE:
725 764 ql_qry_hba_node(ha, cmd, mode);
726 765 break;
727 766 case EXT_SC_QUERY_HBA_PORT:
728 767 ql_qry_hba_port(ha, cmd, mode);
729 768 break;
730 769 case EXT_SC_QUERY_DISC_PORT:
731 770 ql_qry_disc_port(ha, cmd, mode);
732 771 break;
733 772 case EXT_SC_QUERY_DISC_TGT:
734 773 ql_qry_disc_tgt(ha, cmd, mode);
735 774 break;
736 775 case EXT_SC_QUERY_DRIVER:
737 776 ql_qry_driver(ha, cmd, mode);
738 777 break;
739 778 case EXT_SC_QUERY_FW:
740 779 ql_qry_fw(ha, cmd, mode);
741 780 break;
742 781 case EXT_SC_QUERY_CHIP:
743 782 ql_qry_chip(ha, cmd, mode);
744 783 break;
745 784 case EXT_SC_QUERY_CNA_PORT:
746 785 ql_qry_cna_port(ha, cmd, mode);
747 786 break;
748 787 case EXT_SC_QUERY_ADAPTER_VERSIONS:
749 788 ql_qry_adapter_versions(ha, cmd, mode);
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
750 789 break;
751 790 case EXT_SC_QUERY_DISC_LUN:
752 791 default:
753 792 /* function not supported. */
754 793 cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
755 794 EL(ha, "failed, Unsupported Subcode=%xh\n",
756 795 cmd->SubCode);
757 796 break;
758 797 }
759 798
760 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
799 + QL_PRINT_9(ha, "done\n");
761 800 }
762 801
763 802 /*
764 803 * ql_qry_hba_node
765 804 * Performs EXT_SC_QUERY_HBA_NODE subfunction.
766 805 *
767 806 * Input:
768 807 * ha: adapter state pointer.
769 808 * cmd: EXT_IOCTL cmd struct pointer.
770 809 * mode: flags.
771 810 *
772 811 * Returns:
773 812 * None, request status indicated in cmd->Status.
774 813 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
775 814 * Context:
776 815 * Kernel context.
777 816 */
778 817 static void
779 818 ql_qry_hba_node(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
780 819 {
781 820 EXT_HBA_NODE tmp_node = {0};
782 821 uint_t len;
783 822 caddr_t bufp;
784 823
785 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
824 + QL_PRINT_9(ha, "started\n");
786 825
787 826 if (cmd->ResponseLen < sizeof (EXT_HBA_NODE)) {
788 827 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
789 828 cmd->DetailStatus = sizeof (EXT_HBA_NODE);
790 829 EL(ha, "failed, ResponseLen < EXT_HBA_NODE, "
791 830 "Len=%xh\n", cmd->ResponseLen);
792 831 cmd->ResponseLen = 0;
793 832 return;
794 833 }
795 834
796 835 /* fill in the values */
797 836
798 837 bcopy(ha->loginparams.node_ww_name.raw_wwn, tmp_node.WWNN,
799 838 EXT_DEF_WWN_NAME_SIZE);
800 839
801 840 (void) sprintf((char *)(tmp_node.Manufacturer), "QLogic Corporation");
802 841
803 842 (void) sprintf((char *)(tmp_node.Model), "%x", ha->device_id);
804 843
805 844 bcopy(&tmp_node.WWNN[5], tmp_node.SerialNum, 3);
806 845
807 846 (void) sprintf((char *)(tmp_node.DriverVersion), QL_VERSION);
808 847
809 848 if (CFG_IST(ha, CFG_SBUS_CARD)) {
810 849 size_t verlen;
811 850 uint16_t w;
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
812 851 char *tmpptr;
813 852
814 853 verlen = strlen((char *)(tmp_node.DriverVersion));
815 854 if (verlen + 5 > EXT_DEF_MAX_STR_SIZE) {
816 855 EL(ha, "failed, No room for fpga version string\n");
817 856 } else {
818 857 w = (uint16_t)ddi_get16(ha->sbus_fpga_dev_handle,
819 858 (uint16_t *)
820 859 (ha->sbus_fpga_iobase + FPGA_REVISION));
821 860
822 - tmpptr = (char *)&(tmp_node.DriverVersion[verlen+1]);
861 + tmpptr = (char *)&(tmp_node.DriverVersion[verlen + 1]);
823 862 if (tmpptr == NULL) {
824 863 EL(ha, "Unable to insert fpga version str\n");
825 864 } else {
826 865 (void) sprintf(tmpptr, "%d.%d",
827 866 ((w & 0xf0) >> 4), (w & 0x0f));
828 867 tmp_node.DriverAttr |= EXT_CC_HBA_NODE_SBUS;
829 868 }
830 869 }
831 870 }
832 871
833 872 (void) sprintf((char *)(tmp_node.FWVersion), "%01d.%02d.%02d",
834 873 ha->fw_major_version, ha->fw_minor_version,
835 874 ha->fw_subminor_version);
836 875
837 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
876 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
838 877 switch (ha->fw_attributes) {
839 878 case FWATTRIB_EF:
840 879 (void) strcat((char *)(tmp_node.FWVersion), " EF");
841 880 break;
842 881 case FWATTRIB_TP:
843 882 (void) strcat((char *)(tmp_node.FWVersion), " TP");
844 883 break;
845 884 case FWATTRIB_IP:
846 885 (void) strcat((char *)(tmp_node.FWVersion), " IP");
847 886 break;
848 887 case FWATTRIB_IPX:
849 888 (void) strcat((char *)(tmp_node.FWVersion), " IPX");
850 889 break;
851 890 case FWATTRIB_FL:
852 891 (void) strcat((char *)(tmp_node.FWVersion), " FL");
853 892 break;
854 893 case FWATTRIB_FPX:
855 894 (void) strcat((char *)(tmp_node.FWVersion), " FLX");
856 895 break;
857 896 default:
858 897 break;
859 898 }
860 899 }
861 900
862 901 /* FCode version. */
863 902 /*LINTED [Solaris DDI_DEV_T_ANY Lint error]*/
864 903 if (ddi_getlongprop(DDI_DEV_T_ANY, ha->dip, PROP_LEN_AND_VAL_ALLOC |
865 904 DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "version", (caddr_t)&bufp,
866 905 (int *)&len) == DDI_PROP_SUCCESS) {
867 906 if (len < EXT_DEF_MAX_STR_SIZE) {
868 907 bcopy(bufp, tmp_node.OptRomVersion, len);
869 908 } else {
870 909 bcopy(bufp, tmp_node.OptRomVersion,
871 910 EXT_DEF_MAX_STR_SIZE - 1);
|
↓ open down ↓ |
24 lines elided |
↑ open up ↑ |
872 911 tmp_node.OptRomVersion[EXT_DEF_MAX_STR_SIZE - 1] =
873 912 '\0';
874 913 }
875 914 kmem_free(bufp, len);
876 915 } else {
877 916 (void) sprintf((char *)tmp_node.OptRomVersion, "0");
878 917 }
879 918 tmp_node.PortCount = 1;
880 919 tmp_node.InterfaceType = EXT_DEF_FC_INTF_TYPE;
881 920
921 + tmp_node.MpiVersion[0] = ha->mpi_fw_major_version;
922 + tmp_node.MpiVersion[1] = ha->mpi_fw_minor_version;
923 + tmp_node.MpiVersion[2] = ha->mpi_fw_subminor_version;
924 + tmp_node.PepFwVersion[0] = ha->phy_fw_major_version;
925 + tmp_node.PepFwVersion[1] = ha->phy_fw_minor_version;
926 + tmp_node.PepFwVersion[2] = ha->phy_fw_subminor_version;
882 927 if (ddi_copyout((void *)&tmp_node,
883 928 (void *)(uintptr_t)(cmd->ResponseAdr),
884 929 sizeof (EXT_HBA_NODE), mode) != 0) {
885 930 cmd->Status = EXT_STATUS_COPY_ERR;
886 931 cmd->ResponseLen = 0;
887 932 EL(ha, "failed, ddi_copyout\n");
888 933 } else {
889 934 cmd->ResponseLen = sizeof (EXT_HBA_NODE);
890 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
935 + QL_PRINT_9(ha, "done\n");
891 936 }
892 937 }
893 938
894 939 /*
895 940 * ql_qry_hba_port
896 941 * Performs EXT_SC_QUERY_HBA_PORT subfunction.
897 942 *
898 943 * Input:
899 944 * ha: adapter state pointer.
900 945 * cmd: EXT_IOCTL cmd struct pointer.
901 946 * mode: flags.
902 947 *
903 948 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
904 949 * None, request status indicated in cmd->Status.
905 950 *
906 951 * Context:
907 952 * Kernel context.
908 953 */
909 954 static void
910 955 ql_qry_hba_port(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
911 956 {
912 957 ql_link_t *link;
913 958 ql_tgt_t *tq;
914 - ql_mbx_data_t mr;
959 + ql_mbx_data_t mr = {0};
915 960 EXT_HBA_PORT tmp_port = {0};
916 961 int rval;
917 962 uint16_t port_cnt, tgt_cnt, index;
918 963
919 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
964 + QL_PRINT_9(ha, "started\n");
920 965
921 966 if (cmd->ResponseLen < sizeof (EXT_HBA_PORT)) {
922 967 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
923 968 cmd->DetailStatus = sizeof (EXT_HBA_PORT);
924 969 EL(ha, "failed, ResponseLen < EXT_HBA_NODE, Len=%xh\n",
925 970 cmd->ResponseLen);
926 971 cmd->ResponseLen = 0;
927 972 return;
928 973 }
929 974
930 975 /* fill in the values */
931 976
932 977 bcopy(ha->loginparams.nport_ww_name.raw_wwn, tmp_port.WWPN,
933 978 EXT_DEF_WWN_NAME_SIZE);
934 979 tmp_port.Id[0] = 0;
935 980 tmp_port.Id[1] = ha->d_id.b.domain;
936 981 tmp_port.Id[2] = ha->d_id.b.area;
937 982 tmp_port.Id[3] = ha->d_id.b.al_pa;
938 983
939 984 /* For now we are initiator only driver */
940 985 tmp_port.Type = EXT_DEF_INITIATOR_DEV;
941 986
942 987 if (ha->task_daemon_flags & LOOP_DOWN) {
943 988 tmp_port.State = EXT_DEF_HBA_LOOP_DOWN;
944 989 } else if (DRIVER_SUSPENDED(ha)) {
945 990 tmp_port.State = EXT_DEF_HBA_SUSPENDED;
946 991 } else {
947 992 tmp_port.State = EXT_DEF_HBA_OK;
948 993 }
949 994
950 995 if (ha->flags & POINT_TO_POINT) {
951 996 tmp_port.Mode = EXT_DEF_P2P_MODE;
952 997 } else {
953 998 tmp_port.Mode = EXT_DEF_LOOP_MODE;
954 999 }
955 1000 /*
956 1001 * fill in the portspeed values.
957 1002 *
958 1003 * default to not yet negotiated state
959 1004 */
960 1005 tmp_port.PortSpeed = EXT_PORTSPEED_NOT_NEGOTIATED;
961 1006
962 1007 if (tmp_port.State == EXT_DEF_HBA_OK) {
963 1008 switch (ha->iidma_rate) {
964 1009 case IIDMA_RATE_1GB:
965 1010 tmp_port.PortSpeed = EXT_DEF_PORTSPEED_1GBIT;
966 1011 break;
967 1012 case IIDMA_RATE_2GB:
968 1013 tmp_port.PortSpeed = EXT_DEF_PORTSPEED_2GBIT;
|
↓ open down ↓ |
39 lines elided |
↑ open up ↑ |
969 1014 break;
970 1015 case IIDMA_RATE_4GB:
971 1016 tmp_port.PortSpeed = EXT_DEF_PORTSPEED_4GBIT;
972 1017 break;
973 1018 case IIDMA_RATE_8GB:
974 1019 tmp_port.PortSpeed = EXT_DEF_PORTSPEED_8GBIT;
975 1020 break;
976 1021 case IIDMA_RATE_10GB:
977 1022 tmp_port.PortSpeed = EXT_DEF_PORTSPEED_10GBIT;
978 1023 break;
1024 + case IIDMA_RATE_16GB:
1025 + tmp_port.PortSpeed = EXT_DEF_PORTSPEED_16GBIT;
1026 + break;
1027 + case IIDMA_RATE_32GB:
1028 + tmp_port.PortSpeed = EXT_DEF_PORTSPEED_32GBIT;
1029 + break;
979 1030 default:
980 1031 tmp_port.PortSpeed = EXT_DEF_PORTSPEED_UNKNOWN;
981 1032 EL(ha, "failed, data rate=%xh\n", mr.mb[1]);
982 1033 break;
983 1034 }
984 1035 }
985 1036
986 1037 /* Report all supported port speeds */
987 1038 if (CFG_IST(ha, CFG_CTRL_25XX)) {
988 1039 tmp_port.PortSupportedSpeed = (EXT_DEF_PORTSPEED_8GBIT |
989 1040 EXT_DEF_PORTSPEED_4GBIT | EXT_DEF_PORTSPEED_2GBIT |
990 1041 EXT_DEF_PORTSPEED_1GBIT);
991 1042 /*
992 1043 * Correct supported speeds based on type of
993 1044 * sfp that is present
994 1045 */
995 1046 switch (ha->sfp_stat) {
996 1047 case 1:
997 1048 /* no sfp detected */
998 1049 break;
999 1050 case 2:
1000 1051 case 4:
1001 1052 /* 4GB sfp */
1002 1053 tmp_port.PortSupportedSpeed &=
1003 1054 ~EXT_DEF_PORTSPEED_8GBIT;
1004 1055 break;
1005 1056 case 3:
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
1006 1057 case 5:
1007 1058 /* 8GB sfp */
1008 1059 tmp_port.PortSupportedSpeed &=
1009 1060 ~EXT_DEF_PORTSPEED_1GBIT;
1010 1061 break;
1011 1062 default:
1012 1063 EL(ha, "sfp_stat: %xh\n", ha->sfp_stat);
1013 1064 break;
1014 1065
1015 1066 }
1016 - } else if (CFG_IST(ha, CFG_CTRL_8081)) {
1067 + } else if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
1017 1068 tmp_port.PortSupportedSpeed = EXT_DEF_PORTSPEED_10GBIT;
1018 - } else if (CFG_IST(ha, CFG_CTRL_2422)) {
1069 + } else if (CFG_IST(ha, CFG_CTRL_24XX)) {
1019 1070 tmp_port.PortSupportedSpeed = (EXT_DEF_PORTSPEED_4GBIT |
1020 1071 EXT_DEF_PORTSPEED_2GBIT | EXT_DEF_PORTSPEED_1GBIT);
1021 - } else if (CFG_IST(ha, CFG_CTRL_2300)) {
1072 + } else if (CFG_IST(ha, CFG_CTRL_23XX)) {
1022 1073 tmp_port.PortSupportedSpeed = (EXT_DEF_PORTSPEED_2GBIT |
1023 1074 EXT_DEF_PORTSPEED_1GBIT);
1024 - } else if (CFG_IST(ha, CFG_CTRL_6322)) {
1075 + } else if (CFG_IST(ha, CFG_CTRL_63XX)) {
1025 1076 tmp_port.PortSupportedSpeed = EXT_DEF_PORTSPEED_2GBIT;
1026 - } else if (CFG_IST(ha, CFG_CTRL_2200)) {
1077 + } else if (CFG_IST(ha, CFG_CTRL_22XX)) {
1027 1078 tmp_port.PortSupportedSpeed = EXT_DEF_PORTSPEED_1GBIT;
1079 + } else if (CFG_IST(ha, CFG_CTRL_83XX)) {
1080 + tmp_port.PortSupportedSpeed = EXT_DEF_PORTSPEED_4GBIT |
1081 + EXT_DEF_PORTSPEED_8GBIT | EXT_DEF_PORTSPEED_16GBIT;
1082 + } else if (CFG_IST(ha, CFG_CTRL_27XX)) {
1083 + tmp_port.PortSupportedSpeed = EXT_DEF_PORTSPEED_4GBIT |
1084 + EXT_DEF_PORTSPEED_8GBIT | EXT_DEF_PORTSPEED_16GBIT |
1085 + EXT_DEF_PORTSPEED_32GBIT;
1028 1086 } else {
1029 1087 tmp_port.PortSupportedSpeed = EXT_DEF_PORTSPEED_UNKNOWN;
1030 1088 EL(ha, "unknown HBA type: %xh\n", ha->device_id);
1031 1089 }
1090 +
1091 + if (ha->task_daemon_flags & LOOP_DOWN) {
1092 + (void) ql_get_firmware_state(ha, NULL);
1093 + }
1094 +
1095 + tmp_port.LinkState1 = ha->fw_state[1];
1032 1096 tmp_port.LinkState2 = LSB(ha->sfp_stat);
1097 + tmp_port.LinkState3 = ha->fw_state[3];
1098 + tmp_port.LinkState6 = ha->fw_state[6];
1099 +
1033 1100 port_cnt = 0;
1034 1101 tgt_cnt = 0;
1035 1102
1036 1103 for (index = 0; index < DEVICE_HEAD_LIST_SIZE; index++) {
1037 1104 for (link = ha->dev[index].first; link != NULL;
1038 1105 link = link->next) {
1039 1106 tq = link->base_address;
1040 1107
1041 - if (!VALID_TARGET_ID(ha, tq->loop_id)) {
1108 + if (!VALID_TARGET_ID(ha, tq->loop_id) ||
1109 + tq->d_id.b24 == FS_MANAGEMENT_SERVER) {
1042 1110 continue;
1043 1111 }
1044 1112
1113 + if (tq->flags & (TQF_RSCN_RCVD | TQF_IIDMA_NEEDED |
1114 + TQF_NEED_AUTHENTICATION | TQF_PLOGI_PROGRS)) {
1115 + continue;
1116 + }
1117 +
1045 1118 port_cnt++;
1046 1119 if ((tq->flags & TQF_INITIATOR_DEVICE) == 0) {
1047 1120 tgt_cnt++;
1048 1121 }
1049 1122 }
1050 1123 }
1051 1124
1052 1125 tmp_port.DiscPortCount = port_cnt;
1053 1126 tmp_port.DiscTargetCount = tgt_cnt;
1054 1127
1055 1128 tmp_port.DiscPortNameType = EXT_DEF_USE_NODE_NAME;
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
1056 1129
1057 1130 rval = ddi_copyout((void *)&tmp_port,
1058 1131 (void *)(uintptr_t)(cmd->ResponseAdr),
1059 1132 sizeof (EXT_HBA_PORT), mode);
1060 1133 if (rval != 0) {
1061 1134 cmd->Status = EXT_STATUS_COPY_ERR;
1062 1135 cmd->ResponseLen = 0;
1063 1136 EL(ha, "failed, ddi_copyout\n");
1064 1137 } else {
1065 1138 cmd->ResponseLen = sizeof (EXT_HBA_PORT);
1066 - QL_PRINT_9(CE_CONT, "(%d): done, ports=%d, targets=%d\n",
1139 + QL_PRINT_9(ha, "done, ports=%d, targets=%d\n",
1067 1140 ha->instance, port_cnt, tgt_cnt);
1068 1141 }
1069 1142 }
1070 1143
1071 1144 /*
1072 1145 * ql_qry_disc_port
1073 1146 * Performs EXT_SC_QUERY_DISC_PORT subfunction.
1074 1147 *
1075 1148 * Input:
1076 1149 * ha: adapter state pointer.
1077 1150 * cmd: EXT_IOCTL cmd struct pointer.
1078 1151 * mode: flags.
1079 1152 *
1080 1153 * cmd->Instance = Port instance in fcport chain.
1081 1154 *
1082 1155 * Returns:
1083 1156 * None, request status indicated in cmd->Status.
1084 1157 *
1085 1158 * Context:
1086 1159 * Kernel context.
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
1087 1160 */
1088 1161 static void
1089 1162 ql_qry_disc_port(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1090 1163 {
1091 1164 EXT_DISC_PORT tmp_port = {0};
1092 1165 ql_link_t *link;
1093 1166 ql_tgt_t *tq;
1094 1167 uint16_t index;
1095 1168 uint16_t inst = 0;
1096 1169
1097 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1170 + QL_PRINT_9(ha, "started\n");
1098 1171
1099 1172 if (cmd->ResponseLen < sizeof (EXT_DISC_PORT)) {
1100 1173 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
1101 1174 cmd->DetailStatus = sizeof (EXT_DISC_PORT);
1102 1175 EL(ha, "failed, ResponseLen < EXT_DISC_PORT, Len=%xh\n",
1103 1176 cmd->ResponseLen);
1104 1177 cmd->ResponseLen = 0;
1105 1178 return;
1106 1179 }
1107 1180
1108 1181 for (link = NULL, index = 0;
1109 1182 index < DEVICE_HEAD_LIST_SIZE && link == NULL; index++) {
1110 1183 for (link = ha->dev[index].first; link != NULL;
1111 1184 link = link->next) {
1112 1185 tq = link->base_address;
1113 1186
1114 - if (!VALID_TARGET_ID(ha, tq->loop_id)) {
1187 + if (!VALID_TARGET_ID(ha, tq->loop_id) ||
1188 + tq->d_id.b24 == FS_MANAGEMENT_SERVER) {
1115 1189 continue;
1116 1190 }
1191 +
1192 + if (tq->flags & (TQF_RSCN_RCVD | TQF_IIDMA_NEEDED |
1193 + TQF_NEED_AUTHENTICATION | TQF_PLOGI_PROGRS)) {
1194 + continue;
1195 + }
1196 +
1117 1197 if (inst != cmd->Instance) {
1118 1198 inst++;
1119 1199 continue;
1120 1200 }
1121 1201
1122 1202 /* fill in the values */
1123 1203 bcopy(tq->node_name, tmp_port.WWNN,
1124 1204 EXT_DEF_WWN_NAME_SIZE);
1125 1205 bcopy(tq->port_name, tmp_port.WWPN,
1126 1206 EXT_DEF_WWN_NAME_SIZE);
1127 1207
1128 1208 break;
1129 1209 }
1130 1210 }
1131 1211
1132 1212 if (link == NULL) {
1133 1213 /* no matching device */
1134 1214 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
1135 1215 EL(ha, "failed, port not found port=%d\n", cmd->Instance);
1136 1216 cmd->ResponseLen = 0;
1137 1217 return;
1138 1218 }
1139 1219
1140 1220 tmp_port.Id[0] = 0;
1141 1221 tmp_port.Id[1] = tq->d_id.b.domain;
1142 1222 tmp_port.Id[2] = tq->d_id.b.area;
1143 1223 tmp_port.Id[3] = tq->d_id.b.al_pa;
1144 1224
1145 1225 tmp_port.Type = 0;
1146 1226 if (tq->flags & TQF_INITIATOR_DEVICE) {
1147 1227 tmp_port.Type = (uint16_t)(tmp_port.Type |
1148 1228 EXT_DEF_INITIATOR_DEV);
1149 1229 } else if ((tq->flags & TQF_TAPE_DEVICE) == 0) {
1150 1230 (void) ql_inq_scan(ha, tq, 1);
1151 1231 } else if (tq->flags & TQF_TAPE_DEVICE) {
1152 1232 tmp_port.Type = (uint16_t)(tmp_port.Type | EXT_DEF_TAPE_DEV);
1153 1233 }
1154 1234
1155 1235 if (tq->flags & TQF_FABRIC_DEVICE) {
1156 1236 tmp_port.Type = (uint16_t)(tmp_port.Type | EXT_DEF_FABRIC_DEV);
1157 1237 } else {
1158 1238 tmp_port.Type = (uint16_t)(tmp_port.Type | EXT_DEF_TARGET_DEV);
1159 1239 }
1160 1240
1161 1241 tmp_port.Status = 0;
1162 1242 tmp_port.Bus = 0; /* Hard-coded for Solaris */
1163 1243
|
↓ open down ↓ |
37 lines elided |
↑ open up ↑ |
1164 1244 bcopy(tq->port_name, &tmp_port.TargetId, 8);
1165 1245
1166 1246 if (ddi_copyout((void *)&tmp_port,
1167 1247 (void *)(uintptr_t)(cmd->ResponseAdr),
1168 1248 sizeof (EXT_DISC_PORT), mode) != 0) {
1169 1249 cmd->Status = EXT_STATUS_COPY_ERR;
1170 1250 cmd->ResponseLen = 0;
1171 1251 EL(ha, "failed, ddi_copyout\n");
1172 1252 } else {
1173 1253 cmd->ResponseLen = sizeof (EXT_DISC_PORT);
1174 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1254 + QL_PRINT_9(ha, "done\n");
1175 1255 }
1176 1256 }
1177 1257
1178 1258 /*
1179 1259 * ql_qry_disc_tgt
1180 1260 * Performs EXT_SC_QUERY_DISC_TGT subfunction.
1181 1261 *
1182 1262 * Input:
1183 1263 * ha: adapter state pointer.
1184 1264 * cmd: EXT_IOCTL cmd struct pointer.
1185 1265 * mode: flags.
1186 1266 *
1187 1267 * cmd->Instance = Port instance in fcport chain.
1188 1268 *
1189 1269 * Returns:
1190 1270 * None, request status indicated in cmd->Status.
1191 1271 *
1192 1272 * Context:
1193 1273 * Kernel context.
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
1194 1274 */
1195 1275 static void
1196 1276 ql_qry_disc_tgt(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1197 1277 {
1198 1278 EXT_DISC_TARGET tmp_tgt = {0};
1199 1279 ql_link_t *link;
1200 1280 ql_tgt_t *tq;
1201 1281 uint16_t index;
1202 1282 uint16_t inst = 0;
1203 1283
1204 - QL_PRINT_9(CE_CONT, "(%d): started, target=%d\n", ha->instance,
1284 + QL_PRINT_9(ha, "started, target=%d\n",
1205 1285 cmd->Instance);
1206 1286
1207 1287 if (cmd->ResponseLen < sizeof (EXT_DISC_TARGET)) {
1208 1288 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
1209 1289 cmd->DetailStatus = sizeof (EXT_DISC_TARGET);
1210 1290 EL(ha, "failed, ResponseLen < EXT_DISC_TARGET, Len=%xh\n",
1211 1291 cmd->ResponseLen);
1212 1292 cmd->ResponseLen = 0;
1213 1293 return;
1214 1294 }
1215 1295
1216 1296 /* Scan port list for requested target and fill in the values */
1217 1297 for (link = NULL, index = 0;
1218 1298 index < DEVICE_HEAD_LIST_SIZE && link == NULL; index++) {
1219 1299 for (link = ha->dev[index].first; link != NULL;
1220 1300 link = link->next) {
1221 1301 tq = link->base_address;
1222 1302
1223 1303 if (!VALID_TARGET_ID(ha, tq->loop_id) ||
1224 - tq->flags & TQF_INITIATOR_DEVICE) {
1304 + tq->flags & TQF_INITIATOR_DEVICE ||
1305 + tq->d_id.b24 == FS_MANAGEMENT_SERVER) {
1225 1306 continue;
1226 1307 }
1227 1308 if (inst != cmd->Instance) {
1228 1309 inst++;
1229 1310 continue;
1230 1311 }
1231 1312
1232 1313 /* fill in the values */
1233 1314 bcopy(tq->node_name, tmp_tgt.WWNN,
1234 1315 EXT_DEF_WWN_NAME_SIZE);
1235 1316 bcopy(tq->port_name, tmp_tgt.WWPN,
1236 1317 EXT_DEF_WWN_NAME_SIZE);
1237 1318
1238 1319 break;
1239 1320 }
1240 1321 }
1241 1322
1242 1323 if (link == NULL) {
1243 1324 /* no matching device */
1244 1325 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
1245 1326 cmd->DetailStatus = EXT_DSTATUS_TARGET;
1246 1327 EL(ha, "failed, not found target=%d\n", cmd->Instance);
1247 1328 cmd->ResponseLen = 0;
1248 1329 return;
1249 1330 }
1250 1331 tmp_tgt.Id[0] = 0;
1251 1332 tmp_tgt.Id[1] = tq->d_id.b.domain;
1252 1333 tmp_tgt.Id[2] = tq->d_id.b.area;
1253 1334 tmp_tgt.Id[3] = tq->d_id.b.al_pa;
1254 1335
1255 1336 tmp_tgt.LunCount = (uint16_t)ql_lun_count(ha, tq);
1256 1337
1257 1338 if ((tq->flags & TQF_TAPE_DEVICE) == 0) {
1258 1339 (void) ql_inq_scan(ha, tq, 1);
1259 1340 }
1260 1341
1261 1342 tmp_tgt.Type = 0;
1262 1343 if (tq->flags & TQF_TAPE_DEVICE) {
1263 1344 tmp_tgt.Type = (uint16_t)(tmp_tgt.Type | EXT_DEF_TAPE_DEV);
1264 1345 }
1265 1346
1266 1347 if (tq->flags & TQF_FABRIC_DEVICE) {
1267 1348 tmp_tgt.Type = (uint16_t)(tmp_tgt.Type | EXT_DEF_FABRIC_DEV);
1268 1349 } else {
1269 1350 tmp_tgt.Type = (uint16_t)(tmp_tgt.Type | EXT_DEF_TARGET_DEV);
1270 1351 }
1271 1352
1272 1353 tmp_tgt.Status = 0;
1273 1354
1274 1355 tmp_tgt.Bus = 0; /* Hard-coded for Solaris. */
1275 1356
|
↓ open down ↓ |
41 lines elided |
↑ open up ↑ |
1276 1357 bcopy(tq->port_name, &tmp_tgt.TargetId, 8);
1277 1358
1278 1359 if (ddi_copyout((void *)&tmp_tgt,
1279 1360 (void *)(uintptr_t)(cmd->ResponseAdr),
1280 1361 sizeof (EXT_DISC_TARGET), mode) != 0) {
1281 1362 cmd->Status = EXT_STATUS_COPY_ERR;
1282 1363 cmd->ResponseLen = 0;
1283 1364 EL(ha, "failed, ddi_copyout\n");
1284 1365 } else {
1285 1366 cmd->ResponseLen = sizeof (EXT_DISC_TARGET);
1286 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1367 + QL_PRINT_9(ha, "done\n");
1287 1368 }
1288 1369 }
1289 1370
1290 1371 /*
1291 1372 * ql_qry_fw
1292 1373 * Performs EXT_SC_QUERY_FW subfunction.
1293 1374 *
1294 1375 * Input:
1295 1376 * ha: adapter state pointer.
1296 1377 * cmd: EXT_IOCTL cmd struct pointer.
1297 1378 * mode: flags.
1298 1379 *
1299 1380 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
1300 1381 * None, request status indicated in cmd->Status.
1301 1382 *
1302 1383 * Context:
1303 1384 * Kernel context.
1304 1385 */
1305 1386 static void
1306 1387 ql_qry_fw(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1307 1388 {
1308 1389 EXT_FW fw_info = {0};
1309 1390
1310 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1391 + QL_PRINT_9(ha, "started\n");
1311 1392
1312 1393 if (cmd->ResponseLen < sizeof (EXT_FW)) {
1313 1394 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
1314 1395 cmd->DetailStatus = sizeof (EXT_FW);
1315 1396 EL(ha, "failed, ResponseLen < EXT_FW, Len=%xh\n",
1316 1397 cmd->ResponseLen);
1317 1398 cmd->ResponseLen = 0;
1318 1399 return;
1319 1400 }
1320 1401
1321 1402 (void) sprintf((char *)(fw_info.Version), "%d.%02d.%02d",
1322 1403 ha->fw_major_version, ha->fw_minor_version,
1323 1404 ha->fw_subminor_version);
1324 1405
1325 1406 fw_info.Attrib = ha->fw_attributes;
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
1326 1407
1327 1408 if (ddi_copyout((void *)&fw_info,
1328 1409 (void *)(uintptr_t)(cmd->ResponseAdr),
1329 1410 sizeof (EXT_FW), mode) != 0) {
1330 1411 cmd->Status = EXT_STATUS_COPY_ERR;
1331 1412 cmd->ResponseLen = 0;
1332 1413 EL(ha, "failed, ddi_copyout\n");
1333 1414 return;
1334 1415 } else {
1335 1416 cmd->ResponseLen = sizeof (EXT_FW);
1336 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1417 + QL_PRINT_9(ha, "done\n");
1337 1418 }
1338 1419 }
1339 1420
1340 1421 /*
1341 1422 * ql_qry_chip
1342 1423 * Performs EXT_SC_QUERY_CHIP subfunction.
1343 1424 *
1344 1425 * Input:
1345 1426 * ha: adapter state pointer.
1346 1427 * cmd: EXT_IOCTL cmd struct pointer.
1347 1428 * mode: flags.
1348 1429 *
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
1349 1430 * Returns:
1350 1431 * None, request status indicated in cmd->Status.
1351 1432 *
1352 1433 * Context:
1353 1434 * Kernel context.
1354 1435 */
1355 1436 static void
1356 1437 ql_qry_chip(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1357 1438 {
1358 1439 EXT_CHIP chip = {0};
1440 + uint16_t PciDevNumber;
1359 1441
1360 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1442 + QL_PRINT_9(ha, "started\n");
1361 1443
1362 1444 if (cmd->ResponseLen < sizeof (EXT_CHIP)) {
1363 1445 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
1364 1446 cmd->DetailStatus = sizeof (EXT_CHIP);
1365 1447 EL(ha, "failed, ResponseLen < EXT_CHIP, Len=%xh\n",
1366 1448 cmd->ResponseLen);
1367 1449 cmd->ResponseLen = 0;
1368 1450 return;
1369 1451 }
1370 1452
1371 1453 chip.VendorId = ha->ven_id;
1372 1454 chip.DeviceId = ha->device_id;
1373 1455 chip.SubVendorId = ha->subven_id;
1374 1456 chip.SubSystemId = ha->subsys_id;
1375 1457 chip.IoAddr = ql_pci_config_get32(ha, PCI_CONF_BASE0);
1376 1458 chip.IoAddrLen = 0x100;
1377 1459 chip.MemAddr = ql_pci_config_get32(ha, PCI_CONF_BASE1);
1378 1460 chip.MemAddrLen = 0x100;
1379 1461 chip.ChipRevID = ha->rev_id;
1380 - if (ha->flags & FUNCTION_1) {
1381 - chip.FuncNo = 1;
1382 - }
1462 + chip.FuncNo = ha->pci_function_number;
1463 + chip.PciBusNumber = (uint16_t)
1464 + ((ha->pci_bus_addr & PCI_REG_BUS_M) >> PCI_REG_BUS_SHIFT);
1383 1465
1466 + PciDevNumber = (uint16_t)
1467 + ((ha->pci_bus_addr & PCI_REG_DEV_M) >> PCI_REG_DEV_SHIFT);
1468 + chip.PciSlotNumber = (uint16_t)(((PciDevNumber << 3) & 0xF8) |
1469 + (chip.FuncNo & 0x7));
1470 +
1384 1471 if (ddi_copyout((void *)&chip,
1385 1472 (void *)(uintptr_t)(cmd->ResponseAdr),
1386 1473 sizeof (EXT_CHIP), mode) != 0) {
1387 1474 cmd->Status = EXT_STATUS_COPY_ERR;
1388 1475 cmd->ResponseLen = 0;
1389 1476 EL(ha, "failed, ddi_copyout\n");
1390 1477 } else {
1391 1478 cmd->ResponseLen = sizeof (EXT_CHIP);
1392 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1479 + QL_PRINT_9(ha, "done\n");
1393 1480 }
1394 1481 }
1395 1482
1396 1483 /*
1397 1484 * ql_qry_driver
1398 1485 * Performs EXT_SC_QUERY_DRIVER subfunction.
1399 1486 *
1400 1487 * Input:
1401 1488 * ha: adapter state pointer.
1402 1489 * cmd: EXT_IOCTL cmd struct pointer.
1403 1490 * mode: flags.
1404 1491 *
1405 1492 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
1406 1493 * None, request status indicated in cmd->Status.
1407 1494 *
1408 1495 * Context:
1409 1496 * Kernel context.
1410 1497 */
1411 1498 static void
1412 1499 ql_qry_driver(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1413 1500 {
1414 1501 EXT_DRIVER qd = {0};
1415 1502
1416 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1503 + QL_PRINT_9(ha, "started\n");
1417 1504
1418 1505 if (cmd->ResponseLen < sizeof (EXT_DRIVER)) {
1419 1506 cmd->Status = EXT_STATUS_DATA_OVERRUN;
1420 1507 cmd->DetailStatus = sizeof (EXT_DRIVER);
1421 1508 EL(ha, "failed, ResponseLen < EXT_DRIVER, Len=%xh\n",
1422 1509 cmd->ResponseLen);
1423 1510 cmd->ResponseLen = 0;
1424 1511 return;
1425 1512 }
1426 1513
1427 1514 (void) strcpy((void *)&qd.Version[0], QL_VERSION);
1428 1515 qd.NumOfBus = 1; /* Fixed for Solaris */
1429 1516 qd.TargetsPerBus = (uint16_t)
1430 - (CFG_IST(ha, (CFG_CTRL_24258081 | CFG_EXT_FW_INTERFACE)) ?
1517 + (CFG_IST(ha, (CFG_ISP_FW_TYPE_2 | CFG_EXT_FW_INTERFACE)) ?
1431 1518 MAX_24_FIBRE_DEVICES : MAX_22_FIBRE_DEVICES);
1432 1519 qd.LunsPerTarget = 2030;
1433 1520 qd.MaxTransferLen = QL_DMA_MAX_XFER_SIZE;
1434 1521 qd.MaxDataSegments = QL_DMA_SG_LIST_LENGTH;
1435 1522
1436 1523 if (ddi_copyout((void *)&qd, (void *)(uintptr_t)cmd->ResponseAdr,
1437 1524 sizeof (EXT_DRIVER), mode) != 0) {
1438 1525 cmd->Status = EXT_STATUS_COPY_ERR;
1439 1526 cmd->ResponseLen = 0;
1440 1527 EL(ha, "failed, ddi_copyout\n");
1441 1528 } else {
1442 1529 cmd->ResponseLen = sizeof (EXT_DRIVER);
1443 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1530 + QL_PRINT_9(ha, "done\n");
1444 1531 }
1445 1532 }
1446 1533
1447 1534 /*
1448 1535 * ql_fcct
1449 1536 * IOCTL management server FC-CT passthrough.
1450 1537 *
1451 1538 * Input:
1452 1539 * ha: adapter state pointer.
1453 1540 * cmd: User space CT arguments pointer.
1454 1541 * mode: flags.
1455 1542 *
1456 1543 * Returns:
1457 1544 * None, request status indicated in cmd->Status.
1458 1545 *
1459 1546 * Context:
1460 1547 * Kernel context.
1461 1548 */
1462 1549 static void
1463 1550 ql_fcct(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1464 1551 {
1465 1552 ql_mbx_iocb_t *pkt;
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
1466 1553 ql_mbx_data_t mr;
1467 1554 dma_mem_t *dma_mem;
1468 1555 caddr_t pld;
1469 1556 uint32_t pkt_size, pld_byte_cnt, *long_ptr;
1470 1557 int rval;
1471 1558 ql_ct_iu_preamble_t *ct;
1472 1559 ql_xioctl_t *xp = ha->xioctl;
1473 1560 ql_tgt_t tq;
1474 1561 uint16_t comp_status, loop_id;
1475 1562
1476 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1563 + QL_PRINT_9(ha, "started\n");
1477 1564
1478 1565 /* Get CT argument structure. */
1479 - if ((ha->topology & QL_SNS_CONNECTION) == 0) {
1566 + if ((ha->topology & QL_FABRIC_CONNECTION) == 0) {
1480 1567 EL(ha, "failed, No switch\n");
1481 1568 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
1482 1569 cmd->ResponseLen = 0;
1483 1570 return;
1484 1571 }
1485 1572
1486 1573 if (DRIVER_SUSPENDED(ha)) {
1487 1574 EL(ha, "failed, LOOP_NOT_READY\n");
1488 1575 cmd->Status = EXT_STATUS_BUSY;
1489 1576 cmd->ResponseLen = 0;
1490 1577 return;
1491 1578 }
1492 1579
1493 1580 /* Login management server device. */
1494 1581 if ((xp->flags & QL_MGMT_SERVER_LOGIN) == 0) {
1495 1582 tq.d_id.b.al_pa = 0xfa;
1496 1583 tq.d_id.b.area = 0xff;
1497 1584 tq.d_id.b.domain = 0xff;
1498 - tq.loop_id = (uint16_t)(CFG_IST(ha, CFG_CTRL_24258081) ?
1585 + tq.loop_id = (uint16_t)(CFG_IST(ha, CFG_ISP_FW_TYPE_2) ?
1499 1586 MANAGEMENT_SERVER_24XX_LOOP_ID :
1500 1587 MANAGEMENT_SERVER_LOOP_ID);
1501 1588 rval = ql_login_fport(ha, &tq, tq.loop_id, LFF_NO_PRLI, &mr);
1502 1589 if (rval != QL_SUCCESS) {
1503 1590 EL(ha, "failed, server login\n");
1504 1591 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
1505 1592 cmd->ResponseLen = 0;
1506 1593 return;
1507 1594 } else {
1508 1595 xp->flags |= QL_MGMT_SERVER_LOGIN;
1509 1596 }
1510 1597 }
1511 1598
1512 - QL_PRINT_9(CE_CONT, "(%d): cmd\n", ha->instance);
1599 + QL_PRINT_9(ha, "cmd\n");
1513 1600 QL_DUMP_9(cmd, 8, sizeof (EXT_IOCTL));
1514 1601
1515 1602 /* Allocate a DMA Memory Descriptor */
1516 1603 dma_mem = (dma_mem_t *)kmem_zalloc(sizeof (dma_mem_t), KM_SLEEP);
1517 1604 if (dma_mem == NULL) {
1518 1605 EL(ha, "failed, kmem_zalloc\n");
1519 1606 cmd->Status = EXT_STATUS_NO_MEMORY;
1520 1607 cmd->ResponseLen = 0;
1521 1608 return;
1522 1609 }
1523 1610 /* Determine maximum buffer size. */
1524 1611 if (cmd->RequestLen < cmd->ResponseLen) {
1525 1612 pld_byte_cnt = cmd->ResponseLen;
1526 1613 } else {
1527 1614 pld_byte_cnt = cmd->RequestLen;
1528 1615 }
1529 1616
1530 1617 /* Allocate command block. */
1531 1618 pkt_size = (uint32_t)(sizeof (ql_mbx_iocb_t) + pld_byte_cnt);
1532 1619 pkt = kmem_zalloc(pkt_size, KM_SLEEP);
1533 1620 if (pkt == NULL) {
1534 1621 EL(ha, "failed, kmem_zalloc\n");
1535 1622 cmd->Status = EXT_STATUS_NO_MEMORY;
1536 1623 cmd->ResponseLen = 0;
1537 1624 return;
1538 1625 }
1539 1626 pld = (caddr_t)pkt + sizeof (ql_mbx_iocb_t);
1540 1627
1541 1628 /* Get command payload data. */
1542 1629 if (ql_get_buffer_data((caddr_t)(uintptr_t)cmd->RequestAdr, pld,
1543 1630 cmd->RequestLen, mode) != cmd->RequestLen) {
|
↓ open down ↓ |
21 lines elided |
↑ open up ↑ |
1544 1631 EL(ha, "failed, get_buffer_data\n");
1545 1632 kmem_free(pkt, pkt_size);
1546 1633 cmd->Status = EXT_STATUS_COPY_ERR;
1547 1634 cmd->ResponseLen = 0;
1548 1635 return;
1549 1636 }
1550 1637
1551 1638 /* Get DMA memory for the IOCB */
1552 1639 if (ql_get_dma_mem(ha, dma_mem, pkt_size, LITTLE_ENDIAN_DMA,
1553 1640 QL_DMA_RING_ALIGN) != QL_SUCCESS) {
1554 - cmn_err(CE_WARN, "%s(%d): DMA memory "
1555 - "alloc failed", QL_NAME, ha->instance);
1641 + cmn_err(CE_WARN, "%sDMA memory "
1642 + "alloc failed", QL_NAME);
1556 1643 kmem_free(pkt, pkt_size);
1557 1644 kmem_free(dma_mem, sizeof (dma_mem_t));
1558 1645 cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
1559 1646 cmd->ResponseLen = 0;
1560 1647 return;
1561 1648 }
1562 1649
1563 1650 /* Copy out going payload data to IOCB DMA buffer. */
1564 1651 ddi_rep_put8(dma_mem->acc_handle, (uint8_t *)pld,
1565 1652 (uint8_t *)dma_mem->bp, pld_byte_cnt, DDI_DEV_AUTOINCR);
1566 1653
1567 1654 /* Sync IOCB DMA buffer. */
1568 1655 (void) ddi_dma_sync(dma_mem->dma_handle, 0, pld_byte_cnt,
1569 1656 DDI_DMA_SYNC_FORDEV);
1570 1657
1571 1658 /*
1572 1659 * Setup IOCB
1573 1660 */
1574 1661 ct = (ql_ct_iu_preamble_t *)pld;
1575 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
1662 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
1576 1663 pkt->ms24.entry_type = CT_PASSTHRU_TYPE;
1577 1664 pkt->ms24.entry_count = 1;
1578 1665
1579 1666 pkt->ms24.vp_index = ha->vp_index;
1580 1667
1581 1668 /* Set loop ID */
1582 1669 pkt->ms24.n_port_hdl = (uint16_t)
1583 1670 (ct->gs_type == GS_TYPE_DIR_SERVER ?
1584 1671 LE_16(SNS_24XX_HDL) :
1585 1672 LE_16(MANAGEMENT_SERVER_24XX_LOOP_ID));
1586 1673
1587 1674 /* Set ISP command timeout. */
1588 1675 pkt->ms24.timeout = LE_16(120);
1589 1676
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
1590 1677 /* Set cmd/response data segment counts. */
1591 1678 pkt->ms24.cmd_dseg_count = LE_16(1);
1592 1679 pkt->ms24.resp_dseg_count = LE_16(1);
1593 1680
1594 1681 /* Load ct cmd byte count. */
1595 1682 pkt->ms24.cmd_byte_count = LE_32(cmd->RequestLen);
1596 1683
1597 1684 /* Load ct rsp byte count. */
1598 1685 pkt->ms24.resp_byte_count = LE_32(cmd->ResponseLen);
1599 1686
1600 - long_ptr = (uint32_t *)&pkt->ms24.dseg_0_address;
1687 + long_ptr = (uint32_t *)&pkt->ms24.dseg;
1601 1688
1602 1689 /* Load MS command entry data segments. */
1603 1690 *long_ptr++ = (uint32_t)
1604 1691 LE_32(LSD(dma_mem->cookie.dmac_laddress));
1605 1692 *long_ptr++ = (uint32_t)
1606 1693 LE_32(MSD(dma_mem->cookie.dmac_laddress));
1607 1694 *long_ptr++ = (uint32_t)(LE_32(cmd->RequestLen));
1608 1695
1609 1696 /* Load MS response entry data segments. */
1610 1697 *long_ptr++ = (uint32_t)
1611 1698 LE_32(LSD(dma_mem->cookie.dmac_laddress));
1612 1699 *long_ptr++ = (uint32_t)
1613 1700 LE_32(MSD(dma_mem->cookie.dmac_laddress));
1614 1701 *long_ptr = (uint32_t)LE_32(cmd->ResponseLen);
1615 1702
1616 1703 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt,
1617 1704 sizeof (ql_mbx_iocb_t));
1618 1705
1619 1706 comp_status = (uint16_t)LE_16(pkt->sts24.comp_status);
1620 1707 if (comp_status == CS_DATA_UNDERRUN) {
1621 1708 if ((BE_16(ct->max_residual_size)) == 0) {
1622 1709 comp_status = CS_COMPLETE;
1623 1710 }
1624 1711 }
1625 1712
1626 1713 if (rval != QL_SUCCESS || (pkt->sts24.entry_status & 0x3c) !=
1627 1714 0) {
1628 1715 EL(ha, "failed, I/O timeout or "
1629 1716 "es=%xh, ss_l=%xh, rval=%xh\n",
1630 1717 pkt->sts24.entry_status,
1631 1718 pkt->sts24.scsi_status_l, rval);
1632 1719 kmem_free(pkt, pkt_size);
1633 1720 ql_free_dma_resource(ha, dma_mem);
1634 1721 kmem_free(dma_mem, sizeof (dma_mem_t));
1635 1722 cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
1636 1723 cmd->ResponseLen = 0;
1637 1724 return;
1638 1725 }
1639 1726 } else {
1640 1727 pkt->ms.entry_type = MS_TYPE;
1641 1728 pkt->ms.entry_count = 1;
1642 1729
1643 1730 /* Set loop ID */
1644 1731 loop_id = (uint16_t)(ct->gs_type == GS_TYPE_DIR_SERVER ?
1645 1732 SIMPLE_NAME_SERVER_LOOP_ID : MANAGEMENT_SERVER_LOOP_ID);
1646 1733 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
1647 1734 pkt->ms.loop_id_l = LSB(loop_id);
1648 1735 pkt->ms.loop_id_h = MSB(loop_id);
1649 1736 } else {
1650 1737 pkt->ms.loop_id_h = LSB(loop_id);
1651 1738 }
|
↓ open down ↓ |
41 lines elided |
↑ open up ↑ |
1652 1739
1653 1740 /* Set ISP command timeout. */
1654 1741 pkt->ms.timeout = LE_16(120);
1655 1742
1656 1743 /* Set data segment counts. */
1657 1744 pkt->ms.cmd_dseg_count_l = 1;
1658 1745 pkt->ms.total_dseg_count = LE_16(2);
1659 1746
1660 1747 /* Response total byte count. */
1661 1748 pkt->ms.resp_byte_count = LE_32(cmd->ResponseLen);
1662 - pkt->ms.dseg_1_length = LE_32(cmd->ResponseLen);
1749 + pkt->ms.dseg[1].length = LE_32(cmd->ResponseLen);
1663 1750
1664 1751 /* Command total byte count. */
1665 1752 pkt->ms.cmd_byte_count = LE_32(cmd->RequestLen);
1666 - pkt->ms.dseg_0_length = LE_32(cmd->RequestLen);
1753 + pkt->ms.dseg[0].length = LE_32(cmd->RequestLen);
1667 1754
1668 1755 /* Load command/response data segments. */
1669 - pkt->ms.dseg_0_address[0] = (uint32_t)
1756 + pkt->ms.dseg[0].address[0] = (uint32_t)
1670 1757 LE_32(LSD(dma_mem->cookie.dmac_laddress));
1671 - pkt->ms.dseg_0_address[1] = (uint32_t)
1758 + pkt->ms.dseg[0].address[1] = (uint32_t)
1672 1759 LE_32(MSD(dma_mem->cookie.dmac_laddress));
1673 - pkt->ms.dseg_1_address[0] = (uint32_t)
1760 + pkt->ms.dseg[1].address[0] = (uint32_t)
1674 1761 LE_32(LSD(dma_mem->cookie.dmac_laddress));
1675 - pkt->ms.dseg_1_address[1] = (uint32_t)
1762 + pkt->ms.dseg[1].address[1] = (uint32_t)
1676 1763 LE_32(MSD(dma_mem->cookie.dmac_laddress));
1677 1764
1678 1765 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt,
1679 1766 sizeof (ql_mbx_iocb_t));
1680 1767
1681 1768 comp_status = (uint16_t)LE_16(pkt->sts.comp_status);
1682 1769 if (comp_status == CS_DATA_UNDERRUN) {
1683 1770 if ((BE_16(ct->max_residual_size)) == 0) {
1684 1771 comp_status = CS_COMPLETE;
1685 1772 }
1686 1773 }
1687 1774 if (rval != QL_SUCCESS || (pkt->sts.entry_status & 0x7e) != 0) {
1688 1775 EL(ha, "failed, I/O timeout or "
1689 1776 "es=%xh, rval=%xh\n", pkt->sts.entry_status, rval);
1690 1777 kmem_free(pkt, pkt_size);
1691 1778 ql_free_dma_resource(ha, dma_mem);
1692 1779 kmem_free(dma_mem, sizeof (dma_mem_t));
1693 1780 cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
1694 1781 cmd->ResponseLen = 0;
1695 1782 return;
1696 1783 }
1697 1784 }
1698 1785
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
1699 1786 /* Sync in coming DMA buffer. */
1700 1787 (void) ddi_dma_sync(dma_mem->dma_handle, 0,
1701 1788 pld_byte_cnt, DDI_DMA_SYNC_FORKERNEL);
1702 1789 /* Copy in coming DMA data. */
1703 1790 ddi_rep_get8(dma_mem->acc_handle, (uint8_t *)pld,
1704 1791 (uint8_t *)dma_mem->bp, pld_byte_cnt,
1705 1792 DDI_DEV_AUTOINCR);
1706 1793
1707 1794 /* Copy response payload from DMA buffer to application. */
1708 1795 if (cmd->ResponseLen != 0) {
1709 - QL_PRINT_9(CE_CONT, "(%d): ResponseLen=%d\n", ha->instance,
1796 + QL_PRINT_9(ha, "ResponseLen=%d\n",
1710 1797 cmd->ResponseLen);
1711 1798 QL_DUMP_9(pld, 8, cmd->ResponseLen);
1712 1799
1713 1800 /* Send response payload. */
1714 1801 if (ql_send_buffer_data(pld,
1715 1802 (caddr_t)(uintptr_t)cmd->ResponseAdr,
1716 1803 cmd->ResponseLen, mode) != cmd->ResponseLen) {
1717 1804 EL(ha, "failed, send_buffer_data\n");
1718 1805 cmd->Status = EXT_STATUS_COPY_ERR;
1719 1806 cmd->ResponseLen = 0;
1720 1807 }
1721 1808 }
1722 1809
1723 1810 kmem_free(pkt, pkt_size);
1724 1811 ql_free_dma_resource(ha, dma_mem);
1725 1812 kmem_free(dma_mem, sizeof (dma_mem_t));
1726 1813
1727 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1814 + QL_PRINT_9(ha, "done\n");
1728 1815 }
1729 1816
1730 1817 /*
1731 1818 * ql_aen_reg
1732 1819 * IOCTL management server Asynchronous Event Tracking Enable/Disable.
1733 1820 *
1734 1821 * Input:
1735 1822 * ha: adapter state pointer.
1736 1823 * cmd: EXT_IOCTL cmd struct pointer.
1737 1824 * mode: flags.
1738 1825 *
1739 1826 * Returns:
1740 1827 * None, request status indicated in cmd->Status.
1741 1828 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
1742 1829 * Context:
1743 1830 * Kernel context.
1744 1831 */
1745 1832 static void
1746 1833 ql_aen_reg(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1747 1834 {
1748 1835 EXT_REG_AEN reg_struct;
1749 1836 int rval = 0;
1750 1837 ql_xioctl_t *xp = ha->xioctl;
1751 1838
1752 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1839 + QL_PRINT_9(ha, "started\n");
1753 1840
1754 1841 rval = ddi_copyin((void*)(uintptr_t)cmd->RequestAdr, ®_struct,
1755 1842 cmd->RequestLen, mode);
1756 1843
1757 1844 if (rval == 0) {
1758 1845 if (reg_struct.Enable) {
1759 1846 xp->flags |= QL_AEN_TRACKING_ENABLE;
1760 1847 } else {
1761 1848 xp->flags &= ~QL_AEN_TRACKING_ENABLE;
1762 1849 /* Empty the queue. */
1763 1850 INTR_LOCK(ha);
1764 1851 xp->aen_q_head = 0;
1765 1852 xp->aen_q_tail = 0;
1766 1853 INTR_UNLOCK(ha);
1767 1854 }
1768 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1855 + QL_PRINT_9(ha, "done\n");
1769 1856 } else {
1770 1857 cmd->Status = EXT_STATUS_COPY_ERR;
1771 1858 EL(ha, "failed, ddi_copyin\n");
1772 1859 }
1773 1860 }
1774 1861
1775 1862 /*
1776 1863 * ql_aen_get
1777 1864 * IOCTL management server Asynchronous Event Record Transfer.
1778 1865 *
1779 1866 * Input:
1780 1867 * ha: adapter state pointer.
1781 1868 * cmd: EXT_IOCTL cmd struct pointer.
1782 1869 * mode: flags.
1783 1870 *
1784 1871 * Returns:
1785 1872 * None, request status indicated in cmd->Status.
1786 1873 *
1787 1874 * Context:
1788 1875 * Kernel context.
1789 1876 */
1790 1877 static void
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
1791 1878 ql_aen_get(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1792 1879 {
1793 1880 uint32_t out_size;
1794 1881 EXT_ASYNC_EVENT *tmp_q;
1795 1882 EXT_ASYNC_EVENT aen[EXT_DEF_MAX_AEN_QUEUE];
1796 1883 uint8_t i;
1797 1884 uint8_t queue_cnt;
1798 1885 uint8_t request_cnt;
1799 1886 ql_xioctl_t *xp = ha->xioctl;
1800 1887
1801 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1888 + QL_PRINT_9(ha, "started\n");
1802 1889
1803 1890 /* Compute the number of events that can be returned */
1804 1891 request_cnt = (uint8_t)(cmd->ResponseLen / sizeof (EXT_ASYNC_EVENT));
1805 1892
1806 1893 if (request_cnt < EXT_DEF_MAX_AEN_QUEUE) {
1807 1894 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
1808 1895 cmd->DetailStatus = EXT_DEF_MAX_AEN_QUEUE;
1809 1896 EL(ha, "failed, request_cnt < EXT_DEF_MAX_AEN_QUEUE, "
1810 1897 "Len=%xh\n", request_cnt);
1811 1898 cmd->ResponseLen = 0;
1812 1899 return;
1813 1900 }
1814 1901
1815 1902 /* 1st: Make a local copy of the entire queue content. */
1816 1903 tmp_q = (EXT_ASYNC_EVENT *)xp->aen_tracking_queue;
1817 1904 queue_cnt = 0;
1818 1905
1819 1906 INTR_LOCK(ha);
1820 1907 i = xp->aen_q_head;
1821 1908
1822 1909 for (; queue_cnt < EXT_DEF_MAX_AEN_QUEUE; ) {
1823 1910 if (tmp_q[i].AsyncEventCode != 0) {
1824 1911 bcopy(&tmp_q[i], &aen[queue_cnt],
1825 1912 sizeof (EXT_ASYNC_EVENT));
1826 1913 queue_cnt++;
1827 1914 tmp_q[i].AsyncEventCode = 0; /* empty out the slot */
1828 1915 }
1829 1916 if (i == xp->aen_q_tail) {
1830 1917 /* done. */
1831 1918 break;
1832 1919 }
1833 1920 i++;
1834 1921 if (i == EXT_DEF_MAX_AEN_QUEUE) {
1835 1922 i = 0;
1836 1923 }
1837 1924 }
1838 1925
1839 1926 /* Empty the queue. */
1840 1927 xp->aen_q_head = 0;
1841 1928 xp->aen_q_tail = 0;
1842 1929
1843 1930 INTR_UNLOCK(ha);
1844 1931
1845 1932 /* 2nd: Now transfer the queue content to user buffer */
1846 1933 /* Copy the entire queue to user's buffer. */
1847 1934 out_size = (uint32_t)(queue_cnt * sizeof (EXT_ASYNC_EVENT));
|
↓ open down ↓ |
36 lines elided |
↑ open up ↑ |
1848 1935 if (queue_cnt == 0) {
1849 1936 cmd->ResponseLen = 0;
1850 1937 } else if (ddi_copyout((void *)&aen[0],
1851 1938 (void *)(uintptr_t)(cmd->ResponseAdr),
1852 1939 out_size, mode) != 0) {
1853 1940 cmd->Status = EXT_STATUS_COPY_ERR;
1854 1941 cmd->ResponseLen = 0;
1855 1942 EL(ha, "failed, ddi_copyout\n");
1856 1943 } else {
1857 1944 cmd->ResponseLen = out_size;
1858 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
1945 + QL_PRINT_9(ha, "done\n");
1859 1946 }
1860 1947 }
1861 1948
1862 1949 /*
1863 1950 * ql_enqueue_aen
1864 1951 *
1865 1952 * Input:
1866 1953 * ha: adapter state pointer.
1867 1954 * event_code: async event code of the event to add to queue.
1868 1955 * payload: event payload for the queue.
1869 1956 * INTR_LOCK must be already obtained.
1870 1957 *
1871 1958 * Context:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
1872 1959 * Interrupt or Kernel context, no mailbox commands allowed.
1873 1960 */
1874 1961 void
1875 1962 ql_enqueue_aen(ql_adapter_state_t *ha, uint16_t event_code, void *payload)
1876 1963 {
1877 1964 uint8_t new_entry; /* index to current entry */
1878 1965 uint16_t *mbx;
1879 1966 EXT_ASYNC_EVENT *aen_queue;
1880 1967 ql_xioctl_t *xp = ha->xioctl;
1881 1968
1882 - QL_PRINT_9(CE_CONT, "(%d): started, event_code=%d\n", ha->instance,
1969 + QL_PRINT_9(ha, "started, event_code=%d\n",
1883 1970 event_code);
1884 1971
1885 1972 if (xp == NULL) {
1886 - QL_PRINT_9(CE_CONT, "(%d): no context\n", ha->instance);
1973 + QL_PRINT_9(ha, "no context\n");
1887 1974 return;
1888 1975 }
1889 1976 aen_queue = (EXT_ASYNC_EVENT *)xp->aen_tracking_queue;
1890 1977
1891 1978 if (aen_queue[xp->aen_q_tail].AsyncEventCode != NULL) {
1892 1979 /* Need to change queue pointers to make room. */
1893 1980
1894 1981 /* Increment tail for adding new entry. */
1895 1982 xp->aen_q_tail++;
1896 1983 if (xp->aen_q_tail == EXT_DEF_MAX_AEN_QUEUE) {
1897 1984 xp->aen_q_tail = 0;
1898 1985 }
1899 1986 if (xp->aen_q_head == xp->aen_q_tail) {
1900 1987 /*
1901 1988 * We're overwriting the oldest entry, so need to
1902 1989 * update the head pointer.
1903 1990 */
1904 1991 xp->aen_q_head++;
1905 1992 if (xp->aen_q_head == EXT_DEF_MAX_AEN_QUEUE) {
1906 1993 xp->aen_q_head = 0;
1907 1994 }
1908 1995 }
1909 1996 }
1910 1997
1911 1998 new_entry = xp->aen_q_tail;
1912 1999 aen_queue[new_entry].AsyncEventCode = event_code;
1913 2000
1914 2001 /* Update payload */
1915 2002 if (payload != NULL) {
1916 2003 switch (event_code) {
1917 2004 case MBA_LIP_OCCURRED:
1918 2005 case MBA_LOOP_UP:
1919 2006 case MBA_LOOP_DOWN:
1920 2007 case MBA_LIP_F8:
1921 2008 case MBA_LIP_RESET:
1922 2009 case MBA_PORT_UPDATE:
1923 2010 break;
1924 2011 case MBA_RSCN_UPDATE:
1925 2012 mbx = (uint16_t *)payload;
1926 2013 /* al_pa */
1927 2014 aen_queue[new_entry].Payload.RSCN.RSCNInfo[0] =
1928 2015 LSB(mbx[2]);
1929 2016 /* area */
1930 2017 aen_queue[new_entry].Payload.RSCN.RSCNInfo[1] =
1931 2018 MSB(mbx[2]);
1932 2019 /* domain */
1933 2020 aen_queue[new_entry].Payload.RSCN.RSCNInfo[2] =
1934 2021 LSB(mbx[1]);
1935 2022 /* save in big endian */
1936 2023 BIG_ENDIAN_24(&aen_queue[new_entry].
1937 2024 Payload.RSCN.RSCNInfo[0]);
1938 2025
1939 2026 aen_queue[new_entry].Payload.RSCN.AddrFormat =
1940 2027 MSB(mbx[1]);
1941 2028
|
↓ open down ↓ |
45 lines elided |
↑ open up ↑ |
1942 2029 break;
1943 2030 default:
1944 2031 /* Not supported */
1945 2032 EL(ha, "failed, event code not supported=%xh\n",
1946 2033 event_code);
1947 2034 aen_queue[new_entry].AsyncEventCode = 0;
1948 2035 break;
1949 2036 }
1950 2037 }
1951 2038
1952 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2039 + QL_PRINT_9(ha, "done\n");
1953 2040 }
1954 2041
1955 2042 /*
1956 2043 * ql_scsi_passthru
1957 2044 * IOCTL SCSI passthrough.
1958 2045 *
1959 2046 * Input:
1960 2047 * ha: adapter state pointer.
1961 2048 * cmd: User space SCSI command pointer.
1962 2049 * mode: flags.
1963 2050 *
1964 2051 * Returns:
1965 2052 * None, request status indicated in cmd->Status.
1966 2053 *
1967 2054 * Context:
1968 2055 * Kernel context.
1969 2056 */
1970 2057 static void
1971 2058 ql_scsi_passthru(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
1972 2059 {
1973 2060 ql_mbx_iocb_t *pkt;
1974 2061 ql_mbx_data_t mr;
1975 2062 dma_mem_t *dma_mem;
1976 2063 caddr_t pld;
1977 2064 uint32_t pkt_size, pld_size;
1978 2065 uint16_t qlnt, retries, cnt, cnt2;
1979 2066 uint8_t *name;
1980 2067 EXT_FC_SCSI_PASSTHRU *ufc_req;
1981 2068 EXT_SCSI_PASSTHRU *usp_req;
1982 2069 int rval;
1983 2070 union _passthru {
1984 2071 EXT_SCSI_PASSTHRU sp_cmd;
1985 2072 EXT_FC_SCSI_PASSTHRU fc_cmd;
1986 2073 } pt_req; /* Passthru request */
1987 2074 uint32_t status, sense_sz = 0;
1988 2075 ql_tgt_t *tq = NULL;
1989 2076 EXT_SCSI_PASSTHRU *sp_req = &pt_req.sp_cmd;
1990 2077 EXT_FC_SCSI_PASSTHRU *fc_req = &pt_req.fc_cmd;
1991 2078
1992 2079 /* SCSI request struct for SCSI passthrough IOs. */
1993 2080 struct {
1994 2081 uint16_t lun;
1995 2082 uint16_t sense_length; /* Sense buffer size */
1996 2083 size_t resid; /* Residual */
1997 2084 uint8_t *cdbp; /* Requestor's CDB */
1998 2085 uint8_t *u_sense; /* Requestor's sense buffer */
1999 2086 uint8_t cdb_len; /* Requestor's CDB length */
2000 2087 uint8_t direction;
2001 2088 } scsi_req;
2002 2089
2003 2090 struct {
2004 2091 uint8_t *rsp_info;
2005 2092 uint8_t *req_sense_data;
|
↓ open down ↓ |
43 lines elided |
↑ open up ↑ |
2006 2093 uint32_t residual_length;
2007 2094 uint32_t rsp_info_length;
2008 2095 uint32_t req_sense_length;
2009 2096 uint16_t comp_status;
2010 2097 uint8_t state_flags_l;
2011 2098 uint8_t state_flags_h;
2012 2099 uint8_t scsi_status_l;
2013 2100 uint8_t scsi_status_h;
2014 2101 } sts;
2015 2102
2016 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2103 + QL_PRINT_9(ha, "started\n");
2017 2104
2018 2105 /* Verify Sub Code and set cnt to needed request size. */
2019 2106 if (cmd->SubCode == EXT_SC_SEND_SCSI_PASSTHRU) {
2020 2107 pld_size = sizeof (EXT_SCSI_PASSTHRU);
2021 2108 } else if (cmd->SubCode == EXT_SC_SEND_FC_SCSI_PASSTHRU) {
2022 2109 pld_size = sizeof (EXT_FC_SCSI_PASSTHRU);
2023 2110 } else {
2024 2111 EL(ha, "failed, invalid SubCode=%xh\n", cmd->SubCode);
2025 2112 cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
2026 2113 cmd->ResponseLen = 0;
2027 2114 return;
2028 2115 }
2029 2116
2030 2117 dma_mem = (dma_mem_t *)kmem_zalloc(sizeof (dma_mem_t), KM_SLEEP);
2031 2118 if (dma_mem == NULL) {
2032 2119 EL(ha, "failed, kmem_zalloc\n");
2033 2120 cmd->Status = EXT_STATUS_NO_MEMORY;
2034 2121 cmd->ResponseLen = 0;
2035 2122 return;
2036 2123 }
2037 2124 /* Verify the size of and copy in the passthru request structure. */
2038 2125 if (cmd->RequestLen != pld_size) {
2039 2126 /* Return error */
2040 2127 EL(ha, "failed, RequestLen != cnt, is=%xh, expected=%xh\n",
2041 2128 cmd->RequestLen, pld_size);
2042 2129 cmd->Status = EXT_STATUS_INVALID_PARAM;
2043 2130 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
2044 2131 cmd->ResponseLen = 0;
2045 2132 return;
2046 2133 }
2047 2134
2048 2135 if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr, &pt_req,
2049 2136 pld_size, mode) != 0) {
2050 2137 EL(ha, "failed, ddi_copyin\n");
2051 2138 cmd->Status = EXT_STATUS_COPY_ERR;
2052 2139 cmd->ResponseLen = 0;
2053 2140 return;
2054 2141 }
2055 2142
2056 2143 /*
2057 2144 * Find fc_port from SCSI PASSTHRU structure fill in the scsi_req
2058 2145 * request data structure.
2059 2146 */
2060 2147 if (cmd->SubCode == EXT_SC_SEND_SCSI_PASSTHRU) {
2061 2148 scsi_req.lun = sp_req->TargetAddr.Lun;
|
↓ open down ↓ |
35 lines elided |
↑ open up ↑ |
2062 2149 scsi_req.sense_length = sizeof (sp_req->SenseData);
2063 2150 scsi_req.cdbp = &sp_req->Cdb[0];
2064 2151 scsi_req.cdb_len = sp_req->CdbLength;
2065 2152 scsi_req.direction = sp_req->Direction;
2066 2153 usp_req = (EXT_SCSI_PASSTHRU *)(uintptr_t)cmd->RequestAdr;
2067 2154 scsi_req.u_sense = &usp_req->SenseData[0];
2068 2155 cmd->DetailStatus = EXT_DSTATUS_TARGET;
2069 2156
2070 2157 qlnt = QLNT_PORT;
2071 2158 name = (uint8_t *)&sp_req->TargetAddr.Target;
2072 - QL_PRINT_9(CE_CONT, "(%d): SubCode=%xh, Target=%lld\n",
2159 + QL_PRINT_9(ha, "SubCode=%xh, Target=%lld\n",
2073 2160 ha->instance, cmd->SubCode, sp_req->TargetAddr.Target);
2074 2161 tq = ql_find_port(ha, name, qlnt);
2075 2162 } else {
2076 2163 /*
2077 2164 * Must be FC PASSTHRU, verified above.
2078 2165 */
2079 2166 if (fc_req->FCScsiAddr.DestType == EXT_DEF_DESTTYPE_WWPN) {
2080 2167 qlnt = QLNT_PORT;
2081 2168 name = &fc_req->FCScsiAddr.DestAddr.WWPN[0];
2082 - QL_PRINT_9(CE_CONT, "(%d): SubCode=%xh, "
2169 + QL_PRINT_9(ha, "SubCode=%xh, "
2083 2170 "wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
2084 2171 ha->instance, cmd->SubCode, name[0], name[1],
2085 2172 name[2], name[3], name[4], name[5], name[6],
2086 2173 name[7]);
2087 2174 tq = ql_find_port(ha, name, qlnt);
2088 2175 } else if (fc_req->FCScsiAddr.DestType ==
2089 2176 EXT_DEF_DESTTYPE_WWNN) {
2090 2177 qlnt = QLNT_NODE;
2091 2178 name = &fc_req->FCScsiAddr.DestAddr.WWNN[0];
2092 - QL_PRINT_9(CE_CONT, "(%d): SubCode=%xh, "
2179 + QL_PRINT_9(ha, "SubCode=%xh, "
2093 2180 "wwnn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
2094 2181 ha->instance, cmd->SubCode, name[0], name[1],
2095 2182 name[2], name[3], name[4], name[5], name[6],
2096 2183 name[7]);
2097 2184 tq = ql_find_port(ha, name, qlnt);
2098 2185 } else if (fc_req->FCScsiAddr.DestType ==
2099 2186 EXT_DEF_DESTTYPE_PORTID) {
2100 2187 qlnt = QLNT_PID;
2101 2188 name = &fc_req->FCScsiAddr.DestAddr.Id[0];
2102 - QL_PRINT_9(CE_CONT, "(%d): SubCode=%xh, PID="
2103 - "%02x%02x%02x\n", ha->instance, cmd->SubCode,
2189 + QL_PRINT_9(ha, "SubCode=%xh, PID="
2190 + "%02x%02x%02x\n", cmd->SubCode,
2104 2191 name[0], name[1], name[2]);
2105 2192 tq = ql_find_port(ha, name, qlnt);
2106 2193 } else {
2107 2194 EL(ha, "failed, SubCode=%xh invalid DestType=%xh\n",
2108 2195 cmd->SubCode, fc_req->FCScsiAddr.DestType);
2109 2196 cmd->Status = EXT_STATUS_INVALID_PARAM;
2110 2197 cmd->ResponseLen = 0;
2111 2198 return;
2112 2199 }
2113 2200 scsi_req.lun = fc_req->FCScsiAddr.Lun;
2114 2201 scsi_req.sense_length = sizeof (fc_req->SenseData);
2115 2202 scsi_req.cdbp = &sp_req->Cdb[0];
2116 2203 scsi_req.cdb_len = sp_req->CdbLength;
2117 2204 ufc_req = (EXT_FC_SCSI_PASSTHRU *)(uintptr_t)cmd->RequestAdr;
2118 2205 scsi_req.u_sense = &ufc_req->SenseData[0];
2119 2206 scsi_req.direction = fc_req->Direction;
2120 2207 }
2121 2208
2122 2209 if (tq == NULL || !VALID_TARGET_ID(ha, tq->loop_id)) {
2123 2210 EL(ha, "failed, fc_port not found\n");
2124 2211 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
2125 2212 cmd->ResponseLen = 0;
2126 2213 return;
2127 2214 }
2128 2215
2129 2216 if (tq->flags & TQF_NEED_AUTHENTICATION) {
2130 2217 EL(ha, "target not available; loopid=%xh\n", tq->loop_id);
2131 2218 cmd->Status = EXT_STATUS_DEVICE_OFFLINE;
2132 2219 cmd->ResponseLen = 0;
2133 2220 return;
2134 2221 }
2135 2222
2136 2223 /* Allocate command block. */
2137 2224 if ((scsi_req.direction == EXT_DEF_SCSI_PASSTHRU_DATA_IN ||
2138 2225 scsi_req.direction == EXT_DEF_SCSI_PASSTHRU_DATA_OUT) &&
2139 2226 cmd->ResponseLen) {
2140 2227 pld_size = cmd->ResponseLen;
2141 2228 pkt_size = (uint32_t)(sizeof (ql_mbx_iocb_t) + pld_size);
2142 2229 pkt = kmem_zalloc(pkt_size, KM_SLEEP);
2143 2230 if (pkt == NULL) {
|
↓ open down ↓ |
30 lines elided |
↑ open up ↑ |
2144 2231 EL(ha, "failed, kmem_zalloc\n");
2145 2232 cmd->Status = EXT_STATUS_NO_MEMORY;
2146 2233 cmd->ResponseLen = 0;
2147 2234 return;
2148 2235 }
2149 2236 pld = (caddr_t)pkt + sizeof (ql_mbx_iocb_t);
2150 2237
2151 2238 /* Get DMA memory for the IOCB */
2152 2239 if (ql_get_dma_mem(ha, dma_mem, pld_size, LITTLE_ENDIAN_DMA,
2153 2240 QL_DMA_DATA_ALIGN) != QL_SUCCESS) {
2154 - cmn_err(CE_WARN, "%s(%d): request queue DMA memory "
2155 - "alloc failed", QL_NAME, ha->instance);
2241 + cmn_err(CE_WARN, "%srequest queue DMA memory "
2242 + "alloc failed", QL_NAME);
2156 2243 kmem_free(pkt, pkt_size);
2157 2244 cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
2158 2245 cmd->ResponseLen = 0;
2159 2246 return;
2160 2247 }
2161 2248
2162 2249 if (scsi_req.direction == EXT_DEF_SCSI_PASSTHRU_DATA_IN) {
2163 2250 scsi_req.direction = (uint8_t)
2164 - (CFG_IST(ha, CFG_CTRL_24258081) ?
2251 + (CFG_IST(ha, CFG_ISP_FW_TYPE_2) ?
2165 2252 CF_RD : CF_DATA_IN | CF_STAG);
2166 2253 } else {
2167 2254 scsi_req.direction = (uint8_t)
2168 - (CFG_IST(ha, CFG_CTRL_24258081) ?
2255 + (CFG_IST(ha, CFG_ISP_FW_TYPE_2) ?
2169 2256 CF_WR : CF_DATA_OUT | CF_STAG);
2170 2257 cmd->ResponseLen = 0;
2171 2258
2172 2259 /* Get command payload. */
2173 2260 if (ql_get_buffer_data(
2174 2261 (caddr_t)(uintptr_t)cmd->ResponseAdr,
2175 2262 pld, pld_size, mode) != pld_size) {
2176 2263 EL(ha, "failed, get_buffer_data\n");
2177 2264 cmd->Status = EXT_STATUS_COPY_ERR;
2178 2265
2179 2266 kmem_free(pkt, pkt_size);
2180 2267 ql_free_dma_resource(ha, dma_mem);
2181 2268 kmem_free(dma_mem, sizeof (dma_mem_t));
2182 2269 return;
2183 2270 }
2184 2271
2185 2272 /* Copy out going data to DMA buffer. */
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
2186 2273 ddi_rep_put8(dma_mem->acc_handle, (uint8_t *)pld,
2187 2274 (uint8_t *)dma_mem->bp, pld_size,
2188 2275 DDI_DEV_AUTOINCR);
2189 2276
2190 2277 /* Sync DMA buffer. */
2191 2278 (void) ddi_dma_sync(dma_mem->dma_handle, 0,
2192 2279 dma_mem->size, DDI_DMA_SYNC_FORDEV);
2193 2280 }
2194 2281 } else {
2195 2282 scsi_req.direction = (uint8_t)
2196 - (CFG_IST(ha, CFG_CTRL_24258081) ? 0 : CF_STAG);
2283 + (CFG_IST(ha, CFG_ISP_FW_TYPE_2) ? 0 : CF_STAG);
2197 2284 cmd->ResponseLen = 0;
2198 2285
2199 2286 pkt_size = sizeof (ql_mbx_iocb_t);
2200 2287 pkt = kmem_zalloc(pkt_size, KM_SLEEP);
2201 2288 if (pkt == NULL) {
2202 2289 EL(ha, "failed, kmem_zalloc-2\n");
2203 2290 cmd->Status = EXT_STATUS_NO_MEMORY;
2204 2291 return;
2205 2292 }
2206 2293 pld = NULL;
2207 2294 pld_size = 0;
2208 2295 }
2209 2296
2210 2297 /* retries = ha->port_down_retry_count; */
2211 2298 retries = 1;
2212 2299 cmd->Status = EXT_STATUS_OK;
2213 2300 cmd->DetailStatus = EXT_DSTATUS_NOADNL_INFO;
2214 2301
2215 - QL_PRINT_9(CE_CONT, "(%d): SCSI cdb\n", ha->instance);
2302 + QL_PRINT_9(ha, "SCSI cdb\n");
2216 2303 QL_DUMP_9(scsi_req.cdbp, 8, scsi_req.cdb_len);
2217 2304
2218 2305 do {
2219 2306 if (DRIVER_SUSPENDED(ha)) {
2220 2307 sts.comp_status = CS_LOOP_DOWN_ABORT;
2221 2308 break;
2222 2309 }
2223 2310
2224 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2311 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2312 + uint64_t lun_addr = 0;
2313 + fcp_ent_addr_t *fcp_ent_addr = 0;
2314 +
2225 2315 pkt->cmd24.entry_type = IOCB_CMD_TYPE_7;
2226 2316 pkt->cmd24.entry_count = 1;
2227 2317
2228 - /* Set LUN number */
2229 - pkt->cmd24.fcp_lun[2] = LSB(scsi_req.lun);
2230 - pkt->cmd24.fcp_lun[3] = MSB(scsi_req.lun);
2318 + /* Set LUN number and address method */
2319 + lun_addr = ql_get_lun_addr(tq, scsi_req.lun);
2320 + fcp_ent_addr = (fcp_ent_addr_t *)&lun_addr;
2231 2321
2322 + pkt->cmd24.fcp_lun[2] =
2323 + lobyte(fcp_ent_addr->ent_addr_0);
2324 + pkt->cmd24.fcp_lun[3] =
2325 + hibyte(fcp_ent_addr->ent_addr_0);
2326 + pkt->cmd24.fcp_lun[0] =
2327 + lobyte(fcp_ent_addr->ent_addr_1);
2328 + pkt->cmd24.fcp_lun[1] =
2329 + hibyte(fcp_ent_addr->ent_addr_1);
2330 + pkt->cmd24.fcp_lun[6] =
2331 + lobyte(fcp_ent_addr->ent_addr_2);
2332 + pkt->cmd24.fcp_lun[7] =
2333 + hibyte(fcp_ent_addr->ent_addr_2);
2334 + pkt->cmd24.fcp_lun[4] =
2335 + lobyte(fcp_ent_addr->ent_addr_3);
2336 + pkt->cmd24.fcp_lun[5] =
2337 + hibyte(fcp_ent_addr->ent_addr_3);
2338 +
2232 2339 /* Set N_port handle */
2233 2340 pkt->cmd24.n_port_hdl = (uint16_t)LE_16(tq->loop_id);
2234 2341
2235 2342 /* Set VP Index */
2236 2343 pkt->cmd24.vp_index = ha->vp_index;
2237 2344
2238 2345 /* Set target ID */
2239 2346 pkt->cmd24.target_id[0] = tq->d_id.b.al_pa;
2240 2347 pkt->cmd24.target_id[1] = tq->d_id.b.area;
2241 2348 pkt->cmd24.target_id[2] = tq->d_id.b.domain;
2242 2349
2243 2350 /* Set ISP command timeout. */
2244 2351 pkt->cmd24.timeout = (uint16_t)LE_16(15);
2245 2352
2246 2353 /* Load SCSI CDB */
2247 - ddi_rep_put8(ha->hba_buf.acc_handle, scsi_req.cdbp,
2248 - pkt->cmd24.scsi_cdb, scsi_req.cdb_len,
2249 - DDI_DEV_AUTOINCR);
2354 + ddi_rep_put8(ha->req_q[0]->req_ring.acc_handle,
2355 + scsi_req.cdbp, pkt->cmd24.scsi_cdb,
2356 + scsi_req.cdb_len, DDI_DEV_AUTOINCR);
2250 2357 for (cnt = 0; cnt < MAX_CMDSZ;
2251 2358 cnt = (uint16_t)(cnt + 4)) {
2252 2359 ql_chg_endian((uint8_t *)&pkt->cmd24.scsi_cdb
2253 2360 + cnt, 4);
2254 2361 }
2255 2362
2256 2363 /* Set tag queue control flags */
2257 2364 pkt->cmd24.task = TA_STAG;
2258 2365
2259 2366 if (pld_size) {
2260 2367 /* Set transfer direction. */
2261 2368 pkt->cmd24.control_flags = scsi_req.direction;
2262 2369
2263 2370 /* Set data segment count. */
2264 2371 pkt->cmd24.dseg_count = LE_16(1);
2265 2372
2266 2373 /* Load total byte count. */
2267 2374 pkt->cmd24.total_byte_count = LE_32(pld_size);
2268 2375
2269 2376 /* Load data descriptor. */
2270 - pkt->cmd24.dseg_0_address[0] = (uint32_t)
2377 + pkt->cmd24.dseg.address[0] = (uint32_t)
2271 2378 LE_32(LSD(dma_mem->cookie.dmac_laddress));
2272 - pkt->cmd24.dseg_0_address[1] = (uint32_t)
2379 + pkt->cmd24.dseg.address[1] = (uint32_t)
2273 2380 LE_32(MSD(dma_mem->cookie.dmac_laddress));
2274 - pkt->cmd24.dseg_0_length = LE_32(pld_size);
2381 + pkt->cmd24.dseg.length = LE_32(pld_size);
2275 2382 }
2276 2383 } else if (CFG_IST(ha, CFG_ENABLE_64BIT_ADDRESSING)) {
2277 2384 pkt->cmd3.entry_type = IOCB_CMD_TYPE_3;
2278 2385 pkt->cmd3.entry_count = 1;
2279 2386 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
2280 2387 pkt->cmd3.target_l = LSB(tq->loop_id);
2281 2388 pkt->cmd3.target_h = MSB(tq->loop_id);
2282 2389 } else {
2283 2390 pkt->cmd3.target_h = LSB(tq->loop_id);
2284 2391 }
2285 2392 pkt->cmd3.lun_l = LSB(scsi_req.lun);
2286 2393 pkt->cmd3.lun_h = MSB(scsi_req.lun);
2287 2394 pkt->cmd3.control_flags_l = scsi_req.direction;
2288 2395 pkt->cmd3.timeout = LE_16(15);
2289 2396 for (cnt = 0; cnt < scsi_req.cdb_len; cnt++) {
2290 2397 pkt->cmd3.scsi_cdb[cnt] = scsi_req.cdbp[cnt];
2291 2398 }
2292 2399 if (pld_size) {
2293 2400 pkt->cmd3.dseg_count = LE_16(1);
2294 2401 pkt->cmd3.byte_count = LE_32(pld_size);
2295 - pkt->cmd3.dseg_0_address[0] = (uint32_t)
2402 + pkt->cmd3.dseg[0].address[0] = (uint32_t)
2296 2403 LE_32(LSD(dma_mem->cookie.dmac_laddress));
2297 - pkt->cmd3.dseg_0_address[1] = (uint32_t)
2404 + pkt->cmd3.dseg[0].address[1] = (uint32_t)
2298 2405 LE_32(MSD(dma_mem->cookie.dmac_laddress));
2299 - pkt->cmd3.dseg_0_length = LE_32(pld_size);
2406 + pkt->cmd3.dseg[0].length = LE_32(pld_size);
2300 2407 }
2301 2408 } else {
2302 2409 pkt->cmd.entry_type = IOCB_CMD_TYPE_2;
2303 2410 pkt->cmd.entry_count = 1;
2304 2411 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
2305 2412 pkt->cmd.target_l = LSB(tq->loop_id);
2306 2413 pkt->cmd.target_h = MSB(tq->loop_id);
2307 2414 } else {
2308 2415 pkt->cmd.target_h = LSB(tq->loop_id);
2309 2416 }
2310 2417 pkt->cmd.lun_l = LSB(scsi_req.lun);
2311 2418 pkt->cmd.lun_h = MSB(scsi_req.lun);
2312 2419 pkt->cmd.control_flags_l = scsi_req.direction;
2313 2420 pkt->cmd.timeout = LE_16(15);
2314 2421 for (cnt = 0; cnt < scsi_req.cdb_len; cnt++) {
2315 2422 pkt->cmd.scsi_cdb[cnt] = scsi_req.cdbp[cnt];
2316 2423 }
2317 2424 if (pld_size) {
2318 2425 pkt->cmd.dseg_count = LE_16(1);
2319 2426 pkt->cmd.byte_count = LE_32(pld_size);
2320 - pkt->cmd.dseg_0_address = (uint32_t)
2427 + pkt->cmd.dseg[0].address = (uint32_t)
2321 2428 LE_32(LSD(dma_mem->cookie.dmac_laddress));
2322 - pkt->cmd.dseg_0_length = LE_32(pld_size);
2429 + pkt->cmd.dseg[0].length = LE_32(pld_size);
2323 2430 }
2324 2431 }
2325 2432 /* Go issue command and wait for completion. */
2326 - QL_PRINT_9(CE_CONT, "(%d): request pkt\n", ha->instance);
2433 + QL_PRINT_9(ha, "request pkt\n");
2327 2434 QL_DUMP_9(pkt, 8, pkt_size);
2328 2435
2329 2436 status = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size);
2330 2437
2331 2438 if (pld_size) {
2332 2439 /* Sync in coming DMA buffer. */
2333 2440 (void) ddi_dma_sync(dma_mem->dma_handle, 0,
2334 2441 dma_mem->size, DDI_DMA_SYNC_FORKERNEL);
2335 2442 /* Copy in coming DMA data. */
2336 2443 ddi_rep_get8(dma_mem->acc_handle, (uint8_t *)pld,
2337 2444 (uint8_t *)dma_mem->bp, pld_size,
2338 2445 DDI_DEV_AUTOINCR);
2339 2446 }
2340 2447
2341 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2448 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2342 2449 pkt->sts24.entry_status = (uint8_t)
2343 2450 (pkt->sts24.entry_status & 0x3c);
2344 2451 } else {
2345 2452 pkt->sts.entry_status = (uint8_t)
2346 2453 (pkt->sts.entry_status & 0x7e);
2347 2454 }
2348 2455
2349 2456 if (status == QL_SUCCESS && pkt->sts.entry_status != 0) {
2350 2457 EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
2351 2458 pkt->sts.entry_status, tq->d_id.b24);
2352 2459 status = QL_FUNCTION_PARAMETER_ERROR;
2353 2460 }
2354 2461
2355 - sts.comp_status = (uint16_t)(CFG_IST(ha, CFG_CTRL_24258081) ?
2462 + sts.comp_status = (uint16_t)
2463 + (CFG_IST(ha, CFG_ISP_FW_TYPE_2) ?
2356 2464 LE_16(pkt->sts24.comp_status) :
2357 2465 LE_16(pkt->sts.comp_status));
2358 2466
2359 2467 /*
2360 2468 * We have verified about all the request that can be so far.
2361 2469 * Now we need to start verification of our ability to
2362 2470 * actually issue the CDB.
2363 2471 */
2364 2472 if (DRIVER_SUSPENDED(ha)) {
2365 2473 sts.comp_status = CS_LOOP_DOWN_ABORT;
2366 2474 break;
2367 2475 } else if (status == QL_SUCCESS &&
2368 2476 (sts.comp_status == CS_PORT_LOGGED_OUT ||
2369 2477 sts.comp_status == CS_PORT_UNAVAILABLE)) {
2370 2478 EL(ha, "login retry d_id=%xh\n", tq->d_id.b24);
2371 2479 if (tq->flags & TQF_FABRIC_DEVICE) {
2372 2480 rval = ql_login_fport(ha, tq, tq->loop_id,
2373 2481 LFF_NO_PLOGI, &mr);
2374 2482 if (rval != QL_SUCCESS) {
2375 2483 EL(ha, "failed, login_fport=%xh, "
2376 2484 "d_id=%xh\n", rval, tq->d_id.b24);
2377 2485 }
2378 2486 } else {
2379 2487 rval = ql_login_lport(ha, tq, tq->loop_id,
2380 2488 LLF_NONE);
2381 2489 if (rval != QL_SUCCESS) {
2382 2490 EL(ha, "failed, login_lport=%xh, "
2383 2491 "d_id=%xh\n", rval, tq->d_id.b24);
2384 2492 }
2385 2493 }
2386 2494 } else {
2387 2495 break;
2388 2496 }
2389 2497
2390 2498 bzero((caddr_t)pkt, sizeof (ql_mbx_iocb_t));
2391 2499
2392 2500 } while (retries--);
2393 2501
2394 2502 if (sts.comp_status == CS_LOOP_DOWN_ABORT) {
2395 2503 /* Cannot issue command now, maybe later */
2396 2504 EL(ha, "failed, suspended\n");
2397 2505 kmem_free(pkt, pkt_size);
2398 2506 ql_free_dma_resource(ha, dma_mem);
2399 2507 kmem_free(dma_mem, sizeof (dma_mem_t));
2400 2508 cmd->Status = EXT_STATUS_SUSPENDED;
2401 2509 cmd->ResponseLen = 0;
2402 2510 return;
2403 2511 }
2404 2512
2405 2513 if (status != QL_SUCCESS) {
2406 2514 /* Command error */
2407 2515 EL(ha, "failed, I/O\n");
|
↓ open down ↓ |
42 lines elided |
↑ open up ↑ |
2408 2516 kmem_free(pkt, pkt_size);
2409 2517 ql_free_dma_resource(ha, dma_mem);
2410 2518 kmem_free(dma_mem, sizeof (dma_mem_t));
2411 2519 cmd->Status = EXT_STATUS_ERR;
2412 2520 cmd->DetailStatus = status;
2413 2521 cmd->ResponseLen = 0;
2414 2522 return;
2415 2523 }
2416 2524
2417 2525 /* Setup status. */
2418 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
2526 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
2419 2527 sts.scsi_status_l = pkt->sts24.scsi_status_l;
2420 2528 sts.scsi_status_h = pkt->sts24.scsi_status_h;
2421 2529
2422 2530 /* Setup residuals. */
2423 2531 sts.residual_length = LE_32(pkt->sts24.residual_length);
2424 2532
2425 2533 /* Setup state flags. */
2426 2534 sts.state_flags_l = pkt->sts24.state_flags_l;
2427 2535 sts.state_flags_h = pkt->sts24.state_flags_h;
2428 2536 if (pld_size && sts.comp_status != CS_DATA_UNDERRUN) {
2429 2537 sts.state_flags_h = (uint8_t)(sts.state_flags_h |
2430 2538 SF_GOT_BUS | SF_GOT_TARGET | SF_SENT_CMD |
2431 2539 SF_XFERRED_DATA | SF_GOT_STATUS);
2432 2540 } else {
2433 2541 sts.state_flags_h = (uint8_t)(sts.state_flags_h |
2434 2542 SF_GOT_BUS | SF_GOT_TARGET | SF_SENT_CMD |
2435 2543 SF_GOT_STATUS);
2436 2544 }
2437 2545 if (scsi_req.direction & CF_WR) {
2438 2546 sts.state_flags_l = (uint8_t)(sts.state_flags_l |
2439 2547 SF_DATA_OUT);
2440 2548 } else if (scsi_req.direction & CF_RD) {
2441 2549 sts.state_flags_l = (uint8_t)(sts.state_flags_l |
2442 2550 SF_DATA_IN);
2443 2551 }
2444 2552 sts.state_flags_l = (uint8_t)(sts.state_flags_l | SF_SIMPLE_Q);
2445 2553
2446 2554 /* Setup FCP response info. */
2447 2555 sts.rsp_info_length = sts.scsi_status_h & FCP_RSP_LEN_VALID ?
2448 2556 LE_32(pkt->sts24.fcp_rsp_data_length) : 0;
2449 2557 sts.rsp_info = &pkt->sts24.rsp_sense_data[0];
2450 2558 for (cnt = 0; cnt < sts.rsp_info_length;
2451 2559 cnt = (uint16_t)(cnt + 4)) {
2452 2560 ql_chg_endian(sts.rsp_info + cnt, 4);
2453 2561 }
2454 2562
2455 2563 /* Setup sense data. */
2456 2564 if (sts.scsi_status_h & FCP_SNS_LEN_VALID) {
2457 2565 sts.req_sense_length =
2458 2566 LE_32(pkt->sts24.fcp_sense_length);
2459 2567 sts.state_flags_h = (uint8_t)(sts.state_flags_h |
2460 2568 SF_ARQ_DONE);
2461 2569 } else {
2462 2570 sts.req_sense_length = 0;
2463 2571 }
2464 2572 sts.req_sense_data =
2465 2573 &pkt->sts24.rsp_sense_data[sts.rsp_info_length];
2466 2574 cnt2 = (uint16_t)(((uintptr_t)pkt + sizeof (sts_24xx_entry_t)) -
2467 2575 (uintptr_t)sts.req_sense_data);
2468 2576 for (cnt = 0; cnt < cnt2; cnt = (uint16_t)(cnt + 4)) {
2469 2577 ql_chg_endian(sts.req_sense_data + cnt, 4);
2470 2578 }
2471 2579 } else {
2472 2580 sts.scsi_status_l = pkt->sts.scsi_status_l;
2473 2581 sts.scsi_status_h = pkt->sts.scsi_status_h;
2474 2582
2475 2583 /* Setup residuals. */
2476 2584 sts.residual_length = LE_32(pkt->sts.residual_length);
2477 2585
2478 2586 /* Setup state flags. */
2479 2587 sts.state_flags_l = pkt->sts.state_flags_l;
2480 2588 sts.state_flags_h = pkt->sts.state_flags_h;
2481 2589
2482 2590 /* Setup FCP response info. */
|
↓ open down ↓ |
54 lines elided |
↑ open up ↑ |
2483 2591 sts.rsp_info_length = sts.scsi_status_h & FCP_RSP_LEN_VALID ?
2484 2592 LE_16(pkt->sts.rsp_info_length) : 0;
2485 2593 sts.rsp_info = &pkt->sts.rsp_info[0];
2486 2594
2487 2595 /* Setup sense data. */
2488 2596 sts.req_sense_length = sts.scsi_status_h & FCP_SNS_LEN_VALID ?
2489 2597 LE_16(pkt->sts.req_sense_length) : 0;
2490 2598 sts.req_sense_data = &pkt->sts.req_sense_data[0];
2491 2599 }
2492 2600
2493 - QL_PRINT_9(CE_CONT, "(%d): response pkt\n", ha->instance);
2601 + QL_PRINT_9(ha, "response pkt\n");
2494 2602 QL_DUMP_9(&pkt->sts, 8, sizeof (sts_entry_t));
2495 2603
2496 2604 switch (sts.comp_status) {
2497 2605 case CS_INCOMPLETE:
2498 2606 case CS_ABORTED:
2499 2607 case CS_DEVICE_UNAVAILABLE:
2500 2608 case CS_PORT_UNAVAILABLE:
2501 2609 case CS_PORT_LOGGED_OUT:
2502 2610 case CS_PORT_CONFIG_CHG:
2503 2611 case CS_PORT_BUSY:
2504 2612 case CS_LOOP_DOWN_ABORT:
2505 2613 cmd->Status = EXT_STATUS_BUSY;
2506 2614 break;
2507 2615 case CS_RESET:
2508 2616 case CS_QUEUE_FULL:
2509 2617 cmd->Status = EXT_STATUS_ERR;
2510 2618 break;
2511 2619 case CS_TIMEOUT:
2512 2620 cmd->Status = EXT_STATUS_ERR;
2513 2621 break;
2514 2622 case CS_DATA_OVERRUN:
2515 2623 cmd->Status = EXT_STATUS_DATA_OVERRUN;
2516 2624 break;
2517 2625 case CS_DATA_UNDERRUN:
2518 2626 cmd->Status = EXT_STATUS_DATA_UNDERRUN;
2519 2627 break;
2520 2628 }
2521 2629
2522 2630 /*
2523 2631 * If non data transfer commands fix tranfer counts.
2524 2632 */
2525 2633 if (scsi_req.cdbp[0] == SCMD_TEST_UNIT_READY ||
2526 2634 scsi_req.cdbp[0] == SCMD_REZERO_UNIT ||
2527 2635 scsi_req.cdbp[0] == SCMD_SEEK ||
2528 2636 scsi_req.cdbp[0] == SCMD_SEEK_G1 ||
2529 2637 scsi_req.cdbp[0] == SCMD_RESERVE ||
2530 2638 scsi_req.cdbp[0] == SCMD_RELEASE ||
2531 2639 scsi_req.cdbp[0] == SCMD_START_STOP ||
2532 2640 scsi_req.cdbp[0] == SCMD_DOORLOCK ||
2533 2641 scsi_req.cdbp[0] == SCMD_VERIFY ||
2534 2642 scsi_req.cdbp[0] == SCMD_WRITE_FILE_MARK ||
2535 2643 scsi_req.cdbp[0] == SCMD_VERIFY_G0 ||
2536 2644 scsi_req.cdbp[0] == SCMD_SPACE ||
2537 2645 scsi_req.cdbp[0] == SCMD_ERASE ||
2538 2646 (scsi_req.cdbp[0] == SCMD_FORMAT &&
2539 2647 (scsi_req.cdbp[1] & FPB_DATA) == 0)) {
2540 2648 /*
2541 2649 * Non data transfer command, clear sts_entry residual
2542 2650 * length.
2543 2651 */
2544 2652 sts.residual_length = 0;
2545 2653 cmd->ResponseLen = 0;
2546 2654 if (sts.comp_status == CS_DATA_UNDERRUN) {
|
↓ open down ↓ |
43 lines elided |
↑ open up ↑ |
2547 2655 sts.comp_status = CS_COMPLETE;
2548 2656 cmd->Status = EXT_STATUS_OK;
2549 2657 }
2550 2658 } else {
2551 2659 cmd->ResponseLen = pld_size;
2552 2660 }
2553 2661
2554 2662 /* Correct ISP completion status */
2555 2663 if (sts.comp_status == CS_COMPLETE && sts.scsi_status_l == 0 &&
2556 2664 (sts.scsi_status_h & FCP_RSP_MASK) == 0) {
2557 - QL_PRINT_9(CE_CONT, "(%d): Correct completion\n",
2665 + QL_PRINT_9(ha, "Correct completion\n",
2558 2666 ha->instance);
2559 2667 scsi_req.resid = 0;
2560 2668 } else if (sts.comp_status == CS_DATA_UNDERRUN) {
2561 - QL_PRINT_9(CE_CONT, "(%d): Correct UNDERRUN\n",
2669 + QL_PRINT_9(ha, "Correct UNDERRUN\n",
2562 2670 ha->instance);
2563 2671 scsi_req.resid = sts.residual_length;
2564 2672 if (sts.scsi_status_h & FCP_RESID_UNDER) {
2565 2673 cmd->Status = (uint32_t)EXT_STATUS_OK;
2566 2674
2567 2675 cmd->ResponseLen = (uint32_t)
2568 2676 (pld_size - scsi_req.resid);
2569 2677 } else {
2570 2678 EL(ha, "failed, Transfer ERROR\n");
2571 2679 cmd->Status = EXT_STATUS_ERR;
2572 2680 cmd->ResponseLen = 0;
2573 2681 }
2574 2682 } else {
2575 - QL_PRINT_9(CE_CONT, "(%d): error d_id=%xh, comp_status=%xh, "
2576 - "scsi_status_h=%xh, scsi_status_l=%xh\n", ha->instance,
2683 + QL_PRINT_9(ha, "error d_id=%xh, comp_status=%xh, "
2684 + "scsi_status_h=%xh, scsi_status_l=%xh\n",
2577 2685 tq->d_id.b24, sts.comp_status, sts.scsi_status_h,
2578 2686 sts.scsi_status_l);
2579 2687
2580 2688 scsi_req.resid = pld_size;
2581 2689 /*
2582 2690 * Handle residual count on SCSI check
2583 2691 * condition.
2584 2692 *
2585 2693 * - If Residual Under / Over is set, use the
2586 2694 * Residual Transfer Length field in IOCB.
2587 2695 * - If Residual Under / Over is not set, and
2588 2696 * Transferred Data bit is set in State Flags
2589 2697 * field of IOCB, report residual value of 0
2590 2698 * (you may want to do this for tape
2591 2699 * Write-type commands only). This takes care
2592 2700 * of logical end of tape problem and does
2593 2701 * not break Unit Attention.
2594 2702 * - If Residual Under / Over is not set, and
2595 2703 * Transferred Data bit is not set in State
2596 2704 * Flags, report residual value equal to
2597 2705 * original data transfer length.
2598 2706 */
2599 2707 if (sts.scsi_status_l & STATUS_CHECK) {
2600 2708 cmd->Status = EXT_STATUS_SCSI_STATUS;
2601 2709 cmd->DetailStatus = sts.scsi_status_l;
2602 2710 if (sts.scsi_status_h &
2603 2711 (FCP_RESID_OVER | FCP_RESID_UNDER)) {
2604 2712 scsi_req.resid = sts.residual_length;
2605 2713 } else if (sts.state_flags_h &
2606 2714 STATE_XFERRED_DATA) {
2607 2715 scsi_req.resid = 0;
2608 2716 }
2609 2717 }
2610 2718 }
2611 2719
2612 2720 if (sts.scsi_status_l & STATUS_CHECK &&
2613 2721 sts.scsi_status_h & FCP_SNS_LEN_VALID &&
2614 2722 sts.req_sense_length) {
2615 2723 /*
2616 2724 * Check condition with vaild sense data flag set and sense
2617 2725 * length != 0
2618 2726 */
2619 2727 if (sts.req_sense_length > scsi_req.sense_length) {
2620 2728 sense_sz = scsi_req.sense_length;
2621 2729 } else {
2622 2730 sense_sz = sts.req_sense_length;
2623 2731 }
2624 2732
2625 2733 EL(ha, "failed, Check Condition Status, d_id=%xh\n",
2626 2734 tq->d_id.b24);
2627 2735 QL_DUMP_2(sts.req_sense_data, 8, sts.req_sense_length);
2628 2736
2629 2737 if (ddi_copyout(sts.req_sense_data, scsi_req.u_sense,
2630 2738 (size_t)sense_sz, mode) != 0) {
|
↓ open down ↓ |
44 lines elided |
↑ open up ↑ |
2631 2739 EL(ha, "failed, request sense ddi_copyout\n");
2632 2740 }
2633 2741
2634 2742 cmd->Status = EXT_STATUS_SCSI_STATUS;
2635 2743 cmd->DetailStatus = sts.scsi_status_l;
2636 2744 }
2637 2745
2638 2746 /* Copy response payload from DMA buffer to application. */
2639 2747 if (scsi_req.direction & (CF_RD | CF_DATA_IN) &&
2640 2748 cmd->ResponseLen != 0) {
2641 - QL_PRINT_9(CE_CONT, "(%d): Data Return resid=%lu, "
2642 - "byte_count=%u, ResponseLen=%xh\n", ha->instance,
2749 + QL_PRINT_9(ha, "Data Return resid=%lu, "
2750 + "byte_count=%u, ResponseLen=%xh\n",
2643 2751 scsi_req.resid, pld_size, cmd->ResponseLen);
2644 2752 QL_DUMP_9(pld, 8, cmd->ResponseLen);
2645 2753
2646 2754 /* Send response payload. */
2647 2755 if (ql_send_buffer_data(pld,
2648 2756 (caddr_t)(uintptr_t)cmd->ResponseAdr,
2649 2757 cmd->ResponseLen, mode) != cmd->ResponseLen) {
2650 2758 EL(ha, "failed, send_buffer_data\n");
2651 2759 cmd->Status = EXT_STATUS_COPY_ERR;
2652 2760 cmd->ResponseLen = 0;
2653 2761 }
2654 2762 }
2655 2763
2656 2764 if (cmd->Status != EXT_STATUS_OK) {
2657 2765 EL(ha, "failed, cmd->Status=%xh, comp_status=%xh, "
2658 2766 "d_id=%xh\n", cmd->Status, sts.comp_status, tq->d_id.b24);
2659 2767 } else {
2660 2768 /*EMPTY*/
2661 - QL_PRINT_9(CE_CONT, "(%d): done, ResponseLen=%d\n",
2769 + QL_PRINT_9(ha, "done, ResponseLen=%d\n",
2662 2770 ha->instance, cmd->ResponseLen);
2663 2771 }
2664 2772
2665 2773 kmem_free(pkt, pkt_size);
2666 2774 ql_free_dma_resource(ha, dma_mem);
2667 2775 kmem_free(dma_mem, sizeof (dma_mem_t));
2668 2776 }
2669 2777
2670 2778 /*
2671 2779 * ql_wwpn_to_scsiaddr
2672 2780 *
2673 2781 * Input:
2674 2782 * ha: adapter state pointer.
2675 2783 * cmd: EXT_IOCTL cmd struct pointer.
2676 2784 * mode: flags.
2677 2785 *
2678 2786 * Context:
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
2679 2787 * Kernel context.
2680 2788 */
2681 2789 static void
2682 2790 ql_wwpn_to_scsiaddr(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
2683 2791 {
2684 2792 int status;
2685 2793 uint8_t wwpn[EXT_DEF_WWN_NAME_SIZE];
2686 2794 EXT_SCSI_ADDR *tmp_addr;
2687 2795 ql_tgt_t *tq;
2688 2796
2689 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2797 + QL_PRINT_9(ha, "started\n");
2690 2798
2691 2799 if (cmd->RequestLen != EXT_DEF_WWN_NAME_SIZE) {
2692 2800 /* Return error */
2693 2801 EL(ha, "incorrect RequestLen\n");
2694 2802 cmd->Status = EXT_STATUS_INVALID_PARAM;
2695 2803 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
2696 2804 return;
2697 2805 }
2698 2806
2699 2807 status = ddi_copyin((void*)(uintptr_t)cmd->RequestAdr, wwpn,
2700 2808 cmd->RequestLen, mode);
2701 2809
2702 2810 if (status != 0) {
2703 2811 cmd->Status = EXT_STATUS_COPY_ERR;
2704 2812 EL(ha, "failed, ddi_copyin\n");
2705 2813 return;
2706 2814 }
2707 2815
2708 2816 tq = ql_find_port(ha, wwpn, QLNT_PORT);
2709 2817
2710 2818 if (tq == NULL || tq->flags & TQF_INITIATOR_DEVICE) {
2711 2819 /* no matching device */
2712 2820 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
2713 2821 EL(ha, "failed, device not found\n");
2714 2822 return;
2715 2823 }
2716 2824
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
2717 2825 /* Copy out the IDs found. For now we can only return target ID. */
2718 2826 tmp_addr = (EXT_SCSI_ADDR *)(uintptr_t)cmd->ResponseAdr;
2719 2827
2720 2828 status = ddi_copyout((void *)wwpn, (void *)&tmp_addr->Target, 8, mode);
2721 2829
2722 2830 if (status != 0) {
2723 2831 cmd->Status = EXT_STATUS_COPY_ERR;
2724 2832 EL(ha, "failed, ddi_copyout\n");
2725 2833 } else {
2726 2834 cmd->Status = EXT_STATUS_OK;
2727 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2835 + QL_PRINT_9(ha, "done\n");
2728 2836 }
2729 2837 }
2730 2838
2731 2839 /*
2732 2840 * ql_host_idx
2733 2841 * Gets host order index.
2734 2842 *
2735 2843 * Input:
2736 2844 * ha: adapter state pointer.
2737 2845 * cmd: EXT_IOCTL cmd struct pointer.
2738 2846 * mode: flags.
2739 2847 *
2740 2848 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
2741 2849 * None, request status indicated in cmd->Status.
2742 2850 *
2743 2851 * Context:
2744 2852 * Kernel context.
2745 2853 */
2746 2854 static void
2747 2855 ql_host_idx(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
2748 2856 {
2749 2857 uint16_t idx;
2750 2858
2751 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2859 + QL_PRINT_9(ha, "started\n");
2752 2860
2753 2861 if (cmd->ResponseLen < sizeof (uint16_t)) {
2754 2862 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
2755 2863 cmd->DetailStatus = sizeof (uint16_t);
2756 2864 EL(ha, "failed, ResponseLen < Len=%xh\n", cmd->ResponseLen);
2757 2865 cmd->ResponseLen = 0;
2758 2866 return;
2759 2867 }
2760 2868
2761 2869 idx = (uint16_t)ha->instance;
2762 2870
2763 2871 if (ddi_copyout((void *)&idx, (void *)(uintptr_t)(cmd->ResponseAdr),
2764 2872 sizeof (uint16_t), mode) != 0) {
2765 2873 cmd->Status = EXT_STATUS_COPY_ERR;
2766 2874 cmd->ResponseLen = 0;
2767 2875 EL(ha, "failed, ddi_copyout\n");
2768 2876 } else {
2769 2877 cmd->ResponseLen = sizeof (uint16_t);
2770 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2878 + QL_PRINT_9(ha, "done\n");
2771 2879 }
2772 2880 }
2773 2881
2774 2882 /*
2775 2883 * ql_host_drvname
2776 2884 * Gets host driver name
2777 2885 *
2778 2886 * Input:
2779 2887 * ha: adapter state pointer.
2780 2888 * cmd: EXT_IOCTL cmd struct pointer.
2781 2889 * mode: flags.
2782 2890 *
2783 2891 * Returns:
2784 2892 * None, request status indicated in cmd->Status.
2785 2893 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
2786 2894 * Context:
2787 2895 * Kernel context.
2788 2896 */
2789 2897 static void
2790 2898 ql_host_drvname(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
2791 2899 {
2792 2900
2793 2901 char drvname[] = QL_NAME;
2794 2902 uint32_t qlnamelen;
2795 2903
2796 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2904 + QL_PRINT_9(ha, "started\n");
2797 2905
2798 - qlnamelen = (uint32_t)(strlen(QL_NAME)+1);
2906 + qlnamelen = (uint32_t)(strlen(QL_NAME) + 1);
2799 2907
2800 2908 if (cmd->ResponseLen < qlnamelen) {
2801 2909 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
2802 2910 cmd->DetailStatus = qlnamelen;
2803 2911 EL(ha, "failed, ResponseLen: %xh, needed: %xh\n",
2804 2912 cmd->ResponseLen, qlnamelen);
2805 2913 cmd->ResponseLen = 0;
2806 2914 return;
2807 2915 }
2808 2916
2809 2917 if (ddi_copyout((void *)&drvname,
2810 2918 (void *)(uintptr_t)(cmd->ResponseAdr),
2811 2919 qlnamelen, mode) != 0) {
2812 2920 cmd->Status = EXT_STATUS_COPY_ERR;
2813 2921 cmd->ResponseLen = 0;
2814 2922 EL(ha, "failed, ddi_copyout\n");
2815 2923 } else {
2816 - cmd->ResponseLen = qlnamelen-1;
2924 + cmd->ResponseLen = qlnamelen - 1;
2817 2925 }
2818 2926
2819 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2927 + QL_PRINT_9(ha, "done\n");
2820 2928 }
2821 2929
2822 2930 /*
2823 2931 * ql_read_nvram
2824 2932 * Get NVRAM contents.
2825 2933 *
2826 2934 * Input:
2827 2935 * ha: adapter state pointer.
2828 2936 * cmd: EXT_IOCTL cmd struct pointer.
2829 2937 * mode: flags.
2830 2938 *
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
2831 2939 * Returns:
2832 2940 * None, request status indicated in cmd->Status.
2833 2941 *
2834 2942 * Context:
2835 2943 * Kernel context.
2836 2944 */
2837 2945 static void
2838 2946 ql_read_nvram(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
2839 2947 {
2840 2948
2841 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2949 + QL_PRINT_9(ha, "started\n");
2842 2950
2843 2951 if (cmd->ResponseLen < ha->nvram_cache->size) {
2844 2952 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
2845 2953 cmd->DetailStatus = ha->nvram_cache->size;
2846 2954 EL(ha, "failed, ResponseLen != NVRAM, Len=%xh\n",
2847 2955 cmd->ResponseLen);
2848 2956 cmd->ResponseLen = 0;
2849 2957 return;
2850 2958 }
2851 2959
2852 2960 /* Get NVRAM data. */
2853 2961 if (ql_nv_util_dump(ha, (void *)(uintptr_t)(cmd->ResponseAdr),
2854 2962 mode) != 0) {
2855 2963 cmd->Status = EXT_STATUS_COPY_ERR;
2856 2964 cmd->ResponseLen = 0;
2857 2965 EL(ha, "failed, copy error\n");
2858 2966 } else {
2859 2967 cmd->ResponseLen = ha->nvram_cache->size;
2860 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
2968 + QL_PRINT_9(ha, "done\n");
2861 2969 }
2862 2970 }
2863 2971
2864 2972 /*
2865 2973 * ql_write_nvram
2866 2974 * Loads NVRAM contents.
2867 2975 *
2868 2976 * Input:
2869 2977 * ha: adapter state pointer.
2870 2978 * cmd: EXT_IOCTL cmd struct pointer.
2871 2979 * mode: flags.
2872 2980 *
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
2873 2981 * Returns:
2874 2982 * None, request status indicated in cmd->Status.
2875 2983 *
2876 2984 * Context:
2877 2985 * Kernel context.
2878 2986 */
2879 2987 static void
2880 2988 ql_write_nvram(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
2881 2989 {
2882 2990
2883 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2991 + QL_PRINT_9(ha, "started\n");
2884 2992
2885 2993 if (cmd->RequestLen < ha->nvram_cache->size) {
2886 2994 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
2887 2995 cmd->DetailStatus = ha->nvram_cache->size;
2888 2996 EL(ha, "failed, RequestLen != NVRAM, Len=%xh\n",
2889 2997 cmd->RequestLen);
2890 2998 return;
2891 2999 }
2892 3000
2893 3001 /* Load NVRAM data. */
2894 3002 if (ql_nv_util_load(ha, (void *)(uintptr_t)(cmd->RequestAdr),
2895 3003 mode) != 0) {
2896 3004 cmd->Status = EXT_STATUS_COPY_ERR;
2897 3005 EL(ha, "failed, copy error\n");
2898 3006 } else {
2899 3007 /*EMPTY*/
2900 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3008 + QL_PRINT_9(ha, "done\n");
2901 3009 }
2902 3010 }
2903 3011
2904 3012 /*
2905 3013 * ql_write_vpd
2906 3014 * Loads VPD contents.
2907 3015 *
2908 3016 * Input:
2909 3017 * ha: adapter state pointer.
2910 3018 * cmd: EXT_IOCTL cmd struct pointer.
2911 3019 * mode: flags.
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
2912 3020 *
2913 3021 * Returns:
2914 3022 * None, request status indicated in cmd->Status.
2915 3023 *
2916 3024 * Context:
2917 3025 * Kernel context.
2918 3026 */
2919 3027 static void
2920 3028 ql_write_vpd(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
2921 3029 {
2922 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3030 + QL_PRINT_9(ha, "started\n");
2923 3031
2924 3032 int32_t rval = 0;
2925 3033
2926 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
3034 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
2927 3035 cmd->Status = EXT_STATUS_INVALID_REQUEST;
2928 3036 EL(ha, "failed, invalid request for HBA\n");
2929 3037 return;
2930 3038 }
2931 3039
2932 3040 if (cmd->RequestLen < QL_24XX_VPD_SIZE) {
2933 3041 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
2934 3042 cmd->DetailStatus = QL_24XX_VPD_SIZE;
2935 3043 EL(ha, "failed, RequestLen != VPD len, len passed=%xh\n",
2936 3044 cmd->RequestLen);
2937 3045 return;
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
2938 3046 }
2939 3047
2940 3048 /* Load VPD data. */
2941 3049 if ((rval = ql_vpd_load(ha, (void *)(uintptr_t)(cmd->RequestAdr),
2942 3050 mode)) != 0) {
2943 3051 cmd->Status = EXT_STATUS_COPY_ERR;
2944 3052 cmd->DetailStatus = rval;
2945 3053 EL(ha, "failed, errno=%x\n", rval);
2946 3054 } else {
2947 3055 /*EMPTY*/
2948 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3056 + QL_PRINT_9(ha, "done\n");
2949 3057 }
2950 3058 }
2951 3059
2952 3060 /*
2953 3061 * ql_read_vpd
2954 3062 * Dumps VPD contents.
2955 3063 *
2956 3064 * Input:
2957 3065 * ha: adapter state pointer.
2958 3066 * cmd: EXT_IOCTL cmd struct pointer.
2959 3067 * mode: flags.
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
2960 3068 *
2961 3069 * Returns:
2962 3070 * None, request status indicated in cmd->Status.
2963 3071 *
2964 3072 * Context:
2965 3073 * Kernel context.
2966 3074 */
2967 3075 static void
2968 3076 ql_read_vpd(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
2969 3077 {
2970 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3078 + QL_PRINT_9(ha, "started\n");
2971 3079
2972 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
3080 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
2973 3081 cmd->Status = EXT_STATUS_INVALID_REQUEST;
2974 3082 EL(ha, "failed, invalid request for HBA\n");
2975 3083 return;
2976 3084 }
2977 3085
2978 3086 if (cmd->ResponseLen < QL_24XX_VPD_SIZE) {
2979 3087 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
2980 3088 cmd->DetailStatus = QL_24XX_VPD_SIZE;
2981 3089 EL(ha, "failed, ResponseLen < VPD len, len passed=%xh\n",
2982 3090 cmd->ResponseLen);
2983 3091 return;
2984 3092 }
2985 3093
2986 3094 /* Dump VPD data. */
2987 3095 if ((ql_vpd_dump(ha, (void *)(uintptr_t)(cmd->ResponseAdr),
2988 3096 mode)) != 0) {
2989 3097 cmd->Status = EXT_STATUS_COPY_ERR;
2990 3098 EL(ha, "failed,\n");
2991 3099 } else {
2992 3100 /*EMPTY*/
2993 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3101 + QL_PRINT_9(ha, "done\n");
2994 3102 }
2995 3103 }
2996 3104
2997 3105 /*
2998 3106 * ql_get_fcache
2999 3107 * Dumps flash cache contents.
3000 3108 *
3001 3109 * Input:
3002 3110 * ha: adapter state pointer.
3003 3111 * cmd: EXT_IOCTL cmd struct pointer.
3004 3112 * mode: flags.
3005 3113 *
3006 3114 * Returns:
3007 3115 * None, request status indicated in cmd->Status.
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
3008 3116 *
3009 3117 * Context:
3010 3118 * Kernel context.
3011 3119 */
3012 3120 static void
3013 3121 ql_get_fcache(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3014 3122 {
3015 3123 uint32_t bsize, boff, types, cpsize, hsize;
3016 3124 ql_fcache_t *fptr;
3017 3125
3018 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3126 + QL_PRINT_9(ha, "started\n");
3019 3127
3020 - CACHE_LOCK(ha);
3021 -
3022 3128 if (ha->fcache == NULL) {
3023 - CACHE_UNLOCK(ha);
3024 3129 cmd->Status = EXT_STATUS_ERR;
3025 3130 EL(ha, "failed, adapter fcache not setup\n");
3026 3131 return;
3027 3132 }
3028 3133
3029 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
3134 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
3030 3135 bsize = 100;
3031 3136 } else {
3032 3137 bsize = 400;
3033 3138 }
3034 3139
3035 3140 if (cmd->ResponseLen < bsize) {
3036 - CACHE_UNLOCK(ha);
3037 3141 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
3038 3142 cmd->DetailStatus = bsize;
3039 3143 EL(ha, "failed, ResponseLen < %d, len passed=%xh\n",
3040 3144 bsize, cmd->ResponseLen);
3041 3145 return;
3042 3146 }
3043 3147
3044 3148 boff = 0;
3045 3149 bsize = 0;
3046 3150 fptr = ha->fcache;
3047 3151
3048 3152 /*
3049 3153 * For backwards compatibility, get one of each image type
3050 3154 */
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
3051 3155 types = (FTYPE_BIOS | FTYPE_FCODE | FTYPE_EFI);
3052 3156 while ((fptr != NULL) && (fptr->buf != NULL) && (types != 0)) {
3053 3157 /* Get the next image */
3054 3158 if ((fptr = ql_get_fbuf(ha->fcache, types)) != NULL) {
3055 3159
3056 3160 cpsize = (fptr->buflen < 100 ? fptr->buflen : 100);
3057 3161
3058 3162 if (ddi_copyout(fptr->buf,
3059 3163 (void *)(uintptr_t)(cmd->ResponseAdr + boff),
3060 3164 cpsize, mode) != 0) {
3061 - CACHE_UNLOCK(ha);
3062 3165 EL(ha, "ddicopy failed, done\n");
3063 3166 cmd->Status = EXT_STATUS_COPY_ERR;
3064 3167 cmd->DetailStatus = 0;
3065 3168 return;
3066 3169 }
3067 3170 boff += 100;
3068 3171 bsize += cpsize;
3069 3172 types &= ~(fptr->type);
3070 3173 }
3071 3174 }
3072 3175
3073 3176 /*
3074 3177 * Get the firmware image -- it needs to be last in the
3075 3178 * buffer at offset 300 for backwards compatibility. Also for
3076 3179 * backwards compatibility, the pci header is stripped off.
3077 3180 */
3078 3181 if ((fptr = ql_get_fbuf(ha->fcache, FTYPE_FW)) != NULL) {
3079 3182
3080 3183 hsize = sizeof (pci_header_t) + sizeof (pci_data_t);
3081 3184 if (hsize > fptr->buflen) {
3082 - CACHE_UNLOCK(ha);
3083 3185 EL(ha, "header size (%xh) exceeds buflen (%xh)\n",
3084 3186 hsize, fptr->buflen);
3085 3187 cmd->Status = EXT_STATUS_COPY_ERR;
3086 3188 cmd->DetailStatus = 0;
3087 3189 return;
3088 3190 }
3089 3191
3090 3192 cpsize = ((fptr->buflen - hsize) < 100 ?
3091 3193 fptr->buflen - hsize : 100);
3092 3194
3093 - if (ddi_copyout(fptr->buf+hsize,
3195 + if (ddi_copyout(fptr->buf + hsize,
3094 3196 (void *)(uintptr_t)(cmd->ResponseAdr + 300),
3095 3197 cpsize, mode) != 0) {
3096 - CACHE_UNLOCK(ha);
3097 3198 EL(ha, "fw ddicopy failed, done\n");
3098 3199 cmd->Status = EXT_STATUS_COPY_ERR;
3099 3200 cmd->DetailStatus = 0;
3100 3201 return;
3101 3202 }
3102 3203 bsize += 100;
3103 3204 }
3104 3205
3105 - CACHE_UNLOCK(ha);
3106 3206 cmd->Status = EXT_STATUS_OK;
3107 3207 cmd->DetailStatus = bsize;
3108 3208
3109 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3209 + QL_PRINT_9(ha, "done\n");
3110 3210 }
3111 3211
3112 3212 /*
3113 3213 * ql_get_fcache_ex
3114 3214 * Dumps flash cache contents.
3115 3215 *
3116 3216 * Input:
3117 3217 * ha: adapter state pointer.
3118 3218 * cmd: EXT_IOCTL cmd struct pointer.
3119 3219 * mode: flags.
3120 3220 *
3121 3221 * Returns:
3122 3222 * None, request status indicated in cmd->Status.
3123 3223 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
3124 3224 * Context:
3125 3225 * Kernel context.
3126 3226 */
3127 3227 static void
3128 3228 ql_get_fcache_ex(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3129 3229 {
3130 3230 uint32_t bsize = 0;
3131 3231 uint32_t boff = 0;
3132 3232 ql_fcache_t *fptr;
3133 3233
3134 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3234 + QL_PRINT_9(ha, "started\n");
3135 3235
3136 - CACHE_LOCK(ha);
3137 3236 if (ha->fcache == NULL) {
3138 - CACHE_UNLOCK(ha);
3139 3237 cmd->Status = EXT_STATUS_ERR;
3140 3238 EL(ha, "failed, adapter fcache not setup\n");
3141 3239 return;
3142 3240 }
3143 3241
3144 3242 /* Make sure user passed enough buffer space */
3145 3243 for (fptr = ha->fcache; fptr != NULL; fptr = fptr->next) {
3146 3244 bsize += FBUFSIZE;
3147 3245 }
3148 3246
3149 3247 if (cmd->ResponseLen < bsize) {
3150 - CACHE_UNLOCK(ha);
3151 3248 if (cmd->ResponseLen != 0) {
3152 3249 EL(ha, "failed, ResponseLen < %d, len passed=%xh\n",
3153 3250 bsize, cmd->ResponseLen);
3154 3251 }
3155 3252 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
3156 3253 cmd->DetailStatus = bsize;
3157 3254 return;
3158 3255 }
3159 3256
3160 3257 boff = 0;
3161 3258 fptr = ha->fcache;
3162 3259 while ((fptr != NULL) && (fptr->buf != NULL)) {
3163 3260 /* Get the next image */
3164 3261 if (ddi_copyout(fptr->buf,
3165 3262 (void *)(uintptr_t)(cmd->ResponseAdr + boff),
3166 3263 (fptr->buflen < FBUFSIZE ? fptr->buflen : FBUFSIZE),
3167 3264 mode) != 0) {
3168 - CACHE_UNLOCK(ha);
3169 3265 EL(ha, "failed, ddicopy at %xh, done\n", boff);
3170 3266 cmd->Status = EXT_STATUS_COPY_ERR;
3171 3267 cmd->DetailStatus = 0;
3172 3268 return;
3173 3269 }
3174 3270 boff += FBUFSIZE;
3175 3271 fptr = fptr->next;
3176 3272 }
3177 3273
3178 - CACHE_UNLOCK(ha);
3179 3274 cmd->Status = EXT_STATUS_OK;
3180 3275 cmd->DetailStatus = bsize;
3181 3276
3182 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3277 + QL_PRINT_9(ha, "done\n");
3183 3278 }
3184 3279
3185 3280 /*
3186 3281 * ql_read_flash
3187 3282 * Get flash contents.
3188 3283 *
3189 3284 * Input:
3190 3285 * ha: adapter state pointer.
3191 3286 * cmd: EXT_IOCTL cmd struct pointer.
3192 3287 * mode: flags.
3193 3288 *
3194 3289 * Returns:
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
3195 3290 * None, request status indicated in cmd->Status.
3196 3291 *
3197 3292 * Context:
3198 3293 * Kernel context.
3199 3294 */
3200 3295 static void
3201 3296 ql_read_flash(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3202 3297 {
3203 3298 ql_xioctl_t *xp = ha->xioctl;
3204 3299
3205 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3300 + QL_PRINT_9(ha, "started\n");
3206 3301
3207 - if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
3302 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1) &&
3303 + ql_stall_driver(ha, 0) != QL_SUCCESS) {
3208 3304 EL(ha, "ql_stall_driver failed\n");
3305 + ql_restart_driver(ha);
3209 3306 cmd->Status = EXT_STATUS_BUSY;
3210 3307 cmd->DetailStatus = xp->fdesc.flash_size;
3211 3308 cmd->ResponseLen = 0;
3212 3309 return;
3213 3310 }
3214 3311
3215 3312 if (ql_setup_fcache(ha) != QL_SUCCESS) {
3216 3313 cmd->Status = EXT_STATUS_ERR;
3217 3314 cmd->DetailStatus = xp->fdesc.flash_size;
3218 3315 EL(ha, "failed, ResponseLen=%xh, flash size=%xh\n",
3219 3316 cmd->ResponseLen, xp->fdesc.flash_size);
3220 3317 cmd->ResponseLen = 0;
3221 3318 } else {
3222 3319 /* adjust read size to flash size */
3223 3320 if (cmd->ResponseLen > xp->fdesc.flash_size) {
3224 3321 EL(ha, "adjusting req=%xh, max=%xh\n",
3225 3322 cmd->ResponseLen, xp->fdesc.flash_size);
3226 3323 cmd->ResponseLen = xp->fdesc.flash_size;
3227 3324 }
3228 3325
3229 3326 /* Get flash data. */
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
3230 3327 if (ql_flash_fcode_dump(ha,
3231 3328 (void *)(uintptr_t)(cmd->ResponseAdr),
3232 3329 (size_t)(cmd->ResponseLen), 0, mode) != 0) {
3233 3330 cmd->Status = EXT_STATUS_COPY_ERR;
3234 3331 cmd->ResponseLen = 0;
3235 3332 EL(ha, "failed,\n");
3236 3333 }
3237 3334 }
3238 3335
3239 3336 /* Resume I/O */
3240 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
3241 - ql_restart_driver(ha);
3242 - } else {
3337 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
3243 3338 EL(ha, "isp_abort_needed for restart\n");
3244 3339 ql_awaken_task_daemon(ha, NULL, ISP_ABORT_NEEDED,
3245 3340 DRIVER_STALL);
3246 3341 }
3247 3342
3248 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3343 + QL_PRINT_9(ha, "done\n");
3249 3344 }
3250 3345
3251 3346 /*
3252 3347 * ql_write_flash
3253 3348 * Loads flash contents.
3254 3349 *
3255 3350 * Input:
3256 3351 * ha: adapter state pointer.
3257 3352 * cmd: EXT_IOCTL cmd struct pointer.
3258 3353 * mode: flags.
3259 3354 *
3260 3355 * Returns:
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
3261 3356 * None, request status indicated in cmd->Status.
3262 3357 *
3263 3358 * Context:
3264 3359 * Kernel context.
3265 3360 */
3266 3361 static void
3267 3362 ql_write_flash(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3268 3363 {
3269 3364 ql_xioctl_t *xp = ha->xioctl;
3270 3365
3271 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3366 + QL_PRINT_9(ha, "started\n");
3272 3367
3273 - if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
3368 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1) &&
3369 + ql_stall_driver(ha, 0) != QL_SUCCESS) {
3274 3370 EL(ha, "ql_stall_driver failed\n");
3371 + ql_restart_driver(ha);
3275 3372 cmd->Status = EXT_STATUS_BUSY;
3276 3373 cmd->DetailStatus = xp->fdesc.flash_size;
3277 3374 cmd->ResponseLen = 0;
3278 3375 return;
3279 3376 }
3280 3377
3281 3378 if (ql_setup_fcache(ha) != QL_SUCCESS) {
3282 3379 cmd->Status = EXT_STATUS_ERR;
3283 3380 cmd->DetailStatus = xp->fdesc.flash_size;
3284 3381 EL(ha, "failed, RequestLen=%xh, size=%xh\n",
3285 3382 cmd->RequestLen, xp->fdesc.flash_size);
3286 3383 cmd->ResponseLen = 0;
3287 3384 } else {
3288 3385 /* Load flash data. */
3289 3386 if (cmd->RequestLen > xp->fdesc.flash_size) {
3290 3387 cmd->Status = EXT_STATUS_ERR;
3291 - cmd->DetailStatus = xp->fdesc.flash_size;
3388 + cmd->DetailStatus = xp->fdesc.flash_size;
3292 3389 EL(ha, "failed, RequestLen=%xh, flash size=%xh\n",
3293 3390 cmd->RequestLen, xp->fdesc.flash_size);
3294 3391 } else if (ql_flash_fcode_load(ha,
3295 3392 (void *)(uintptr_t)(cmd->RequestAdr),
3296 3393 (size_t)(cmd->RequestLen), mode) != 0) {
3297 3394 cmd->Status = EXT_STATUS_COPY_ERR;
3298 3395 EL(ha, "failed,\n");
3299 3396 }
3300 3397 }
3301 3398
3302 3399 /* Resume I/O */
3303 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
3304 - ql_restart_driver(ha);
3305 - } else {
3400 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
3306 3401 EL(ha, "isp_abort_needed for restart\n");
3307 3402 ql_awaken_task_daemon(ha, NULL, ISP_ABORT_NEEDED,
3308 3403 DRIVER_STALL);
3309 3404 }
3310 3405
3311 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3406 + QL_PRINT_9(ha, "done\n");
3312 3407 }
3313 3408
3314 3409 /*
3315 3410 * ql_diagnostic_loopback
3316 3411 * Performs EXT_CC_LOOPBACK Command
3317 3412 *
3318 3413 * Input:
3319 3414 * ha: adapter state pointer.
3320 3415 * cmd: Local EXT_IOCTL cmd struct pointer.
3321 3416 * mode: flags.
3322 3417 *
3323 3418 * Returns:
3324 3419 * None, request status indicated in cmd->Status.
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
3325 3420 *
3326 3421 * Context:
3327 3422 * Kernel context.
3328 3423 */
3329 3424 static void
3330 3425 ql_diagnostic_loopback(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3331 3426 {
3332 3427 EXT_LOOPBACK_REQ plbreq;
3333 3428 EXT_LOOPBACK_RSP plbrsp;
3334 3429 ql_mbx_data_t mr;
3335 - uint32_t rval;
3336 - caddr_t bp;
3430 + uint32_t rval, timer, bpsize;
3431 + caddr_t bp, pld;
3337 3432 uint16_t opt;
3433 + boolean_t loop_up;
3338 3434
3339 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3435 + QL_PRINT_9(ha, "started\n");
3340 3436
3341 3437 /* Get loop back request. */
3342 3438 if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
3343 3439 (void *)&plbreq, sizeof (EXT_LOOPBACK_REQ), mode) != 0) {
3344 3440 EL(ha, "failed, ddi_copyin\n");
3345 3441 cmd->Status = EXT_STATUS_COPY_ERR;
3346 3442 cmd->ResponseLen = 0;
3347 3443 return;
3348 3444 }
3349 3445
3350 - opt = (uint16_t)(plbreq.Options & MBC_LOOPBACK_POINT_MASK);
3351 -
3352 3446 /* Check transfer length fits in buffer. */
3353 - if (plbreq.BufferLength < plbreq.TransferCount &&
3354 - plbreq.TransferCount < MAILBOX_BUFFER_SIZE) {
3355 - EL(ha, "failed, BufferLength=%d, xfercnt=%d, "
3356 - "mailbox_buffer_size=%d\n", plbreq.BufferLength,
3357 - plbreq.TransferCount, MAILBOX_BUFFER_SIZE);
3447 + if (plbreq.BufferLength < plbreq.TransferCount) {
3448 + EL(ha, "failed, BufferLength=%d, xfercnt=%d\n",
3449 +
3450 + plbreq.BufferLength, plbreq.TransferCount);
3358 3451 cmd->Status = EXT_STATUS_INVALID_PARAM;
3359 3452 cmd->ResponseLen = 0;
3360 3453 return;
3361 3454 }
3362 3455
3363 3456 /* Allocate command memory. */
3364 - bp = kmem_zalloc(plbreq.TransferCount, KM_SLEEP);
3457 + bpsize = plbreq.TransferCount + 4; /* Include opcode size */
3458 + bp = kmem_zalloc(bpsize, KM_SLEEP);
3365 3459 if (bp == NULL) {
3366 3460 EL(ha, "failed, kmem_zalloc\n");
3367 3461 cmd->Status = EXT_STATUS_NO_MEMORY;
3368 3462 cmd->ResponseLen = 0;
3369 3463 return;
3370 3464 }
3465 + pld = bp + 4;
3466 + *bp = 0x10; /* opcode */
3371 3467
3372 3468 /* Get loopback data. */
3373 3469 if (ql_get_buffer_data((caddr_t)(uintptr_t)plbreq.BufferAddress,
3374 - bp, plbreq.TransferCount, mode) != plbreq.TransferCount) {
3470 + pld, plbreq.TransferCount, mode) != plbreq.TransferCount) {
3375 3471 EL(ha, "failed, ddi_copyin-2\n");
3376 - kmem_free(bp, plbreq.TransferCount);
3472 + kmem_free(bp, bpsize);
3377 3473 cmd->Status = EXT_STATUS_COPY_ERR;
3378 3474 cmd->ResponseLen = 0;
3379 3475 return;
3380 3476 }
3381 3477
3382 - if ((ha->task_daemon_flags & (QL_LOOP_TRANSITION | DRIVER_STALL)) ||
3478 + if (LOOP_RECONFIGURE(ha) ||
3383 3479 ql_stall_driver(ha, 0) != QL_SUCCESS) {
3384 3480 EL(ha, "failed, LOOP_NOT_READY\n");
3385 - kmem_free(bp, plbreq.TransferCount);
3481 + ql_restart_driver(ha);
3482 + kmem_free(bp, bpsize);
3386 3483 cmd->Status = EXT_STATUS_BUSY;
3387 3484 cmd->ResponseLen = 0;
3388 3485 return;
3389 3486 }
3487 + loop_up = ha->task_daemon_flags & LOOP_DOWN ? B_FALSE : B_TRUE;
3390 3488
3391 3489 /* Shutdown IP. */
3392 3490 if (ha->flags & IP_INITIALIZED) {
3393 3491 (void) ql_shutdown_ip(ha);
3394 3492 }
3395 3493
3396 3494 /* determine topology so we can send the loopback or the echo */
3397 3495 /* Echo is supported on 2300's only and above */
3398 3496
3399 - if (CFG_IST(ha, CFG_CTRL_8081)) {
3400 - if (!(ha->task_daemon_flags & LOOP_DOWN) && opt ==
3401 - MBC_LOOPBACK_POINT_EXTERNAL) {
3497 + ADAPTER_STATE_LOCK(ha);
3498 + ha->flags |= LOOPBACK_ACTIVE;
3499 + ADAPTER_STATE_UNLOCK(ha);
3500 +
3501 + opt = plbreq.Options;
3502 +
3503 + if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
3504 + opt = (uint16_t)(plbreq.Options & MBC_LOOPBACK_POINT_MASK);
3505 + if (loop_up && opt == MBC_LOOPBACK_POINT_EXTERNAL) {
3402 3506 if (plbreq.TransferCount > 252) {
3403 3507 EL(ha, "transfer count (%d) > 252\n",
3404 3508 plbreq.TransferCount);
3405 - kmem_free(bp, plbreq.TransferCount);
3509 + ql_restart_driver(ha);
3510 + kmem_free(bp, bpsize);
3406 3511 cmd->Status = EXT_STATUS_INVALID_PARAM;
3407 3512 cmd->ResponseLen = 0;
3408 3513 return;
3409 3514 }
3410 3515 plbrsp.CommandSent = INT_DEF_LB_ECHO_CMD;
3411 - rval = ql_diag_echo(ha, 0, bp, plbreq.TransferCount,
3516 + rval = ql_diag_echo(ha, pld, plbreq.TransferCount,
3412 3517 MBC_ECHO_ELS, &mr);
3413 3518 } else {
3414 - if (CFG_IST(ha, CFG_CTRL_81XX)) {
3519 + if (CFG_IST(ha, CFG_LOOP_POINT_SUPPORT)) {
3415 3520 (void) ql_set_loop_point(ha, opt);
3416 3521 }
3417 3522 plbrsp.CommandSent = INT_DEF_LB_LOOPBACK_CMD;
3418 - rval = ql_diag_loopback(ha, 0, bp, plbreq.TransferCount,
3523 + rval = ql_diag_loopback(ha, pld, plbreq.TransferCount,
3419 3524 opt, plbreq.IterationCount, &mr);
3420 - if (CFG_IST(ha, CFG_CTRL_81XX)) {
3525 + if (mr.mb[0] == 0x4005 && mr.mb[1] == 0x17) {
3526 + (void) ql_abort_isp(ha);
3527 + }
3528 + if (CFG_IST(ha, CFG_LOOP_POINT_SUPPORT)) {
3421 3529 (void) ql_set_loop_point(ha, 0);
3422 3530 }
3423 3531 }
3424 3532 } else {
3425 - if (!(ha->task_daemon_flags & LOOP_DOWN) &&
3426 - (ha->topology & QL_F_PORT) &&
3427 - ha->device_id >= 0x2300) {
3428 - QL_PRINT_9(CE_CONT, "(%d): F_PORT topology -- using "
3429 - "echo\n", ha->instance);
3533 + if (loop_up && (ha->topology & QL_F_PORT) &&
3534 + CFG_IST(ha, CFG_LB_ECHO_SUPPORT)) {
3535 + QL_PRINT_9(ha, "F_PORT topology -- using "
3536 + "echo\n");
3430 3537 plbrsp.CommandSent = INT_DEF_LB_ECHO_CMD;
3431 - rval = ql_diag_echo(ha, 0, bp, plbreq.TransferCount,
3432 - (uint16_t)(CFG_IST(ha, CFG_CTRL_8081) ?
3433 - MBC_ECHO_ELS : MBC_ECHO_64BIT), &mr);
3538 + if ((rval = ql_diag_echo(ha, bp, bpsize,
3539 + (uint16_t)(CFG_IST(ha, CFG_ISP_FW_TYPE_1) ?
3540 + MBC_ECHO_64BIT : MBC_ECHO_ELS), &mr)) !=
3541 + QL_SUCCESS) {
3542 + rval = ql_diag_echo(ha, pld,
3543 + plbreq.TransferCount,
3544 + (uint16_t)(CFG_IST(ha, CFG_ISP_FW_TYPE_1) ?
3545 + MBC_ECHO_64BIT : 0), &mr);
3546 + }
3434 3547 } else {
3435 3548 plbrsp.CommandSent = INT_DEF_LB_LOOPBACK_CMD;
3436 - rval = ql_diag_loopback(ha, 0, bp, plbreq.TransferCount,
3549 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
3550 + opt = (uint16_t)(opt | MBC_LOOPBACK_64BIT);
3551 + }
3552 + rval = ql_diag_loopback(ha, pld, plbreq.TransferCount,
3437 3553 opt, plbreq.IterationCount, &mr);
3438 3554 }
3439 3555 }
3556 + ADAPTER_STATE_LOCK(ha);
3557 + ha->flags &= ~LOOPBACK_ACTIVE;
3558 + ADAPTER_STATE_UNLOCK(ha);
3440 3559
3441 3560 ql_restart_driver(ha);
3561 + if (loop_up && opt == MBC_LOOPBACK_POINT_INTERNAL) {
3562 + timer = 30;
3563 + do {
3564 + delay(100);
3565 + } while (timer-- && LOOP_NOT_READY(ha));
3566 + }
3442 3567
3443 3568 /* Restart IP if it was shutdown. */
3444 3569 if (ha->flags & IP_ENABLED && !(ha->flags & IP_INITIALIZED)) {
3445 3570 (void) ql_initialize_ip(ha);
3446 3571 ql_isp_rcvbuf(ha);
3447 3572 }
3448 3573
3449 3574 if (rval != QL_SUCCESS) {
3450 3575 EL(ha, "failed, diagnostic_loopback_mbx=%xh\n", rval);
3451 - kmem_free(bp, plbreq.TransferCount);
3576 + kmem_free(bp, bpsize);
3452 3577 cmd->Status = EXT_STATUS_MAILBOX;
3453 3578 cmd->DetailStatus = rval;
3454 3579 cmd->ResponseLen = 0;
3455 3580 return;
3456 3581 }
3457 3582
3458 3583 /* Return loopback data. */
3459 - if (ql_send_buffer_data(bp, (caddr_t)(uintptr_t)plbreq.BufferAddress,
3584 + if (ql_send_buffer_data(pld, (caddr_t)(uintptr_t)plbreq.BufferAddress,
3460 3585 plbreq.TransferCount, mode) != plbreq.TransferCount) {
3461 3586 EL(ha, "failed, ddi_copyout\n");
3462 - kmem_free(bp, plbreq.TransferCount);
3587 + kmem_free(bp, bpsize);
3463 3588 cmd->Status = EXT_STATUS_COPY_ERR;
3464 3589 cmd->ResponseLen = 0;
3465 3590 return;
3466 3591 }
3467 - kmem_free(bp, plbreq.TransferCount);
3592 + kmem_free(bp, bpsize);
3468 3593
3469 3594 /* Return loopback results. */
3470 3595 plbrsp.BufferAddress = plbreq.BufferAddress;
3471 3596 plbrsp.BufferLength = plbreq.TransferCount;
3472 3597 plbrsp.CompletionStatus = mr.mb[0];
3473 3598
3474 3599 if (plbrsp.CommandSent == INT_DEF_LB_ECHO_CMD) {
3475 3600 plbrsp.CrcErrorCount = 0;
3476 3601 plbrsp.DisparityErrorCount = 0;
3477 3602 plbrsp.FrameLengthErrorCount = 0;
3478 3603 plbrsp.IterationCountLastError = 0;
3479 3604 } else {
3480 3605 plbrsp.CrcErrorCount = mr.mb[1];
3481 3606 plbrsp.DisparityErrorCount = mr.mb[2];
3482 3607 plbrsp.FrameLengthErrorCount = mr.mb[3];
3483 - plbrsp.IterationCountLastError = (mr.mb[19] >> 16) | mr.mb[18];
3608 + plbrsp.IterationCountLastError =
3609 + SHORT_TO_LONG(mr.mb[18], mr.mb[19]);
3484 3610 }
3485 3611
3486 3612 rval = ddi_copyout((void *)&plbrsp,
3487 3613 (void *)(uintptr_t)cmd->ResponseAdr,
3488 3614 sizeof (EXT_LOOPBACK_RSP), mode);
3489 3615 if (rval != 0) {
3490 3616 EL(ha, "failed, ddi_copyout-2\n");
3491 3617 cmd->Status = EXT_STATUS_COPY_ERR;
3492 3618 cmd->ResponseLen = 0;
3493 3619 return;
3494 3620 }
3495 3621 cmd->ResponseLen = sizeof (EXT_LOOPBACK_RSP);
3496 3622
3497 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3623 + QL_PRINT_9(ha, "done\n");
3498 3624 }
3499 3625
3500 3626 /*
3501 3627 * ql_set_loop_point
3502 3628 * Setup loop point for port configuration.
3503 3629 *
3504 3630 * Input:
3505 3631 * ha: adapter state structure.
3506 3632 * opt: loop point option.
3507 3633 *
3508 3634 * Returns:
3509 3635 * ql local function return status code.
3510 3636 *
3511 3637 * Context:
3512 3638 * Kernel context.
3513 3639 */
3514 -static int
3640 +int
3515 3641 ql_set_loop_point(ql_adapter_state_t *ha, uint16_t opt)
3516 3642 {
3517 3643 ql_mbx_data_t mr;
3518 3644 int rval;
3519 3645 uint32_t timer;
3520 3646
3521 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3647 + QL_PRINT_9(ha, "started\n");
3522 3648
3523 3649 /*
3524 3650 * We get the current port config, modify the loopback field and
3525 3651 * write it back out.
3526 3652 */
3527 3653 if ((rval = ql_get_port_config(ha, &mr)) != QL_SUCCESS) {
3528 3654 EL(ha, "get_port_config status=%xh\n", rval);
3529 3655 return (rval);
3530 3656 }
3531 3657 /*
3532 3658 * Set the loopback mode field while maintaining the others.
3533 - * Currently only internal or none are supported.
3534 3659 */
3535 - mr.mb[1] = (uint16_t)(mr.mb[1] &~LOOPBACK_MODE_FIELD_MASK);
3660 + mr.mb[1] = (uint16_t)(mr.mb[1] & ~LOOPBACK_MODE_FIELD_MASK);
3536 3661 if (opt == MBC_LOOPBACK_POINT_INTERNAL) {
3537 - mr.mb[1] = (uint16_t)(mr.mb[1] |
3538 - LOOPBACK_MODE(LOOPBACK_MODE_INTERNAL));
3662 + mr.mb[1] = (uint16_t)(mr.mb[1] | LOOPBACK_MODE_INTERNAL);
3663 + } else if (CFG_IST(ha, CFG_CTRL_80XX) &&
3664 + opt == MBC_LOOPBACK_POINT_EXTERNAL) {
3665 + mr.mb[1] = (uint16_t)(mr.mb[1] | LOOPBACK_MODE_EXTERNAL);
3539 3666 }
3540 3667 /*
3541 3668 * Changing the port configuration will cause the port state to cycle
3542 3669 * down and back up. The indication that this has happened is that
3543 3670 * the point to point flag gets set.
3544 3671 */
3545 3672 ADAPTER_STATE_LOCK(ha);
3546 3673 ha->flags &= ~POINT_TO_POINT;
3547 3674 ADAPTER_STATE_UNLOCK(ha);
3548 3675 if ((rval = ql_set_port_config(ha, &mr)) != QL_SUCCESS) {
3549 3676 EL(ha, "set_port_config status=%xh\n", rval);
3550 3677 }
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
3551 3678
3552 3679 /* wait for a while */
3553 3680 for (timer = opt ? 10 : 0; timer; timer--) {
3554 3681 if (ha->flags & POINT_TO_POINT) {
3555 3682 break;
3556 3683 }
3557 3684 /* Delay for 1000000 usec (1 second). */
3558 3685 ql_delay(ha, 1000000);
3559 3686 }
3560 3687
3561 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3688 + QL_PRINT_9(ha, "done\n");
3562 3689
3563 3690 return (rval);
3564 3691 }
3565 3692
3566 3693 /*
3567 3694 * ql_send_els_rnid
3568 3695 * IOCTL for extended link service RNID command.
3569 3696 *
3570 3697 * Input:
3571 3698 * ha: adapter state pointer.
3572 3699 * cmd: User space CT arguments pointer.
3573 3700 * mode: flags.
3574 3701 *
3575 3702 * Returns:
3576 3703 * None, request status indicated in cmd->Status.
3577 3704 *
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3578 3705 * Context:
3579 3706 * Kernel context.
3580 3707 */
3581 3708 static void
3582 3709 ql_send_els_rnid(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3583 3710 {
3584 3711 EXT_RNID_REQ tmp_rnid;
3585 3712 port_id_t tmp_fcid;
3586 3713 caddr_t tmp_buf, bptr;
3587 3714 uint32_t copy_len;
3588 - ql_tgt_t *tq;
3715 + ql_tgt_t *tq = NULL;
3589 3716 EXT_RNID_DATA rnid_data;
3590 3717 uint32_t loop_ready_wait = 10 * 60 * 10;
3591 3718 int rval = 0;
3592 3719 uint32_t local_hba = 0;
3593 3720
3594 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
3721 + QL_PRINT_9(ha, "started\n");
3595 3722
3596 3723 if (DRIVER_SUSPENDED(ha)) {
3597 3724 EL(ha, "failed, LOOP_NOT_READY\n");
3598 3725 cmd->Status = EXT_STATUS_BUSY;
3599 3726 cmd->ResponseLen = 0;
3600 3727 return;
3601 3728 }
3602 3729
3603 3730 if (cmd->RequestLen != sizeof (EXT_RNID_REQ)) {
3604 3731 /* parameter error */
3605 3732 EL(ha, "failed, RequestLen < EXT_RNID_REQ, Len=%xh\n",
3606 3733 cmd->RequestLen);
3607 3734 cmd->Status = EXT_STATUS_INVALID_PARAM;
3608 3735 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
3609 3736 cmd->ResponseLen = 0;
3610 3737 return;
3611 3738 }
3612 3739
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
3613 3740 if (ddi_copyin((void*)(uintptr_t)cmd->RequestAdr,
3614 3741 &tmp_rnid, cmd->RequestLen, mode) != 0) {
3615 3742 EL(ha, "failed, ddi_copyin\n");
3616 3743 cmd->Status = EXT_STATUS_COPY_ERR;
3617 3744 cmd->ResponseLen = 0;
3618 3745 return;
3619 3746 }
3620 3747
3621 3748 /* Find loop ID of the device */
3622 3749 if (tmp_rnid.Addr.Type == EXT_DEF_TYPE_WWNN) {
3623 - bptr = CFG_IST(ha, CFG_CTRL_24258081) ?
3624 - (caddr_t)&ha->init_ctrl_blk.cb24.node_name :
3625 - (caddr_t)&ha->init_ctrl_blk.cb.node_name;
3750 + bptr = (caddr_t)ha->loginparams.node_ww_name.raw_wwn;
3626 3751 if (bcmp((void *)bptr, (void *)tmp_rnid.Addr.FcAddr.WWNN,
3627 3752 EXT_DEF_WWN_NAME_SIZE) == 0) {
3628 3753 local_hba = 1;
3629 3754 } else {
3630 3755 tq = ql_find_port(ha,
3631 3756 (uint8_t *)tmp_rnid.Addr.FcAddr.WWNN, QLNT_NODE);
3632 3757 }
3633 3758 } else if (tmp_rnid.Addr.Type == EXT_DEF_TYPE_WWPN) {
3634 - bptr = CFG_IST(ha, CFG_CTRL_24258081) ?
3635 - (caddr_t)&ha->init_ctrl_blk.cb24.port_name :
3636 - (caddr_t)&ha->init_ctrl_blk.cb.port_name;
3759 + bptr = (caddr_t)ha->loginparams.nport_ww_name.raw_wwn;
3637 3760 if (bcmp((void *)bptr, (void *)tmp_rnid.Addr.FcAddr.WWPN,
3638 3761 EXT_DEF_WWN_NAME_SIZE) == 0) {
3639 3762 local_hba = 1;
3640 3763 } else {
3641 3764 tq = ql_find_port(ha,
3642 3765 (uint8_t *)tmp_rnid.Addr.FcAddr.WWPN, QLNT_PORT);
3643 3766 }
3644 3767 } else if (tmp_rnid.Addr.Type == EXT_DEF_TYPE_PORTID) {
3645 3768 /*
3646 3769 * Copy caller's d_id to tmp space.
3647 3770 */
3648 3771 bcopy(&tmp_rnid.Addr.FcAddr.Id[1], tmp_fcid.r.d_id,
3649 3772 EXT_DEF_PORTID_SIZE_ACTUAL);
3650 3773 BIG_ENDIAN_24(&tmp_fcid.r.d_id[0]);
3651 3774
3652 3775 if (bcmp((void *)&ha->d_id, (void *)tmp_fcid.r.d_id,
3653 3776 EXT_DEF_PORTID_SIZE_ACTUAL) == 0) {
3654 3777 local_hba = 1;
3655 3778 } else {
3656 3779 tq = ql_find_port(ha, (uint8_t *)tmp_fcid.r.d_id,
3657 3780 QLNT_PID);
3658 3781 }
3659 3782 }
3660 3783
3661 3784 /* Allocate memory for command. */
3662 3785 tmp_buf = kmem_zalloc(SEND_RNID_RSP_SIZE, KM_SLEEP);
3663 3786 if (tmp_buf == NULL) {
3664 3787 EL(ha, "failed, kmem_zalloc\n");
3665 3788 cmd->Status = EXT_STATUS_NO_MEMORY;
3666 3789 cmd->ResponseLen = 0;
3667 3790 return;
3668 3791 }
3669 3792
3670 3793 if (local_hba) {
3671 3794 rval = ql_get_rnid_params(ha, SEND_RNID_RSP_SIZE, tmp_buf);
3672 3795 if (rval != QL_SUCCESS) {
3673 3796 EL(ha, "failed, get_rnid_params_mbx=%xh\n", rval);
3674 3797 kmem_free(tmp_buf, SEND_RNID_RSP_SIZE);
3675 3798 cmd->Status = EXT_STATUS_ERR;
3676 3799 cmd->ResponseLen = 0;
3677 3800 return;
|
↓ open down ↓ |
31 lines elided |
↑ open up ↑ |
3678 3801 }
3679 3802
3680 3803 /* Save gotten RNID data. */
3681 3804 bcopy(tmp_buf, &rnid_data, sizeof (EXT_RNID_DATA));
3682 3805
3683 3806 /* Now build the Send RNID response */
3684 3807 tmp_buf[0] = (char)(EXT_DEF_RNID_DFORMAT_TOPO_DISC);
3685 3808 tmp_buf[1] = (2 * EXT_DEF_WWN_NAME_SIZE);
3686 3809 tmp_buf[2] = 0;
3687 3810 tmp_buf[3] = sizeof (EXT_RNID_DATA);
3688 -
3689 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
3690 - bcopy(ha->init_ctrl_blk.cb24.port_name, &tmp_buf[4],
3691 - EXT_DEF_WWN_NAME_SIZE);
3692 - bcopy(ha->init_ctrl_blk.cb24.node_name,
3693 - &tmp_buf[4 + EXT_DEF_WWN_NAME_SIZE],
3694 - EXT_DEF_WWN_NAME_SIZE);
3695 - } else {
3696 - bcopy(ha->init_ctrl_blk.cb.port_name, &tmp_buf[4],
3697 - EXT_DEF_WWN_NAME_SIZE);
3698 - bcopy(ha->init_ctrl_blk.cb.node_name,
3699 - &tmp_buf[4 + EXT_DEF_WWN_NAME_SIZE],
3700 - EXT_DEF_WWN_NAME_SIZE);
3701 - }
3702 -
3811 + bcopy(ha->loginparams.nport_ww_name.raw_wwn, &tmp_buf[4],
3812 + EXT_DEF_WWN_NAME_SIZE);
3813 + bcopy(ha->loginparams.node_ww_name.raw_wwn,
3814 + &tmp_buf[4 + EXT_DEF_WWN_NAME_SIZE],
3815 + EXT_DEF_WWN_NAME_SIZE);
3703 3816 bcopy((uint8_t *)&rnid_data,
3704 3817 &tmp_buf[4 + 2 * EXT_DEF_WWN_NAME_SIZE],
3705 3818 sizeof (EXT_RNID_DATA));
3706 3819 } else {
3707 3820 if (tq == NULL) {
3708 3821 /* no matching device */
3709 3822 EL(ha, "failed, device not found\n");
3710 3823 kmem_free(tmp_buf, SEND_RNID_RSP_SIZE);
3711 3824 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
3712 3825 cmd->DetailStatus = EXT_DSTATUS_TARGET;
3713 3826 cmd->ResponseLen = 0;
3714 3827 return;
3715 3828 }
3716 3829
3717 3830 /* Send command */
3718 3831 rval = ql_send_rnid_els(ha, tq->loop_id,
3719 3832 (uint8_t)tmp_rnid.DataFormat, SEND_RNID_RSP_SIZE, tmp_buf);
3720 3833 if (rval != QL_SUCCESS) {
3721 3834 EL(ha, "failed, send_rnid_mbx=%xh, id=%xh\n",
3722 3835 rval, tq->loop_id);
3723 3836 while (LOOP_NOT_READY(ha)) {
3724 3837 ql_delay(ha, 100000);
3725 3838 if (loop_ready_wait-- == 0) {
3726 3839 EL(ha, "failed, loop not ready\n");
3727 3840 cmd->Status = EXT_STATUS_ERR;
3728 3841 cmd->ResponseLen = 0;
3729 3842 }
3730 3843 }
3731 3844 rval = ql_send_rnid_els(ha, tq->loop_id,
3732 3845 (uint8_t)tmp_rnid.DataFormat, SEND_RNID_RSP_SIZE,
3733 3846 tmp_buf);
3734 3847 if (rval != QL_SUCCESS) {
3735 3848 /* error */
3736 3849 EL(ha, "failed, send_rnid_mbx=%xh, id=%xh\n",
3737 3850 rval, tq->loop_id);
3738 3851 kmem_free(tmp_buf, SEND_RNID_RSP_SIZE);
3739 3852 cmd->Status = EXT_STATUS_ERR;
3740 3853 cmd->ResponseLen = 0;
3741 3854 return;
3742 3855 }
3743 3856 }
3744 3857 }
3745 3858
3746 3859 /* Copy the response */
3747 3860 copy_len = (cmd->ResponseLen > SEND_RNID_RSP_SIZE) ?
3748 3861 SEND_RNID_RSP_SIZE : cmd->ResponseLen;
3749 3862
3750 3863 if (ql_send_buffer_data(tmp_buf, (caddr_t)(uintptr_t)cmd->ResponseAdr,
3751 3864 copy_len, mode) != copy_len) {
3752 3865 cmd->Status = EXT_STATUS_COPY_ERR;
3753 3866 EL(ha, "failed, ddi_copyout\n");
3754 3867 } else {
|
↓ open down ↓ |
42 lines elided |
↑ open up ↑ |
3755 3868 cmd->ResponseLen = copy_len;
3756 3869 if (copy_len < SEND_RNID_RSP_SIZE) {
3757 3870 cmd->Status = EXT_STATUS_DATA_OVERRUN;
3758 3871 EL(ha, "failed, EXT_STATUS_DATA_OVERRUN\n");
3759 3872
3760 3873 } else if (cmd->ResponseLen > SEND_RNID_RSP_SIZE) {
3761 3874 cmd->Status = EXT_STATUS_DATA_UNDERRUN;
3762 3875 EL(ha, "failed, EXT_STATUS_DATA_UNDERRUN\n");
3763 3876 } else {
3764 3877 cmd->Status = EXT_STATUS_OK;
3765 - QL_PRINT_9(CE_CONT, "(%d): done\n",
3878 + QL_PRINT_9(ha, "done\n",
3766 3879 ha->instance);
3767 3880 }
3768 3881 }
3769 3882
3770 3883 kmem_free(tmp_buf, SEND_RNID_RSP_SIZE);
3771 3884 }
3772 3885
3773 3886 /*
3774 3887 * ql_set_host_data
3775 3888 * Process IOCTL subcommand to set host/adapter related data.
3776 3889 *
3777 3890 * Input:
3778 3891 * ha: adapter state pointer.
3779 3892 * cmd: User space CT arguments pointer.
3780 3893 * mode: flags.
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
3781 3894 *
3782 3895 * Returns:
3783 3896 * None, request status indicated in cmd->Status.
3784 3897 *
3785 3898 * Context:
3786 3899 * Kernel context.
3787 3900 */
3788 3901 static void
3789 3902 ql_set_host_data(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3790 3903 {
3791 - QL_PRINT_9(CE_CONT, "(%d): started, SubCode=%d\n", ha->instance,
3904 + QL_PRINT_9(ha, "started, SubCode=%d\n",
3792 3905 cmd->SubCode);
3793 3906
3794 3907 /*
3795 3908 * case off on command subcode
3796 3909 */
3797 3910 switch (cmd->SubCode) {
3798 3911 case EXT_SC_SET_RNID:
3799 3912 ql_set_rnid_parameters(ha, cmd, mode);
3800 3913 break;
3801 3914 case EXT_SC_RST_STATISTICS:
3802 3915 (void) ql_reset_statistics(ha, cmd);
3803 3916 break;
3804 3917 case EXT_SC_SET_BEACON_STATE:
3805 3918 ql_set_led_state(ha, cmd, mode);
3806 3919 break;
3807 3920 case EXT_SC_SET_PARMS:
3808 3921 case EXT_SC_SET_BUS_MODE:
3809 3922 case EXT_SC_SET_DR_DUMP_BUF:
3810 3923 case EXT_SC_SET_RISC_CODE:
3811 3924 case EXT_SC_SET_FLASH_RAM:
3812 3925 case EXT_SC_SET_LUN_BITMASK:
3813 3926 case EXT_SC_SET_RETRY_CNT:
3814 3927 case EXT_SC_SET_RTIN:
3815 3928 case EXT_SC_SET_FC_LUN_BITMASK:
3816 3929 case EXT_SC_ADD_TARGET_DEVICE:
3817 3930 case EXT_SC_SWAP_TARGET_DEVICE:
3818 3931 case EXT_SC_SET_SEL_TIMEOUT:
3819 3932 default:
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
3820 3933 /* function not supported. */
3821 3934 EL(ha, "failed, function not supported=%d\n", cmd->SubCode);
3822 3935 cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
3823 3936 break;
3824 3937 }
3825 3938
3826 3939 if (cmd->Status != EXT_STATUS_OK) {
3827 3940 EL(ha, "failed, Status=%d\n", cmd->Status);
3828 3941 } else {
3829 3942 /*EMPTY*/
3830 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
3943 + QL_PRINT_9(ha, "done\n");
3831 3944 }
3832 3945 }
3833 3946
3834 3947 /*
3835 3948 * ql_get_host_data
3836 3949 * Performs EXT_CC_GET_DATA subcommands.
3837 3950 *
3838 3951 * Input:
3839 3952 * ha: adapter state pointer.
3840 3953 * cmd: Local EXT_IOCTL cmd struct pointer.
3841 3954 * mode: flags.
3842 3955 *
3843 3956 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
3844 3957 * None, request status indicated in cmd->Status.
3845 3958 *
3846 3959 * Context:
3847 3960 * Kernel context.
3848 3961 */
3849 3962 static void
3850 3963 ql_get_host_data(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
3851 3964 {
3852 3965 int out_size = 0;
3853 3966
3854 - QL_PRINT_9(CE_CONT, "(%d): started, SubCode=%d\n", ha->instance,
3967 + QL_PRINT_9(ha, "started, SubCode=%d\n",
3855 3968 cmd->SubCode);
3856 3969
3857 3970 /* case off on command subcode */
3858 3971 switch (cmd->SubCode) {
3859 3972 case EXT_SC_GET_STATISTICS:
3860 3973 out_size = sizeof (EXT_HBA_PORT_STAT);
3861 3974 break;
3862 3975 case EXT_SC_GET_FC_STATISTICS:
3863 3976 out_size = sizeof (EXT_HBA_PORT_STAT);
3864 3977 break;
3865 3978 case EXT_SC_GET_PORT_SUMMARY:
3866 3979 out_size = sizeof (EXT_DEVICEDATA);
3867 3980 break;
3868 3981 case EXT_SC_GET_RNID:
3869 3982 out_size = sizeof (EXT_RNID_DATA);
3870 3983 break;
3871 3984 case EXT_SC_GET_TARGET_ID:
3872 3985 out_size = sizeof (EXT_DEST_ADDR);
3873 3986 break;
3874 3987 case EXT_SC_GET_BEACON_STATE:
3875 3988 out_size = sizeof (EXT_BEACON_CONTROL);
3876 3989 break;
3877 3990 case EXT_SC_GET_FC4_STATISTICS:
3878 3991 out_size = sizeof (EXT_HBA_FC4STATISTICS);
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
3879 3992 break;
3880 3993 case EXT_SC_GET_DCBX_PARAM:
3881 3994 out_size = EXT_DEF_DCBX_PARAM_BUF_SIZE;
3882 3995 break;
3883 3996 case EXT_SC_GET_RESOURCE_CNTS:
3884 3997 out_size = sizeof (EXT_RESOURCE_CNTS);
3885 3998 break;
3886 3999 case EXT_SC_GET_FCF_LIST:
3887 4000 out_size = sizeof (EXT_FCF_LIST);
3888 4001 break;
4002 + case EXT_SC_GET_PRIV_STATS:
4003 + out_size = cmd->ResponseLen;
4004 + break;
3889 4005 case EXT_SC_GET_SCSI_ADDR:
3890 4006 case EXT_SC_GET_ERR_DETECTIONS:
3891 4007 case EXT_SC_GET_BUS_MODE:
3892 4008 case EXT_SC_GET_DR_DUMP_BUF:
3893 4009 case EXT_SC_GET_RISC_CODE:
3894 4010 case EXT_SC_GET_FLASH_RAM:
3895 4011 case EXT_SC_GET_LINK_STATUS:
3896 4012 case EXT_SC_GET_LOOP_ID:
3897 4013 case EXT_SC_GET_LUN_BITMASK:
3898 4014 case EXT_SC_GET_PORT_DATABASE:
3899 4015 case EXT_SC_GET_PORT_DATABASE_MEM:
3900 4016 case EXT_SC_GET_POSITION_MAP:
3901 4017 case EXT_SC_GET_RETRY_CNT:
3902 4018 case EXT_SC_GET_RTIN:
3903 4019 case EXT_SC_GET_FC_LUN_BITMASK:
3904 4020 case EXT_SC_GET_SEL_TIMEOUT:
3905 4021 default:
3906 4022 /* function not supported. */
3907 4023 EL(ha, "failed, function not supported=%d\n", cmd->SubCode);
3908 4024 cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
3909 4025 cmd->ResponseLen = 0;
3910 4026 return;
3911 4027 }
3912 4028
3913 4029 if (cmd->ResponseLen < out_size) {
3914 4030 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
3915 4031 cmd->DetailStatus = out_size;
3916 4032 EL(ha, "failed, ResponseLen=%xh, size=%xh\n",
3917 4033 cmd->ResponseLen, out_size);
3918 4034 cmd->ResponseLen = 0;
3919 4035 return;
3920 4036 }
3921 4037
3922 4038 switch (cmd->SubCode) {
3923 4039 case EXT_SC_GET_RNID:
3924 4040 ql_get_rnid_parameters(ha, cmd, mode);
3925 4041 break;
3926 4042 case EXT_SC_GET_STATISTICS:
3927 4043 ql_get_statistics(ha, cmd, mode);
3928 4044 break;
3929 4045 case EXT_SC_GET_FC_STATISTICS:
3930 4046 ql_get_statistics_fc(ha, cmd, mode);
3931 4047 break;
3932 4048 case EXT_SC_GET_FC4_STATISTICS:
3933 4049 ql_get_statistics_fc4(ha, cmd, mode);
3934 4050 break;
3935 4051 case EXT_SC_GET_PORT_SUMMARY:
3936 4052 ql_get_port_summary(ha, cmd, mode);
3937 4053 break;
3938 4054 case EXT_SC_GET_TARGET_ID:
3939 4055 ql_get_target_id(ha, cmd, mode);
3940 4056 break;
3941 4057 case EXT_SC_GET_BEACON_STATE:
3942 4058 ql_get_led_state(ha, cmd, mode);
|
↓ open down ↓ |
44 lines elided |
↑ open up ↑ |
3943 4059 break;
3944 4060 case EXT_SC_GET_DCBX_PARAM:
3945 4061 ql_get_dcbx_parameters(ha, cmd, mode);
3946 4062 break;
3947 4063 case EXT_SC_GET_FCF_LIST:
3948 4064 ql_get_fcf_list(ha, cmd, mode);
3949 4065 break;
3950 4066 case EXT_SC_GET_RESOURCE_CNTS:
3951 4067 ql_get_resource_counts(ha, cmd, mode);
3952 4068 break;
4069 + case EXT_SC_GET_PRIV_STATS:
4070 + ql_get_priv_stats(ha, cmd, mode);
4071 + break;
3953 4072 }
3954 4073
3955 4074 if (cmd->Status != EXT_STATUS_OK) {
3956 4075 EL(ha, "failed, Status=%d\n", cmd->Status);
3957 4076 } else {
3958 4077 /*EMPTY*/
3959 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
4078 + QL_PRINT_9(ha, "done\n");
3960 4079 }
3961 4080 }
3962 4081
3963 4082 /* ******************************************************************** */
3964 4083 /* Helper Functions */
3965 4084 /* ******************************************************************** */
3966 4085
3967 4086 /*
3968 4087 * ql_lun_count
3969 4088 * Get numbers of LUNS on target.
3970 4089 *
3971 4090 * Input:
3972 4091 * ha: adapter state pointer.
3973 4092 * q: device queue pointer.
3974 4093 *
3975 4094 * Returns:
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
3976 4095 * Number of LUNs.
3977 4096 *
3978 4097 * Context:
3979 4098 * Kernel context.
3980 4099 */
3981 4100 static int
3982 4101 ql_lun_count(ql_adapter_state_t *ha, ql_tgt_t *tq)
3983 4102 {
3984 4103 int cnt;
3985 4104
3986 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4105 + QL_PRINT_9(ha, "started\n");
3987 4106
3988 4107 /* Bypass LUNs that failed. */
3989 4108 cnt = ql_report_lun(ha, tq);
3990 4109 if (cnt == 0) {
3991 4110 cnt = ql_inq_scan(ha, tq, ha->maximum_luns_per_target);
3992 4111 }
3993 4112
3994 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
4113 + QL_PRINT_9(ha, "done\n");
3995 4114
3996 4115 return (cnt);
3997 4116 }
3998 4117
3999 4118 /*
4000 4119 * ql_report_lun
4001 4120 * Get numbers of LUNS using report LUN command.
4002 4121 *
4003 4122 * Input:
4004 4123 * ha: adapter state pointer.
4005 4124 * q: target queue pointer.
4006 4125 *
4007 4126 * Returns:
4008 4127 * Number of LUNs.
4009 4128 *
4010 4129 * Context:
4011 4130 * Kernel context.
4012 4131 */
4013 4132 static int
4014 4133 ql_report_lun(ql_adapter_state_t *ha, ql_tgt_t *tq)
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
4015 4134 {
4016 4135 int rval;
4017 4136 uint8_t retries;
4018 4137 ql_mbx_iocb_t *pkt;
4019 4138 ql_rpt_lun_lst_t *rpt;
4020 4139 dma_mem_t dma_mem;
4021 4140 uint32_t pkt_size, cnt;
4022 4141 uint16_t comp_status;
4023 4142 uint8_t scsi_status_h, scsi_status_l, *reqs;
4024 4143
4025 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4144 + QL_PRINT_9(ha, "started\n");
4026 4145
4027 4146 if (DRIVER_SUSPENDED(ha)) {
4028 4147 EL(ha, "failed, LOOP_NOT_READY\n");
4029 4148 return (0);
4030 4149 }
4031 4150
4032 4151 pkt_size = sizeof (ql_mbx_iocb_t) + sizeof (ql_rpt_lun_lst_t);
4033 4152 pkt = kmem_zalloc(pkt_size, KM_SLEEP);
4034 4153 if (pkt == NULL) {
4035 4154 EL(ha, "failed, kmem_zalloc\n");
4036 4155 return (0);
4037 4156 }
4038 4157 rpt = (ql_rpt_lun_lst_t *)((caddr_t)pkt + sizeof (ql_mbx_iocb_t));
4039 4158
4040 4159 /* Get DMA memory for the IOCB */
4041 4160 if (ql_get_dma_mem(ha, &dma_mem, sizeof (ql_rpt_lun_lst_t),
4042 4161 LITTLE_ENDIAN_DMA, QL_DMA_RING_ALIGN) != QL_SUCCESS) {
4043 - cmn_err(CE_WARN, "%s(%d): DMA memory "
4162 + cmn_err(CE_WARN, "%s(%d) DMA memory "
4044 4163 "alloc failed", QL_NAME, ha->instance);
4045 4164 kmem_free(pkt, pkt_size);
4046 4165 return (0);
4047 4166 }
4048 4167
4049 4168 for (retries = 0; retries < 4; retries++) {
4050 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
4169 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
4051 4170 pkt->cmd24.entry_type = IOCB_CMD_TYPE_7;
4052 4171 pkt->cmd24.entry_count = 1;
4053 4172
4054 4173 /* Set N_port handle */
4055 4174 pkt->cmd24.n_port_hdl = (uint16_t)LE_16(tq->loop_id);
4056 4175
4057 4176 /* Set target ID */
4058 4177 pkt->cmd24.target_id[0] = tq->d_id.b.al_pa;
4059 4178 pkt->cmd24.target_id[1] = tq->d_id.b.area;
4060 4179 pkt->cmd24.target_id[2] = tq->d_id.b.domain;
4061 4180
4062 4181 /* Set Virtual Port ID */
4063 4182 pkt->cmd24.vp_index = ha->vp_index;
4064 4183
4065 4184 /* Set ISP command timeout. */
4066 4185 pkt->cmd24.timeout = LE_16(15);
4067 4186
4068 4187 /* Load SCSI CDB */
4069 4188 pkt->cmd24.scsi_cdb[0] = SCMD_REPORT_LUNS;
4070 4189 pkt->cmd24.scsi_cdb[6] =
4071 4190 MSB(MSW(sizeof (ql_rpt_lun_lst_t)));
4072 4191 pkt->cmd24.scsi_cdb[7] =
4073 4192 LSB(MSW(sizeof (ql_rpt_lun_lst_t)));
4074 4193 pkt->cmd24.scsi_cdb[8] =
4075 4194 MSB(LSW(sizeof (ql_rpt_lun_lst_t)));
4076 4195 pkt->cmd24.scsi_cdb[9] =
4077 4196 LSB(LSW(sizeof (ql_rpt_lun_lst_t)));
4078 4197 for (cnt = 0; cnt < MAX_CMDSZ; cnt += 4) {
4079 4198 ql_chg_endian((uint8_t *)&pkt->cmd24.scsi_cdb
4080 4199 + cnt, 4);
4081 4200 }
4082 4201
4083 4202 /* Set tag queue control flags */
|
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
4084 4203 pkt->cmd24.task = TA_STAG;
4085 4204
4086 4205 /* Set transfer direction. */
4087 4206 pkt->cmd24.control_flags = CF_RD;
4088 4207
4089 4208 /* Set data segment count. */
4090 4209 pkt->cmd24.dseg_count = LE_16(1);
4091 4210
4092 4211 /* Load total byte count. */
4093 4212 /* Load data descriptor. */
4094 - pkt->cmd24.dseg_0_address[0] = (uint32_t)
4213 + pkt->cmd24.dseg.address[0] = (uint32_t)
4095 4214 LE_32(LSD(dma_mem.cookie.dmac_laddress));
4096 - pkt->cmd24.dseg_0_address[1] = (uint32_t)
4215 + pkt->cmd24.dseg.address[1] = (uint32_t)
4097 4216 LE_32(MSD(dma_mem.cookie.dmac_laddress));
4098 4217 pkt->cmd24.total_byte_count =
4099 4218 LE_32(sizeof (ql_rpt_lun_lst_t));
4100 - pkt->cmd24.dseg_0_length =
4219 + pkt->cmd24.dseg.length =
4101 4220 LE_32(sizeof (ql_rpt_lun_lst_t));
4102 4221 } else if (CFG_IST(ha, CFG_ENABLE_64BIT_ADDRESSING)) {
4103 4222 pkt->cmd3.entry_type = IOCB_CMD_TYPE_3;
4104 4223 pkt->cmd3.entry_count = 1;
4105 4224 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
4106 4225 pkt->cmd3.target_l = LSB(tq->loop_id);
4107 4226 pkt->cmd3.target_h = MSB(tq->loop_id);
4108 4227 } else {
4109 4228 pkt->cmd3.target_h = LSB(tq->loop_id);
4110 4229 }
4111 4230 pkt->cmd3.control_flags_l = CF_DATA_IN | CF_STAG;
4112 4231 pkt->cmd3.timeout = LE_16(15);
4113 4232 pkt->cmd3.dseg_count = LE_16(1);
4114 4233 pkt->cmd3.scsi_cdb[0] = SCMD_REPORT_LUNS;
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
4115 4234 pkt->cmd3.scsi_cdb[6] =
4116 4235 MSB(MSW(sizeof (ql_rpt_lun_lst_t)));
4117 4236 pkt->cmd3.scsi_cdb[7] =
4118 4237 LSB(MSW(sizeof (ql_rpt_lun_lst_t)));
4119 4238 pkt->cmd3.scsi_cdb[8] =
4120 4239 MSB(LSW(sizeof (ql_rpt_lun_lst_t)));
4121 4240 pkt->cmd3.scsi_cdb[9] =
4122 4241 LSB(LSW(sizeof (ql_rpt_lun_lst_t)));
4123 4242 pkt->cmd3.byte_count =
4124 4243 LE_32(sizeof (ql_rpt_lun_lst_t));
4125 - pkt->cmd3.dseg_0_address[0] = (uint32_t)
4244 + pkt->cmd3.dseg[0].address[0] = (uint32_t)
4126 4245 LE_32(LSD(dma_mem.cookie.dmac_laddress));
4127 - pkt->cmd3.dseg_0_address[1] = (uint32_t)
4246 + pkt->cmd3.dseg[0].address[1] = (uint32_t)
4128 4247 LE_32(MSD(dma_mem.cookie.dmac_laddress));
4129 - pkt->cmd3.dseg_0_length =
4248 + pkt->cmd3.dseg[0].length =
4130 4249 LE_32(sizeof (ql_rpt_lun_lst_t));
4131 4250 } else {
4132 4251 pkt->cmd.entry_type = IOCB_CMD_TYPE_2;
4133 4252 pkt->cmd.entry_count = 1;
4134 4253 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
4135 4254 pkt->cmd.target_l = LSB(tq->loop_id);
4136 4255 pkt->cmd.target_h = MSB(tq->loop_id);
4137 4256 } else {
4138 4257 pkt->cmd.target_h = LSB(tq->loop_id);
4139 4258 }
4140 4259 pkt->cmd.control_flags_l = CF_DATA_IN | CF_STAG;
4141 4260 pkt->cmd.timeout = LE_16(15);
4142 4261 pkt->cmd.dseg_count = LE_16(1);
4143 4262 pkt->cmd.scsi_cdb[0] = SCMD_REPORT_LUNS;
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
4144 4263 pkt->cmd.scsi_cdb[6] =
4145 4264 MSB(MSW(sizeof (ql_rpt_lun_lst_t)));
4146 4265 pkt->cmd.scsi_cdb[7] =
4147 4266 LSB(MSW(sizeof (ql_rpt_lun_lst_t)));
4148 4267 pkt->cmd.scsi_cdb[8] =
4149 4268 MSB(LSW(sizeof (ql_rpt_lun_lst_t)));
4150 4269 pkt->cmd.scsi_cdb[9] =
4151 4270 LSB(LSW(sizeof (ql_rpt_lun_lst_t)));
4152 4271 pkt->cmd.byte_count =
4153 4272 LE_32(sizeof (ql_rpt_lun_lst_t));
4154 - pkt->cmd.dseg_0_address = (uint32_t)
4273 + pkt->cmd.dseg[0].address = (uint32_t)
4155 4274 LE_32(LSD(dma_mem.cookie.dmac_laddress));
4156 - pkt->cmd.dseg_0_length =
4275 + pkt->cmd.dseg[0].length =
4157 4276 LE_32(sizeof (ql_rpt_lun_lst_t));
4158 4277 }
4159 4278
4160 4279 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt,
4161 4280 sizeof (ql_mbx_iocb_t));
4162 4281
4163 4282 /* Sync in coming DMA buffer. */
4164 4283 (void) ddi_dma_sync(dma_mem.dma_handle, 0, dma_mem.size,
4165 4284 DDI_DMA_SYNC_FORKERNEL);
4166 4285 /* Copy in coming DMA data. */
4167 4286 ddi_rep_get8(dma_mem.acc_handle, (uint8_t *)rpt,
4168 4287 (uint8_t *)dma_mem.bp, dma_mem.size, DDI_DEV_AUTOINCR);
4169 4288
4170 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
4289 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
4171 4290 pkt->sts24.entry_status = (uint8_t)
4172 4291 (pkt->sts24.entry_status & 0x3c);
4173 4292 comp_status = (uint16_t)LE_16(pkt->sts24.comp_status);
4174 4293 scsi_status_h = pkt->sts24.scsi_status_h;
4175 4294 scsi_status_l = pkt->sts24.scsi_status_l;
4176 4295 cnt = scsi_status_h & FCP_RSP_LEN_VALID ?
4177 4296 LE_32(pkt->sts24.fcp_rsp_data_length) : 0;
4178 4297 reqs = &pkt->sts24.rsp_sense_data[cnt];
4179 4298 } else {
4180 4299 pkt->sts.entry_status = (uint8_t)
4181 4300 (pkt->sts.entry_status & 0x7e);
4182 4301 comp_status = (uint16_t)LE_16(pkt->sts.comp_status);
4183 4302 scsi_status_h = pkt->sts.scsi_status_h;
4184 4303 scsi_status_l = pkt->sts.scsi_status_l;
4185 4304 reqs = &pkt->sts.req_sense_data[0];
4186 4305 }
4187 4306 if (rval == QL_SUCCESS && pkt->sts.entry_status != 0) {
4188 4307 EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
4189 4308 pkt->sts.entry_status, tq->d_id.b24);
4190 4309 rval = QL_FUNCTION_PARAMETER_ERROR;
4191 4310 }
4192 4311
4193 4312 if (rval != QL_SUCCESS || comp_status != CS_COMPLETE ||
4194 4313 scsi_status_l & STATUS_CHECK) {
4195 4314 /* Device underrun, treat as OK. */
4196 4315 if (rval == QL_SUCCESS &&
4197 4316 comp_status == CS_DATA_UNDERRUN &&
4198 4317 scsi_status_h & FCP_RESID_UNDER) {
4199 4318 break;
4200 4319 }
4201 4320
4202 4321 EL(ha, "failed, issue_iocb=%xh, d_id=%xh, cs=%xh, "
4203 4322 "ss_h=%xh, ss_l=%xh\n", rval, tq->d_id.b24,
4204 4323 comp_status, scsi_status_h, scsi_status_l);
4205 4324
4206 4325 if (rval == QL_SUCCESS) {
4207 4326 if ((comp_status == CS_TIMEOUT) ||
4208 4327 (comp_status == CS_PORT_UNAVAILABLE) ||
4209 4328 (comp_status == CS_PORT_LOGGED_OUT)) {
4210 4329 rval = QL_FUNCTION_TIMEOUT;
4211 4330 break;
4212 4331 }
4213 4332 rval = QL_FUNCTION_FAILED;
4214 4333 } else if (rval == QL_ABORTED) {
4215 4334 break;
4216 4335 }
4217 4336
4218 4337 if (scsi_status_l & STATUS_CHECK) {
4219 4338 EL(ha, "STATUS_CHECK Sense Data\n%2xh%3xh"
4220 4339 "%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh"
4221 4340 "%3xh%3xh%3xh%3xh%3xh%3xh%3xh\n", reqs[0],
4222 4341 reqs[1], reqs[2], reqs[3], reqs[4],
4223 4342 reqs[5], reqs[6], reqs[7], reqs[8],
4224 4343 reqs[9], reqs[10], reqs[11], reqs[12],
4225 4344 reqs[13], reqs[14], reqs[15], reqs[16],
4226 4345 reqs[17]);
4227 4346 }
|
↓ open down ↓ |
47 lines elided |
↑ open up ↑ |
4228 4347 } else {
4229 4348 break;
4230 4349 }
4231 4350 bzero((caddr_t)pkt, pkt_size);
4232 4351 }
4233 4352
4234 4353 if (rval != QL_SUCCESS) {
4235 4354 EL(ha, "failed=%xh\n", rval);
4236 4355 rval = 0;
4237 4356 } else {
4238 - QL_PRINT_9(CE_CONT, "(%d): LUN list\n", ha->instance);
4357 + QL_PRINT_9(ha, "LUN list\n");
4239 4358 QL_DUMP_9(rpt, 8, rpt->hdr.len + 8);
4240 4359 rval = (int)(BE_32(rpt->hdr.len) / 8);
4241 4360 }
4242 4361
4243 4362 kmem_free(pkt, pkt_size);
4244 4363 ql_free_dma_resource(ha, &dma_mem);
4245 4364
4246 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
4365 + QL_PRINT_9(ha, "done\n");
4247 4366
4248 4367 return (rval);
4249 4368 }
4250 4369
4251 4370 /*
4252 4371 * ql_inq_scan
4253 4372 * Get numbers of LUNS using inquiry command.
4254 4373 *
4255 4374 * Input:
4256 4375 * ha: adapter state pointer.
4257 4376 * tq: target queue pointer.
4258 4377 * count: scan for the number of existing LUNs.
4259 4378 *
4260 4379 * Returns:
4261 4380 * Number of LUNs.
4262 4381 *
4263 4382 * Context:
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
4264 4383 * Kernel context.
4265 4384 */
4266 4385 static int
4267 4386 ql_inq_scan(ql_adapter_state_t *ha, ql_tgt_t *tq, int count)
4268 4387 {
4269 4388 int lun, cnt, rval;
4270 4389 ql_mbx_iocb_t *pkt;
4271 4390 uint8_t *inq;
4272 4391 uint32_t pkt_size;
4273 4392
4274 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4393 + QL_PRINT_9(ha, "started\n");
4275 4394
4276 4395 pkt_size = sizeof (ql_mbx_iocb_t) + INQ_DATA_SIZE;
4277 4396 pkt = kmem_zalloc(pkt_size, KM_SLEEP);
4278 4397 if (pkt == NULL) {
4279 4398 EL(ha, "failed, kmem_zalloc\n");
4280 4399 return (0);
4281 4400 }
4282 4401 inq = (uint8_t *)((caddr_t)pkt + sizeof (ql_mbx_iocb_t));
4283 4402
4284 4403 cnt = 0;
4285 4404 for (lun = 0; lun < MAX_LUNS; lun++) {
4286 4405
4287 4406 if (DRIVER_SUSPENDED(ha)) {
4288 4407 rval = QL_LOOP_DOWN;
4289 4408 cnt = 0;
4290 4409 break;
4291 4410 }
4292 4411
4293 4412 rval = ql_inq(ha, tq, lun, pkt, INQ_DATA_SIZE);
4294 4413 if (rval == QL_SUCCESS) {
4295 4414 switch (*inq) {
4296 4415 case DTYPE_DIRECT:
4297 4416 case DTYPE_PROCESSOR: /* Appliance. */
4298 4417 case DTYPE_WORM:
4299 4418 case DTYPE_RODIRECT:
4300 4419 case DTYPE_SCANNER:
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
4301 4420 case DTYPE_OPTICAL:
4302 4421 case DTYPE_CHANGER:
4303 4422 case DTYPE_ESI:
4304 4423 cnt++;
4305 4424 break;
4306 4425 case DTYPE_SEQUENTIAL:
4307 4426 cnt++;
4308 4427 tq->flags |= TQF_TAPE_DEVICE;
4309 4428 break;
4310 4429 default:
4311 - QL_PRINT_9(CE_CONT, "(%d): failed, "
4430 + QL_PRINT_9(ha, "failed, "
4312 4431 "unsupported device id=%xh, lun=%d, "
4313 - "type=%xh\n", ha->instance, tq->loop_id,
4432 + "type=%xh\n", tq->loop_id,
4314 4433 lun, *inq);
4315 4434 break;
4316 4435 }
4317 4436
4318 4437 if (*inq == DTYPE_ESI || cnt >= count) {
4319 4438 break;
4320 4439 }
4321 4440 } else if (rval == QL_ABORTED || rval == QL_FUNCTION_TIMEOUT) {
4322 4441 cnt = 0;
4323 4442 break;
4324 4443 }
4325 4444 }
4326 4445
4327 4446 kmem_free(pkt, pkt_size);
4328 4447
4329 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
4448 + QL_PRINT_9(ha, "done\n");
4330 4449
4331 4450 return (cnt);
4332 4451 }
4333 4452
4334 4453 /*
4335 4454 * ql_inq
4336 4455 * Issue inquiry command.
4337 4456 *
4338 4457 * Input:
4339 4458 * ha: adapter state pointer.
4340 4459 * tq: target queue pointer.
4341 4460 * lun: LUN number.
4342 4461 * pkt: command and buffer pointer.
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
4343 4462 * inq_len: amount of inquiry data.
4344 4463 *
4345 4464 * Returns:
4346 4465 * ql local function return status code.
4347 4466 *
4348 4467 * Context:
4349 4468 * Kernel context.
4350 4469 */
4351 4470 static int
4352 4471 ql_inq(ql_adapter_state_t *ha, ql_tgt_t *tq, int lun, ql_mbx_iocb_t *pkt,
4353 - uint8_t inq_len)
4472 + uint32_t inq_len)
4354 4473 {
4355 4474 dma_mem_t dma_mem;
4356 4475 int rval, retries;
4357 4476 uint32_t pkt_size, cnt;
4358 4477 uint16_t comp_status;
4359 4478 uint8_t scsi_status_h, scsi_status_l, *reqs;
4360 4479 caddr_t inq_data;
4480 + uint64_t lun_addr;
4481 + fcp_ent_addr_t *fcp_ent_addr = (fcp_ent_addr_t *)&lun_addr;
4361 4482
4362 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4483 + QL_PRINT_9(ha, "started\n");
4363 4484
4364 4485 if (DRIVER_SUSPENDED(ha)) {
4365 4486 EL(ha, "failed, loop down\n");
4366 4487 return (QL_FUNCTION_TIMEOUT);
4367 4488 }
4368 4489
4369 4490 pkt_size = (uint32_t)(sizeof (ql_mbx_iocb_t) + inq_len);
4370 4491 bzero((caddr_t)pkt, pkt_size);
4371 4492
4372 4493 inq_data = (caddr_t)pkt + sizeof (ql_mbx_iocb_t);
4373 4494
4374 4495 /* Get DMA memory for the IOCB */
4375 4496 if (ql_get_dma_mem(ha, &dma_mem, inq_len,
4376 4497 LITTLE_ENDIAN_DMA, QL_DMA_RING_ALIGN) != QL_SUCCESS) {
4377 - cmn_err(CE_WARN, "%s(%d): DMA memory "
4498 + cmn_err(CE_WARN, "%s(%d) DMA memory "
4378 4499 "alloc failed", QL_NAME, ha->instance);
4379 4500 return (0);
4380 4501 }
4381 4502
4382 4503 for (retries = 0; retries < 4; retries++) {
4383 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
4504 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
4384 4505 pkt->cmd24.entry_type = IOCB_CMD_TYPE_7;
4385 4506 pkt->cmd24.entry_count = 1;
4386 4507
4387 4508 /* Set LUN number */
4388 - pkt->cmd24.fcp_lun[2] = LSB(lun);
4389 - pkt->cmd24.fcp_lun[3] = MSB(lun);
4509 + lun_addr = ql_get_lun_addr(tq, lun);
4510 + fcp_ent_addr = (fcp_ent_addr_t *)&lun_addr;
4511 + pkt->cmd24.fcp_lun[2] =
4512 + lobyte(fcp_ent_addr->ent_addr_0);
4513 + pkt->cmd24.fcp_lun[3] =
4514 + hibyte(fcp_ent_addr->ent_addr_0);
4515 + pkt->cmd24.fcp_lun[0] =
4516 + lobyte(fcp_ent_addr->ent_addr_1);
4517 + pkt->cmd24.fcp_lun[1] =
4518 + hibyte(fcp_ent_addr->ent_addr_1);
4519 + pkt->cmd24.fcp_lun[6] =
4520 + lobyte(fcp_ent_addr->ent_addr_2);
4521 + pkt->cmd24.fcp_lun[7] =
4522 + hibyte(fcp_ent_addr->ent_addr_2);
4523 + pkt->cmd24.fcp_lun[4] =
4524 + lobyte(fcp_ent_addr->ent_addr_3);
4525 + pkt->cmd24.fcp_lun[5] =
4526 + hibyte(fcp_ent_addr->ent_addr_3);
4390 4527
4391 4528 /* Set N_port handle */
4392 4529 pkt->cmd24.n_port_hdl = (uint16_t)LE_16(tq->loop_id);
4393 4530
4394 4531 /* Set target ID */
4395 4532 pkt->cmd24.target_id[0] = tq->d_id.b.al_pa;
4396 4533 pkt->cmd24.target_id[1] = tq->d_id.b.area;
4397 4534 pkt->cmd24.target_id[2] = tq->d_id.b.domain;
4398 4535
4399 4536 /* Set Virtual Port ID */
4400 4537 pkt->cmd24.vp_index = ha->vp_index;
4401 4538
4402 4539 /* Set ISP command timeout. */
4403 4540 pkt->cmd24.timeout = LE_16(15);
4404 4541
4405 4542 /* Load SCSI CDB */
4406 4543 pkt->cmd24.scsi_cdb[0] = SCMD_INQUIRY;
4407 - pkt->cmd24.scsi_cdb[4] = inq_len;
4544 + pkt->cmd24.scsi_cdb[4] = LSB(LSW(inq_len));
4408 4545 for (cnt = 0; cnt < MAX_CMDSZ; cnt += 4) {
4409 4546 ql_chg_endian((uint8_t *)&pkt->cmd24.scsi_cdb
4410 4547 + cnt, 4);
4411 4548 }
4412 4549
4413 4550 /* Set tag queue control flags */
4414 4551 pkt->cmd24.task = TA_STAG;
4415 4552
4416 4553 /* Set transfer direction. */
4417 4554 pkt->cmd24.control_flags = CF_RD;
4418 4555
4419 4556 /* Set data segment count. */
4420 4557 pkt->cmd24.dseg_count = LE_16(1);
4421 4558
4422 4559 /* Load total byte count. */
4423 4560 pkt->cmd24.total_byte_count = LE_32(inq_len);
4424 4561
4425 4562 /* Load data descriptor. */
4426 - pkt->cmd24.dseg_0_address[0] = (uint32_t)
4563 + pkt->cmd24.dseg.address[0] = (uint32_t)
4427 4564 LE_32(LSD(dma_mem.cookie.dmac_laddress));
4428 - pkt->cmd24.dseg_0_address[1] = (uint32_t)
4565 + pkt->cmd24.dseg.address[1] = (uint32_t)
4429 4566 LE_32(MSD(dma_mem.cookie.dmac_laddress));
4430 - pkt->cmd24.dseg_0_length = LE_32(inq_len);
4567 + pkt->cmd24.dseg.length = LE_32(inq_len);
4431 4568 } else if (CFG_IST(ha, CFG_ENABLE_64BIT_ADDRESSING)) {
4432 4569 pkt->cmd3.entry_type = IOCB_CMD_TYPE_3;
4433 4570 cnt = CMD_TYPE_3_DATA_SEGMENTS;
4434 4571
4435 4572 pkt->cmd3.entry_count = 1;
4436 4573 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
4437 4574 pkt->cmd3.target_l = LSB(tq->loop_id);
4438 4575 pkt->cmd3.target_h = MSB(tq->loop_id);
4439 4576 } else {
4440 4577 pkt->cmd3.target_h = LSB(tq->loop_id);
4441 4578 }
4442 4579 pkt->cmd3.lun_l = LSB(lun);
4443 4580 pkt->cmd3.lun_h = MSB(lun);
4444 4581 pkt->cmd3.control_flags_l = CF_DATA_IN | CF_STAG;
4445 4582 pkt->cmd3.timeout = LE_16(15);
4446 4583 pkt->cmd3.scsi_cdb[0] = SCMD_INQUIRY;
4447 - pkt->cmd3.scsi_cdb[4] = inq_len;
4584 + pkt->cmd3.scsi_cdb[4] = LSB(LSW(inq_len));
4448 4585 pkt->cmd3.dseg_count = LE_16(1);
4449 4586 pkt->cmd3.byte_count = LE_32(inq_len);
4450 - pkt->cmd3.dseg_0_address[0] = (uint32_t)
4587 + pkt->cmd3.dseg[0].address[0] = (uint32_t)
4451 4588 LE_32(LSD(dma_mem.cookie.dmac_laddress));
4452 - pkt->cmd3.dseg_0_address[1] = (uint32_t)
4589 + pkt->cmd3.dseg[0].address[1] = (uint32_t)
4453 4590 LE_32(MSD(dma_mem.cookie.dmac_laddress));
4454 - pkt->cmd3.dseg_0_length = LE_32(inq_len);
4591 + pkt->cmd3.dseg[0].length = LE_32(inq_len);
4455 4592 } else {
4456 4593 pkt->cmd.entry_type = IOCB_CMD_TYPE_2;
4457 4594 cnt = CMD_TYPE_2_DATA_SEGMENTS;
4458 4595
4459 4596 pkt->cmd.entry_count = 1;
4460 4597 if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
4461 4598 pkt->cmd.target_l = LSB(tq->loop_id);
4462 4599 pkt->cmd.target_h = MSB(tq->loop_id);
4463 4600 } else {
4464 4601 pkt->cmd.target_h = LSB(tq->loop_id);
4465 4602 }
4466 4603 pkt->cmd.lun_l = LSB(lun);
4467 4604 pkt->cmd.lun_h = MSB(lun);
4468 4605 pkt->cmd.control_flags_l = CF_DATA_IN | CF_STAG;
4469 4606 pkt->cmd.timeout = LE_16(15);
4470 4607 pkt->cmd.scsi_cdb[0] = SCMD_INQUIRY;
4471 - pkt->cmd.scsi_cdb[4] = inq_len;
4608 + pkt->cmd.scsi_cdb[4] = LSB(LSW(inq_len));
4472 4609 pkt->cmd.dseg_count = LE_16(1);
4473 4610 pkt->cmd.byte_count = LE_32(inq_len);
4474 - pkt->cmd.dseg_0_address = (uint32_t)
4611 + pkt->cmd.dseg[0].address = (uint32_t)
4475 4612 LE_32(LSD(dma_mem.cookie.dmac_laddress));
4476 - pkt->cmd.dseg_0_length = LE_32(inq_len);
4613 + pkt->cmd.dseg[0].length = LE_32(inq_len);
4477 4614 }
4478 4615
4479 4616 /* rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, pkt_size); */
4480 4617 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt,
4481 4618 sizeof (ql_mbx_iocb_t));
4482 4619
4483 4620 /* Sync in coming IOCB DMA buffer. */
4484 4621 (void) ddi_dma_sync(dma_mem.dma_handle, 0, dma_mem.size,
4485 4622 DDI_DMA_SYNC_FORKERNEL);
4486 4623 /* Copy in coming DMA data. */
4487 4624 ddi_rep_get8(dma_mem.acc_handle, (uint8_t *)inq_data,
4488 4625 (uint8_t *)dma_mem.bp, dma_mem.size, DDI_DEV_AUTOINCR);
4489 4626
4490 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
4627 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
4491 4628 pkt->sts24.entry_status = (uint8_t)
4492 4629 (pkt->sts24.entry_status & 0x3c);
4493 4630 comp_status = (uint16_t)LE_16(pkt->sts24.comp_status);
4494 4631 scsi_status_h = pkt->sts24.scsi_status_h;
4495 4632 scsi_status_l = pkt->sts24.scsi_status_l;
4496 4633 cnt = scsi_status_h & FCP_RSP_LEN_VALID ?
4497 4634 LE_32(pkt->sts24.fcp_rsp_data_length) : 0;
4498 4635 reqs = &pkt->sts24.rsp_sense_data[cnt];
4499 4636 } else {
4500 4637 pkt->sts.entry_status = (uint8_t)
4501 4638 (pkt->sts.entry_status & 0x7e);
4502 4639 comp_status = (uint16_t)LE_16(pkt->sts.comp_status);
4503 4640 scsi_status_h = pkt->sts.scsi_status_h;
4504 4641 scsi_status_l = pkt->sts.scsi_status_l;
4505 4642 reqs = &pkt->sts.req_sense_data[0];
4506 4643 }
4507 4644 if (rval == QL_SUCCESS && pkt->sts.entry_status != 0) {
4508 4645 EL(ha, "failed, entry_status=%xh, d_id=%xh\n",
4509 4646 pkt->sts.entry_status, tq->d_id.b24);
4510 4647 rval = QL_FUNCTION_PARAMETER_ERROR;
4511 4648 }
4512 4649
4513 4650 if (rval != QL_SUCCESS || comp_status != CS_COMPLETE ||
4514 4651 scsi_status_l & STATUS_CHECK) {
4515 4652 EL(ha, "failed, issue_iocb=%xh, d_id=%xh, cs=%xh, "
4516 4653 "ss_h=%xh, ss_l=%xh\n", rval, tq->d_id.b24,
4517 4654 comp_status, scsi_status_h, scsi_status_l);
4518 4655
4519 4656 if (rval == QL_SUCCESS) {
4520 4657 if ((comp_status == CS_TIMEOUT) ||
4521 4658 (comp_status == CS_PORT_UNAVAILABLE) ||
4522 4659 (comp_status == CS_PORT_LOGGED_OUT)) {
4523 4660 rval = QL_FUNCTION_TIMEOUT;
4524 4661 break;
4525 4662 }
4526 4663 rval = QL_FUNCTION_FAILED;
4527 4664 }
4528 4665
4529 4666 if (scsi_status_l & STATUS_CHECK) {
4530 4667 EL(ha, "STATUS_CHECK Sense Data\n%2xh%3xh"
4531 4668 "%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh%3xh"
4532 4669 "%3xh%3xh%3xh%3xh%3xh%3xh%3xh\n", reqs[0],
4533 4670 reqs[1], reqs[2], reqs[3], reqs[4],
4534 4671 reqs[5], reqs[6], reqs[7], reqs[8],
|
↓ open down ↓ |
34 lines elided |
↑ open up ↑ |
4535 4672 reqs[9], reqs[10], reqs[11], reqs[12],
4536 4673 reqs[13], reqs[14], reqs[15], reqs[16],
4537 4674 reqs[17]);
4538 4675 }
4539 4676 } else {
4540 4677 break;
4541 4678 }
4542 4679 }
4543 4680 ql_free_dma_resource(ha, &dma_mem);
4544 4681
4545 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
4682 + QL_PRINT_9(ha, "done\n");
4546 4683
4547 4684 return (rval);
4548 4685 }
4549 4686
4550 4687 /*
4551 4688 * ql_get_buffer_data
4552 4689 * Copies data from user space to kernal buffer.
4553 4690 *
4554 4691 * Input:
4555 4692 * src: User source buffer address.
4556 4693 * dst: Kernal destination buffer address.
4557 4694 * size: Amount of data.
4558 4695 * mode: flags.
4559 4696 *
4560 4697 * Returns:
4561 4698 * Returns number of bytes transferred.
4562 4699 *
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
4563 4700 * Context:
4564 4701 * Kernel context.
4565 4702 */
4566 4703 static uint32_t
4567 4704 ql_get_buffer_data(caddr_t src, caddr_t dst, uint32_t size, int mode)
4568 4705 {
4569 4706 uint32_t cnt;
4570 4707
4571 4708 for (cnt = 0; cnt < size; cnt++) {
4572 4709 if (ddi_copyin(src++, dst++, 1, mode) != 0) {
4573 - QL_PRINT_2(CE_CONT, "failed, ddi_copyin\n");
4710 + QL_PRINT_2(NULL, "failed, ddi_copyin\n");
4574 4711 break;
4575 4712 }
4576 4713 }
4577 4714
4578 4715 return (cnt);
4579 4716 }
4580 4717
4581 4718 /*
4582 4719 * ql_send_buffer_data
4583 4720 * Copies data from kernal buffer to user space.
4584 4721 *
4585 4722 * Input:
4586 4723 * src: Kernal source buffer address.
4587 4724 * dst: User destination buffer address.
4588 4725 * size: Amount of data.
4589 4726 * mode: flags.
4590 4727 *
4591 4728 * Returns:
4592 4729 * Returns number of bytes transferred.
4593 4730 *
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
4594 4731 * Context:
4595 4732 * Kernel context.
4596 4733 */
4597 4734 static uint32_t
4598 4735 ql_send_buffer_data(caddr_t src, caddr_t dst, uint32_t size, int mode)
4599 4736 {
4600 4737 uint32_t cnt;
4601 4738
4602 4739 for (cnt = 0; cnt < size; cnt++) {
4603 4740 if (ddi_copyout(src++, dst++, 1, mode) != 0) {
4604 - QL_PRINT_2(CE_CONT, "failed, ddi_copyin\n");
4741 + QL_PRINT_2(NULL, "failed, ddi_copyin\n");
4605 4742 break;
4606 4743 }
4607 4744 }
4608 4745
4609 4746 return (cnt);
4610 4747 }
4611 4748
4612 4749 /*
4613 4750 * ql_find_port
4614 4751 * Locates device queue.
4615 4752 *
4616 4753 * Input:
4617 4754 * ha: adapter state pointer.
4618 4755 * name: device port name.
4619 4756 *
4620 4757 * Returns:
4621 4758 * Returns target queue pointer.
4622 4759 *
4623 4760 * Context:
4624 4761 * Kernel context.
4625 4762 */
4626 4763 static ql_tgt_t *
4627 4764 ql_find_port(ql_adapter_state_t *ha, uint8_t *name, uint16_t type)
4628 4765 {
4629 4766 ql_link_t *link;
4630 4767 ql_tgt_t *tq;
4631 4768 uint16_t index;
4632 4769
4633 4770 /* Scan port list for requested target */
4634 4771 for (index = 0; index < DEVICE_HEAD_LIST_SIZE; index++) {
4635 4772 for (link = ha->dev[index].first; link != NULL;
4636 4773 link = link->next) {
4637 4774 tq = link->base_address;
4638 4775
4639 4776 switch (type) {
4640 4777 case QLNT_LOOP_ID:
4641 4778 if (bcmp(name, &tq->loop_id,
4642 4779 sizeof (uint16_t)) == 0) {
4643 4780 return (tq);
4644 4781 }
4645 4782 break;
4646 4783 case QLNT_PORT:
4647 4784 if (bcmp(name, tq->port_name, 8) == 0) {
4648 4785 return (tq);
4649 4786 }
4650 4787 break;
4651 4788 case QLNT_NODE:
4652 4789 if (bcmp(name, tq->node_name, 8) == 0) {
|
↓ open down ↓ |
38 lines elided |
↑ open up ↑ |
4653 4790 return (tq);
4654 4791 }
4655 4792 break;
4656 4793 case QLNT_PID:
4657 4794 if (bcmp(name, tq->d_id.r.d_id,
4658 4795 sizeof (tq->d_id.r.d_id)) == 0) {
4659 4796 return (tq);
4660 4797 }
4661 4798 break;
4662 4799 default:
4663 - EL(ha, "failed, invalid type=%d\n", type);
4800 + EL(ha, "failed, invalid type=%d\n", type);
4664 4801 return (NULL);
4665 4802 }
4666 4803 }
4667 4804 }
4668 4805
4669 4806 return (NULL);
4670 4807 }
4671 4808
4672 4809 /*
4673 4810 * ql_24xx_flash_desc
4674 4811 * Get flash descriptor table.
4675 4812 *
4676 4813 * Input:
4677 4814 * ha: adapter state pointer.
4678 4815 *
4679 4816 * Returns:
4680 4817 * ql local function return status code.
4681 4818 *
4682 4819 * Context:
4683 4820 * Kernel context.
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
4684 4821 */
4685 4822 static int
4686 4823 ql_24xx_flash_desc(ql_adapter_state_t *ha)
4687 4824 {
4688 4825 uint32_t cnt;
4689 4826 uint16_t chksum, *bp, data;
4690 4827 int rval;
4691 4828 flash_desc_t *fdesc;
4692 4829 ql_xioctl_t *xp = ha->xioctl;
4693 4830
4694 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4831 + QL_PRINT_9(ha, "started\n");
4695 4832
4696 4833 if (ha->flash_desc_addr == 0) {
4697 - QL_PRINT_9(CE_CONT, "(%d): desc ptr=0\n", ha->instance);
4834 + QL_PRINT_9(ha, "desc ptr=0\n");
4698 4835 return (QL_FUNCTION_FAILED);
4699 4836 }
4700 4837
4701 4838 if ((fdesc = kmem_zalloc(sizeof (flash_desc_t), KM_SLEEP)) == NULL) {
4702 4839 EL(ha, "kmem_zalloc=null\n");
4703 4840 return (QL_MEMORY_ALLOC_FAILED);
4704 4841 }
4705 4842 rval = ql_dump_fcode(ha, (uint8_t *)fdesc, sizeof (flash_desc_t),
4706 4843 ha->flash_desc_addr << 2);
4707 4844 if (rval != QL_SUCCESS) {
4708 4845 EL(ha, "read status=%xh\n", rval);
4709 4846 kmem_free(fdesc, sizeof (flash_desc_t));
4710 4847 return (rval);
4711 4848 }
4712 4849
4713 4850 chksum = 0;
4714 4851 bp = (uint16_t *)fdesc;
4715 4852 for (cnt = 0; cnt < (sizeof (flash_desc_t)) / 2; cnt++) {
4716 4853 data = *bp++;
4717 4854 LITTLE_ENDIAN_16(&data);
4718 4855 chksum += data;
4719 4856 }
4720 4857
4721 4858 LITTLE_ENDIAN_32(&fdesc->flash_valid);
4722 4859 LITTLE_ENDIAN_16(&fdesc->flash_version);
4723 4860 LITTLE_ENDIAN_16(&fdesc->flash_len);
4724 4861 LITTLE_ENDIAN_16(&fdesc->flash_checksum);
4725 4862 LITTLE_ENDIAN_16(&fdesc->flash_manuf);
4726 4863 LITTLE_ENDIAN_16(&fdesc->flash_id);
4727 4864 LITTLE_ENDIAN_32(&fdesc->block_size);
4728 4865 LITTLE_ENDIAN_32(&fdesc->alt_block_size);
4729 4866 LITTLE_ENDIAN_32(&fdesc->flash_size);
4730 4867 LITTLE_ENDIAN_32(&fdesc->write_enable_data);
4731 4868 LITTLE_ENDIAN_32(&fdesc->read_timeout);
4732 4869
4733 4870 /* flash size in desc table is in 1024 bytes */
4734 4871 fdesc->flash_size = fdesc->flash_size * 0x400;
4735 4872
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
4736 4873 if (chksum != 0 || fdesc->flash_valid != FLASH_DESC_VAILD ||
4737 4874 fdesc->flash_version != FLASH_DESC_VERSION) {
4738 4875 EL(ha, "invalid descriptor table\n");
4739 4876 kmem_free(fdesc, sizeof (flash_desc_t));
4740 4877 return (QL_FUNCTION_FAILED);
4741 4878 }
4742 4879
4743 4880 bcopy(fdesc, &xp->fdesc, sizeof (flash_desc_t));
4744 4881 kmem_free(fdesc, sizeof (flash_desc_t));
4745 4882
4746 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
4883 + QL_PRINT_9(ha, "done\n");
4747 4884
4748 4885 return (QL_SUCCESS);
4749 4886 }
4750 4887
4751 4888 /*
4752 4889 * ql_setup_flash
4753 4890 * Gets the manufacturer and id number of the flash chip, and
4754 4891 * sets up the size parameter.
4755 4892 *
4756 4893 * Input:
4757 4894 * ha: adapter state pointer.
4758 4895 *
4759 4896 * Returns:
4760 4897 * int: ql local function return status code.
4761 4898 *
4762 4899 * Context:
4763 4900 * Kernel context.
4764 4901 */
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
4765 4902 static int
4766 4903 ql_setup_flash(ql_adapter_state_t *ha)
4767 4904 {
4768 4905 ql_xioctl_t *xp = ha->xioctl;
4769 4906 int rval = QL_SUCCESS;
4770 4907
4771 4908 if (xp->fdesc.flash_size != 0) {
4772 4909 return (rval);
4773 4910 }
4774 4911
4775 - if (CFG_IST(ha, CFG_CTRL_2200) && !ha->subven_id) {
4912 + if (CFG_IST(ha, CFG_CTRL_22XX) && !ha->subven_id) {
4776 4913 return (QL_FUNCTION_FAILED);
4777 4914 }
4778 4915
4779 - if (CFG_IST(ha, CFG_CTRL_258081)) {
4916 + if (CFG_IST(ha, CFG_CTRL_252780818283)) {
4780 4917 /*
4781 4918 * Temporarily set the ha->xioctl->fdesc.flash_size to
4782 4919 * 25xx flash size to avoid failing of ql_dump_focde.
4783 4920 */
4784 - if (CFG_IST(ha, CFG_CTRL_8021)) {
4921 + if (CFG_IST(ha, CFG_CTRL_278083)) {
4922 + ha->xioctl->fdesc.flash_size = 0x1000000;
4923 + } else if (CFG_IST(ha, CFG_CTRL_82XX)) {
4785 4924 ha->xioctl->fdesc.flash_size = 0x800000;
4786 4925 } else if (CFG_IST(ha, CFG_CTRL_25XX)) {
4787 4926 ha->xioctl->fdesc.flash_size = 0x200000;
4788 4927 } else {
4789 4928 ha->xioctl->fdesc.flash_size = 0x400000;
4790 4929 }
4791 4930
4792 4931 if (ql_24xx_flash_desc(ha) == QL_SUCCESS) {
4793 4932 EL(ha, "flash desc table ok, exit\n");
4794 4933 return (rval);
4795 4934 }
4796 - if (CFG_IST(ha, CFG_CTRL_8021)) {
4797 - xp->fdesc.flash_manuf = WINBOND_FLASH;
4798 - xp->fdesc.flash_id = WINBOND_FLASHID;
4935 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
4936 + xp->fdesc.flash_manuf = MXIC_FLASH;
4937 + xp->fdesc.flash_id = MXIC_FLASHID_25LXX;
4799 4938 xp->fdesc.flash_len = 0x17;
4800 4939 } else {
4801 4940 (void) ql_24xx_flash_id(ha);
4802 4941 }
4803 4942
4804 - } else if (CFG_IST(ha, CFG_CTRL_2422)) {
4943 + } else if (CFG_IST(ha, CFG_CTRL_24XX)) {
4805 4944 (void) ql_24xx_flash_id(ha);
4806 4945 } else {
4807 4946 ql_flash_enable(ha);
4808 4947
4809 4948 ql_write_flash_byte(ha, 0x5555, 0xaa);
4810 4949 ql_write_flash_byte(ha, 0x2aaa, 0x55);
4811 4950 ql_write_flash_byte(ha, 0x5555, 0x90);
4812 4951 xp->fdesc.flash_manuf = (uint8_t)ql_read_flash_byte(ha, 0x0000);
4813 4952
4814 4953 if (CFG_IST(ha, CFG_SBUS_CARD)) {
4815 4954 ql_write_flash_byte(ha, 0xaaaa, 0xaa);
4816 4955 ql_write_flash_byte(ha, 0x5555, 0x55);
4817 4956 ql_write_flash_byte(ha, 0xaaaa, 0x90);
4818 4957 xp->fdesc.flash_id = (uint16_t)
4819 4958 ql_read_flash_byte(ha, 0x0002);
4820 4959 } else {
4821 4960 ql_write_flash_byte(ha, 0x5555, 0xaa);
4822 4961 ql_write_flash_byte(ha, 0x2aaa, 0x55);
4823 4962 ql_write_flash_byte(ha, 0x5555, 0x90);
4824 4963 xp->fdesc.flash_id = (uint16_t)
4825 4964 ql_read_flash_byte(ha, 0x0001);
4826 4965 }
4827 4966
4828 4967 ql_write_flash_byte(ha, 0x5555, 0xaa);
4829 4968 ql_write_flash_byte(ha, 0x2aaa, 0x55);
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
4830 4969 ql_write_flash_byte(ha, 0x5555, 0xf0);
4831 4970
4832 4971 ql_flash_disable(ha);
4833 4972 }
4834 4973
4835 4974 /* Default flash descriptor table. */
4836 4975 xp->fdesc.write_statusreg_cmd = 1;
4837 4976 xp->fdesc.write_enable_bits = 0;
4838 4977 xp->fdesc.unprotect_sector_cmd = 0;
4839 4978 xp->fdesc.protect_sector_cmd = 0;
4840 - xp->fdesc.write_disable_bits = 0x9c;
4979 + xp->fdesc.write_disable_bits = 0xbc;
4841 4980 xp->fdesc.block_size = 0x10000;
4842 4981 xp->fdesc.erase_cmd = 0xd8;
4843 4982
4844 4983 switch (xp->fdesc.flash_manuf) {
4845 4984 case AMD_FLASH:
4846 4985 switch (xp->fdesc.flash_id) {
4986 + case SPAN_FLASHID_16384K:
4987 + if (xp->fdesc.flash_len == 0x18) {
4988 + xp->fdesc.flash_size = 0x1000000;
4989 + } else {
4990 + rval = QL_FUNCTION_FAILED;
4991 + }
4992 + break;
4847 4993 case SPAN_FLASHID_2048K:
4848 4994 xp->fdesc.flash_size = 0x200000;
4849 4995 break;
4850 4996 case AMD_FLASHID_1024K:
4851 4997 xp->fdesc.flash_size = 0x100000;
4852 4998 break;
4853 4999 case AMD_FLASHID_512K:
4854 5000 case AMD_FLASHID_512Kt:
4855 5001 case AMD_FLASHID_512Kb:
4856 5002 if (CFG_IST(ha, CFG_SBUS_CARD)) {
4857 5003 xp->fdesc.flash_size = QL_SBUS_FCODE_SIZE;
4858 5004 } else {
4859 5005 xp->fdesc.flash_size = 0x80000;
4860 5006 }
4861 5007 break;
4862 5008 case AMD_FLASHID_128K:
4863 5009 xp->fdesc.flash_size = 0x20000;
4864 5010 break;
4865 5011 default:
4866 5012 rval = QL_FUNCTION_FAILED;
4867 5013 break;
4868 5014 }
4869 5015 break;
4870 5016 case ST_FLASH:
4871 5017 switch (xp->fdesc.flash_id) {
4872 5018 case ST_FLASHID_128K:
4873 5019 xp->fdesc.flash_size = 0x20000;
4874 5020 break;
4875 5021 case ST_FLASHID_512K:
4876 5022 xp->fdesc.flash_size = 0x80000;
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
4877 5023 break;
4878 5024 case ST_FLASHID_M25PXX:
4879 5025 if (xp->fdesc.flash_len == 0x14) {
4880 5026 xp->fdesc.flash_size = 0x100000;
4881 5027 } else if (xp->fdesc.flash_len == 0x15) {
4882 5028 xp->fdesc.flash_size = 0x200000;
4883 5029 } else {
4884 5030 rval = QL_FUNCTION_FAILED;
4885 5031 }
4886 5032 break;
5033 + case ST_FLASHID_N25QXXX:
5034 + if (xp->fdesc.flash_len == 0x18) {
5035 + xp->fdesc.flash_size = 0x1000000;
5036 + } else {
5037 + rval = QL_FUNCTION_FAILED;
5038 + }
5039 + break;
4887 5040 default:
4888 5041 rval = QL_FUNCTION_FAILED;
4889 5042 break;
4890 5043 }
4891 5044 break;
4892 5045 case SST_FLASH:
4893 5046 switch (xp->fdesc.flash_id) {
4894 5047 case SST_FLASHID_128K:
4895 5048 xp->fdesc.flash_size = 0x20000;
4896 5049 break;
4897 5050 case SST_FLASHID_1024K_A:
4898 5051 xp->fdesc.flash_size = 0x100000;
4899 5052 xp->fdesc.block_size = 0x8000;
4900 5053 xp->fdesc.erase_cmd = 0x52;
4901 5054 break;
4902 5055 case SST_FLASHID_1024K:
4903 5056 case SST_FLASHID_1024K_B:
4904 5057 xp->fdesc.flash_size = 0x100000;
4905 5058 break;
4906 5059 case SST_FLASHID_2048K:
4907 5060 xp->fdesc.flash_size = 0x200000;
4908 5061 break;
4909 5062 default:
4910 5063 rval = QL_FUNCTION_FAILED;
4911 5064 break;
4912 5065 }
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
4913 5066 break;
4914 5067 case MXIC_FLASH:
4915 5068 switch (xp->fdesc.flash_id) {
4916 5069 case MXIC_FLASHID_512K:
4917 5070 xp->fdesc.flash_size = 0x80000;
4918 5071 break;
4919 5072 case MXIC_FLASHID_1024K:
4920 5073 xp->fdesc.flash_size = 0x100000;
4921 5074 break;
4922 5075 case MXIC_FLASHID_25LXX:
5076 + xp->fdesc.write_disable_bits = 0xbc;
4923 5077 if (xp->fdesc.flash_len == 0x14) {
4924 5078 xp->fdesc.flash_size = 0x100000;
4925 5079 } else if (xp->fdesc.flash_len == 0x15) {
4926 5080 xp->fdesc.flash_size = 0x200000;
5081 + } else if (xp->fdesc.flash_len == 0x16) {
5082 + xp->fdesc.flash_size = 0x400000;
5083 + } else if (xp->fdesc.flash_len == 0x17) {
5084 + xp->fdesc.flash_size = 0x800000;
5085 + } else if (xp->fdesc.flash_len == 0x18) {
5086 + xp->fdesc.flash_size = 0x1000000;
4927 5087 } else {
4928 5088 rval = QL_FUNCTION_FAILED;
4929 5089 }
4930 5090 break;
4931 5091 default:
4932 5092 rval = QL_FUNCTION_FAILED;
4933 5093 break;
4934 5094 }
4935 5095 break;
4936 5096 case ATMEL_FLASH:
4937 5097 switch (xp->fdesc.flash_id) {
4938 5098 case ATMEL_FLASHID_1024K:
4939 5099 xp->fdesc.flash_size = 0x100000;
4940 5100 xp->fdesc.write_disable_bits = 0xbc;
4941 5101 xp->fdesc.unprotect_sector_cmd = 0x39;
4942 5102 xp->fdesc.protect_sector_cmd = 0x36;
4943 5103 break;
4944 5104 default:
4945 5105 rval = QL_FUNCTION_FAILED;
4946 5106 break;
4947 5107 }
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
4948 5108 break;
4949 5109 case WINBOND_FLASH:
4950 5110 switch (xp->fdesc.flash_id) {
4951 5111 case WINBOND_FLASHID:
4952 5112 if (xp->fdesc.flash_len == 0x15) {
4953 5113 xp->fdesc.flash_size = 0x200000;
4954 5114 } else if (xp->fdesc.flash_len == 0x16) {
4955 5115 xp->fdesc.flash_size = 0x400000;
4956 5116 } else if (xp->fdesc.flash_len == 0x17) {
4957 5117 xp->fdesc.flash_size = 0x800000;
5118 + } else if (xp->fdesc.flash_len == 0x18) {
5119 + xp->fdesc.flash_size = 0x1000000;
4958 5120 } else {
4959 5121 rval = QL_FUNCTION_FAILED;
4960 5122 }
4961 5123 break;
4962 5124 default:
4963 5125 rval = QL_FUNCTION_FAILED;
4964 5126 break;
4965 5127 }
4966 5128 break;
4967 5129 case INTEL_FLASH:
4968 5130 switch (xp->fdesc.flash_id) {
4969 5131 case INTEL_FLASHID:
4970 5132 if (xp->fdesc.flash_len == 0x11) {
4971 5133 xp->fdesc.flash_size = 0x200000;
4972 5134 } else if (xp->fdesc.flash_len == 0x12) {
4973 5135 xp->fdesc.flash_size = 0x400000;
4974 5136 } else if (xp->fdesc.flash_len == 0x13) {
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
4975 5137 xp->fdesc.flash_size = 0x800000;
4976 5138 } else {
4977 5139 rval = QL_FUNCTION_FAILED;
4978 5140 }
4979 5141 break;
4980 5142 default:
4981 5143 rval = QL_FUNCTION_FAILED;
4982 5144 break;
4983 5145 }
4984 5146 break;
5147 + case EON_FLASH:
5148 + switch (xp->fdesc.flash_id) {
5149 + case EON_FLASHID_EN25QXXX:
5150 + if (xp->fdesc.flash_len == 0x18) {
5151 + xp->fdesc.flash_size = 0x1000000;
5152 + } else {
5153 + rval = QL_FUNCTION_FAILED;
5154 + }
5155 + break;
5156 + default:
5157 + rval = QL_FUNCTION_FAILED;
5158 + break;
5159 + }
5160 + break;
4985 5161 default:
4986 5162 rval = QL_FUNCTION_FAILED;
4987 5163 break;
4988 5164 }
4989 5165
4990 5166 /* Try flash table later. */
4991 - if (rval != QL_SUCCESS && CFG_IST(ha, CFG_CTRL_24258081)) {
5167 + if (rval != QL_SUCCESS && CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
4992 5168 EL(ha, "no default id\n");
4993 5169 return (QL_SUCCESS);
4994 5170 }
4995 5171
4996 5172 /*
4997 - * hack for non std 2312 and 6312 boards. hardware people need to
4998 - * use either the 128k flash chip (original), or something larger.
4999 - * For driver purposes, we'll treat it as a 128k flash chip.
5173 + * hack for non std 2312/2322 and 6312/6322 boards. hardware people
5174 + * need to use either the 128k flash chip (original), or something
5175 + * larger. For driver purposes, we'll treat it as a 128k flash chip.
5000 5176 */
5001 5177 if ((ha->device_id == 0x2312 || ha->device_id == 0x6312 ||
5002 5178 ha->device_id == 0x2322 || ha->device_id == 0x6322) &&
5003 5179 (xp->fdesc.flash_size > 0x20000) &&
5004 - (CFG_IST(ha, CFG_SBUS_CARD) == 0)) {
5180 + (CFG_IST(ha, CFG_SBUS_CARD) == 0)) {
5005 5181 EL(ha, "chip exceeds max size: %xh, using 128k\n",
5006 5182 xp->fdesc.flash_size);
5007 5183 xp->fdesc.flash_size = 0x20000;
5008 5184 }
5009 5185
5010 5186 if (rval == QL_SUCCESS) {
5011 5187 EL(ha, "man_id=%xh, flash_id=%xh, size=%xh\n",
5012 5188 xp->fdesc.flash_manuf, xp->fdesc.flash_id,
5013 5189 xp->fdesc.flash_size);
5014 5190 } else {
5015 5191 EL(ha, "unsupported mfr / type: man_id=%xh, flash_id=%xh\n",
5016 5192 xp->fdesc.flash_manuf, xp->fdesc.flash_id);
5017 5193 }
5018 5194
5019 5195 return (rval);
5020 5196 }
5021 5197
5022 5198 /*
5023 5199 * ql_flash_fcode_load
5024 5200 * Loads fcode data into flash from application.
5025 5201 *
5026 5202 * Input:
5027 5203 * ha: adapter state pointer.
5028 5204 * bp: user buffer address.
5029 5205 * size: user buffer size.
5030 5206 * mode: flags
5031 5207 *
5032 5208 * Returns:
5033 5209 *
5034 5210 * Context:
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
5035 5211 * Kernel context.
5036 5212 */
5037 5213 static int
5038 5214 ql_flash_fcode_load(ql_adapter_state_t *ha, void *bp, uint32_t bsize,
5039 5215 int mode)
5040 5216 {
5041 5217 uint8_t *bfp;
5042 5218 ql_xioctl_t *xp = ha->xioctl;
5043 5219 int rval = 0;
5044 5220
5045 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5221 + QL_PRINT_9(ha, "started\n");
5046 5222
5047 5223 if (bsize > xp->fdesc.flash_size) {
5048 5224 EL(ha, "failed, bufsize: %xh, flash size: %xh\n", bsize,
5049 5225 xp->fdesc.flash_size);
5050 5226 return (ENOMEM);
5051 5227 }
5052 5228
5053 5229 if ((bfp = (uint8_t *)kmem_zalloc(bsize, KM_SLEEP)) == NULL) {
5054 5230 EL(ha, "failed, kmem_zalloc\n");
5055 5231 rval = ENOMEM;
5056 - } else {
5232 + } else {
5057 5233 if (ddi_copyin(bp, bfp, bsize, mode) != 0) {
5058 5234 EL(ha, "failed, ddi_copyin\n");
5059 5235 rval = EFAULT;
5060 5236 } else if (ql_load_fcode(ha, bfp, bsize, 0) != QL_SUCCESS) {
5061 5237 EL(ha, "failed, load_fcode\n");
5062 5238 rval = EFAULT;
5063 5239 } else {
5064 5240 /* Reset caches on all adapter instances. */
5065 5241 ql_update_flash_caches(ha);
5066 5242 rval = 0;
5067 5243 }
5068 5244 kmem_free(bfp, bsize);
5069 5245 }
5070 5246
5071 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5247 + QL_PRINT_9(ha, "done\n");
5072 5248
5073 5249 return (rval);
5074 5250 }
5075 5251
5076 5252 /*
5077 5253 * ql_load_fcode
5078 5254 * Loads fcode in to flash.
5079 5255 *
5080 5256 * Input:
5081 5257 * ha: adapter state pointer.
5082 5258 * dp: data pointer.
5083 5259 * size: data length.
5084 5260 * addr: flash byte address.
5085 5261 *
5086 5262 * Returns:
5087 5263 * ql local function return status code.
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
5088 5264 *
5089 5265 * Context:
5090 5266 * Kernel context.
5091 5267 */
5092 5268 int
5093 5269 ql_load_fcode(ql_adapter_state_t *ha, uint8_t *dp, uint32_t size, uint32_t addr)
5094 5270 {
5095 5271 uint32_t cnt;
5096 5272 int rval;
5097 5273
5098 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
5274 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
5099 5275 return (ql_24xx_load_flash(ha, dp, size, addr));
5100 5276 }
5101 5277
5102 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5278 + QL_PRINT_9(ha, "started\n");
5103 5279
5104 5280 if (CFG_IST(ha, CFG_SBUS_CARD)) {
5105 5281 /*
5106 5282 * sbus has an additional check to make
5107 5283 * sure they don't brick the HBA.
5108 5284 */
5109 5285 if (dp[0] != 0xf1) {
5110 5286 EL(ha, "failed, incorrect fcode for sbus\n");
5111 5287 return (QL_FUNCTION_PARAMETER_ERROR);
5112 5288 }
5113 5289 }
5114 5290
5115 5291 GLOBAL_HW_LOCK();
5116 5292
5117 5293 /* Enable Flash Read/Write. */
5118 5294 ql_flash_enable(ha);
5119 5295
5120 5296 /* Erase flash prior to write. */
5121 5297 rval = ql_erase_flash(ha, 0);
5122 5298
5123 5299 if (rval == QL_SUCCESS) {
5124 5300 /* Write fcode data to flash. */
5125 5301 for (cnt = 0; cnt < (uint32_t)size; cnt++) {
5126 5302 /* Allow other system activity. */
5127 5303 if (cnt % 0x1000 == 0) {
5128 5304 drv_usecwait(1);
5129 5305 }
5130 5306 rval = ql_program_flash_address(ha, addr++, *dp++);
5131 5307 if (rval != QL_SUCCESS)
5132 5308 break;
5133 5309 }
|
↓ open down ↓ |
21 lines elided |
↑ open up ↑ |
5134 5310 }
5135 5311
5136 5312 ql_flash_disable(ha);
5137 5313
5138 5314 GLOBAL_HW_UNLOCK();
5139 5315
5140 5316 if (rval != QL_SUCCESS) {
5141 5317 EL(ha, "failed, rval=%xh\n", rval);
5142 5318 } else {
5143 5319 /*EMPTY*/
5144 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5320 + QL_PRINT_9(ha, "done\n");
5145 5321 }
5146 5322 return (rval);
5147 5323 }
5148 5324
5149 5325 /*
5150 5326 * ql_flash_fcode_dump
5151 5327 * Dumps FLASH to application.
5152 5328 *
5153 5329 * Input:
5154 5330 * ha: adapter state pointer.
5155 5331 * bp: user buffer address.
5156 5332 * bsize: user buffer size
5157 5333 * faddr: flash byte address
5158 5334 * mode: flags
5159 5335 *
5160 5336 * Returns:
5161 5337 *
5162 5338 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
5163 5339 * Kernel context.
5164 5340 */
5165 5341 static int
5166 5342 ql_flash_fcode_dump(ql_adapter_state_t *ha, void *bp, uint32_t bsize,
5167 5343 uint32_t faddr, int mode)
5168 5344 {
5169 5345 uint8_t *bfp;
5170 5346 int rval;
5171 5347 ql_xioctl_t *xp = ha->xioctl;
5172 5348
5173 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5349 + QL_PRINT_9(ha, "started\n");
5174 5350
5175 5351 /* adjust max read size to flash size */
5176 5352 if (bsize > xp->fdesc.flash_size) {
5177 5353 EL(ha, "adjusting req=%xh, max=%xh\n", bsize,
5178 5354 xp->fdesc.flash_size);
5179 5355 bsize = xp->fdesc.flash_size;
5180 5356 }
5181 5357
5182 5358 if ((bfp = (uint8_t *)kmem_zalloc(bsize, KM_SLEEP)) == NULL) {
5183 5359 EL(ha, "failed, kmem_zalloc\n");
5184 5360 rval = ENOMEM;
5185 5361 } else {
5186 5362 /* Dump Flash fcode. */
5187 5363 rval = ql_dump_fcode(ha, bfp, bsize, faddr);
5188 5364
5189 5365 if (rval != QL_SUCCESS) {
5190 5366 EL(ha, "failed, dump_fcode = %x\n", rval);
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
5191 5367 rval = EFAULT;
5192 5368 } else if (ddi_copyout(bfp, bp, bsize, mode) != 0) {
5193 5369 EL(ha, "failed, ddi_copyout\n");
5194 5370 rval = EFAULT;
5195 5371 } else {
5196 5372 rval = 0;
5197 5373 }
5198 5374 kmem_free(bfp, bsize);
5199 5375 }
5200 5376
5201 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5377 + QL_PRINT_9(ha, "done\n");
5202 5378
5203 5379 return (rval);
5204 5380 }
5205 5381
5206 5382 /*
5207 5383 * ql_dump_fcode
5208 5384 * Dumps fcode from flash.
5209 5385 *
5210 5386 * Input:
5211 5387 * ha: adapter state pointer.
5212 5388 * dp: data pointer.
5213 5389 * size: data length in bytes.
5214 5390 * startpos: starting position in flash (byte address).
5215 5391 *
5216 5392 * Returns:
5217 5393 * ql local function return status code.
5218 5394 *
5219 5395 * Context:
5220 5396 * Kernel context.
5221 5397 *
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
5222 5398 */
5223 5399 int
5224 5400 ql_dump_fcode(ql_adapter_state_t *ha, uint8_t *dp, uint32_t size,
5225 5401 uint32_t startpos)
5226 5402 {
5227 5403 uint32_t cnt, data, addr;
5228 5404 uint8_t bp[4], *src;
5229 5405 int fp_rval, rval = QL_SUCCESS;
5230 5406 dma_mem_t mem;
5231 5407
5232 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5408 + QL_PRINT_9(ha, "started\n");
5233 5409
5234 5410 /* make sure startpos+size doesn't exceed flash */
5235 5411 if (size + startpos > ha->xioctl->fdesc.flash_size) {
5236 5412 EL(ha, "exceeded flash range, sz=%xh, stp=%xh, flsz=%xh\n",
5237 5413 size, startpos, ha->xioctl->fdesc.flash_size);
5238 5414 return (QL_FUNCTION_PARAMETER_ERROR);
5239 5415 }
5240 5416
5241 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
5417 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
5242 5418 /* check start addr is 32 bit aligned for 24xx */
5243 5419 if ((startpos & 0x3) != 0) {
5244 5420 rval = ql_24xx_read_flash(ha,
5245 5421 ha->flash_data_addr | startpos >> 2, &data);
5246 5422 if (rval != QL_SUCCESS) {
5247 5423 EL(ha, "failed2, rval = %xh\n", rval);
5248 5424 return (rval);
5249 5425 }
5250 5426 bp[0] = LSB(LSW(data));
5251 5427 bp[1] = MSB(LSW(data));
5252 5428 bp[2] = LSB(MSW(data));
5253 5429 bp[3] = MSB(MSW(data));
5254 5430 while (size && startpos & 0x3) {
5255 5431 *dp++ = bp[startpos & 0x3];
5256 5432 startpos++;
5257 5433 size--;
5258 5434 }
5259 5435 if (size == 0) {
5260 - QL_PRINT_9(CE_CONT, "(%d): done2\n",
5436 + QL_PRINT_9(ha, "done2\n",
5261 5437 ha->instance);
5262 5438 return (rval);
5263 5439 }
5264 5440 }
5265 5441
5266 5442 /* adjust 24xx start addr for 32 bit words */
5267 5443 addr = startpos / 4 | ha->flash_data_addr;
5268 5444 }
5269 5445
5270 5446 bzero(&mem, sizeof (dma_mem_t));
5271 5447 /* Check for Fast page is supported */
5272 5448 if ((ha->pha->task_daemon_flags & FIRMWARE_UP) &&
5273 - (CFG_IST(ha, CFG_CTRL_2581))) {
5449 + (CFG_IST(ha, CFG_FLASH_DMA_SUPPORT))) {
5274 5450 fp_rval = QL_SUCCESS;
5275 5451 /* Setup DMA buffer. */
5276 5452 rval = ql_get_dma_mem(ha, &mem, size,
5277 5453 LITTLE_ENDIAN_DMA, QL_DMA_DATA_ALIGN);
5278 5454 if (rval != QL_SUCCESS) {
5279 5455 EL(ha, "failed, ql_get_dma_mem=%xh\n",
5280 5456 rval);
5281 5457 return (ENOMEM);
5282 5458 }
5283 5459 } else {
5284 5460 fp_rval = QL_NOT_SUPPORTED;
5285 5461 }
5286 5462
5287 5463 GLOBAL_HW_LOCK();
5288 5464
5289 5465 /* Enable Flash Read/Write. */
5290 - if (CFG_IST(ha, CFG_CTRL_24258081) == 0) {
5466 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
5291 5467 ql_flash_enable(ha);
5292 5468 }
5293 5469
5294 5470 /* Read fcode data from flash. */
5295 5471 while (size) {
5296 5472 /* Allow other system activity. */
5297 5473 if (size % 0x1000 == 0) {
5298 - ql_delay(ha, 100000);
5474 + ql_delay(ha, 10000);
5299 5475 }
5300 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
5476 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
5301 5477 if (fp_rval == QL_SUCCESS && (addr & 0x3f) == 0) {
5302 5478 cnt = (size + 3) >> 2;
5303 5479 fp_rval = ql_rd_risc_ram(ha, addr,
5304 5480 mem.cookie.dmac_laddress, cnt);
5305 5481 if (fp_rval == QL_SUCCESS) {
5306 5482 for (src = mem.bp; size; size--) {
5307 5483 *dp++ = *src++;
5308 5484 }
5309 5485 addr += cnt;
5310 5486 continue;
5311 5487 }
5312 5488 }
5313 5489 rval = ql_24xx_read_flash(ha, addr++,
5314 5490 &data);
5315 5491 if (rval != QL_SUCCESS) {
5316 5492 break;
5317 5493 }
5318 5494 bp[0] = LSB(LSW(data));
5319 5495 bp[1] = MSB(LSW(data));
5320 5496 bp[2] = LSB(MSW(data));
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
5321 5497 bp[3] = MSB(MSW(data));
5322 5498 for (cnt = 0; size && cnt < 4; size--) {
5323 5499 *dp++ = bp[cnt++];
5324 5500 }
5325 5501 } else {
5326 5502 *dp++ = (uint8_t)ql_read_flash_byte(ha, startpos++);
5327 5503 size--;
5328 5504 }
5329 5505 }
5330 5506
5331 - if (CFG_IST(ha, CFG_CTRL_24258081) == 0) {
5507 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
5332 5508 ql_flash_disable(ha);
5333 5509 }
5334 5510
5335 5511 GLOBAL_HW_UNLOCK();
5336 5512
5337 5513 if (mem.dma_handle != NULL) {
5338 5514 ql_free_dma_resource(ha, &mem);
5339 5515 }
5340 5516
5341 5517 if (rval != QL_SUCCESS) {
5342 5518 EL(ha, "failed, rval = %xh\n", rval);
5343 5519 } else {
5344 5520 /*EMPTY*/
5345 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5521 + QL_PRINT_9(ha, "done\n");
5346 5522 }
5347 5523 return (rval);
5348 5524 }
5349 5525
5350 5526 /*
5351 5527 * ql_program_flash_address
5352 5528 * Program flash address.
5353 5529 *
5354 5530 * Input:
5355 5531 * ha: adapter state pointer.
5356 5532 * addr: flash byte address.
5357 5533 * data: data to be written to flash.
5358 5534 *
5359 5535 * Returns:
5360 5536 * ql local function return status code.
5361 5537 *
5362 5538 * Context:
5363 5539 * Kernel context.
5364 5540 */
5365 5541 static int
5366 5542 ql_program_flash_address(ql_adapter_state_t *ha, uint32_t addr,
5367 5543 uint8_t data)
5368 5544 {
5369 5545 int rval;
5370 5546
5371 5547 /* Write Program Command Sequence */
5372 5548 if (CFG_IST(ha, CFG_SBUS_CARD)) {
5373 5549 ql_write_flash_byte(ha, 0x5555, 0xa0);
5374 5550 ql_write_flash_byte(ha, addr, data);
5375 5551 } else {
5376 5552 ql_write_flash_byte(ha, 0x5555, 0xaa);
5377 5553 ql_write_flash_byte(ha, 0x2aaa, 0x55);
5378 5554 ql_write_flash_byte(ha, 0x5555, 0xa0);
5379 5555 ql_write_flash_byte(ha, addr, data);
5380 5556 }
5381 5557
5382 5558 /* Wait for write to complete. */
5383 5559 rval = ql_poll_flash(ha, addr, data);
5384 5560
5385 5561 if (rval != QL_SUCCESS) {
5386 5562 EL(ha, "failed, rval=%xh\n", rval);
5387 5563 }
5388 5564 return (rval);
5389 5565 }
5390 5566
5391 5567 /*
5392 5568 * ql_set_rnid_parameters
5393 5569 * Set RNID parameters.
5394 5570 *
5395 5571 * Input:
5396 5572 * ha: adapter state pointer.
|
↓ open down ↓ |
41 lines elided |
↑ open up ↑ |
5397 5573 * cmd: User space CT arguments pointer.
5398 5574 * mode: flags.
5399 5575 */
5400 5576 static void
5401 5577 ql_set_rnid_parameters(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
5402 5578 {
5403 5579 EXT_SET_RNID_REQ tmp_set;
5404 5580 EXT_RNID_DATA *tmp_buf;
5405 5581 int rval = 0;
5406 5582
5407 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5583 + QL_PRINT_9(ha, "started\n");
5408 5584
5409 5585 if (DRIVER_SUSPENDED(ha)) {
5410 5586 EL(ha, "failed, LOOP_NOT_READY\n");
5411 5587 cmd->Status = EXT_STATUS_BUSY;
5412 5588 cmd->ResponseLen = 0;
5413 5589 return;
5414 5590 }
5415 5591
5416 5592 cmd->ResponseLen = 0; /* NO response to caller. */
5417 5593 if (cmd->RequestLen != sizeof (EXT_SET_RNID_REQ)) {
5418 5594 /* parameter error */
5419 5595 EL(ha, "failed, RequestLen < EXT_SET_RNID_REQ, Len=%xh\n",
5420 5596 cmd->RequestLen);
5421 5597 cmd->Status = EXT_STATUS_INVALID_PARAM;
5422 5598 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
5423 5599 cmd->ResponseLen = 0;
5424 5600 return;
5425 5601 }
5426 5602
5427 5603 rval = ddi_copyin((void*)(uintptr_t)cmd->RequestAdr, &tmp_set,
5428 5604 cmd->RequestLen, mode);
5429 5605 if (rval != 0) {
5430 5606 EL(ha, "failed, ddi_copyin\n");
5431 5607 cmd->Status = EXT_STATUS_COPY_ERR;
5432 5608 cmd->ResponseLen = 0;
5433 5609 return;
5434 5610 }
5435 5611
5436 5612 /* Allocate memory for command. */
5437 5613 tmp_buf = kmem_zalloc(sizeof (EXT_RNID_DATA), KM_SLEEP);
5438 5614 if (tmp_buf == NULL) {
5439 5615 EL(ha, "failed, kmem_zalloc\n");
5440 5616 cmd->Status = EXT_STATUS_NO_MEMORY;
5441 5617 cmd->ResponseLen = 0;
5442 5618 return;
5443 5619 }
5444 5620
5445 5621 rval = ql_get_rnid_params(ha, sizeof (EXT_RNID_DATA),
5446 5622 (caddr_t)tmp_buf);
5447 5623 if (rval != QL_SUCCESS) {
5448 5624 /* error */
5449 5625 EL(ha, "failed, get_rnid_params_mbx=%xh\n", rval);
5450 5626 kmem_free(tmp_buf, sizeof (EXT_RNID_DATA));
5451 5627 cmd->Status = EXT_STATUS_ERR;
5452 5628 cmd->ResponseLen = 0;
5453 5629 return;
5454 5630 }
5455 5631
5456 5632 /* Now set the requested params. */
5457 5633 bcopy(tmp_set.IPVersion, tmp_buf->IPVersion, 2);
5458 5634 bcopy(tmp_set.UDPPortNumber, tmp_buf->UDPPortNumber, 2);
5459 5635 bcopy(tmp_set.IPAddress, tmp_buf->IPAddress, 16);
5460 5636
5461 5637 rval = ql_set_rnid_params(ha, sizeof (EXT_RNID_DATA),
|
↓ open down ↓ |
44 lines elided |
↑ open up ↑ |
5462 5638 (caddr_t)tmp_buf);
5463 5639 if (rval != QL_SUCCESS) {
5464 5640 /* error */
5465 5641 EL(ha, "failed, set_rnid_params_mbx=%xh\n", rval);
5466 5642 cmd->Status = EXT_STATUS_ERR;
5467 5643 cmd->ResponseLen = 0;
5468 5644 }
5469 5645
5470 5646 kmem_free(tmp_buf, sizeof (EXT_RNID_DATA));
5471 5647
5472 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5648 + QL_PRINT_9(ha, "done\n");
5473 5649 }
5474 5650
5475 5651 /*
5476 5652 * ql_get_rnid_parameters
5477 5653 * Get RNID parameters.
5478 5654 *
5479 5655 * Input:
5480 5656 * ha: adapter state pointer.
5481 5657 * cmd: User space CT arguments pointer.
5482 5658 * mode: flags.
5483 5659 */
5484 5660 static void
5485 5661 ql_get_rnid_parameters(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
5486 5662 {
5487 5663 EXT_RNID_DATA *tmp_buf;
5488 5664 uint32_t rval;
5489 5665
5490 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5666 + QL_PRINT_9(ha, "started\n");
5491 5667
5492 5668 if (DRIVER_SUSPENDED(ha)) {
5493 5669 EL(ha, "failed, LOOP_NOT_READY\n");
5494 5670 cmd->Status = EXT_STATUS_BUSY;
5495 5671 cmd->ResponseLen = 0;
5496 5672 return;
5497 5673 }
5498 5674
5499 5675 /* Allocate memory for command. */
5500 5676 tmp_buf = kmem_zalloc(sizeof (EXT_RNID_DATA), KM_SLEEP);
5501 5677 if (tmp_buf == NULL) {
5502 5678 EL(ha, "failed, kmem_zalloc\n");
5503 5679 cmd->Status = EXT_STATUS_NO_MEMORY;
5504 5680 cmd->ResponseLen = 0;
5505 5681 return;
5506 5682 }
5507 5683
5508 5684 /* Send command */
5509 5685 rval = ql_get_rnid_params(ha, sizeof (EXT_RNID_DATA),
5510 5686 (caddr_t)tmp_buf);
5511 5687 if (rval != QL_SUCCESS) {
5512 5688 /* error */
5513 5689 EL(ha, "failed, get_rnid_params_mbx=%xh\n", rval);
5514 5690 kmem_free(tmp_buf, sizeof (EXT_RNID_DATA));
5515 5691 cmd->Status = EXT_STATUS_ERR;
5516 5692 cmd->ResponseLen = 0;
5517 5693 return;
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
5518 5694 }
5519 5695
5520 5696 /* Copy the response */
5521 5697 if (ql_send_buffer_data((caddr_t)tmp_buf,
5522 5698 (caddr_t)(uintptr_t)cmd->ResponseAdr,
5523 5699 sizeof (EXT_RNID_DATA), mode) != sizeof (EXT_RNID_DATA)) {
5524 5700 EL(ha, "failed, ddi_copyout\n");
5525 5701 cmd->Status = EXT_STATUS_COPY_ERR;
5526 5702 cmd->ResponseLen = 0;
5527 5703 } else {
5528 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5704 + QL_PRINT_9(ha, "done\n");
5529 5705 cmd->ResponseLen = sizeof (EXT_RNID_DATA);
5530 5706 }
5531 5707
5532 5708 kmem_free(tmp_buf, sizeof (EXT_RNID_DATA));
5533 5709 }
5534 5710
5535 5711 /*
5536 5712 * ql_reset_statistics
5537 5713 * Performs EXT_SC_RST_STATISTICS subcommand. of EXT_CC_SET_DATA.
5538 5714 *
5539 5715 * Input:
5540 5716 * ha: adapter state pointer.
5541 5717 * cmd: Local EXT_IOCTL cmd struct pointer.
5542 5718 *
5543 5719 * Returns:
5544 5720 * None, request status indicated in cmd->Status.
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
5545 5721 *
5546 5722 * Context:
5547 5723 * Kernel context.
5548 5724 */
5549 5725 static int
5550 5726 ql_reset_statistics(ql_adapter_state_t *ha, EXT_IOCTL *cmd)
5551 5727 {
5552 5728 ql_xioctl_t *xp = ha->xioctl;
5553 5729 int rval = 0;
5554 5730
5555 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5731 + QL_PRINT_9(ha, "started\n");
5556 5732
5557 5733 if (DRIVER_SUSPENDED(ha)) {
5558 5734 EL(ha, "failed, LOOP_NOT_READY\n");
5559 5735 cmd->Status = EXT_STATUS_BUSY;
5560 5736 cmd->ResponseLen = 0;
5561 5737 return (QL_FUNCTION_SUSPENDED);
5562 5738 }
5563 5739
5564 5740 rval = ql_reset_link_status(ha);
5565 5741 if (rval != QL_SUCCESS) {
5566 5742 EL(ha, "failed, reset_link_status_mbx=%xh\n", rval);
5567 5743 cmd->Status = EXT_STATUS_MAILBOX;
5568 5744 cmd->DetailStatus = rval;
5569 5745 cmd->ResponseLen = 0;
5570 5746 }
5571 5747
5572 5748 TASK_DAEMON_LOCK(ha);
5573 5749 xp->IosRequested = 0;
5574 5750 xp->BytesRequested = 0;
5575 5751 xp->IOInputRequests = 0;
5576 5752 xp->IOOutputRequests = 0;
5577 5753 xp->IOControlRequests = 0;
5578 5754 xp->IOInputMByteCnt = 0;
5579 5755 xp->IOOutputMByteCnt = 0;
5580 5756 xp->IOOutputByteCnt = 0;
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
5581 5757 xp->IOInputByteCnt = 0;
5582 5758 TASK_DAEMON_UNLOCK(ha);
5583 5759
5584 5760 INTR_LOCK(ha);
5585 5761 xp->ControllerErrorCount = 0;
5586 5762 xp->DeviceErrorCount = 0;
5587 5763 xp->TotalLipResets = 0;
5588 5764 xp->TotalInterrupts = 0;
5589 5765 INTR_UNLOCK(ha);
5590 5766
5591 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5767 + QL_PRINT_9(ha, "done\n");
5592 5768
5593 5769 return (rval);
5594 5770 }
5595 5771
5596 5772 /*
5597 5773 * ql_get_statistics
5598 5774 * Performs EXT_SC_GET_STATISTICS subcommand. of EXT_CC_GET_DATA.
5599 5775 *
5600 5776 * Input:
5601 5777 * ha: adapter state pointer.
5602 5778 * cmd: Local EXT_IOCTL cmd struct pointer.
5603 5779 * mode: flags.
5604 5780 *
5605 5781 * Returns:
5606 5782 * None, request status indicated in cmd->Status.
5607 5783 *
5608 5784 * Context:
5609 5785 * Kernel context.
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
5610 5786 */
5611 5787 static void
5612 5788 ql_get_statistics(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
5613 5789 {
5614 5790 EXT_HBA_PORT_STAT ps = {0};
5615 5791 ql_link_stats_t *ls;
5616 5792 int rval;
5617 5793 ql_xioctl_t *xp = ha->xioctl;
5618 5794 int retry = 10;
5619 5795
5620 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5796 + QL_PRINT_9(ha, "started\n");
5621 5797
5622 5798 while (ha->task_daemon_flags &
5623 5799 (ABORT_ISP_ACTIVE | LOOP_RESYNC_ACTIVE | DRIVER_STALL)) {
5624 5800 ql_delay(ha, 10000000); /* 10 second delay */
5625 5801
5626 5802 retry--;
5627 5803
5628 5804 if (retry == 0) { /* effectively 100 seconds */
5629 5805 EL(ha, "failed, LOOP_NOT_READY\n");
5630 5806 cmd->Status = EXT_STATUS_BUSY;
5631 5807 cmd->ResponseLen = 0;
5632 5808 return;
5633 5809 }
5634 5810 }
5635 5811
5636 5812 /* Allocate memory for command. */
5637 5813 ls = kmem_zalloc(sizeof (ql_link_stats_t), KM_SLEEP);
5638 5814 if (ls == NULL) {
5639 5815 EL(ha, "failed, kmem_zalloc\n");
5640 5816 cmd->Status = EXT_STATUS_NO_MEMORY;
5641 5817 cmd->ResponseLen = 0;
5642 5818 return;
5643 5819 }
5644 5820
5645 5821 /*
5646 5822 * I think these are supposed to be port statistics
5647 5823 * the loop ID or port ID should be in cmd->Instance.
5648 5824 */
5649 5825 rval = ql_get_status_counts(ha, (uint16_t)
5650 5826 (ha->task_daemon_flags & LOOP_DOWN ? 0xFF : ha->loop_id),
5651 5827 sizeof (ql_link_stats_t), (caddr_t)ls, 0);
5652 5828 if (rval != QL_SUCCESS) {
5653 5829 EL(ha, "failed, get_link_status=%xh, id=%xh\n", rval,
5654 5830 ha->loop_id);
5655 5831 cmd->Status = EXT_STATUS_MAILBOX;
5656 5832 cmd->DetailStatus = rval;
5657 5833 cmd->ResponseLen = 0;
5658 5834 } else {
5659 5835 ps.ControllerErrorCount = xp->ControllerErrorCount;
5660 5836 ps.DeviceErrorCount = xp->DeviceErrorCount;
5661 5837 ps.IoCount = (uint32_t)(xp->IOInputRequests +
5662 5838 xp->IOOutputRequests + xp->IOControlRequests);
5663 5839 ps.MBytesCount = (uint32_t)(xp->IOInputMByteCnt +
5664 5840 xp->IOOutputMByteCnt);
5665 5841 ps.LipResetCount = xp->TotalLipResets;
5666 5842 ps.InterruptCount = xp->TotalInterrupts;
5667 5843 ps.LinkFailureCount = LE_32(ls->link_fail_cnt);
5668 5844 ps.LossOfSyncCount = LE_32(ls->sync_loss_cnt);
5669 5845 ps.LossOfSignalsCount = LE_32(ls->signal_loss_cnt);
5670 5846 ps.PrimitiveSeqProtocolErrorCount = LE_32(ls->prot_err_cnt);
5671 5847 ps.InvalidTransmissionWordCount = LE_32(ls->inv_xmit_cnt);
5672 5848 ps.InvalidCRCCount = LE_32(ls->inv_crc_cnt);
5673 5849
5674 5850 rval = ddi_copyout((void *)&ps,
5675 5851 (void *)(uintptr_t)cmd->ResponseAdr,
5676 5852 sizeof (EXT_HBA_PORT_STAT), mode);
5677 5853 if (rval != 0) {
|
↓ open down ↓ |
47 lines elided |
↑ open up ↑ |
5678 5854 EL(ha, "failed, ddi_copyout\n");
5679 5855 cmd->Status = EXT_STATUS_COPY_ERR;
5680 5856 cmd->ResponseLen = 0;
5681 5857 } else {
5682 5858 cmd->ResponseLen = sizeof (EXT_HBA_PORT_STAT);
5683 5859 }
5684 5860 }
5685 5861
5686 5862 kmem_free(ls, sizeof (ql_link_stats_t));
5687 5863
5688 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5864 + QL_PRINT_9(ha, "done\n");
5689 5865 }
5690 5866
5691 5867 /*
5692 5868 * ql_get_statistics_fc
5693 5869 * Performs EXT_SC_GET_FC_STATISTICS subcommand. of EXT_CC_GET_DATA.
5694 5870 *
5695 5871 * Input:
5696 5872 * ha: adapter state pointer.
5697 5873 * cmd: Local EXT_IOCTL cmd struct pointer.
5698 5874 * mode: flags.
5699 5875 *
5700 5876 * Returns:
5701 5877 * None, request status indicated in cmd->Status.
5702 5878 *
5703 5879 * Context:
5704 5880 * Kernel context.
5705 5881 */
5706 5882 static void
5707 5883 ql_get_statistics_fc(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
5708 5884 {
5709 5885 EXT_HBA_PORT_STAT ps = {0};
5710 5886 ql_link_stats_t *ls;
5711 5887 int rval;
5712 5888 uint16_t qlnt;
5713 5889 EXT_DEST_ADDR pextdestaddr;
5714 5890 uint8_t *name;
5715 5891 ql_tgt_t *tq = NULL;
5716 5892 int retry = 10;
5717 5893
5718 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5894 + QL_PRINT_9(ha, "started\n");
5719 5895
5720 5896 if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
5721 5897 (void *)&pextdestaddr, sizeof (EXT_DEST_ADDR), mode) != 0) {
5722 5898 EL(ha, "failed, ddi_copyin\n");
5723 5899 cmd->Status = EXT_STATUS_COPY_ERR;
5724 5900 cmd->ResponseLen = 0;
5725 5901 return;
5726 5902 }
5727 5903
5728 5904 qlnt = QLNT_PORT;
5729 5905 name = pextdestaddr.DestAddr.WWPN;
5730 5906
5731 - QL_PRINT_9(CE_CONT, "(%d): wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
5907 + QL_PRINT_9(ha, "wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
5732 5908 ha->instance, name[0], name[1], name[2], name[3], name[4],
5733 5909 name[5], name[6], name[7]);
5734 5910
5735 5911 tq = ql_find_port(ha, name, qlnt);
5736 5912
5737 5913 if (tq == NULL || !VALID_TARGET_ID(ha, tq->loop_id)) {
5738 5914 EL(ha, "failed, fc_port not found\n");
5739 5915 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
5740 5916 cmd->ResponseLen = 0;
5741 5917 return;
5742 5918 }
5743 5919
5744 5920 while (ha->task_daemon_flags &
5745 - (ABORT_ISP_ACTIVE | LOOP_RESYNC_ACTIVE | DRIVER_STALL)) {
5921 + (ABORT_ISP_ACTIVE | LOOP_RESYNC_ACTIVE | DRIVER_STALL)) {
5746 5922 ql_delay(ha, 10000000); /* 10 second delay */
5747 5923
5748 5924 retry--;
5749 5925
5750 5926 if (retry == 0) { /* effectively 100 seconds */
5751 5927 EL(ha, "failed, LOOP_NOT_READY\n");
5752 5928 cmd->Status = EXT_STATUS_BUSY;
5753 5929 cmd->ResponseLen = 0;
5754 5930 return;
5755 5931 }
5756 5932 }
5757 5933
5758 5934 /* Allocate memory for command. */
5759 5935 ls = kmem_zalloc(sizeof (ql_link_stats_t), KM_SLEEP);
5760 5936 if (ls == NULL) {
5761 5937 EL(ha, "failed, kmem_zalloc\n");
5762 5938 cmd->Status = EXT_STATUS_NO_MEMORY;
5763 5939 cmd->ResponseLen = 0;
5764 5940 return;
5765 5941 }
5766 5942
5767 5943 rval = ql_get_link_status(ha, tq->loop_id, sizeof (ql_link_stats_t),
5768 5944 (caddr_t)ls, 0);
5769 5945 if (rval != QL_SUCCESS) {
5770 5946 EL(ha, "failed, get_link_status=%xh, d_id=%xh\n", rval,
5771 5947 tq->d_id.b24);
5772 5948 cmd->Status = EXT_STATUS_MAILBOX;
5773 5949 cmd->DetailStatus = rval;
5774 5950 cmd->ResponseLen = 0;
5775 5951 } else {
5776 5952 ps.LinkFailureCount = LE_32(ls->link_fail_cnt);
5777 5953 ps.LossOfSyncCount = LE_32(ls->sync_loss_cnt);
5778 5954 ps.LossOfSignalsCount = LE_32(ls->signal_loss_cnt);
5779 5955 ps.PrimitiveSeqProtocolErrorCount = LE_32(ls->prot_err_cnt);
5780 5956 ps.InvalidTransmissionWordCount = LE_32(ls->inv_xmit_cnt);
5781 5957 ps.InvalidCRCCount = LE_32(ls->inv_crc_cnt);
5782 5958
5783 5959 rval = ddi_copyout((void *)&ps,
5784 5960 (void *)(uintptr_t)cmd->ResponseAdr,
5785 5961 sizeof (EXT_HBA_PORT_STAT), mode);
5786 5962
5787 5963 if (rval != 0) {
|
↓ open down ↓ |
32 lines elided |
↑ open up ↑ |
5788 5964 EL(ha, "failed, ddi_copyout\n");
5789 5965 cmd->Status = EXT_STATUS_COPY_ERR;
5790 5966 cmd->ResponseLen = 0;
5791 5967 } else {
5792 5968 cmd->ResponseLen = sizeof (EXT_HBA_PORT_STAT);
5793 5969 }
5794 5970 }
5795 5971
5796 5972 kmem_free(ls, sizeof (ql_link_stats_t));
5797 5973
5798 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
5974 + QL_PRINT_9(ha, "done\n");
5799 5975 }
5800 5976
5801 5977 /*
5802 5978 * ql_get_statistics_fc4
5803 5979 * Performs EXT_SC_GET_FC_STATISTICS subcommand. of EXT_CC_GET_DATA.
5804 5980 *
5805 5981 * Input:
5806 5982 * ha: adapter state pointer.
5807 5983 * cmd: Local EXT_IOCTL cmd struct pointer.
5808 5984 * mode: flags.
5809 5985 *
5810 5986 * Returns:
5811 5987 * None, request status indicated in cmd->Status.
5812 5988 *
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
5813 5989 * Context:
5814 5990 * Kernel context.
5815 5991 */
5816 5992 static void
5817 5993 ql_get_statistics_fc4(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
5818 5994 {
5819 5995 uint32_t rval;
5820 5996 EXT_HBA_FC4STATISTICS fc4stats = {0};
5821 5997 ql_xioctl_t *xp = ha->xioctl;
5822 5998
5823 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
5999 + QL_PRINT_9(ha, "started\n");
5824 6000
5825 6001 fc4stats.InputRequests = xp->IOInputRequests;
5826 6002 fc4stats.OutputRequests = xp->IOOutputRequests;
5827 6003 fc4stats.ControlRequests = xp->IOControlRequests;
5828 6004 fc4stats.InputMegabytes = xp->IOInputMByteCnt;
5829 6005 fc4stats.OutputMegabytes = xp->IOOutputMByteCnt;
5830 6006
5831 6007 rval = ddi_copyout((void *)&fc4stats,
5832 6008 (void *)(uintptr_t)cmd->ResponseAdr,
5833 6009 sizeof (EXT_HBA_FC4STATISTICS), mode);
5834 6010
5835 6011 if (rval != 0) {
5836 6012 EL(ha, "failed, ddi_copyout\n");
5837 6013 cmd->Status = EXT_STATUS_COPY_ERR;
5838 6014 cmd->ResponseLen = 0;
5839 6015 } else {
5840 6016 cmd->ResponseLen = sizeof (EXT_HBA_FC4STATISTICS);
5841 6017 }
5842 6018
5843 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6019 + QL_PRINT_9(ha, "done\n");
5844 6020 }
5845 6021
5846 6022 /*
5847 6023 * ql_set_led_state
5848 6024 * Performs EXT_SET_BEACON_STATE subcommand of EXT_CC_SET_DATA.
5849 6025 *
5850 6026 * Input:
5851 6027 * ha: adapter state pointer.
5852 6028 * cmd: Local EXT_IOCTL cmd struct pointer.
5853 6029 * mode: flags.
5854 6030 *
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
5855 6031 * Returns:
5856 6032 * None, request status indicated in cmd->Status.
5857 6033 *
5858 6034 * Context:
5859 6035 * Kernel context.
5860 6036 */
5861 6037 static void
5862 6038 ql_set_led_state(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
5863 6039 {
5864 6040 EXT_BEACON_CONTROL bstate;
5865 - uint32_t rval;
5866 - ql_xioctl_t *xp = ha->xioctl;
6041 + int rval;
6042 + ql_mbx_data_t mr;
5867 6043
5868 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6044 + QL_PRINT_9(ha, "started\n");
5869 6045
5870 6046 if (cmd->RequestLen < sizeof (EXT_BEACON_CONTROL)) {
5871 6047 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
5872 6048 cmd->DetailStatus = sizeof (EXT_BEACON_CONTROL);
5873 6049 EL(ha, "done - failed, RequestLen < EXT_BEACON_CONTROL,"
5874 6050 " Len=%xh\n", cmd->RequestLen);
5875 6051 cmd->ResponseLen = 0;
5876 6052 return;
5877 6053 }
5878 6054
5879 - if (ha->device_id < 0x2300) {
6055 + if (!CFG_IST(ha, CFG_SET_LEDS_SUPPORT)) {
5880 6056 cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
5881 6057 cmd->DetailStatus = 0;
5882 6058 EL(ha, "done - failed, Invalid function for HBA model\n");
5883 6059 cmd->ResponseLen = 0;
5884 6060 return;
5885 6061 }
5886 6062
5887 6063 rval = ddi_copyin((void*)(uintptr_t)cmd->RequestAdr, &bstate,
5888 6064 cmd->RequestLen, mode);
5889 6065
5890 6066 if (rval != 0) {
5891 6067 cmd->Status = EXT_STATUS_COPY_ERR;
5892 6068 EL(ha, "done - failed, ddi_copyin\n");
5893 6069 return;
5894 6070 }
5895 6071
5896 6072 switch (bstate.State) {
5897 6073 case EXT_DEF_GRN_BLINK_OFF: /* turn beacon off */
5898 - if (xp->ledstate.BeaconState == BEACON_OFF) {
6074 + if (ha->ledstate.BeaconState == BEACON_OFF) {
5899 6075 /* not quite an error -- LED state is already off */
5900 6076 cmd->Status = EXT_STATUS_OK;
5901 6077 EL(ha, "LED off request -- LED is already off\n");
5902 6078 break;
5903 6079 }
5904 6080
5905 - xp->ledstate.BeaconState = BEACON_OFF;
5906 - xp->ledstate.LEDflags = LED_ALL_OFF;
6081 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
6082 + rval = ql_diag_beacon(ha, QL_BEACON_DISABLE,
6083 + &mr);
5907 6084
6085 + if (rval == QL_SUCCESS) {
6086 + ha->ledstate.BeaconState = BEACON_OFF;
6087 + ha->ledstate.LEDflags = LED_ALL_OFF;
6088 + cmd->Status = EXT_STATUS_OK;
6089 + } else {
6090 + cmd->Status = EXT_STATUS_ERR;
6091 + EL(ha, "failed, disable beacon request %xh\n",
6092 + bstate.State);
6093 + }
6094 + break;
6095 + }
6096 +
6097 + ha->ledstate.BeaconState = BEACON_OFF;
6098 + ha->ledstate.LEDflags = LED_ALL_OFF;
6099 +
5908 6100 if ((rval = ql_wrapup_led(ha)) != QL_SUCCESS) {
5909 6101 cmd->Status = EXT_STATUS_MAILBOX;
5910 6102 } else {
5911 6103 cmd->Status = EXT_STATUS_OK;
5912 6104 }
5913 6105 break;
5914 6106
5915 6107 case EXT_DEF_GRN_BLINK_ON: /* turn beacon on */
5916 - if (xp->ledstate.BeaconState == BEACON_ON) {
6108 + if (ha->ledstate.BeaconState == BEACON_ON) {
5917 6109 /* not quite an error -- LED state is already on */
5918 6110 cmd->Status = EXT_STATUS_OK;
5919 6111 EL(ha, "LED on request - LED is already on\n");
5920 6112 break;
5921 6113 }
5922 6114
6115 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
6116 + rval = ql_diag_beacon(ha, QL_BEACON_ENABLE,
6117 + &mr);
6118 +
6119 + if (rval == QL_SUCCESS) {
6120 + ha->ledstate.BeaconState = BEACON_ON;
6121 + ha->ledstate.LEDflags = LED_GREEN;
6122 + cmd->Status = EXT_STATUS_OK;
6123 + } else {
6124 + cmd->Status = EXT_STATUS_ERR;
6125 + EL(ha, "failed, enable beacon request %xh\n",
6126 + bstate.State);
6127 + }
6128 + break;
6129 + }
6130 +
5923 6131 if ((rval = ql_setup_led(ha)) != QL_SUCCESS) {
5924 6132 cmd->Status = EXT_STATUS_MAILBOX;
5925 6133 break;
5926 6134 }
5927 6135
5928 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
5929 - xp->ledstate.LEDflags = LED_YELLOW_24 | LED_AMBER_24;
6136 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
6137 + ha->ledstate.LEDflags = LED_YELLOW_24 | LED_AMBER_24;
5930 6138 } else {
5931 - xp->ledstate.LEDflags = LED_GREEN;
6139 + ha->ledstate.LEDflags = LED_GREEN;
5932 6140 }
5933 - xp->ledstate.BeaconState = BEACON_ON;
6141 + ha->ledstate.BeaconState = BEACON_ON;
5934 6142
5935 6143 cmd->Status = EXT_STATUS_OK;
5936 6144 break;
5937 6145 default:
5938 6146 cmd->Status = EXT_STATUS_ERR;
5939 6147 EL(ha, "failed, unknown state request %xh\n", bstate.State);
5940 6148 break;
5941 6149 }
5942 6150
5943 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6151 + QL_PRINT_9(ha, "done\n");
5944 6152 }
5945 6153
5946 6154 /*
5947 6155 * ql_get_led_state
5948 6156 * Performs EXT_GET_BEACON_STATE subcommand of EXT_CC_GET_DATA.
5949 6157 *
5950 6158 * Input:
5951 6159 * ha: adapter state pointer.
5952 6160 * cmd: Local EXT_IOCTL cmd struct pointer.
5953 6161 * mode: flags.
5954 6162 *
5955 6163 * Returns:
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
5956 6164 * None, request status indicated in cmd->Status.
5957 6165 *
5958 6166 * Context:
5959 6167 * Kernel context.
5960 6168 */
5961 6169 static void
5962 6170 ql_get_led_state(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
5963 6171 {
5964 6172 EXT_BEACON_CONTROL bstate = {0};
5965 6173 uint32_t rval;
5966 - ql_xioctl_t *xp = ha->xioctl;
5967 6174
5968 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6175 + QL_PRINT_9(ha, "started\n");
5969 6176
5970 6177 if (cmd->ResponseLen < sizeof (EXT_BEACON_CONTROL)) {
5971 6178 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
5972 6179 cmd->DetailStatus = sizeof (EXT_BEACON_CONTROL);
5973 6180 EL(ha, "done - failed, ResponseLen < EXT_BEACON_CONTROL,"
5974 6181 "Len=%xh\n", cmd->ResponseLen);
5975 6182 cmd->ResponseLen = 0;
5976 6183 return;
5977 6184 }
5978 6185
5979 - if (ha->device_id < 0x2300) {
6186 + if (!CFG_IST(ha, CFG_SET_LEDS_SUPPORT)) {
5980 6187 cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
5981 6188 cmd->DetailStatus = 0;
5982 6189 EL(ha, "done - failed, Invalid function for HBA model\n");
5983 6190 cmd->ResponseLen = 0;
5984 6191 return;
5985 6192 }
5986 6193
5987 6194 if (ha->task_daemon_flags & ABORT_ISP_ACTIVE) {
5988 6195 cmd->Status = EXT_STATUS_BUSY;
5989 6196 EL(ha, "done - failed, isp abort active\n");
5990 6197 cmd->ResponseLen = 0;
5991 6198 return;
5992 6199 }
5993 6200
5994 6201 /* inform the user of the current beacon state (off or on) */
5995 - bstate.State = xp->ledstate.BeaconState;
6202 + bstate.State = ha->ledstate.BeaconState;
5996 6203
5997 6204 rval = ddi_copyout((void *)&bstate,
5998 6205 (void *)(uintptr_t)cmd->ResponseAdr,
5999 6206 sizeof (EXT_BEACON_CONTROL), mode);
6000 6207
6001 6208 if (rval != 0) {
6002 6209 EL(ha, "failed, ddi_copyout\n");
6003 6210 cmd->Status = EXT_STATUS_COPY_ERR;
6004 6211 cmd->ResponseLen = 0;
6005 6212 } else {
6006 6213 cmd->Status = EXT_STATUS_OK;
6007 6214 cmd->ResponseLen = sizeof (EXT_BEACON_CONTROL);
6008 6215 }
6009 6216
6010 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6217 + QL_PRINT_9(ha, "done\n");
6011 6218 }
6012 6219
6013 6220 /*
6014 6221 * ql_blink_led
6015 6222 * Determine the next state of the LED and drive it
6016 6223 *
6017 6224 * Input:
6018 6225 * ha: adapter state pointer.
6019 6226 *
6020 6227 * Context:
6021 6228 * Interrupt context.
6022 6229 */
6023 6230 void
6024 6231 ql_blink_led(ql_adapter_state_t *ha)
6025 6232 {
6026 - uint32_t nextstate;
6027 - ql_xioctl_t *xp = ha->xioctl;
6233 + uint32_t nextstate;
6234 + ql_mbx_data_t mr;
6028 6235
6029 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6236 + QL_PRINT_9(ha, "started\n");
6030 6237
6031 - if (xp->ledstate.BeaconState == BEACON_ON) {
6032 - /* determine the next led state */
6033 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
6034 - nextstate = (xp->ledstate.LEDflags) &
6035 - (~(RD32_IO_REG(ha, gpiod)));
6036 - } else {
6037 - nextstate = (xp->ledstate.LEDflags) &
6038 - (~(RD16_IO_REG(ha, gpiod)));
6039 - }
6238 + if (ha->ledstate.BeaconState == BEACON_ON) {
6239 + if (CFG_IST(ha, CFG_CTRL_2363 | CFG_CTRL_2425)) {
6240 + /* determine the next led state */
6241 + if (CFG_IST(ha, CFG_CTRL_2425)) {
6242 + nextstate = (ha->ledstate.LEDflags) &
6243 + (~(RD32_IO_REG(ha, gpiod)));
6244 + } else {
6245 + nextstate = (ha->ledstate.LEDflags) &
6246 + (~(RD16_IO_REG(ha, gpiod)));
6247 + }
6040 6248
6041 - /* turn the led on or off */
6042 - ql_drive_led(ha, nextstate);
6249 + /* turn the led on or off */
6250 + ql_drive_led(ha, nextstate);
6251 + } else if (CFG_IST(ha, CFG_CTRL_81XX)) {
6252 + if (ha->ledstate.flags & LED_ACTIVE) {
6253 + mr.mb[1] = 0x2000;
6254 + mr.mb[2] = 0x4000;
6255 + ha->ledstate.flags &= ~LED_ACTIVE;
6256 + } else {
6257 + mr.mb[1] = 0x4000;
6258 + mr.mb[2] = 0x2000;
6259 + ha->ledstate.flags |= LED_ACTIVE;
6260 + }
6261 + (void) ql_set_led_config(ha, &mr);
6262 + } else if (CFG_IST(ha, CFG_CTRL_80XX)) {
6263 + if (ha->ledstate.flags & LED_ACTIVE) {
6264 + mr.mb[1] = 0x4000;
6265 + mr.mb[2] = 0x2000;
6266 + mr.mb[3] = 0x4000;
6267 + mr.mb[4] = 0x4000;
6268 + mr.mb[5] = 0;
6269 + mr.mb[6] = 0x2000;
6270 + (void) ql_set_led_config(ha, &mr);
6271 + ha->ledstate.flags &= ~LED_ACTIVE;
6272 + } else {
6273 + mr.mb[1] = 0x4000;
6274 + mr.mb[2] = 0x4000;
6275 + mr.mb[3] = 0x4000;
6276 + mr.mb[4] = 0x2000;
6277 + mr.mb[5] = 0;
6278 + mr.mb[6] = 0x2000;
6279 + (void) ql_set_led_config(ha, &mr);
6280 + ha->ledstate.flags |= LED_ACTIVE;
6281 + }
6282 + } else if (CFG_IST(ha, CFG_CTRL_83XX)) {
6283 + if (ha->ledstate.flags & LED_ACTIVE) {
6284 + (void) ql_write_remote_reg(ha,
6285 + ha->ledstate.select,
6286 + 0x40004000);
6287 + (void) ql_write_remote_reg(ha,
6288 + ha->ledstate.select + 4,
6289 + 0x40004000);
6290 + ha->ledstate.flags &= ~LED_ACTIVE;
6291 + } else {
6292 + (void) ql_write_remote_reg(ha,
6293 + ha->ledstate.select,
6294 + 0x40002000);
6295 + (void) ql_write_remote_reg(ha,
6296 + ha->ledstate.select + 4,
6297 + 0x40002000);
6298 + ha->ledstate.flags |= LED_ACTIVE;
6299 + }
6300 + } else if (!CFG_IST(ha, CFG_CTRL_27XX)) {
6301 + EL(ha, "unsupported HBA: %xh\n", ha->device_id);
6302 + }
6043 6303 }
6044 6304
6045 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6305 + QL_PRINT_9(ha, "done\n");
6046 6306 }
6047 6307
6048 6308 /*
6049 6309 * ql_drive_led
6050 6310 * drive the led's as determined by LEDflags
6051 6311 *
6052 6312 * Input:
6053 6313 * ha: adapter state pointer.
6054 6314 * LEDflags: LED flags
6055 6315 *
6056 6316 * Context:
6057 6317 * Kernel/Interrupt context.
6058 6318 */
6059 6319 static void
6060 6320 ql_drive_led(ql_adapter_state_t *ha, uint32_t LEDflags)
6061 6321 {
6322 + QL_PRINT_9(ha, "started\n");
6062 6323
6063 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6324 + if (CFG_IST(ha, CFG_CTRL_2363)) {
6064 6325
6065 - if (CFG_IST(ha, (CFG_CTRL_2300 | CFG_CTRL_6322))) {
6066 -
6067 6326 uint16_t gpio_enable, gpio_data;
6068 6327
6069 6328 /* setup to send new data */
6070 6329 gpio_enable = (uint16_t)RD16_IO_REG(ha, gpioe);
6071 6330 gpio_enable = (uint16_t)(gpio_enable | LED_MASK);
6072 6331 WRT16_IO_REG(ha, gpioe, gpio_enable);
6073 6332
6074 6333 /* read current data and clear out old led data */
6075 6334 gpio_data = (uint16_t)RD16_IO_REG(ha, gpiod);
6076 6335 gpio_data = (uint16_t)(gpio_data & ~LED_MASK);
6077 6336
6078 6337 /* set in the new led data. */
6079 6338 gpio_data = (uint16_t)(gpio_data | LEDflags);
6080 6339
6081 6340 /* write out the new led data */
6082 6341 WRT16_IO_REG(ha, gpiod, gpio_data);
6083 6342
6084 - } else if (CFG_IST(ha, CFG_CTRL_24258081)) {
6085 -
6343 + } else if (CFG_IST(ha, CFG_CTRL_2425)) {
6086 6344 uint32_t gpio_data;
6087 6345
6088 6346 /* setup to send new data */
6089 6347 gpio_data = RD32_IO_REG(ha, gpiod);
6090 6348 gpio_data |= LED_MASK_UPDATE_24;
6091 6349 WRT32_IO_REG(ha, gpiod, gpio_data);
6092 6350
6093 6351 /* read current data and clear out old led data */
6094 6352 gpio_data = RD32_IO_REG(ha, gpiod);
6095 6353 gpio_data &= ~LED_MASK_COLORS_24;
6096 6354
6097 6355 /* set in the new led data */
6098 6356 gpio_data |= LEDflags;
6099 6357
6100 6358 /* write out the new led data */
6101 6359 WRT32_IO_REG(ha, gpiod, gpio_data);
6102 6360
6103 6361 } else {
6104 - EL(ha, "unsupported HBA: %xh", ha->device_id);
6362 + EL(ha, "unsupported HBA: %xh\n", ha->device_id);
6105 6363 }
6106 6364
6107 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6365 + QL_PRINT_9(ha, "done\n");
6108 6366 }
6109 6367
6110 6368 /*
6111 6369 * ql_setup_led
6112 6370 * Setup LED for driver control
6113 6371 *
6114 6372 * Input:
6115 6373 * ha: adapter state pointer.
6116 6374 *
6117 6375 * Context:
6118 6376 * Kernel/Interrupt context.
6119 6377 */
6120 -static uint32_t
6378 +static int
6121 6379 ql_setup_led(ql_adapter_state_t *ha)
6122 6380 {
6123 - uint32_t rval;
6381 + int rval = QL_SUCCESS;
6124 6382 ql_mbx_data_t mr;
6125 6383
6126 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6384 + QL_PRINT_9(ha, "started\n");
6127 6385
6128 - /* decouple the LED control from the fw */
6129 - rval = ql_get_firmware_option(ha, &mr);
6130 - if (rval != QL_SUCCESS) {
6131 - EL(ha, "failed, get_firmware_option=%xh\n", rval);
6132 - return (rval);
6133 - }
6386 + if (CFG_IST(ha, CFG_CTRL_2363 | CFG_CTRL_2425)) {
6387 + /* decouple the LED control from the fw */
6388 + rval = ql_get_firmware_option(ha, &mr);
6389 + if (rval != QL_SUCCESS) {
6390 + EL(ha, "failed, get_firmware_option=%xh\n", rval);
6391 + return (rval);
6392 + }
6134 6393
6135 - /* set the appropriate options */
6136 - mr.mb[1] = (uint16_t)(mr.mb[1] | FO1_DISABLE_GPIO);
6394 + /* set the appropriate options */
6395 + mr.mb[1] = (uint16_t)(mr.mb[1] | FO1_DISABLE_GPIO);
6137 6396
6138 - /* send it back to the firmware */
6139 - rval = ql_set_firmware_option(ha, &mr);
6140 - if (rval != QL_SUCCESS) {
6141 - EL(ha, "failed, set_firmware_option=%xh\n", rval);
6142 - return (rval);
6143 - }
6397 + /* send it back to the firmware */
6398 + rval = ql_set_firmware_option(ha, &mr);
6399 + if (rval != QL_SUCCESS) {
6400 + EL(ha, "failed, set_firmware_option=%xh\n", rval);
6401 + return (rval);
6402 + }
6144 6403
6145 - /* initally, turn the LED's off */
6146 - ql_drive_led(ha, LED_ALL_OFF);
6404 + /* initally, turn the LED's off */
6405 + ql_drive_led(ha, LED_ALL_OFF);
6147 6406
6148 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6407 + } else if (CFG_IST(ha, CFG_CTRL_81XX)) {
6408 + (void) ql_get_led_config(ha, &ha->ledstate.cfg);
6409 + mr.mb[1] = 0x2000;
6410 + mr.mb[2] = 0x2000;
6411 + rval = ql_set_led_config(ha, &mr);
6149 6412
6413 + } else if (CFG_IST(ha, CFG_CTRL_80XX)) {
6414 + /* Save initial value */
6415 + rval = ql_get_led_config(ha, &ha->ledstate.cfg);
6416 + if (rval != QL_SUCCESS) {
6417 + EL(ha, "failed, get_led_config=%xh\n", rval);
6418 + return (rval);
6419 + }
6420 + mr.mb[1] = 0x4000;
6421 + mr.mb[2] = 0x4000;
6422 + mr.mb[3] = 0x4000;
6423 + mr.mb[4] = 0x2000;
6424 + mr.mb[5] = 0;
6425 + mr.mb[6] = 0x2000;
6426 + rval = ql_set_led_config(ha, &mr);
6427 +
6428 + } else if (CFG_IST(ha, CFG_CTRL_83XX)) {
6429 + rval = ql_get_firmware_option(ha, &mr);
6430 + if (rval != QL_SUCCESS) {
6431 + EL(ha, "failed, get_firmware_option=%xh\n", rval);
6432 + return (rval);
6433 + }
6434 +
6435 + mr.mb[1] = (uint16_t)(mr.mb[1] | FO1_DISABLE_LEDS);
6436 +
6437 + rval = ql_set_firmware_option(ha, &mr);
6438 + if (rval != QL_SUCCESS) {
6439 + EL(ha, "failed, set_firmware_option=%xh\n", rval);
6440 + return (rval);
6441 + }
6442 +
6443 + (void) ql_write_remote_reg(ha, ha->ledstate.select,
6444 + 0x40002000);
6445 + (void) ql_write_remote_reg(ha, ha->ledstate.select + 4,
6446 + 0x40002000);
6447 +
6448 + } else if (CFG_IST(ha, CFG_CTRL_27XX)) {
6449 + /* take control of LED */
6450 + rval = ql_get_firmware_option(ha, &mr);
6451 + if (rval != QL_SUCCESS) {
6452 + EL(ha, "failed, get_firmware_option=%xh\n", rval);
6453 + return (rval);
6454 + }
6455 +
6456 + mr.mb[1] = (uint16_t)(mr.mb[1] | FO1_DISABLE_LEDS);
6457 +
6458 + rval = ql_set_firmware_option(ha, &mr);
6459 + if (rval != QL_SUCCESS) {
6460 + EL(ha, "failed, set_firmware_option=%xh\n", rval);
6461 + return (rval);
6462 + }
6463 +
6464 + mr.mb[1] = 0xf;
6465 + mr.mb[2] = 0x230;
6466 + mr.mb[3] = 0x230;
6467 + mr.mb[4] = 0x4000;
6468 + rval = ql_led_config(ha, &mr);
6469 + if (rval != QL_SUCCESS) {
6470 + EL(ha, "failed, led_config=%xh\n", rval);
6471 + return (rval);
6472 + }
6473 + } else {
6474 + EL(ha, "unsupported HBA: %xh\n", ha->device_id);
6475 + }
6476 + ha->ledstate.flags |= LED_ACTIVE;
6477 +
6478 + QL_PRINT_9(ha, "done\n");
6479 +
6150 6480 return (rval);
6151 6481 }
6152 6482
6153 6483 /*
6154 6484 * ql_wrapup_led
6155 6485 * Return LED control to the firmware
6156 6486 *
6157 6487 * Input:
6158 6488 * ha: adapter state pointer.
6159 6489 *
6160 6490 * Context:
6161 6491 * Kernel/Interrupt context.
6162 6492 */
6163 -static uint32_t
6493 +static int
6164 6494 ql_wrapup_led(ql_adapter_state_t *ha)
6165 6495 {
6166 - uint32_t rval;
6496 + int rval = QL_SUCCESS;
6167 6497 ql_mbx_data_t mr;
6168 6498
6169 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6499 + QL_PRINT_9(ha, "started\n");
6170 6500
6171 - /* Turn all LED's off */
6172 - ql_drive_led(ha, LED_ALL_OFF);
6173 6501
6174 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
6175 -
6502 + if (CFG_IST(ha, CFG_CTRL_2363 | CFG_CTRL_2425)) {
6176 6503 uint32_t gpio_data;
6177 6504
6178 - /* disable the LED update mask */
6179 - gpio_data = RD32_IO_REG(ha, gpiod);
6180 - gpio_data &= ~LED_MASK_UPDATE_24;
6505 + /* Turn all LED's off */
6506 + ql_drive_led(ha, LED_ALL_OFF);
6181 6507
6182 - /* write out the data */
6183 - WRT32_IO_REG(ha, gpiod, gpio_data);
6184 - }
6508 + if (CFG_IST(ha, CFG_CTRL_2425)) {
6509 + /* disable the LED update mask */
6510 + gpio_data = RD32_IO_REG(ha, gpiod);
6511 + gpio_data &= ~LED_MASK_UPDATE_24;
6185 6512
6186 - /* give LED control back to the f/w */
6187 - rval = ql_get_firmware_option(ha, &mr);
6188 - if (rval != QL_SUCCESS) {
6189 - EL(ha, "failed, get_firmware_option=%xh\n", rval);
6190 - return (rval);
6191 - }
6513 + /* write out the data */
6514 + WRT32_IO_REG(ha, gpiod, gpio_data);
6515 + /* give LED control back to the f/w */
6516 + }
6517 + rval = ql_get_firmware_option(ha, &mr);
6518 + if (rval != QL_SUCCESS) {
6519 + EL(ha, "failed, get_firmware_option=%xh\n", rval);
6520 + return (rval);
6521 + }
6192 6522
6193 - mr.mb[1] = (uint16_t)(mr.mb[1] & ~FO1_DISABLE_GPIO);
6523 + mr.mb[1] = (uint16_t)(mr.mb[1] & ~FO1_DISABLE_GPIO);
6194 6524
6195 - rval = ql_set_firmware_option(ha, &mr);
6196 - if (rval != QL_SUCCESS) {
6197 - EL(ha, "failed, set_firmware_option=%xh\n", rval);
6198 - return (rval);
6525 + rval = ql_set_firmware_option(ha, &mr);
6526 + if (rval != QL_SUCCESS) {
6527 + EL(ha, "failed, set_firmware_option=%xh\n", rval);
6528 + return (rval);
6529 + }
6530 + } else if (CFG_IST(ha, CFG_CTRL_8081)) {
6531 + rval = ql_set_led_config(ha, &ha->ledstate.cfg);
6532 +
6533 + } else if (CFG_IST(ha, CFG_CTRL_2783)) {
6534 + /* give LED control back to the f/w */
6535 + rval = ql_get_firmware_option(ha, &mr);
6536 + if (rval != QL_SUCCESS) {
6537 + EL(ha, "failed, get_firmware_option=%xh\n", rval);
6538 + return (rval);
6539 + }
6540 +
6541 + mr.mb[1] = (uint16_t)(mr.mb[1] & ~FO1_DISABLE_LEDS);
6542 +
6543 + rval = ql_set_firmware_option(ha, &mr);
6544 + if (rval != QL_SUCCESS) {
6545 + EL(ha, "failed, set_firmware_option=%xh\n", rval);
6546 + return (rval);
6547 + }
6548 +
6549 + } else {
6550 + EL(ha, "unsupported HBA: %xh\n", ha->device_id);
6199 6551 }
6200 6552
6201 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6553 + QL_PRINT_9(ha, "done\n");
6202 6554
6203 6555 return (rval);
6204 6556 }
6205 6557
6206 6558 /*
6207 6559 * ql_get_port_summary
6208 6560 * Performs EXT_SC_GET_PORT_SUMMARY subcommand. of EXT_CC_GET_DATA.
6209 6561 *
6210 6562 * The EXT_IOCTL->RequestAdr points to a single
6211 6563 * UINT32 which identifies the device type.
6212 6564 *
6213 6565 * Input:
6214 6566 * ha: adapter state pointer.
6215 6567 * cmd: Local EXT_IOCTL cmd struct pointer.
6216 6568 * mode: flags.
6217 6569 *
6218 6570 * Returns:
6219 6571 * None, request status indicated in cmd->Status.
6220 6572 *
6221 6573 * Context:
6222 6574 * Kernel context.
6223 6575 */
6224 6576 static void
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
6225 6577 ql_get_port_summary(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
6226 6578 {
6227 6579 EXT_DEVICEDATA dd = {0};
6228 6580 EXT_DEVICEDATA *uddp;
6229 6581 ql_link_t *link;
6230 6582 ql_tgt_t *tq;
6231 6583 uint32_t rlen, dev_type, index;
6232 6584 int rval = 0;
6233 6585 EXT_DEVICEDATAENTRY *uddep, *ddep;
6234 6586
6235 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6587 + QL_PRINT_9(ha, "started\n");
6236 6588
6237 6589 ddep = &dd.EntryList[0];
6238 6590
6239 6591 /*
6240 6592 * Get the type of device the requestor is looking for.
6241 6593 *
6242 6594 * We ignore this for now.
6243 6595 */
6244 6596 rval = ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
6245 6597 (void *)&dev_type, sizeof (dev_type), mode);
6246 6598 if (rval != 0) {
6247 6599 cmd->Status = EXT_STATUS_COPY_ERR;
6248 6600 cmd->ResponseLen = 0;
6249 6601 EL(ha, "failed, ddi_copyin\n");
6250 6602 return;
6251 6603 }
6252 6604 /*
6253 6605 * Count the number of entries to be returned. Count devices
6254 6606 * that are offlline, but have been persistently bound.
6255 6607 */
6256 6608 for (index = 0; index < DEVICE_HEAD_LIST_SIZE; index++) {
6257 6609 for (link = ha->dev[index].first; link != NULL;
6258 6610 link = link->next) {
6259 6611 tq = link->base_address;
6260 6612 if (tq->flags & TQF_INITIATOR_DEVICE ||
6261 6613 !VALID_TARGET_ID(ha, tq->loop_id)) {
6262 6614 continue; /* Skip this one */
6263 6615 }
6264 6616 dd.TotalDevices++;
6265 6617 }
6266 6618 }
6267 6619 /*
6268 6620 * Compute the number of entries that can be returned
6269 6621 * based upon the size of caller's response buffer.
6270 6622 */
6271 6623 dd.ReturnListEntryCount = 0;
6272 6624 if (dd.TotalDevices == 0) {
6273 6625 rlen = sizeof (EXT_DEVICEDATA) - sizeof (EXT_DEVICEDATAENTRY);
6274 6626 } else {
6275 6627 rlen = (uint32_t)(sizeof (EXT_DEVICEDATA) +
6276 6628 (sizeof (EXT_DEVICEDATAENTRY) * (dd.TotalDevices - 1)));
6277 6629 }
6278 6630 if (rlen > cmd->ResponseLen) {
6279 6631 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
6280 6632 cmd->DetailStatus = rlen;
6281 6633 EL(ha, "failed, rlen > ResponseLen, rlen=%d, Len=%d\n",
6282 6634 rlen, cmd->ResponseLen);
6283 6635 cmd->ResponseLen = 0;
|
↓ open down ↓ |
38 lines elided |
↑ open up ↑ |
6284 6636 return;
6285 6637 }
6286 6638 cmd->ResponseLen = 0;
6287 6639 uddp = (EXT_DEVICEDATA *)(uintptr_t)cmd->ResponseAdr;
6288 6640 uddep = &uddp->EntryList[0];
6289 6641 for (index = 0; index < DEVICE_HEAD_LIST_SIZE; index++) {
6290 6642 for (link = ha->dev[index].first; link != NULL;
6291 6643 link = link->next) {
6292 6644 tq = link->base_address;
6293 6645 if (tq->flags & TQF_INITIATOR_DEVICE ||
6294 - !VALID_TARGET_ID(ha, tq->loop_id)) {
6646 + !VALID_TARGET_ID(ha, tq->loop_id) ||
6647 + tq->d_id.b24 == FS_MANAGEMENT_SERVER) {
6295 6648 continue; /* Skip this one */
6296 6649 }
6297 6650
6298 6651 bzero((void *)ddep, sizeof (EXT_DEVICEDATAENTRY));
6299 6652
6300 6653 bcopy(tq->node_name, ddep->NodeWWN, 8);
6301 6654 bcopy(tq->port_name, ddep->PortWWN, 8);
6302 6655
6303 6656 ddep->PortID[0] = tq->d_id.b.domain;
6304 6657 ddep->PortID[1] = tq->d_id.b.area;
6305 6658 ddep->PortID[2] = tq->d_id.b.al_pa;
6306 6659
6307 6660 bcopy(tq->port_name,
6308 6661 (caddr_t)&ddep->TargetAddress.Target, 8);
6309 6662
6310 6663 ddep->DeviceFlags = tq->flags;
6311 6664 ddep->LoopID = tq->loop_id;
6312 - QL_PRINT_9(CE_CONT, "(%d): Tgt=%lld, loop=%xh, "
6665 + QL_PRINT_9(ha, "Tgt=%lld, loop=%xh, "
6313 6666 "wwnn=%02x%02x%02x%02x%02x%02x%02x%02x, "
6314 6667 "wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
6315 6668 ha->instance, ddep->TargetAddress.Target,
6316 6669 ddep->LoopID, ddep->NodeWWN[0], ddep->NodeWWN[1],
6317 6670 ddep->NodeWWN[2], ddep->NodeWWN[3],
6318 6671 ddep->NodeWWN[4], ddep->NodeWWN[5],
6319 6672 ddep->NodeWWN[6], ddep->NodeWWN[7],
6320 6673 ddep->PortWWN[0], ddep->PortWWN[1],
6321 6674 ddep->PortWWN[2], ddep->PortWWN[3],
6322 6675 ddep->PortWWN[4], ddep->PortWWN[5],
6323 6676 ddep->PortWWN[6], ddep->PortWWN[7]);
6324 6677 rval = ddi_copyout((void *)ddep, (void *)uddep,
6325 6678 sizeof (EXT_DEVICEDATAENTRY), mode);
6326 6679
6327 6680 if (rval != 0) {
6328 6681 cmd->Status = EXT_STATUS_COPY_ERR;
6329 6682 cmd->ResponseLen = 0;
6330 6683 EL(ha, "failed, ddi_copyout\n");
6331 6684 break;
6332 6685 }
6333 6686 dd.ReturnListEntryCount++;
6334 6687 uddep++;
6335 6688 cmd->ResponseLen += (uint32_t)
6336 6689 sizeof (EXT_DEVICEDATAENTRY);
6337 6690 }
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
6338 6691 }
6339 6692 rval = ddi_copyout((void *)&dd, (void *)uddp,
6340 6693 sizeof (EXT_DEVICEDATA) - sizeof (EXT_DEVICEDATAENTRY), mode);
6341 6694
6342 6695 if (rval != 0) {
6343 6696 cmd->Status = EXT_STATUS_COPY_ERR;
6344 6697 cmd->ResponseLen = 0;
6345 6698 EL(ha, "failed, ddi_copyout-2\n");
6346 6699 } else {
6347 6700 cmd->ResponseLen += (uint32_t)sizeof (EXT_DEVICEDATAENTRY);
6348 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6701 + QL_PRINT_9(ha, "done\n");
6349 6702 }
6350 6703 }
6351 6704
6352 6705 /*
6353 6706 * ql_get_target_id
6354 6707 * Performs EXT_SC_GET_TARGET_ID subcommand. of EXT_CC_GET_DATA.
6355 6708 *
6356 6709 * Input:
6357 6710 * ha: adapter state pointer.
6358 6711 * cmd: Local EXT_IOCTL cmd struct pointer.
6359 6712 * mode: flags.
6360 6713 *
6361 6714 * Returns:
6362 6715 * None, request status indicated in cmd->Status.
6363 6716 *
6364 6717 * Context:
6365 6718 * Kernel context.
6366 6719 */
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
6367 6720 static void
6368 6721 ql_get_target_id(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
6369 6722 {
6370 6723 uint32_t rval;
6371 6724 uint16_t qlnt;
6372 6725 EXT_DEST_ADDR extdestaddr = {0};
6373 6726 uint8_t *name;
6374 6727 uint8_t wwpn[EXT_DEF_WWN_NAME_SIZE];
6375 6728 ql_tgt_t *tq;
6376 6729
6377 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6730 + QL_PRINT_9(ha, "started\n");
6378 6731
6379 6732 if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
6380 6733 (void*)wwpn, sizeof (EXT_DEST_ADDR), mode) != 0) {
6381 6734 EL(ha, "failed, ddi_copyin\n");
6382 6735 cmd->Status = EXT_STATUS_COPY_ERR;
6383 6736 cmd->ResponseLen = 0;
6384 6737 return;
6385 6738 }
6386 6739
6387 6740 qlnt = QLNT_PORT;
6388 6741 name = wwpn;
6389 - QL_PRINT_9(CE_CONT, "(%d): wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
6742 + QL_PRINT_9(ha, "wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
6390 6743 ha->instance, name[0], name[1], name[2], name[3], name[4],
6391 6744 name[5], name[6], name[7]);
6392 6745
6393 6746 tq = ql_find_port(ha, name, qlnt);
6394 6747 if (tq == NULL || !VALID_TARGET_ID(ha, tq->loop_id)) {
6395 6748 EL(ha, "failed, fc_port not found\n");
6396 6749 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
6397 6750 cmd->ResponseLen = 0;
6398 6751 return;
6399 6752 }
6400 6753
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
6401 6754 bcopy(tq->port_name, (caddr_t)&extdestaddr.DestAddr.ScsiAddr.Target, 8);
6402 6755
6403 6756 rval = ddi_copyout((void *)&extdestaddr,
6404 6757 (void *)(uintptr_t)cmd->ResponseAdr, sizeof (EXT_DEST_ADDR), mode);
6405 6758 if (rval != 0) {
6406 6759 EL(ha, "failed, ddi_copyout\n");
6407 6760 cmd->Status = EXT_STATUS_COPY_ERR;
6408 6761 cmd->ResponseLen = 0;
6409 6762 }
6410 6763
6411 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
6764 + QL_PRINT_9(ha, "done\n");
6412 6765 }
6413 6766
6414 6767 /*
6415 6768 * ql_setup_fcache
6416 6769 * Populates selected flash sections into the cache
6417 6770 *
6418 6771 * Input:
6419 6772 * ha = adapter state pointer.
6420 6773 *
6421 6774 * Returns:
6422 6775 * ql local function return status code.
6423 6776 *
6424 6777 * Context:
6425 6778 * Kernel context.
6426 6779 *
6427 6780 * Note:
6428 6781 * Driver must be in stalled state prior to entering or
6429 6782 * add code to this function prior to calling ql_setup_flash()
6430 6783 */
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
6431 6784 int
6432 6785 ql_setup_fcache(ql_adapter_state_t *ha)
6433 6786 {
6434 6787 int rval;
6435 6788 uint32_t freadpos = 0;
6436 6789 uint32_t fw_done = 0;
6437 6790 ql_fcache_t *head = NULL;
6438 6791 ql_fcache_t *tail = NULL;
6439 6792 ql_fcache_t *ftmp;
6440 6793
6441 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
6794 + QL_PRINT_10(ha, "started cfg=0x%llx\n", ha->cfg_flags);
6442 6795
6443 - CACHE_LOCK(ha);
6444 -
6445 6796 /* If we already have populated it, rtn */
6446 6797 if (ha->fcache != NULL) {
6447 - CACHE_UNLOCK(ha);
6448 6798 EL(ha, "buffer already populated\n");
6449 6799 return (QL_SUCCESS);
6450 6800 }
6451 6801
6452 6802 ql_flash_nvram_defaults(ha);
6453 6803
6454 6804 if ((rval = ql_setup_flash(ha)) != QL_SUCCESS) {
6455 - CACHE_UNLOCK(ha);
6456 6805 EL(ha, "unable to setup flash; rval=%xh\n", rval);
6457 6806 return (rval);
6458 6807 }
6459 6808
6460 6809 while (freadpos != 0xffffffff) {
6461 6810 /* Allocate & populate this node */
6462 6811 if ((ftmp = ql_setup_fnode(ha)) == NULL) {
6463 6812 EL(ha, "node alloc failed\n");
6464 6813 rval = QL_FUNCTION_FAILED;
6465 6814 break;
6466 6815 }
6467 6816
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
6468 6817 /* link in the new node */
6469 6818 if (head == NULL) {
6470 6819 head = tail = ftmp;
6471 6820 } else {
6472 6821 tail->next = ftmp;
6473 6822 tail = ftmp;
6474 6823 }
6475 6824
6476 6825 /* Do the firmware node first for 24xx/25xx's */
6477 6826 if (fw_done == 0) {
6478 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
6827 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
6479 6828 freadpos = ha->flash_fw_addr << 2;
6480 6829 }
6481 6830 fw_done = 1;
6482 6831 }
6483 6832
6484 6833 if ((rval = ql_dump_fcode(ha, ftmp->buf, FBUFSIZE,
6485 6834 freadpos)) != QL_SUCCESS) {
6486 6835 EL(ha, "failed, 24xx dump_fcode"
6487 6836 " pos=%xh rval=%xh\n", freadpos, rval);
6488 6837 rval = QL_FUNCTION_FAILED;
6489 6838 break;
6490 6839 }
6491 6840
6492 6841 /* checkout the pci data / format */
6493 6842 if (ql_check_pci(ha, ftmp, &freadpos)) {
6494 6843 EL(ha, "flash header incorrect\n");
6495 6844 rval = QL_FUNCTION_FAILED;
6496 6845 break;
6497 6846 }
6498 6847 }
6499 6848
6500 6849 if (rval != QL_SUCCESS) {
6501 6850 /* release all resources we have */
6502 6851 ftmp = head;
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
6503 6852 while (ftmp != NULL) {
6504 6853 tail = ftmp->next;
6505 6854 kmem_free(ftmp->buf, FBUFSIZE);
6506 6855 kmem_free(ftmp, sizeof (ql_fcache_t));
6507 6856 ftmp = tail;
6508 6857 }
6509 6858
6510 6859 EL(ha, "failed, done\n");
6511 6860 } else {
6512 6861 ha->fcache = head;
6513 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
6862 + QL_PRINT_10(ha, "done\n");
6514 6863 }
6515 - CACHE_UNLOCK(ha);
6516 6864
6517 6865 return (rval);
6518 6866 }
6519 6867
6520 6868 /*
6521 6869 * ql_update_fcache
6522 6870 * re-populates updated flash into the fcache. If
6523 6871 * fcache does not exist (e.g., flash was empty/invalid on
6524 6872 * boot), this routine will create and the populate it.
6525 6873 *
6526 6874 * Input:
6527 6875 * ha = adapter state pointer.
6528 6876 * *bpf = Pointer to flash buffer.
6529 6877 * bsize = Size of flash buffer.
6530 6878 *
6531 6879 * Returns:
6532 6880 *
6533 6881 * Context:
6534 6882 * Kernel context.
6535 6883 */
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
6536 6884 void
6537 6885 ql_update_fcache(ql_adapter_state_t *ha, uint8_t *bfp, uint32_t bsize)
6538 6886 {
6539 6887 int rval = QL_SUCCESS;
6540 6888 uint32_t freadpos = 0;
6541 6889 uint32_t fw_done = 0;
6542 6890 ql_fcache_t *head = NULL;
6543 6891 ql_fcache_t *tail = NULL;
6544 6892 ql_fcache_t *ftmp;
6545 6893
6546 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
6894 + QL_PRINT_3(ha, "started\n");
6547 6895
6548 6896 while (freadpos != 0xffffffff) {
6549 6897
6550 6898 /* Allocate & populate this node */
6551 6899
6552 6900 if ((ftmp = ql_setup_fnode(ha)) == NULL) {
6553 6901 EL(ha, "node alloc failed\n");
6554 6902 rval = QL_FUNCTION_FAILED;
6555 6903 break;
6556 6904 }
6557 6905
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
6558 6906 /* link in the new node */
6559 6907 if (head == NULL) {
6560 6908 head = tail = ftmp;
6561 6909 } else {
6562 6910 tail->next = ftmp;
6563 6911 tail = ftmp;
6564 6912 }
6565 6913
6566 6914 /* Do the firmware node first for 24xx's */
6567 6915 if (fw_done == 0) {
6568 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
6916 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
6569 6917 freadpos = ha->flash_fw_addr << 2;
6570 6918 }
6571 6919 fw_done = 1;
6572 6920 }
6573 6921
6574 6922 /* read in first FBUFSIZE bytes of this flash section */
6575 - if (freadpos+FBUFSIZE > bsize) {
6923 + if (freadpos + FBUFSIZE > bsize) {
6576 6924 EL(ha, "passed buffer too small; fr=%xh, bsize=%xh\n",
6577 6925 freadpos, bsize);
6578 6926 rval = QL_FUNCTION_FAILED;
6579 6927 break;
6580 6928 }
6581 - bcopy(bfp+freadpos, ftmp->buf, FBUFSIZE);
6929 + bcopy(bfp + freadpos, ftmp->buf, FBUFSIZE);
6582 6930
6583 6931 /* checkout the pci data / format */
6584 6932 if (ql_check_pci(ha, ftmp, &freadpos)) {
6585 6933 EL(ha, "flash header incorrect\n");
6586 6934 rval = QL_FUNCTION_FAILED;
6587 6935 break;
6588 6936 }
6589 6937 }
6590 6938
6591 6939 if (rval != QL_SUCCESS) {
6592 6940 /*
6593 6941 * release all resources we have
6594 6942 */
6595 6943 ql_fcache_rel(head);
6596 6944 EL(ha, "failed, done\n");
6597 6945 } else {
6598 6946 /*
6599 6947 * Release previous fcache resources and update with new
6600 6948 */
6601 - CACHE_LOCK(ha);
6602 6949 ql_fcache_rel(ha->fcache);
6603 6950 ha->fcache = head;
6604 - CACHE_UNLOCK(ha);
6605 6951
6606 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
6952 + QL_PRINT_3(ha, "done\n");
6607 6953 }
6608 6954 }
6609 6955
6610 6956 /*
6611 6957 * ql_setup_fnode
6612 6958 * Allocates fcache node
6613 6959 *
6614 6960 * Input:
6615 6961 * ha = adapter state pointer.
6616 6962 * node = point to allocated fcache node (NULL = failed)
6617 6963 *
6618 6964 * Returns:
6619 6965 *
6620 6966 * Context:
6621 6967 * Kernel context.
6622 6968 *
6623 6969 * Note:
6624 6970 * Driver must be in stalled state prior to entering or
6625 6971 * add code to this function prior to calling ql_setup_flash()
6626 6972 */
6627 6973 static ql_fcache_t *
6628 6974 ql_setup_fnode(ql_adapter_state_t *ha)
6629 6975 {
6630 6976 ql_fcache_t *fnode = NULL;
6631 6977
6632 6978 if ((fnode = (ql_fcache_t *)(kmem_zalloc(sizeof (ql_fcache_t),
6633 6979 KM_SLEEP))) == NULL) {
6634 6980 EL(ha, "fnode alloc failed\n");
6635 6981 fnode = NULL;
6636 6982 } else if ((fnode->buf = (uint8_t *)(kmem_zalloc(FBUFSIZE,
6637 6983 KM_SLEEP))) == NULL) {
6638 6984 EL(ha, "buf alloc failed\n");
6639 6985 kmem_free(fnode, sizeof (ql_fcache_t));
6640 6986 fnode = NULL;
6641 6987 } else {
6642 6988 fnode->buflen = FBUFSIZE;
6643 6989 }
6644 6990
6645 6991 return (fnode);
6646 6992 }
6647 6993
6648 6994 /*
6649 6995 * ql_fcache_rel
6650 6996 * Releases the fcache resources
6651 6997 *
6652 6998 * Input:
6653 6999 * ha = adapter state pointer.
6654 7000 * head = Pointer to fcache linked list
6655 7001 *
6656 7002 * Returns:
6657 7003 *
6658 7004 * Context:
6659 7005 * Kernel context.
6660 7006 *
6661 7007 */
6662 7008 void
6663 7009 ql_fcache_rel(ql_fcache_t *head)
6664 7010 {
6665 7011 ql_fcache_t *ftmp = head;
6666 7012 ql_fcache_t *tail;
6667 7013
6668 7014 /* release all resources we have */
6669 7015 while (ftmp != NULL) {
6670 7016 tail = ftmp->next;
6671 7017 kmem_free(ftmp->buf, FBUFSIZE);
6672 7018 kmem_free(ftmp, sizeof (ql_fcache_t));
6673 7019 ftmp = tail;
6674 7020 }
6675 7021 }
6676 7022
6677 7023 /*
6678 7024 * ql_update_flash_caches
6679 7025 * Updates driver flash caches
6680 7026 *
6681 7027 * Input:
6682 7028 * ha: adapter state pointer.
6683 7029 *
|
↓ open down ↓ |
67 lines elided |
↑ open up ↑ |
6684 7030 * Context:
6685 7031 * Kernel context.
6686 7032 */
6687 7033 static void
6688 7034 ql_update_flash_caches(ql_adapter_state_t *ha)
6689 7035 {
6690 7036 uint32_t len;
6691 7037 ql_link_t *link;
6692 7038 ql_adapter_state_t *ha2;
6693 7039
6694 - QL_PRINT_3(CE_CONT, "(%d): started\n", ha->instance);
7040 + QL_PRINT_3(ha, "started\n");
6695 7041
6696 7042 /* Get base path length. */
6697 7043 for (len = (uint32_t)strlen(ha->devpath); len; len--) {
6698 7044 if (ha->devpath[len] == ',' ||
6699 7045 ha->devpath[len] == '@') {
6700 7046 break;
6701 7047 }
6702 7048 }
6703 7049
6704 7050 /* Reset fcache on all adapter instances. */
6705 7051 for (link = ql_hba.first; link != NULL; link = link->next) {
6706 7052 ha2 = link->base_address;
6707 7053
6708 7054 if (strncmp(ha->devpath, ha2->devpath, len) != 0) {
6709 7055 continue;
6710 7056 }
6711 7057
6712 - CACHE_LOCK(ha2);
6713 7058 ql_fcache_rel(ha2->fcache);
6714 7059 ha2->fcache = NULL;
6715 7060
6716 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
7061 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
6717 7062 if (ha2->vcache != NULL) {
6718 7063 kmem_free(ha2->vcache, QL_24XX_VPD_SIZE);
6719 7064 ha2->vcache = NULL;
6720 7065 }
6721 7066 }
6722 - CACHE_UNLOCK(ha2);
6723 7067
6724 7068 (void) ql_setup_fcache(ha2);
6725 7069 }
6726 7070
6727 - QL_PRINT_3(CE_CONT, "(%d): done\n", ha->instance);
7071 + QL_PRINT_3(ha, "done\n");
6728 7072 }
6729 7073
6730 7074 /*
6731 7075 * ql_get_fbuf
6732 7076 * Search the fcache list for the type specified
6733 7077 *
6734 7078 * Input:
6735 7079 * fptr = Pointer to fcache linked list
6736 7080 * ftype = Type of image to be returned.
6737 7081 *
6738 7082 * Returns:
6739 7083 * Pointer to ql_fcache_t.
6740 7084 * NULL means not found.
6741 7085 *
6742 7086 * Context:
6743 7087 * Kernel context.
6744 7088 *
6745 7089 *
6746 7090 */
6747 7091 ql_fcache_t *
6748 7092 ql_get_fbuf(ql_fcache_t *fptr, uint32_t ftype)
6749 7093 {
6750 7094 while (fptr != NULL) {
6751 7095 /* does this image meet criteria? */
6752 7096 if (ftype & fptr->type) {
6753 7097 break;
6754 7098 }
6755 7099 fptr = fptr->next;
6756 7100 }
6757 7101 return (fptr);
6758 7102 }
6759 7103
6760 7104 /*
6761 7105 * ql_check_pci
6762 7106 *
6763 7107 * checks the passed buffer for a valid pci signature and
6764 7108 * expected (and in range) pci length values.
6765 7109 *
6766 7110 * For firmware type, a pci header is added since the image in
6767 7111 * the flash does not have one (!!!).
6768 7112 *
6769 7113 * On successful pci check, nextpos adjusted to next pci header.
6770 7114 *
6771 7115 * Returns:
6772 7116 * -1 --> last pci image
6773 7117 * 0 --> pci header valid
6774 7118 * 1 --> pci header invalid.
6775 7119 *
6776 7120 * Context:
|
↓ open down ↓ |
39 lines elided |
↑ open up ↑ |
6777 7121 * Kernel context.
6778 7122 */
6779 7123 static int
6780 7124 ql_check_pci(ql_adapter_state_t *ha, ql_fcache_t *fcache, uint32_t *nextpos)
6781 7125 {
6782 7126 pci_header_t *pcih;
6783 7127 pci_data_t *pcid;
6784 7128 uint32_t doff;
6785 7129 uint8_t *pciinfo;
6786 7130
6787 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
7131 + QL_PRINT_3(ha, "started\n");
6788 7132
6789 7133 if (fcache != NULL) {
6790 7134 pciinfo = fcache->buf;
6791 7135 } else {
6792 7136 EL(ha, "failed, null fcache ptr passed\n");
6793 7137 return (1);
6794 7138 }
6795 7139
6796 7140 if (pciinfo == NULL) {
6797 7141 EL(ha, "failed, null pciinfo ptr passed\n");
6798 7142 return (1);
6799 7143 }
6800 7144
6801 7145 if (CFG_IST(ha, CFG_SBUS_CARD)) {
6802 7146 caddr_t bufp;
6803 7147 uint_t len;
6804 7148
6805 7149 if (pciinfo[0] != SBUS_CODE_FCODE) {
6806 7150 EL(ha, "failed, unable to detect sbus fcode\n");
6807 7151 return (1);
6808 7152 }
6809 7153 fcache->type = FTYPE_FCODE;
6810 7154
6811 7155 /*LINTED [Solaris DDI_DEV_T_ANY Lint error]*/
6812 7156 if (ddi_getlongprop(DDI_DEV_T_ANY, ha->dip,
6813 7157 PROP_LEN_AND_VAL_ALLOC | DDI_PROP_DONTPASS |
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
6814 7158 DDI_PROP_CANSLEEP, "version", (caddr_t)&bufp,
6815 7159 (int *)&len) == DDI_PROP_SUCCESS) {
6816 7160
6817 7161 (void) snprintf(fcache->verstr,
6818 7162 FCHBA_OPTION_ROM_VERSION_LEN, "%s", bufp);
6819 7163 kmem_free(bufp, len);
6820 7164 }
6821 7165
6822 7166 *nextpos = 0xffffffff;
6823 7167
6824 - QL_PRINT_9(CE_CONT, "(%d): CFG_SBUS_CARD, done\n",
6825 - ha->instance);
7168 + QL_PRINT_3(ha, "CFG_SBUS_CARD, done\n");
6826 7169
6827 7170 return (0);
6828 7171 }
6829 7172
6830 7173 if (*nextpos == ha->flash_fw_addr << 2) {
6831 7174
6832 7175 pci_header_t fwh = {0};
6833 7176 pci_data_t fwd = {0};
6834 7177 uint8_t *buf, *bufp;
6835 7178
6836 7179 /*
6837 7180 * Build a pci header for the firmware module
6838 7181 */
6839 7182 if ((buf = (uint8_t *)(kmem_zalloc(FBUFSIZE, KM_SLEEP))) ==
6840 7183 NULL) {
6841 7184 EL(ha, "failed, unable to allocate buffer\n");
6842 7185 return (1);
6843 7186 }
6844 7187
6845 7188 fwh.signature[0] = PCI_HEADER0;
6846 7189 fwh.signature[1] = PCI_HEADER1;
6847 7190 fwh.dataoffset[0] = LSB(sizeof (pci_header_t));
6848 7191 fwh.dataoffset[1] = MSB(sizeof (pci_header_t));
6849 7192
6850 7193 fwd.signature[0] = 'P';
6851 7194 fwd.signature[1] = 'C';
6852 7195 fwd.signature[2] = 'I';
6853 7196 fwd.signature[3] = 'R';
6854 7197 fwd.codetype = PCI_CODE_FW;
6855 7198 fwd.pcidatalen[0] = LSB(sizeof (pci_data_t));
6856 7199 fwd.pcidatalen[1] = MSB(sizeof (pci_data_t));
6857 7200
6858 7201 bufp = buf;
6859 7202 bcopy(&fwh, bufp, sizeof (pci_header_t));
6860 7203 bufp += sizeof (pci_header_t);
6861 7204 bcopy(&fwd, bufp, sizeof (pci_data_t));
6862 7205 bufp += sizeof (pci_data_t);
6863 7206
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
6864 7207 bcopy(fcache->buf, bufp, (FBUFSIZE - sizeof (pci_header_t) -
6865 7208 sizeof (pci_data_t)));
6866 7209 bcopy(buf, fcache->buf, FBUFSIZE);
6867 7210
6868 7211 fcache->type = FTYPE_FW;
6869 7212
6870 7213 (void) snprintf(fcache->verstr, FCHBA_OPTION_ROM_VERSION_LEN,
6871 7214 "%d.%02d.%02d", fcache->buf[19], fcache->buf[23],
6872 7215 fcache->buf[27]);
6873 7216
6874 - if (CFG_IST(ha, CFG_CTRL_81XX)) {
6875 - *nextpos = 0x200000;
6876 - } else if (CFG_IST(ha, CFG_CTRL_8021)) {
6877 - *nextpos = 0x80000;
6878 - } else {
6879 - *nextpos = 0;
6880 - }
7217 + *nextpos = ha->boot_code_addr << 2;
6881 7218 kmem_free(buf, FBUFSIZE);
6882 7219
6883 - QL_PRINT_9(CE_CONT, "(%d): FTYPE_FW, done\n", ha->instance);
7220 + QL_PRINT_3(ha, "FTYPE_FW, done\n");
6884 7221
6885 7222 return (0);
6886 7223 }
6887 7224
6888 7225 /* get to the pci header image length */
6889 7226 pcih = (pci_header_t *)pciinfo;
6890 7227
6891 7228 doff = pcih->dataoffset[0] | (pcih->dataoffset[1] << 8);
6892 7229
6893 7230 /* some header section sanity check */
6894 7231 if (pcih->signature[0] != PCI_HEADER0 ||
6895 7232 pcih->signature[1] != PCI_HEADER1 || doff > 50) {
6896 7233 EL(ha, "buffer format error: s0=%xh, s1=%xh, off=%xh\n",
6897 7234 pcih->signature[0], pcih->signature[1], doff);
6898 7235 return (1);
6899 7236 }
6900 7237
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
6901 7238 pcid = (pci_data_t *)(pciinfo + doff);
6902 7239
6903 7240 /* a slight sanity data section check */
6904 7241 if (pcid->signature[0] != 'P' || pcid->signature[1] != 'C' ||
6905 7242 pcid->signature[2] != 'I' || pcid->signature[3] != 'R') {
6906 7243 EL(ha, "failed, data sig mismatch!\n");
6907 7244 return (1);
6908 7245 }
6909 7246
6910 7247 if (pcid->indicator == PCI_IND_LAST_IMAGE) {
6911 - QL_PRINT_9(CE_CONT, "(%d): last image\n", ha->instance);
6912 - if (CFG_IST(ha, CFG_CTRL_24258081)) {
7248 + QL_PRINT_3(ha, "last image\n");
7249 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
6913 7250 ql_flash_layout_table(ha, *nextpos +
6914 7251 (pcid->imagelength[0] | (pcid->imagelength[1] <<
6915 7252 8)) * PCI_SECTOR_SIZE);
6916 7253 (void) ql_24xx_flash_desc(ha);
6917 7254 }
6918 7255 *nextpos = 0xffffffff;
6919 7256 } else {
6920 7257 /* adjust the next flash read start position */
6921 7258 *nextpos += (pcid->imagelength[0] |
6922 7259 (pcid->imagelength[1] << 8)) * PCI_SECTOR_SIZE;
6923 7260 }
6924 7261
6925 7262 switch (pcid->codetype) {
6926 7263 case PCI_CODE_X86PC:
6927 7264 fcache->type = FTYPE_BIOS;
6928 7265 break;
6929 7266 case PCI_CODE_FCODE:
6930 7267 fcache->type = FTYPE_FCODE;
6931 7268 break;
6932 7269 case PCI_CODE_EFI:
6933 7270 fcache->type = FTYPE_EFI;
6934 7271 break;
6935 7272 case PCI_CODE_HPPA:
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
6936 7273 fcache->type = FTYPE_HPPA;
6937 7274 break;
6938 7275 default:
6939 7276 fcache->type = FTYPE_UNKNOWN;
6940 7277 break;
6941 7278 }
6942 7279
6943 7280 (void) snprintf(fcache->verstr, FCHBA_OPTION_ROM_VERSION_LEN,
6944 7281 "%d.%02d", pcid->revisionlevel[1], pcid->revisionlevel[0]);
6945 7282
6946 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
7283 + QL_PRINT_3(ha, "done\n");
6947 7284
6948 7285 return (0);
6949 7286 }
6950 7287
6951 7288 /*
6952 7289 * ql_flash_layout_table
6953 7290 * Obtains flash addresses from table
6954 7291 *
6955 7292 * Input:
6956 7293 * ha: adapter state pointer.
6957 7294 * flt_paddr: flash layout pointer address.
6958 7295 *
6959 7296 * Context:
6960 7297 * Kernel context.
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
6961 7298 */
6962 7299 static void
6963 7300 ql_flash_layout_table(ql_adapter_state_t *ha, uint32_t flt_paddr)
6964 7301 {
6965 7302 ql_flt_ptr_t *fptr;
6966 7303 uint8_t *bp;
6967 7304 int rval;
6968 7305 uint32_t len, faddr, cnt;
6969 7306 uint16_t chksum, w16;
6970 7307
6971 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
7308 + QL_PRINT_9(ha, "started\n");
6972 7309
6973 7310 /* Process flash layout table header */
6974 7311 len = sizeof (ql_flt_ptr_t);
6975 7312 if ((bp = kmem_zalloc(len, KM_SLEEP)) == NULL) {
6976 7313 EL(ha, "kmem_zalloc=null\n");
6977 7314 return;
6978 7315 }
6979 7316
6980 7317 /* Process pointer to flash layout table */
6981 7318 if ((rval = ql_dump_fcode(ha, bp, len, flt_paddr)) != QL_SUCCESS) {
6982 7319 EL(ha, "fptr dump_flash pos=%xh, status=%xh\n", flt_paddr,
6983 7320 rval);
6984 7321 kmem_free(bp, len);
6985 7322 return;
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
6986 7323 }
6987 7324 fptr = (ql_flt_ptr_t *)bp;
6988 7325
6989 7326 /* Verify pointer to flash layout table. */
6990 7327 for (chksum = 0, cnt = 0; cnt < len; cnt += 2) {
6991 7328 w16 = (uint16_t)CHAR_TO_SHORT(bp[cnt], bp[cnt + 1]);
6992 7329 chksum += w16;
6993 7330 }
6994 7331 if (chksum != 0 || fptr->sig[0] != 'Q' || fptr->sig[1] != 'F' ||
6995 7332 fptr->sig[2] != 'L' || fptr->sig[3] != 'T') {
6996 - EL(ha, "ptr chksum=%xh, sig=%c%c%c%c\n", chksum, fptr->sig[0],
7333 + EL(ha, "ptr chksum=%xh, sig=%c%c%c%c \n",
7334 + chksum, fptr->sig[0],
6997 7335 fptr->sig[1], fptr->sig[2], fptr->sig[3]);
6998 7336 kmem_free(bp, len);
6999 7337 return;
7000 7338 }
7001 7339 faddr = CHAR_TO_LONG(fptr->addr[0], fptr->addr[1], fptr->addr[2],
7002 7340 fptr->addr[3]);
7003 7341
7004 7342 kmem_free(bp, len);
7005 7343
7006 7344 ql_process_flt(ha, faddr);
7007 7345
7008 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
7346 + QL_PRINT_9(ha, "done\n");
7009 7347 }
7010 7348
7011 7349 /*
7012 7350 * ql_process_flt
7013 7351 * Obtains flash addresses from flash layout table
7014 7352 *
7015 7353 * Input:
7016 7354 * ha: adapter state pointer.
7017 7355 * faddr: flash layout table byte address.
7018 7356 *
7019 7357 * Context:
7020 7358 * Kernel context.
7021 7359 */
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
7022 7360 static void
7023 7361 ql_process_flt(ql_adapter_state_t *ha, uint32_t faddr)
7024 7362 {
7025 7363 ql_flt_hdr_t *fhdr;
7026 7364 ql_flt_region_t *frgn;
7027 7365 uint8_t *bp, *eaddr, nv_rg, vpd_rg;
7028 7366 int rval;
7029 7367 uint32_t len, cnt, fe_addr;
7030 7368 uint16_t chksum, w16;
7031 7369
7032 - QL_PRINT_9(CE_CONT, "(%d): started faddr=%xh\n", ha->instance, faddr);
7370 + QL_PRINT_9(ha, "started faddr=%xh\n", faddr);
7033 7371
7034 7372 /* Process flash layout table header */
7035 7373 if ((bp = kmem_zalloc(FLASH_LAYOUT_TABLE_SIZE, KM_SLEEP)) == NULL) {
7036 7374 EL(ha, "kmem_zalloc=null\n");
7037 7375 return;
7038 7376 }
7039 7377 fhdr = (ql_flt_hdr_t *)bp;
7040 7378
7041 7379 /* Process flash layout table. */
7042 7380 if ((rval = ql_dump_fcode(ha, bp, FLASH_LAYOUT_TABLE_SIZE, faddr)) !=
7043 7381 QL_SUCCESS) {
7044 7382 EL(ha, "fhdr dump_flash pos=%xh, status=%xh\n", faddr, rval);
7045 7383 kmem_free(bp, FLASH_LAYOUT_TABLE_SIZE);
7046 7384 return;
7047 7385 }
7048 7386
7049 7387 /* Verify flash layout table. */
7050 7388 len = (uint32_t)(CHAR_TO_SHORT(fhdr->len[0], fhdr->len[1]) +
7051 7389 sizeof (ql_flt_hdr_t) + sizeof (ql_flt_region_t));
7052 7390 if (len > FLASH_LAYOUT_TABLE_SIZE) {
7053 7391 chksum = 0xffff;
7054 7392 } else {
7055 7393 for (chksum = 0, cnt = 0; cnt < len; cnt += 2) {
7056 7394 w16 = (uint16_t)CHAR_TO_SHORT(bp[cnt], bp[cnt + 1]);
7057 7395 chksum += w16;
7058 7396 }
7059 7397 }
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
7060 7398 w16 = CHAR_TO_SHORT(fhdr->version[0], fhdr->version[1]);
7061 7399 if (chksum != 0 || w16 != 1) {
7062 7400 EL(ha, "table chksum=%xh, version=%d\n", chksum, w16);
7063 7401 kmem_free(bp, FLASH_LAYOUT_TABLE_SIZE);
7064 7402 return;
7065 7403 }
7066 7404 eaddr = bp + len;
7067 7405
7068 7406 /* Process Function/Port Configuration Map. */
7069 7407 nv_rg = vpd_rg = 0;
7070 - if (CFG_IST(ha, CFG_CTRL_8021)) {
7408 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
7071 7409 uint16_t i;
7072 7410 uint8_t *mbp = eaddr;
7073 7411 ql_fp_cfg_map_t *cmp = (ql_fp_cfg_map_t *)mbp;
7074 7412
7075 7413 len = (uint32_t)(CHAR_TO_SHORT(cmp->hdr.len[0],
7076 7414 cmp->hdr.len[1]));
7077 7415 if (len > FLASH_LAYOUT_TABLE_SIZE) {
7078 7416 chksum = 0xffff;
7079 7417 } else {
7080 7418 for (chksum = 0, cnt = 0; cnt < len; cnt += 2) {
7081 7419 w16 = (uint16_t)CHAR_TO_SHORT(mbp[cnt],
7082 7420 mbp[cnt + 1]);
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
7083 7421 chksum += w16;
7084 7422 }
7085 7423 }
7086 7424 w16 = CHAR_TO_SHORT(cmp->hdr.version[0], cmp->hdr.version[1]);
7087 7425 if (chksum != 0 || w16 != 1 ||
7088 7426 cmp->hdr.Signature[0] != 'F' ||
7089 7427 cmp->hdr.Signature[1] != 'P' ||
7090 7428 cmp->hdr.Signature[2] != 'C' ||
7091 7429 cmp->hdr.Signature[3] != 'M') {
7092 7430 EL(ha, "cfg_map chksum=%xh, version=%d, "
7093 - "sig=%c%c%c%c\n", chksum, w16,
7431 + "sig=%c%c%c%c \n", chksum, w16,
7094 7432 cmp->hdr.Signature[0], cmp->hdr.Signature[1],
7095 7433 cmp->hdr.Signature[2], cmp->hdr.Signature[3]);
7096 7434 } else {
7097 7435 cnt = (uint16_t)
7098 7436 (CHAR_TO_SHORT(cmp->hdr.NumberEntries[0],
7099 7437 cmp->hdr.NumberEntries[1]));
7100 7438 /* Locate entry for function. */
7101 7439 for (i = 0; i < cnt; i++) {
7102 7440 if (cmp->cfg[i].FunctionType == FT_FC &&
7103 7441 cmp->cfg[i].FunctionNumber[0] ==
7104 - ha->function_number &&
7442 + ha->pci_function_number &&
7105 7443 cmp->cfg[i].FunctionNumber[1] == 0) {
7106 7444 nv_rg = cmp->cfg[i].ConfigRegion;
7107 7445 vpd_rg = cmp->cfg[i].VpdRegion;
7108 7446 break;
7109 7447 }
7110 7448 }
7111 7449
7112 7450 if (nv_rg == 0 || vpd_rg == 0) {
7113 7451 EL(ha, "cfg_map nv_rg=%d, vpd_rg=%d\n", nv_rg,
7114 7452 vpd_rg);
7115 7453 nv_rg = vpd_rg = 0;
7116 7454 }
7117 7455 }
7118 7456 }
7119 7457
7120 7458 /* Process flash layout table regions */
7121 7459 for (frgn = (ql_flt_region_t *)(bp + sizeof (ql_flt_hdr_t));
7122 7460 (uint8_t *)frgn < eaddr; frgn++) {
7123 7461 faddr = CHAR_TO_LONG(frgn->beg_addr[0], frgn->beg_addr[1],
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
7124 7462 frgn->beg_addr[2], frgn->beg_addr[3]);
7125 7463 faddr >>= 2;
7126 7464 fe_addr = CHAR_TO_LONG(frgn->end_addr[0], frgn->end_addr[1],
7127 7465 frgn->end_addr[2], frgn->end_addr[3]);
7128 7466 fe_addr >>= 2;
7129 7467
7130 7468 switch (frgn->region) {
7131 7469 case FLASH_8021_BOOTLOADER_REGION:
7132 7470 ha->bootloader_addr = faddr;
7133 7471 ha->bootloader_size = (fe_addr - faddr) + 1;
7134 - QL_PRINT_9(CE_CONT, "(%d): bootloader_addr=%xh, "
7135 - "size=%xh\n", ha->instance, faddr,
7472 + QL_PRINT_9(ha, "bootloader_addr=%xh, "
7473 + "size=%xh\n", faddr,
7136 7474 ha->bootloader_size);
7137 7475 break;
7138 7476 case FLASH_FW_REGION:
7139 7477 case FLASH_8021_FW_REGION:
7140 7478 ha->flash_fw_addr = faddr;
7141 7479 ha->flash_fw_size = (fe_addr - faddr) + 1;
7142 - QL_PRINT_9(CE_CONT, "(%d): flash_fw_addr=%xh, "
7143 - "size=%xh\n", ha->instance, faddr,
7480 + QL_PRINT_9(ha, "flash_fw_addr=%xh, "
7481 + "size=%xh\n", faddr,
7144 7482 ha->flash_fw_size);
7145 7483 break;
7146 7484 case FLASH_GOLDEN_FW_REGION:
7147 7485 case FLASH_8021_GOLDEN_FW_REGION:
7148 7486 ha->flash_golden_fw_addr = faddr;
7149 - QL_PRINT_9(CE_CONT, "(%d): flash_golden_fw_addr=%xh\n",
7487 + QL_PRINT_9(ha, "flash_golden_fw_addr=%xh\n",
7150 7488 ha->instance, faddr);
7151 7489 break;
7152 7490 case FLASH_8021_VPD_REGION:
7153 7491 if (!vpd_rg || vpd_rg == FLASH_8021_VPD_REGION) {
7154 7492 ha->flash_vpd_addr = faddr;
7155 - QL_PRINT_9(CE_CONT, "(%d): 8021_flash_vpd_"
7156 - "addr=%xh\n", ha->instance, faddr);
7493 + QL_PRINT_9(ha, "8021_flash_vpd_"
7494 + "addr=%xh\n", faddr);
7157 7495 }
7158 7496 break;
7159 7497 case FLASH_VPD_0_REGION:
7160 7498 if (vpd_rg) {
7161 7499 if (vpd_rg == FLASH_VPD_0_REGION) {
7162 7500 ha->flash_vpd_addr = faddr;
7163 - QL_PRINT_9(CE_CONT, "(%d): vpd_rg "
7501 + QL_PRINT_9(ha, "vpd_rg "
7164 7502 "flash_vpd_addr=%xh\n",
7165 7503 ha->instance, faddr);
7166 7504 }
7167 - } else if (!(ha->flags & FUNCTION_1) &&
7168 - !(CFG_IST(ha, CFG_CTRL_8021))) {
7505 + } else if (ha->function_number == 0 &&
7506 + !(CFG_IST(ha, CFG_CTRL_82XX))) {
7169 7507 ha->flash_vpd_addr = faddr;
7170 - QL_PRINT_9(CE_CONT, "(%d): flash_vpd_addr=%xh"
7171 - "\n", ha->instance, faddr);
7508 + QL_PRINT_9(ha, "flash_vpd_addr=%xh"
7509 + "\n", faddr);
7172 7510 }
7173 7511 break;
7174 7512 case FLASH_NVRAM_0_REGION:
7175 7513 if (nv_rg) {
7176 7514 if (nv_rg == FLASH_NVRAM_0_REGION) {
7177 7515 ADAPTER_STATE_LOCK(ha);
7178 - ha->flags &= ~FUNCTION_1;
7516 + ha->function_number = 0;
7179 7517 ADAPTER_STATE_UNLOCK(ha);
7180 7518 ha->flash_nvram_addr = faddr;
7181 - QL_PRINT_9(CE_CONT, "(%d): nv_rg "
7519 + QL_PRINT_9(ha, "nv_rg "
7182 7520 "flash_nvram_addr=%xh\n",
7183 7521 ha->instance, faddr);
7184 7522 }
7185 - } else if (!(ha->flags & FUNCTION_1)) {
7523 + } else if (ha->function_number == 0) {
7186 7524 ha->flash_nvram_addr = faddr;
7187 - QL_PRINT_9(CE_CONT, "(%d): flash_nvram_addr="
7188 - "%xh\n", ha->instance, faddr);
7525 + QL_PRINT_9(ha, "flash_nvram_addr="
7526 + "%xh\n", faddr);
7189 7527 }
7190 7528 break;
7191 7529 case FLASH_VPD_1_REGION:
7192 7530 if (vpd_rg) {
7193 7531 if (vpd_rg == FLASH_VPD_1_REGION) {
7194 7532 ha->flash_vpd_addr = faddr;
7195 - QL_PRINT_9(CE_CONT, "(%d): vpd_rg "
7533 + QL_PRINT_9(ha, "vpd_rg "
7196 7534 "flash_vpd_addr=%xh\n",
7197 7535 ha->instance, faddr);
7198 7536 }
7199 - } else if (ha->flags & FUNCTION_1 &&
7200 - !(CFG_IST(ha, CFG_CTRL_8021))) {
7537 + } else if (ha->function_number &&
7538 + !(CFG_IST(ha, CFG_CTRL_82XX))) {
7201 7539 ha->flash_vpd_addr = faddr;
7202 - QL_PRINT_9(CE_CONT, "(%d): flash_vpd_addr=%xh"
7203 - "\n", ha->instance, faddr);
7540 + QL_PRINT_9(ha, "flash_vpd_addr=%xh"
7541 + "\n", faddr);
7204 7542 }
7205 7543 break;
7206 7544 case FLASH_NVRAM_1_REGION:
7207 7545 if (nv_rg) {
7208 7546 if (nv_rg == FLASH_NVRAM_1_REGION) {
7209 7547 ADAPTER_STATE_LOCK(ha);
7210 - ha->flags |= FUNCTION_1;
7548 + ha->function_number = 1;
7211 7549 ADAPTER_STATE_UNLOCK(ha);
7212 7550 ha->flash_nvram_addr = faddr;
7213 - QL_PRINT_9(CE_CONT, "(%d): nv_rg "
7551 + QL_PRINT_9(ha, "nv_rg "
7214 7552 "flash_nvram_addr=%xh\n",
7215 7553 ha->instance, faddr);
7216 7554 }
7217 - } else if (ha->flags & FUNCTION_1) {
7555 + } else if (ha->function_number) {
7218 7556 ha->flash_nvram_addr = faddr;
7219 - QL_PRINT_9(CE_CONT, "(%d): flash_nvram_addr="
7220 - "%xh\n", ha->instance, faddr);
7557 + QL_PRINT_9(ha, "flash_nvram_addr="
7558 + "%xh\n", faddr);
7221 7559 }
7222 7560 break;
7223 7561 case FLASH_DESC_TABLE_REGION:
7224 - if (!(CFG_IST(ha, CFG_CTRL_8021))) {
7562 + if (!(CFG_IST(ha, CFG_CTRL_82XX))) {
7225 7563 ha->flash_desc_addr = faddr;
7226 - QL_PRINT_9(CE_CONT, "(%d): flash_desc_addr="
7227 - "%xh\n", ha->instance, faddr);
7564 + QL_PRINT_9(ha, "flash_desc_addr="
7565 + "%xh\n", faddr);
7228 7566 }
7229 7567 break;
7230 7568 case FLASH_ERROR_LOG_0_REGION:
7231 - if (!(ha->flags & FUNCTION_1)) {
7569 + if (ha->function_number == 0) {
7232 7570 ha->flash_errlog_start = faddr;
7233 - QL_PRINT_9(CE_CONT, "(%d): flash_errlog_addr="
7234 - "%xh\n", ha->instance, faddr);
7571 + QL_PRINT_9(ha, "flash_errlog_addr="
7572 + "%xh\n", faddr);
7235 7573 }
7236 7574 break;
7237 7575 case FLASH_ERROR_LOG_1_REGION:
7238 - if (ha->flags & FUNCTION_1) {
7576 + if (ha->function_number) {
7239 7577 ha->flash_errlog_start = faddr;
7240 - QL_PRINT_9(CE_CONT, "(%d): flash_errlog_addr="
7241 - "%xh\n", ha->instance, faddr);
7578 + QL_PRINT_9(ha, "flash_errlog_addr="
7579 + "%xh\n", faddr);
7242 7580 }
7243 7581 break;
7244 7582 default:
7245 7583 break;
7246 7584 }
7247 7585 }
7248 7586 kmem_free(bp, FLASH_LAYOUT_TABLE_SIZE);
7249 7587
7250 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
7588 + QL_PRINT_9(ha, "done\n");
7251 7589 }
7252 7590
7253 7591 /*
7254 7592 * ql_flash_nvram_defaults
7255 7593 * Flash default addresses.
7256 7594 *
7257 7595 * Input:
7258 7596 * ha: adapter state pointer.
7259 7597 *
7260 7598 * Returns:
7261 7599 * ql local function return status code.
7262 7600 *
7263 7601 * Context:
7264 7602 * Kernel context.
7265 7603 */
7266 7604 static void
7267 7605 ql_flash_nvram_defaults(ql_adapter_state_t *ha)
7268 7606 {
7269 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
7607 + QL_PRINT_10(ha, "started\n");
7270 7608
7271 - if (ha->flags & FUNCTION_1) {
7272 - if (CFG_IST(ha, CFG_CTRL_2300)) {
7609 + if (ha->function_number == 3) {
7610 + if (CFG_IST(ha, CFG_CTRL_27XX)) {
7611 + ha->flash_nvram_addr = NVRAM_2700_FUNC3_ADDR;
7612 + ha->flash_vpd_addr = VPD_2700_FUNC3_ADDR;
7613 + ha->ledstate.select = BEACON_2700_FUNC3_ADDR;
7614 + ha->flash_data_addr = FLASH_2700_DATA_ADDR;
7615 + ha->flash_desc_addr = FLASH_2700_DESCRIPTOR_TABLE;
7616 + ha->flash_fw_addr = FLASH_2700_FIRMWARE_ADDR;
7617 + ha->flash_fw_size = FLASH_2700_FIRMWARE_SIZE;
7618 + ha->boot_code_addr = FLASH_2700_BOOT_CODE_ADDR;
7619 + } else {
7620 + EL(ha, "unassigned flash fn%d addr: %x\n",
7621 + ha->function_number, ha->device_id);
7622 + }
7623 + } else if (ha->function_number == 2) {
7624 + if (CFG_IST(ha, CFG_CTRL_27XX)) {
7625 + ha->flash_nvram_addr = NVRAM_2700_FUNC2_ADDR;
7626 + ha->flash_vpd_addr = VPD_2700_FUNC2_ADDR;
7627 + ha->ledstate.select = BEACON_2700_FUNC2_ADDR;
7628 + ha->flash_data_addr = FLASH_2700_DATA_ADDR;
7629 + ha->flash_desc_addr = FLASH_2700_DESCRIPTOR_TABLE;
7630 + ha->flash_fw_addr = FLASH_2700_FIRMWARE_ADDR;
7631 + ha->flash_fw_size = FLASH_2700_FIRMWARE_SIZE;
7632 + ha->boot_code_addr = FLASH_2700_BOOT_CODE_ADDR;
7633 + } else {
7634 + EL(ha, "unassigned flash fn%d addr: %x\n",
7635 + ha->function_number, ha->device_id);
7636 + }
7637 + } else if (ha->function_number == 1) {
7638 + if (CFG_IST(ha, CFG_CTRL_23XX) ||
7639 + (CFG_IST(ha, CFG_CTRL_63XX))) {
7273 7640 ha->flash_nvram_addr = NVRAM_2300_FUNC1_ADDR;
7274 7641 ha->flash_fw_addr = FLASH_2300_FIRMWARE_ADDR;
7275 - } else if (CFG_IST(ha, CFG_CTRL_2422)) {
7642 + ha->boot_code_addr = FLASH_2300_BOOT_CODE_ADDR;
7643 + } else if (CFG_IST(ha, CFG_CTRL_24XX)) {
7276 7644 ha->flash_data_addr = FLASH_24_25_DATA_ADDR;
7277 7645 ha->flash_nvram_addr = NVRAM_2400_FUNC1_ADDR;
7278 7646 ha->flash_vpd_addr = VPD_2400_FUNC1_ADDR;
7279 7647 ha->flash_errlog_start = FLASH_2400_ERRLOG_START_ADDR_1;
7280 7648 ha->flash_desc_addr = FLASH_2400_DESCRIPTOR_TABLE;
7281 7649 ha->flash_fw_addr = FLASH_2400_FIRMWARE_ADDR;
7650 + ha->boot_code_addr = FLASH_2400_BOOT_CODE_ADDR;
7282 7651 } else if (CFG_IST(ha, CFG_CTRL_25XX)) {
7283 7652 ha->flash_data_addr = FLASH_24_25_DATA_ADDR;
7284 7653 ha->flash_nvram_addr = NVRAM_2500_FUNC1_ADDR;
7285 7654 ha->flash_vpd_addr = VPD_2500_FUNC1_ADDR;
7286 7655 ha->flash_errlog_start = FLASH_2500_ERRLOG_START_ADDR_1;
7287 7656 ha->flash_desc_addr = FLASH_2500_DESCRIPTOR_TABLE;
7288 7657 ha->flash_fw_addr = FLASH_2500_FIRMWARE_ADDR;
7658 + ha->boot_code_addr = FLASH_2500_BOOT_CODE_ADDR;
7289 7659 } else if (CFG_IST(ha, CFG_CTRL_81XX)) {
7290 7660 ha->flash_data_addr = FLASH_8100_DATA_ADDR;
7291 7661 ha->flash_nvram_addr = NVRAM_8100_FUNC1_ADDR;
7292 7662 ha->flash_vpd_addr = VPD_8100_FUNC1_ADDR;
7293 7663 ha->flash_errlog_start = FLASH_8100_ERRLOG_START_ADDR_1;
7294 7664 ha->flash_desc_addr = FLASH_8100_DESCRIPTOR_TABLE;
7295 7665 ha->flash_fw_addr = FLASH_8100_FIRMWARE_ADDR;
7296 - } else if (CFG_IST(ha, CFG_CTRL_8021)) {
7666 + ha->boot_code_addr = FLASH_8100_BOOT_CODE_ADDR;
7667 + } else if (CFG_IST(ha, CFG_CTRL_82XX)) {
7297 7668 ha->flash_data_addr = 0;
7298 7669 ha->flash_nvram_addr = NVRAM_8021_FUNC1_ADDR;
7299 7670 ha->flash_vpd_addr = VPD_8021_FUNC1_ADDR;
7300 7671 ha->flash_errlog_start = 0;
7301 7672 ha->flash_desc_addr = FLASH_8021_DESCRIPTOR_TABLE;
7302 7673 ha->flash_fw_addr = FLASH_8021_FIRMWARE_ADDR;
7303 7674 ha->flash_fw_size = FLASH_8021_FIRMWARE_SIZE;
7304 7675 ha->bootloader_addr = FLASH_8021_BOOTLOADER_ADDR;
7305 7676 ha->bootloader_size = FLASH_8021_BOOTLOADER_SIZE;
7677 + ha->boot_code_addr = FLASH_8021_BOOT_CODE_ADDR;
7678 + } else if (CFG_IST(ha, CFG_CTRL_83XX)) {
7679 + ha->flash_nvram_addr = NVRAM_8300_FC_FUNC1_ADDR;
7680 + ha->flash_vpd_addr = VPD_8300_FC_FUNC1_ADDR;
7681 + ha->ledstate.select = BEACON_8300_FC_FUNC1_ADDR;
7682 + ha->flash_errlog_start = FLASH_8300_ERRLOG_START_ADDR_1;
7683 + ha->flash_data_addr = FLASH_8300_DATA_ADDR;
7684 + ha->flash_desc_addr = FLASH_8300_DESCRIPTOR_TABLE;
7685 + ha->flash_fw_addr = FLASH_8300_FC_FIRMWARE_ADDR;
7686 + ha->flash_fw_size = FLASH_8300_FIRMWARE_SIZE;
7687 + ha->bootloader_addr = FLASH_8300_BOOTLOADER_ADDR;
7688 + ha->bootloader_size = FLASH_8300_BOOTLOADER_SIZE;
7689 + ha->boot_code_addr = FLASH_8300_BOOT_CODE_ADDR;
7690 + } else if (CFG_IST(ha, CFG_CTRL_27XX)) {
7691 + ha->flash_nvram_addr = NVRAM_2700_FUNC1_ADDR;
7692 + ha->flash_vpd_addr = VPD_2700_FUNC1_ADDR;
7693 + ha->ledstate.select = BEACON_2700_FUNC1_ADDR;
7694 + ha->flash_data_addr = FLASH_2700_DATA_ADDR;
7695 + ha->flash_desc_addr = FLASH_2700_DESCRIPTOR_TABLE;
7696 + ha->flash_fw_addr = FLASH_2700_FIRMWARE_ADDR;
7697 + ha->flash_fw_size = FLASH_2700_FIRMWARE_SIZE;
7698 + ha->boot_code_addr = FLASH_2700_BOOT_CODE_ADDR;
7699 + } else {
7700 + EL(ha, "unassigned flash fn%d addr: %x\n",
7701 + ha->function_number, ha->device_id);
7306 7702 }
7307 - } else {
7308 - if (CFG_IST(ha, CFG_CTRL_2200)) {
7703 + } else if (ha->function_number == 0) {
7704 + if (CFG_IST(ha, CFG_CTRL_22XX)) {
7309 7705 ha->flash_nvram_addr = NVRAM_2200_FUNC0_ADDR;
7310 7706 ha->flash_fw_addr = FLASH_2200_FIRMWARE_ADDR;
7311 - } else if (CFG_IST(ha, CFG_CTRL_2300) ||
7312 - (CFG_IST(ha, CFG_CTRL_6322))) {
7707 + ha->boot_code_addr = FLASH_2200_BOOT_CODE_ADDR;
7708 + } else if (CFG_IST(ha, CFG_CTRL_23XX) ||
7709 + (CFG_IST(ha, CFG_CTRL_63XX))) {
7313 7710 ha->flash_nvram_addr = NVRAM_2300_FUNC0_ADDR;
7314 7711 ha->flash_fw_addr = FLASH_2300_FIRMWARE_ADDR;
7315 - } else if (CFG_IST(ha, CFG_CTRL_2422)) {
7712 + ha->boot_code_addr = FLASH_2300_BOOT_CODE_ADDR;
7713 + } else if (CFG_IST(ha, CFG_CTRL_24XX)) {
7316 7714 ha->flash_data_addr = FLASH_24_25_DATA_ADDR;
7317 7715 ha->flash_nvram_addr = NVRAM_2400_FUNC0_ADDR;
7318 7716 ha->flash_vpd_addr = VPD_2400_FUNC0_ADDR;
7319 7717 ha->flash_errlog_start = FLASH_2400_ERRLOG_START_ADDR_0;
7320 7718 ha->flash_desc_addr = FLASH_2400_DESCRIPTOR_TABLE;
7321 7719 ha->flash_fw_addr = FLASH_2400_FIRMWARE_ADDR;
7720 + ha->boot_code_addr = FLASH_2400_BOOT_CODE_ADDR;
7322 7721 } else if (CFG_IST(ha, CFG_CTRL_25XX)) {
7323 7722 ha->flash_data_addr = FLASH_24_25_DATA_ADDR;
7324 7723 ha->flash_nvram_addr = NVRAM_2500_FUNC0_ADDR;
7325 7724 ha->flash_vpd_addr = VPD_2500_FUNC0_ADDR;
7326 7725 ha->flash_errlog_start = FLASH_2500_ERRLOG_START_ADDR_0;
7327 7726 ha->flash_desc_addr = FLASH_2500_DESCRIPTOR_TABLE;
7328 7727 ha->flash_fw_addr = FLASH_2500_FIRMWARE_ADDR;
7728 + ha->boot_code_addr = FLASH_2500_BOOT_CODE_ADDR;
7329 7729 } else if (CFG_IST(ha, CFG_CTRL_81XX)) {
7330 7730 ha->flash_data_addr = FLASH_8100_DATA_ADDR;
7331 7731 ha->flash_nvram_addr = NVRAM_8100_FUNC0_ADDR;
7332 7732 ha->flash_vpd_addr = VPD_8100_FUNC0_ADDR;
7333 7733 ha->flash_errlog_start = FLASH_8100_ERRLOG_START_ADDR_0;
7334 7734 ha->flash_desc_addr = FLASH_8100_DESCRIPTOR_TABLE;
7335 7735 ha->flash_fw_addr = FLASH_8100_FIRMWARE_ADDR;
7336 - } else if (CFG_IST(ha, CFG_CTRL_8021)) {
7736 + ha->boot_code_addr = FLASH_8100_BOOT_CODE_ADDR;
7737 + } else if (CFG_IST(ha, CFG_CTRL_82XX)) {
7337 7738 ha->flash_data_addr = 0;
7338 7739 ha->flash_nvram_addr = NVRAM_8021_FUNC0_ADDR;
7339 7740 ha->flash_vpd_addr = VPD_8021_FUNC0_ADDR;
7340 7741 ha->flash_errlog_start = 0;
7341 7742 ha->flash_desc_addr = FLASH_8021_DESCRIPTOR_TABLE;
7342 7743 ha->flash_fw_addr = FLASH_8021_FIRMWARE_ADDR;
7343 7744 ha->flash_fw_size = FLASH_8021_FIRMWARE_SIZE;
7344 7745 ha->bootloader_addr = FLASH_8021_BOOTLOADER_ADDR;
7345 7746 ha->bootloader_size = FLASH_8021_BOOTLOADER_SIZE;
7747 + ha->boot_code_addr = FLASH_8021_BOOT_CODE_ADDR;
7748 + } else if (CFG_IST(ha, CFG_CTRL_83XX)) {
7749 + ha->flash_nvram_addr = NVRAM_8300_FC_FUNC0_ADDR;
7750 + ha->flash_vpd_addr = VPD_8300_FC_FUNC0_ADDR;
7751 + ha->ledstate.select = BEACON_8300_FCOE_FUNC0_ADDR;
7752 + ha->flash_errlog_start = FLASH_8300_ERRLOG_START_ADDR_0;
7753 + ha->flash_data_addr = FLASH_8300_DATA_ADDR;
7754 + ha->flash_desc_addr = FLASH_8300_DESCRIPTOR_TABLE;
7755 + ha->flash_fw_addr = FLASH_8300_FC_FIRMWARE_ADDR;
7756 + ha->flash_fw_size = FLASH_8300_FIRMWARE_SIZE;
7757 + ha->bootloader_addr = FLASH_8300_BOOTLOADER_ADDR;
7758 + ha->bootloader_size = FLASH_8300_BOOTLOADER_SIZE;
7759 + ha->boot_code_addr = FLASH_8300_BOOT_CODE_ADDR;
7760 + } else if (CFG_IST(ha, CFG_CTRL_27XX)) {
7761 + ha->flash_nvram_addr = NVRAM_2700_FUNC0_ADDR;
7762 + ha->flash_vpd_addr = VPD_2700_FUNC0_ADDR;
7763 + ha->ledstate.select = BEACON_2700_FUNC0_ADDR;
7764 + ha->flash_data_addr = FLASH_2700_DATA_ADDR;
7765 + ha->flash_desc_addr = FLASH_2700_DESCRIPTOR_TABLE;
7766 + ha->flash_fw_addr = FLASH_2700_FIRMWARE_ADDR;
7767 + ha->flash_fw_size = FLASH_2700_FIRMWARE_SIZE;
7768 + ha->boot_code_addr = FLASH_2700_BOOT_CODE_ADDR;
7346 7769 } else {
7347 - EL(ha, "unassigned flash fn0 addr: %x\n",
7348 - ha->device_id);
7770 + EL(ha, "unassigned flash fn%d addr: %x\n",
7771 + ha->function_number, ha->device_id);
7349 7772 }
7773 + } else {
7774 + EL(ha, "known function=%d, device_id=%x\n",
7775 + ha->function_number, ha->device_id);
7350 7776 }
7351 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
7777 + QL_PRINT_10(ha, "done\n");
7352 7778 }
7353 7779
7354 7780 /*
7355 7781 * ql_get_sfp
7356 7782 * Returns sfp data to sdmapi caller
7357 7783 *
7358 7784 * Input:
7359 7785 * ha: adapter state pointer.
7360 7786 * cmd: Local EXT_IOCTL cmd struct pointer.
7361 7787 * mode: flags.
7362 7788 *
7363 7789 * Returns:
7364 7790 * None, request status indicated in cmd->Status.
7365 7791 *
7366 7792 * Context:
7367 7793 * Kernel context.
7368 7794 */
7369 7795 static void
7370 7796 ql_get_sfp(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
7371 7797 {
7372 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
7798 + QL_PRINT_9(ha, "started\n");
7373 7799
7374 - if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
7800 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
7375 7801 cmd->Status = EXT_STATUS_INVALID_REQUEST;
7376 7802 EL(ha, "failed, invalid request for HBA\n");
7377 7803 return;
7378 7804 }
7379 7805
7380 7806 if (cmd->ResponseLen < QL_24XX_SFP_SIZE) {
7381 7807 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
7382 7808 cmd->DetailStatus = QL_24XX_SFP_SIZE;
7383 7809 EL(ha, "failed, ResponseLen < SFP len, len passed=%xh\n",
7384 7810 cmd->ResponseLen);
7385 7811 return;
7386 7812 }
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
7387 7813
7388 7814 /* Dump SFP data in user buffer */
7389 7815 if ((ql_dump_sfp(ha, (void *)(uintptr_t)(cmd->ResponseAdr),
7390 7816 mode)) != 0) {
7391 7817 cmd->Status = EXT_STATUS_COPY_ERR;
7392 7818 EL(ha, "failed, copy error\n");
7393 7819 } else {
7394 7820 cmd->Status = EXT_STATUS_OK;
7395 7821 }
7396 7822
7397 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
7823 + QL_PRINT_9(ha, "done\n");
7398 7824 }
7399 7825
7400 7826 /*
7401 7827 * ql_dump_sfp
7402 7828 * Dumps SFP.
7403 7829 *
7404 7830 * Input:
7405 7831 * ha: adapter state pointer.
7406 7832 * bp: buffer address.
7407 7833 * mode: flags
7408 7834 *
7409 7835 * Returns:
7410 7836 *
7411 7837 * Context:
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
7412 7838 * Kernel context.
7413 7839 */
7414 7840 static int
7415 7841 ql_dump_sfp(ql_adapter_state_t *ha, void *bp, int mode)
7416 7842 {
7417 7843 dma_mem_t mem;
7418 7844 uint32_t cnt;
7419 7845 int rval2, rval = 0;
7420 7846 uint32_t dxfer;
7421 7847
7422 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
7848 + QL_PRINT_9(ha, "started\n");
7423 7849
7424 7850 /* Get memory for SFP. */
7425 7851
7426 7852 if ((rval2 = ql_get_dma_mem(ha, &mem, 64, LITTLE_ENDIAN_DMA,
7427 7853 QL_DMA_DATA_ALIGN)) != QL_SUCCESS) {
7428 7854 EL(ha, "failed, ql_get_dma_mem=%xh\n", rval2);
7429 7855 return (ENOMEM);
7430 7856 }
7431 7857
7432 7858 for (cnt = 0; cnt < QL_24XX_SFP_SIZE; cnt += mem.size) {
7433 7859 rval2 = ql_read_sfp(ha, &mem,
7434 7860 (uint16_t)(cnt < 256 ? 0xA0 : 0xA2),
7435 7861 (uint16_t)(cnt & 0xff));
7436 7862 if (rval2 != QL_SUCCESS) {
7437 7863 EL(ha, "failed, read_sfp=%xh\n", rval2);
7438 7864 rval = EFAULT;
7439 7865 break;
7440 7866 }
7441 7867
7442 7868 /* copy the data back */
7443 7869 if ((dxfer = ql_send_buffer_data(mem.bp, bp, mem.size,
7444 7870 mode)) != mem.size) {
7445 7871 /* ddi copy error */
7446 7872 EL(ha, "failed, ddi copy; byte cnt = %xh", dxfer);
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
7447 7873 rval = EFAULT;
7448 7874 break;
7449 7875 }
7450 7876
7451 7877 /* adjust the buffer pointer */
7452 7878 bp = (caddr_t)bp + mem.size;
7453 7879 }
7454 7880
7455 7881 ql_free_phys(ha, &mem);
7456 7882
7457 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
7883 + QL_PRINT_9(ha, "done\n");
7458 7884
7459 7885 return (rval);
7460 7886 }
7461 7887
7462 7888 /*
7463 7889 * ql_port_param
7464 7890 * Retrieves or sets the firmware port speed settings
7465 7891 *
7466 7892 * Input:
7467 7893 * ha: adapter state pointer.
7468 7894 * cmd: Local EXT_IOCTL cmd struct pointer.
7469 7895 * mode: flags.
7470 7896 *
7471 7897 * Returns:
7472 7898 * None, request status indicated in cmd->Status.
7473 7899 *
7474 7900 * Context:
7475 7901 * Kernel context.
7476 7902 *
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
7477 7903 */
7478 7904 static void
7479 7905 ql_port_param(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
7480 7906 {
7481 7907 uint8_t *name;
7482 7908 ql_tgt_t *tq;
7483 7909 EXT_PORT_PARAM port_param = {0};
7484 7910 uint32_t rval = QL_SUCCESS;
7485 7911 uint32_t idma_rate;
7486 7912
7487 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
7913 + QL_PRINT_9(ha, "started\n");
7488 7914
7489 - if (CFG_IST(ha, CFG_CTRL_242581) == 0) {
7915 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
7490 7916 EL(ha, "invalid request for this HBA\n");
7491 7917 cmd->Status = EXT_STATUS_INVALID_REQUEST;
7492 7918 cmd->ResponseLen = 0;
7493 7919 return;
7494 7920 }
7495 7921
7496 7922 if (LOOP_NOT_READY(ha)) {
7497 7923 EL(ha, "failed, loop not ready\n");
7498 7924 cmd->Status = EXT_STATUS_DEVICE_OFFLINE;
7499 7925 cmd->ResponseLen = 0;
7500 7926 return;
7501 7927 }
7502 7928
7503 7929 if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
7504 7930 (void*)&port_param, sizeof (EXT_PORT_PARAM), mode) != 0) {
7505 7931 EL(ha, "failed, ddi_copyin\n");
7506 7932 cmd->Status = EXT_STATUS_COPY_ERR;
7507 7933 cmd->ResponseLen = 0;
7508 7934 return;
7509 7935 }
7510 7936
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
7511 7937 if (port_param.FCScsiAddr.DestType != EXT_DEF_DESTTYPE_WWPN) {
7512 7938 EL(ha, "Unsupported dest lookup type: %xh\n",
7513 7939 port_param.FCScsiAddr.DestType);
7514 7940 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
7515 7941 cmd->ResponseLen = 0;
7516 7942 return;
7517 7943 }
7518 7944
7519 7945 name = port_param.FCScsiAddr.DestAddr.WWPN;
7520 7946
7521 - QL_PRINT_9(CE_CONT, "(%d): wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
7947 + QL_PRINT_9(ha, "wwpn=%02x%02x%02x%02x%02x%02x%02x%02x\n",
7522 7948 ha->instance, name[0], name[1], name[2], name[3], name[4],
7523 7949 name[5], name[6], name[7]);
7524 7950
7525 7951 tq = ql_find_port(ha, name, (uint16_t)QLNT_PORT);
7526 - if (tq == NULL || !VALID_TARGET_ID(ha, tq->loop_id)) {
7952 + if (tq == NULL || !VALID_TARGET_ID(ha, tq->loop_id) ||
7953 + tq->d_id.b24 == FS_MANAGEMENT_SERVER) {
7527 7954 EL(ha, "failed, fc_port not found\n");
7528 7955 cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
7529 7956 cmd->ResponseLen = 0;
7530 7957 return;
7531 7958 }
7532 7959
7533 7960 cmd->Status = EXT_STATUS_OK;
7534 7961 cmd->DetailStatus = EXT_STATUS_OK;
7535 7962
7536 7963 switch (port_param.Mode) {
7537 7964 case EXT_IIDMA_MODE_GET:
7538 7965 /*
7539 7966 * Report the firmware's port rate for the wwpn
7540 7967 */
7541 7968 rval = ql_iidma_rate(ha, tq->loop_id, &idma_rate,
7542 7969 port_param.Mode);
7543 7970
7544 7971 if (rval != QL_SUCCESS) {
7545 7972 EL(ha, "iidma get failed: %xh\n", rval);
7546 7973 cmd->Status = EXT_STATUS_MAILBOX;
7547 7974 cmd->DetailStatus = rval;
7548 7975 cmd->ResponseLen = 0;
7549 7976 } else {
7550 7977 switch (idma_rate) {
7551 7978 case IIDMA_RATE_1GB:
7552 7979 port_param.Speed =
7553 7980 EXT_DEF_PORTSPEED_1GBIT;
7554 7981 break;
7555 7982 case IIDMA_RATE_2GB:
7556 7983 port_param.Speed =
7557 7984 EXT_DEF_PORTSPEED_2GBIT;
7558 7985 break;
7559 7986 case IIDMA_RATE_4GB:
7560 7987 port_param.Speed =
|
↓ open down ↓ |
24 lines elided |
↑ open up ↑ |
7561 7988 EXT_DEF_PORTSPEED_4GBIT;
7562 7989 break;
7563 7990 case IIDMA_RATE_8GB:
7564 7991 port_param.Speed =
7565 7992 EXT_DEF_PORTSPEED_8GBIT;
7566 7993 break;
7567 7994 case IIDMA_RATE_10GB:
7568 7995 port_param.Speed =
7569 7996 EXT_DEF_PORTSPEED_10GBIT;
7570 7997 break;
7998 + case IIDMA_RATE_16GB:
7999 + port_param.Speed =
8000 + EXT_DEF_PORTSPEED_16GBIT;
8001 + break;
8002 + case IIDMA_RATE_32GB:
8003 + port_param.Speed =
8004 + EXT_DEF_PORTSPEED_32GBIT;
8005 + break;
7571 8006 default:
7572 8007 port_param.Speed =
7573 8008 EXT_DEF_PORTSPEED_UNKNOWN;
7574 8009 EL(ha, "failed, Port speed rate=%xh\n",
7575 8010 idma_rate);
7576 8011 break;
7577 8012 }
7578 8013
7579 8014 /* Copy back the data */
7580 8015 rval = ddi_copyout((void *)&port_param,
7581 8016 (void *)(uintptr_t)cmd->ResponseAdr,
7582 8017 sizeof (EXT_PORT_PARAM), mode);
7583 8018
7584 8019 if (rval != 0) {
7585 8020 cmd->Status = EXT_STATUS_COPY_ERR;
7586 8021 cmd->ResponseLen = 0;
7587 8022 EL(ha, "failed, ddi_copyout\n");
7588 8023 } else {
7589 8024 cmd->ResponseLen = (uint32_t)
7590 8025 sizeof (EXT_PORT_PARAM);
7591 8026 }
7592 8027 }
7593 8028 break;
7594 8029
7595 8030 case EXT_IIDMA_MODE_SET:
7596 8031 /*
7597 8032 * Set the firmware's port rate for the wwpn
7598 8033 */
7599 8034 switch (port_param.Speed) {
7600 8035 case EXT_DEF_PORTSPEED_1GBIT:
7601 8036 idma_rate = IIDMA_RATE_1GB;
7602 8037 break;
|
↓ open down ↓ |
22 lines elided |
↑ open up ↑ |
7603 8038 case EXT_DEF_PORTSPEED_2GBIT:
7604 8039 idma_rate = IIDMA_RATE_2GB;
7605 8040 break;
7606 8041 case EXT_DEF_PORTSPEED_4GBIT:
7607 8042 idma_rate = IIDMA_RATE_4GB;
7608 8043 break;
7609 8044 case EXT_DEF_PORTSPEED_8GBIT:
7610 8045 idma_rate = IIDMA_RATE_8GB;
7611 8046 break;
7612 8047 case EXT_DEF_PORTSPEED_10GBIT:
7613 - port_param.Speed = IIDMA_RATE_10GB;
8048 + idma_rate = IIDMA_RATE_10GB;
7614 8049 break;
8050 + case EXT_DEF_PORTSPEED_16GBIT:
8051 + idma_rate = IIDMA_RATE_16GB;
8052 + break;
8053 + case EXT_DEF_PORTSPEED_32GBIT:
8054 + idma_rate = IIDMA_RATE_32GB;
8055 + break;
7615 8056 default:
7616 8057 EL(ha, "invalid set iidma rate: %x\n",
7617 8058 port_param.Speed);
7618 8059 cmd->Status = EXT_STATUS_INVALID_PARAM;
7619 8060 cmd->ResponseLen = 0;
7620 8061 rval = QL_PARAMETER_ERROR;
7621 8062 break;
7622 8063 }
7623 8064
7624 8065 if (rval == QL_SUCCESS) {
7625 8066 rval = ql_iidma_rate(ha, tq->loop_id, &idma_rate,
7626 8067 port_param.Mode);
7627 8068 if (rval != QL_SUCCESS) {
7628 8069 EL(ha, "iidma set failed: %xh\n", rval);
7629 8070 cmd->Status = EXT_STATUS_MAILBOX;
7630 8071 cmd->DetailStatus = rval;
7631 8072 cmd->ResponseLen = 0;
7632 8073 }
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
7633 8074 }
7634 8075 break;
7635 8076 default:
7636 8077 EL(ha, "invalid mode specified: %x\n", port_param.Mode);
7637 8078 cmd->Status = EXT_STATUS_INVALID_PARAM;
7638 8079 cmd->ResponseLen = 0;
7639 8080 cmd->DetailStatus = 0;
7640 8081 break;
7641 8082 }
7642 8083
7643 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8084 + QL_PRINT_9(ha, "done\n");
7644 8085 }
7645 8086
7646 8087 /*
7647 8088 * ql_get_fwexttrace
7648 8089 * Dumps f/w extended trace buffer
7649 8090 *
7650 8091 * Input:
7651 8092 * ha: adapter state pointer.
7652 8093 * bp: buffer address.
7653 8094 * mode: flags
7654 8095 *
7655 8096 * Returns:
7656 8097 *
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
7657 8098 * Context:
7658 8099 * Kernel context.
7659 8100 */
7660 8101 /* ARGSUSED */
7661 8102 static void
7662 8103 ql_get_fwexttrace(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
7663 8104 {
7664 8105 int rval;
7665 8106 caddr_t payload;
7666 8107
7667 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8108 + QL_PRINT_9(ha, "started\n");
7668 8109
7669 - if (CFG_IST(ha, CFG_CTRL_24258081) == 0) {
8110 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
7670 8111 EL(ha, "invalid request for this HBA\n");
7671 8112 cmd->Status = EXT_STATUS_INVALID_REQUEST;
7672 8113 cmd->ResponseLen = 0;
7673 8114 return;
7674 8115 }
7675 8116
7676 8117 if ((CFG_IST(ha, CFG_ENABLE_FWEXTTRACE) == 0) ||
7677 8118 (ha->fwexttracebuf.bp == NULL)) {
7678 8119 EL(ha, "f/w extended trace is not enabled\n");
7679 8120 cmd->Status = EXT_STATUS_INVALID_REQUEST;
7680 8121 cmd->ResponseLen = 0;
7681 8122 return;
7682 8123 }
7683 8124
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
7684 8125 if (cmd->ResponseLen < FWEXTSIZE) {
7685 8126 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
7686 8127 cmd->DetailStatus = FWEXTSIZE;
7687 8128 EL(ha, "failed, ResponseLen (%xh) < %xh (FWEXTSIZE)\n",
7688 8129 cmd->ResponseLen, FWEXTSIZE);
7689 8130 cmd->ResponseLen = 0;
7690 8131 return;
7691 8132 }
7692 8133
7693 8134 /* Time Stamp */
7694 - rval = ql_fw_etrace(ha, &ha->fwexttracebuf, FTO_INSERT_TIME_STAMP);
8135 + rval = ql_fw_etrace(ha, &ha->fwexttracebuf, FTO_INSERT_TIME_STAMP,
8136 + NULL);
7695 8137 if (rval != QL_SUCCESS) {
7696 8138 EL(ha, "f/w extended trace insert"
7697 8139 "time stamp failed: %xh\n", rval);
7698 8140 cmd->Status = EXT_STATUS_ERR;
7699 8141 cmd->ResponseLen = 0;
7700 8142 return;
7701 8143 }
7702 8144
7703 8145 /* Disable Tracing */
7704 - rval = ql_fw_etrace(ha, &ha->fwexttracebuf, FTO_EXT_TRACE_DISABLE);
8146 + rval = ql_fw_etrace(ha, &ha->fwexttracebuf, FTO_EXT_TRACE_DISABLE,
8147 + NULL);
7705 8148 if (rval != QL_SUCCESS) {
7706 8149 EL(ha, "f/w extended trace disable failed: %xh\n", rval);
7707 8150 cmd->Status = EXT_STATUS_ERR;
7708 8151 cmd->ResponseLen = 0;
7709 8152 return;
7710 8153 }
7711 8154
7712 8155 /* Allocate payload buffer */
7713 8156 payload = kmem_zalloc(FWEXTSIZE, KM_SLEEP);
7714 8157 if (payload == NULL) {
7715 8158 EL(ha, "failed, kmem_zalloc\n");
7716 8159 cmd->Status = EXT_STATUS_NO_MEMORY;
7717 8160 cmd->ResponseLen = 0;
7718 8161 return;
7719 8162 }
7720 8163
7721 8164 /* Sync DMA buffer. */
7722 8165 (void) ddi_dma_sync(ha->fwexttracebuf.dma_handle, 0,
7723 8166 FWEXTSIZE, DDI_DMA_SYNC_FORKERNEL);
7724 8167
7725 8168 /* Copy trace buffer data. */
7726 8169 ddi_rep_get8(ha->fwexttracebuf.acc_handle, (uint8_t *)payload,
7727 8170 (uint8_t *)ha->fwexttracebuf.bp, FWEXTSIZE,
7728 8171 DDI_DEV_AUTOINCR);
7729 8172
7730 8173 /* Send payload to application. */
7731 8174 if (ql_send_buffer_data(payload, (caddr_t)(uintptr_t)cmd->ResponseAdr,
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
7732 8175 cmd->ResponseLen, mode) != cmd->ResponseLen) {
7733 8176 EL(ha, "failed, send_buffer_data\n");
7734 8177 cmd->Status = EXT_STATUS_COPY_ERR;
7735 8178 cmd->ResponseLen = 0;
7736 8179 } else {
7737 8180 cmd->Status = EXT_STATUS_OK;
7738 8181 }
7739 8182
7740 8183 kmem_free(payload, FWEXTSIZE);
7741 8184
7742 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8185 + QL_PRINT_9(ha, "done\n");
7743 8186 }
7744 8187
7745 8188 /*
7746 8189 * ql_get_fwfcetrace
7747 8190 * Dumps f/w fibre channel event trace buffer
7748 8191 *
7749 8192 * Input:
7750 8193 * ha: adapter state pointer.
7751 8194 * bp: buffer address.
7752 8195 * mode: flags
7753 8196 *
7754 8197 * Returns:
7755 8198 *
7756 8199 * Context:
7757 8200 * Kernel context.
7758 8201 */
7759 8202 /* ARGSUSED */
7760 8203 static void
7761 8204 ql_get_fwfcetrace(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
7762 8205 {
7763 - int rval;
7764 - caddr_t payload;
8206 + int rval;
8207 + caddr_t fce_trace_p;
8208 + ql_mbx_data_t mr;
8209 + EXT_FW_FCE_TRACE *fce_trace;
8210 + size_t cnt;
8211 + uint32_t *bp;
7765 8212
7766 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8213 + QL_PRINT_9(ha, "started\n");
7767 8214
7768 - if (CFG_IST(ha, CFG_CTRL_24258081) == 0) {
8215 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
7769 8216 EL(ha, "invalid request for this HBA\n");
7770 8217 cmd->Status = EXT_STATUS_INVALID_REQUEST;
7771 8218 cmd->ResponseLen = 0;
7772 8219 return;
7773 8220 }
7774 8221
7775 8222 if ((CFG_IST(ha, CFG_ENABLE_FWFCETRACE) == 0) ||
7776 8223 (ha->fwfcetracebuf.bp == NULL)) {
7777 8224 EL(ha, "f/w FCE trace is not enabled\n");
7778 8225 cmd->Status = EXT_STATUS_INVALID_REQUEST;
7779 8226 cmd->ResponseLen = 0;
7780 8227 return;
7781 8228 }
7782 8229
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
7783 8230 if (cmd->ResponseLen < FWFCESIZE) {
7784 8231 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
7785 8232 cmd->DetailStatus = FWFCESIZE;
7786 8233 EL(ha, "failed, ResponseLen (%xh) < %xh (FWFCESIZE)\n",
7787 8234 cmd->ResponseLen, FWFCESIZE);
7788 8235 cmd->ResponseLen = 0;
7789 8236 return;
7790 8237 }
7791 8238
7792 8239 /* Disable Tracing */
7793 - rval = ql_fw_etrace(ha, &ha->fwfcetracebuf, FTO_FCE_TRACE_DISABLE);
8240 + rval = ql_fw_etrace(ha, &ha->fwfcetracebuf, FTO_FCE_TRACE_DISABLE, &mr);
7794 8241 if (rval != QL_SUCCESS) {
7795 8242 EL(ha, "f/w FCE trace disable failed: %xh\n", rval);
7796 8243 cmd->Status = EXT_STATUS_ERR;
7797 8244 cmd->ResponseLen = 0;
7798 8245 return;
7799 8246 }
7800 8247
7801 8248 /* Allocate payload buffer */
7802 - payload = kmem_zalloc(FWEXTSIZE, KM_SLEEP);
7803 - if (payload == NULL) {
8249 + fce_trace = kmem_zalloc(FWFCESIZE, KM_SLEEP);
8250 + if (fce_trace == NULL) {
7804 8251 EL(ha, "failed, kmem_zalloc\n");
7805 8252 cmd->Status = EXT_STATUS_NO_MEMORY;
7806 8253 cmd->ResponseLen = 0;
7807 8254 return;
7808 8255 }
8256 + fce_trace_p = (caddr_t)&fce_trace->TraceData[0];
7809 8257
8258 + /* Copy In Ponter and Base Pointer values */
8259 + fce_trace->Registers[0] = mr.mb[2];
8260 + fce_trace->Registers[1] = mr.mb[3];
8261 + fce_trace->Registers[2] = mr.mb[4];
8262 + fce_trace->Registers[3] = mr.mb[5];
8263 +
8264 + fce_trace->Registers[4] = LSW(ha->fwexttracebuf.cookies->dmac_address);
8265 + fce_trace->Registers[5] = MSW(ha->fwexttracebuf.cookies->dmac_address);
8266 + fce_trace->Registers[6] = LSW(ha->fwexttracebuf.cookies->dmac_notused);
8267 + fce_trace->Registers[7] = MSW(ha->fwexttracebuf.cookies->dmac_notused);
8268 +
8269 + /* Copy FCE Trace Enable Registers */
8270 + fce_trace->Registers[8] = ha->fw_fce_trace_enable.mb[0];
8271 + fce_trace->Registers[9] = ha->fw_fce_trace_enable.mb[2];
8272 + fce_trace->Registers[10] = ha->fw_fce_trace_enable.mb[3];
8273 + fce_trace->Registers[11] = ha->fw_fce_trace_enable.mb[4];
8274 + fce_trace->Registers[12] = ha->fw_fce_trace_enable.mb[5];
8275 + fce_trace->Registers[13] = ha->fw_fce_trace_enable.mb[6];
8276 +
7810 8277 /* Sync DMA buffer. */
7811 8278 (void) ddi_dma_sync(ha->fwfcetracebuf.dma_handle, 0,
7812 8279 FWFCESIZE, DDI_DMA_SYNC_FORKERNEL);
7813 8280
7814 8281 /* Copy trace buffer data. */
7815 - ddi_rep_get8(ha->fwfcetracebuf.acc_handle, (uint8_t *)payload,
8282 + ddi_rep_get8(ha->fwfcetracebuf.acc_handle, (uint8_t *)fce_trace_p,
7816 8283 (uint8_t *)ha->fwfcetracebuf.bp, FWFCESIZE,
7817 8284 DDI_DEV_AUTOINCR);
7818 8285
8286 + /* Swap bytes in buffer in case of Big Endian */
8287 + bp = (uint32_t *)&fce_trace->TraceData[0];
8288 + for (cnt = 0; cnt < (FWFCESIZE / sizeof (uint32_t)); cnt++) {
8289 + LITTLE_ENDIAN_32(bp);
8290 + bp++;
8291 + }
8292 +
7819 8293 /* Send payload to application. */
7820 - if (ql_send_buffer_data(payload, (caddr_t)(uintptr_t)cmd->ResponseAdr,
8294 + if (ql_send_buffer_data((caddr_t)fce_trace,
8295 + (caddr_t)(uintptr_t)cmd->ResponseAdr,
7821 8296 cmd->ResponseLen, mode) != cmd->ResponseLen) {
7822 8297 EL(ha, "failed, send_buffer_data\n");
7823 8298 cmd->Status = EXT_STATUS_COPY_ERR;
7824 8299 cmd->ResponseLen = 0;
7825 8300 } else {
7826 8301 cmd->Status = EXT_STATUS_OK;
7827 8302 }
7828 8303
7829 - kmem_free(payload, FWFCESIZE);
8304 + /* Re-enable Tracing */
8305 + bzero(ha->fwfcetracebuf.bp, ha->fwfcetracebuf.size);
8306 + if ((rval = ql_fw_etrace(ha, &ha->fwfcetracebuf,
8307 + FTO_FCE_TRACE_ENABLE, &mr)) != QL_SUCCESS) {
8308 + EL(ha, "fcetrace enable failed: %xh\n", rval);
8309 + } else {
8310 + ha->fw_fce_trace_enable = mr;
8311 + EL(ha, "FCE Trace Re-Enabled\n");
8312 + }
7830 8313
7831 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8314 + kmem_free(fce_trace, FWFCESIZE);
8315 +
8316 + QL_PRINT_9(ha, "done\n");
7832 8317 }
7833 8318
7834 8319 /*
7835 8320 * ql_get_pci_data
7836 8321 * Retrieves pci config space data
7837 8322 *
7838 8323 * Input:
7839 8324 * ha: adapter state pointer.
7840 8325 * cmd: Local EXT_IOCTL cmd struct pointer.
7841 8326 * mode: flags.
7842 8327 *
7843 8328 * Returns:
7844 8329 * None, request status indicated in cmd->Status.
7845 8330 *
7846 8331 * Context:
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
7847 8332 * Kernel context.
7848 8333 *
7849 8334 */
7850 8335 static void
7851 8336 ql_get_pci_data(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
7852 8337 {
7853 8338 uint8_t cap_ptr;
7854 8339 uint8_t cap_id;
7855 8340 uint32_t buf_size = 256;
7856 8341
7857 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8342 + QL_PRINT_9(ha, "started\n");
7858 8343
7859 8344 /*
7860 8345 * First check the "Capabilities List" bit of the status register.
7861 8346 */
7862 8347 if (ql_pci_config_get16(ha, PCI_CONF_STAT) & PCI_STAT_CAP) {
7863 8348 /*
7864 8349 * Now get the capability pointer
7865 8350 */
7866 8351 cap_ptr = (uint8_t)ql_pci_config_get8(ha, PCI_CONF_CAP_PTR);
7867 8352 while (cap_ptr != PCI_CAP_NEXT_PTR_NULL) {
7868 8353 /*
7869 8354 * Check for the pcie capability.
7870 8355 */
7871 8356 cap_id = (uint8_t)ql_pci_config_get8(ha, cap_ptr);
7872 8357 if (cap_id == PCI_CAP_ID_PCI_E) {
7873 8358 buf_size = 4096;
7874 8359 break;
7875 8360 }
7876 8361 cap_ptr = (uint8_t)ql_pci_config_get8(ha,
7877 8362 (cap_ptr + PCI_CAP_NEXT_PTR));
7878 8363 }
7879 8364 }
7880 8365
7881 8366 if (cmd->ResponseLen < buf_size) {
7882 8367 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
7883 8368 cmd->DetailStatus = buf_size;
7884 8369 EL(ha, "failed ResponseLen < buf_size, len passed=%xh\n",
7885 8370 cmd->ResponseLen);
7886 8371 return;
7887 8372 }
7888 8373
7889 8374 /* Dump PCI config data. */
|
↓ open down ↓ |
22 lines elided |
↑ open up ↑ |
7890 8375 if ((ql_pci_dump(ha, (void *)(uintptr_t)(cmd->ResponseAdr),
7891 8376 buf_size, mode)) != 0) {
7892 8377 cmd->Status = EXT_STATUS_COPY_ERR;
7893 8378 cmd->DetailStatus = 0;
7894 8379 EL(ha, "failed, copy err pci_dump\n");
7895 8380 } else {
7896 8381 cmd->Status = EXT_STATUS_OK;
7897 8382 cmd->DetailStatus = buf_size;
7898 8383 }
7899 8384
7900 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8385 + QL_PRINT_9(ha, "done\n");
7901 8386 }
7902 8387
7903 8388 /*
7904 8389 * ql_pci_dump
7905 8390 * Dumps PCI config data to application buffer.
7906 8391 *
7907 8392 * Input:
7908 8393 * ha = adapter state pointer.
7909 8394 * bp = user buffer address.
7910 8395 *
7911 8396 * Returns:
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
7912 8397 *
7913 8398 * Context:
7914 8399 * Kernel context.
7915 8400 */
7916 8401 int
7917 8402 ql_pci_dump(ql_adapter_state_t *ha, uint32_t *bp, uint32_t pci_size, int mode)
7918 8403 {
7919 8404 uint32_t pci_os;
7920 8405 uint32_t *ptr32, *org_ptr32;
7921 8406
7922 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8407 + QL_PRINT_9(ha, "started\n");
7923 8408
7924 8409 ptr32 = kmem_zalloc(pci_size, KM_SLEEP);
7925 8410 if (ptr32 == NULL) {
7926 8411 EL(ha, "failed kmem_zalloc\n");
7927 8412 return (ENOMEM);
7928 8413 }
7929 8414
7930 8415 /* store the initial value of ptr32 */
7931 8416 org_ptr32 = ptr32;
7932 8417 for (pci_os = 0; pci_os < pci_size; pci_os += 4) {
7933 8418 *ptr32 = (uint32_t)ql_pci_config_get32(ha, pci_os);
7934 8419 LITTLE_ENDIAN_32(ptr32);
7935 8420 ptr32++;
7936 8421 }
7937 8422
7938 8423 if (ddi_copyout((void *)org_ptr32, (void *)bp, pci_size, mode) !=
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
7939 8424 0) {
7940 8425 EL(ha, "failed ddi_copyout\n");
7941 8426 kmem_free(org_ptr32, pci_size);
7942 8427 return (EFAULT);
7943 8428 }
7944 8429
7945 8430 QL_DUMP_9(org_ptr32, 8, pci_size);
7946 8431
7947 8432 kmem_free(org_ptr32, pci_size);
7948 8433
7949 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8434 + QL_PRINT_9(ha, "done\n");
7950 8435
7951 8436 return (0);
7952 8437 }
7953 8438
7954 8439 /*
7955 8440 * ql_menlo_reset
7956 8441 * Reset Menlo
7957 8442 *
7958 8443 * Input:
7959 8444 * ha: adapter state pointer.
7960 8445 * bp: buffer address.
7961 8446 * mode: flags
7962 8447 *
7963 8448 * Returns:
7964 8449 *
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
7965 8450 * Context:
7966 8451 * Kernel context.
7967 8452 */
7968 8453 static void
7969 8454 ql_menlo_reset(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
7970 8455 {
7971 8456 EXT_MENLO_RESET rst;
7972 8457 ql_mbx_data_t mr;
7973 8458 int rval;
7974 8459
7975 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8460 + QL_PRINT_9(ha, "started\n");
7976 8461
7977 8462 if ((CFG_IST(ha, CFG_CTRL_MENLO)) == 0) {
7978 8463 EL(ha, "failed, invalid request for HBA\n");
7979 8464 cmd->Status = EXT_STATUS_INVALID_REQUEST;
7980 8465 cmd->ResponseLen = 0;
7981 8466 return;
7982 8467 }
7983 8468
7984 8469 /*
7985 8470 * TODO: only vp_index 0 can do this (?)
7986 8471 */
7987 8472
7988 8473 /* Verify the size of request structure. */
7989 8474 if (cmd->RequestLen < sizeof (EXT_MENLO_RESET)) {
7990 8475 /* Return error */
7991 8476 EL(ha, "RequestLen=%d < %d\n", cmd->RequestLen,
7992 8477 sizeof (EXT_MENLO_RESET));
7993 8478 cmd->Status = EXT_STATUS_INVALID_PARAM;
7994 8479 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
7995 8480 cmd->ResponseLen = 0;
7996 8481 return;
7997 8482 }
7998 8483
7999 8484 /* Get reset request. */
8000 8485 if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
8001 8486 (void *)&rst, sizeof (EXT_MENLO_RESET), mode) != 0) {
8002 8487 EL(ha, "failed, ddi_copyin\n");
8003 8488 cmd->Status = EXT_STATUS_COPY_ERR;
8004 8489 cmd->ResponseLen = 0;
8005 8490 return;
8006 8491 }
8007 8492
8008 8493 /* Wait for I/O to stop and daemon to stall. */
8009 8494 if (ql_suspend_hba(ha, 0) != QL_SUCCESS) {
8010 8495 EL(ha, "ql_stall_driver failed\n");
8011 8496 ql_restart_hba(ha);
8012 8497 cmd->Status = EXT_STATUS_BUSY;
8013 8498 cmd->ResponseLen = 0;
8014 8499 return;
8015 8500 }
8016 8501
8017 8502 rval = ql_reset_menlo(ha, &mr, rst.Flags);
8018 8503 if (rval != QL_SUCCESS) {
8019 8504 EL(ha, "failed, status=%xh\n", rval);
8020 8505 cmd->Status = EXT_STATUS_MAILBOX;
8021 8506 cmd->DetailStatus = rval;
|
↓ open down ↓ |
36 lines elided |
↑ open up ↑ |
8022 8507 cmd->ResponseLen = 0;
8023 8508 } else if (mr.mb[1] != 0) {
8024 8509 EL(ha, "failed, substatus=%d\n", mr.mb[1]);
8025 8510 cmd->Status = EXT_STATUS_ERR;
8026 8511 cmd->DetailStatus = mr.mb[1];
8027 8512 cmd->ResponseLen = 0;
8028 8513 }
8029 8514
8030 8515 ql_restart_hba(ha);
8031 8516
8032 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8517 + QL_PRINT_9(ha, "done\n");
8033 8518 }
8034 8519
8035 8520 /*
8036 8521 * ql_menlo_get_fw_version
8037 8522 * Get Menlo firmware version.
8038 8523 *
8039 8524 * Input:
8040 8525 * ha: adapter state pointer.
8041 8526 * bp: buffer address.
8042 8527 * mode: flags
8043 8528 *
8044 8529 * Returns:
8045 8530 *
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
8046 8531 * Context:
8047 8532 * Kernel context.
8048 8533 */
8049 8534 static void
8050 8535 ql_menlo_get_fw_version(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8051 8536 {
8052 8537 int rval;
8053 8538 ql_mbx_iocb_t *pkt;
8054 8539 EXT_MENLO_GET_FW_VERSION ver = {0};
8055 8540
8056 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8541 + QL_PRINT_9(ha, "started\n");
8057 8542
8058 8543 if ((CFG_IST(ha, CFG_CTRL_MENLO)) == 0) {
8059 8544 EL(ha, "failed, invalid request for HBA\n");
8060 8545 cmd->Status = EXT_STATUS_INVALID_REQUEST;
8061 8546 cmd->ResponseLen = 0;
8062 8547 return;
8063 8548 }
8064 8549
8065 8550 if (cmd->ResponseLen < sizeof (EXT_MENLO_GET_FW_VERSION)) {
8066 8551 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
8067 8552 cmd->DetailStatus = sizeof (EXT_MENLO_GET_FW_VERSION);
8068 8553 EL(ha, "ResponseLen=%d < %d\n", cmd->ResponseLen,
8069 8554 sizeof (EXT_MENLO_GET_FW_VERSION));
8070 8555 cmd->ResponseLen = 0;
8071 8556 return;
8072 8557 }
8073 8558
8074 8559 /* Allocate packet. */
8075 8560 pkt = kmem_zalloc(sizeof (ql_mbx_iocb_t), KM_SLEEP);
8076 8561 if (pkt == NULL) {
8077 8562 EL(ha, "failed, kmem_zalloc\n");
8078 8563 cmd->Status = EXT_STATUS_NO_MEMORY;
8079 8564 cmd->ResponseLen = 0;
8080 8565 return;
8081 8566 }
8082 8567
8083 8568 pkt->mvfy.entry_type = VERIFY_MENLO_TYPE;
8084 8569 pkt->mvfy.entry_count = 1;
8085 8570 pkt->mvfy.options_status = LE_16(VMF_DO_NOT_UPDATE_FW);
8086 8571
8087 8572 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, sizeof (ql_mbx_iocb_t));
8088 8573 LITTLE_ENDIAN_16(&pkt->mvfy.options_status);
8089 8574 LITTLE_ENDIAN_16(&pkt->mvfy.failure_code);
8090 8575 ver.FwVersion = LE_32(pkt->mvfy.fw_version);
8091 8576
8092 8577 if (rval != QL_SUCCESS || (pkt->mvfy.entry_status & 0x3c) != 0 ||
8093 8578 pkt->mvfy.options_status != CS_COMPLETE) {
8094 8579 /* Command error */
8095 8580 EL(ha, "failed, status=%xh, es=%xh, cs=%xh, fc=%xh\n", rval,
8096 8581 pkt->mvfy.entry_status & 0x3c, pkt->mvfy.options_status,
8097 8582 pkt->mvfy.failure_code);
8098 8583 cmd->Status = EXT_STATUS_ERR;
8099 8584 cmd->DetailStatus = rval != QL_SUCCESS ? rval :
8100 8585 QL_FUNCTION_FAILED;
8101 8586 cmd->ResponseLen = 0;
8102 8587 } else if (ddi_copyout((void *)&ver,
8103 8588 (void *)(uintptr_t)cmd->ResponseAdr,
|
↓ open down ↓ |
37 lines elided |
↑ open up ↑ |
8104 8589 sizeof (EXT_MENLO_GET_FW_VERSION), mode) != 0) {
8105 8590 EL(ha, "failed, ddi_copyout\n");
8106 8591 cmd->Status = EXT_STATUS_COPY_ERR;
8107 8592 cmd->ResponseLen = 0;
8108 8593 } else {
8109 8594 cmd->ResponseLen = sizeof (EXT_MENLO_GET_FW_VERSION);
8110 8595 }
8111 8596
8112 8597 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8113 8598
8114 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8599 + QL_PRINT_9(ha, "done\n");
8115 8600 }
8116 8601
8117 8602 /*
8118 8603 * ql_menlo_update_fw
8119 8604 * Get Menlo update firmware.
8120 8605 *
8121 8606 * Input:
8122 8607 * ha: adapter state pointer.
8123 8608 * bp: buffer address.
8124 8609 * mode: flags
8125 8610 *
8126 8611 * Returns:
8127 8612 *
8128 8613 * Context:
8129 8614 * Kernel context.
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
8130 8615 */
8131 8616 static void
8132 8617 ql_menlo_update_fw(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8133 8618 {
8134 8619 ql_mbx_iocb_t *pkt;
8135 8620 dma_mem_t *dma_mem;
8136 8621 EXT_MENLO_UPDATE_FW fw;
8137 8622 uint32_t *ptr32;
8138 8623 int rval;
8139 8624
8140 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8625 + QL_PRINT_9(ha, "started\n");
8141 8626
8142 8627 if ((CFG_IST(ha, CFG_CTRL_MENLO)) == 0) {
8143 8628 EL(ha, "failed, invalid request for HBA\n");
8144 8629 cmd->Status = EXT_STATUS_INVALID_REQUEST;
8145 8630 cmd->ResponseLen = 0;
8146 8631 return;
8147 8632 }
8148 8633
8149 8634 /*
8150 8635 * TODO: only vp_index 0 can do this (?)
8151 8636 */
8152 8637
8153 8638 /* Verify the size of request structure. */
8154 8639 if (cmd->RequestLen < sizeof (EXT_MENLO_UPDATE_FW)) {
8155 8640 /* Return error */
8156 8641 EL(ha, "RequestLen=%d < %d\n", cmd->RequestLen,
8157 8642 sizeof (EXT_MENLO_UPDATE_FW));
8158 8643 cmd->Status = EXT_STATUS_INVALID_PARAM;
8159 8644 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
8160 8645 cmd->ResponseLen = 0;
8161 8646 return;
8162 8647 }
8163 8648
8164 8649 /* Get update fw request. */
8165 8650 if (ddi_copyin((caddr_t)(uintptr_t)cmd->RequestAdr, (caddr_t)&fw,
8166 8651 sizeof (EXT_MENLO_UPDATE_FW), mode) != 0) {
8167 8652 EL(ha, "failed, ddi_copyin\n");
8168 8653 cmd->Status = EXT_STATUS_COPY_ERR;
8169 8654 cmd->ResponseLen = 0;
8170 8655 return;
8171 8656 }
8172 8657
8173 8658 /* Wait for I/O to stop and daemon to stall. */
8174 8659 if (ql_suspend_hba(ha, 0) != QL_SUCCESS) {
8175 8660 EL(ha, "ql_stall_driver failed\n");
8176 8661 ql_restart_hba(ha);
8177 8662 cmd->Status = EXT_STATUS_BUSY;
8178 8663 cmd->ResponseLen = 0;
8179 8664 return;
8180 8665 }
8181 8666
8182 8667 /* Allocate packet. */
8183 8668 dma_mem = (dma_mem_t *)kmem_zalloc(sizeof (dma_mem_t), KM_SLEEP);
8184 8669 if (dma_mem == NULL) {
8185 8670 EL(ha, "failed, kmem_zalloc\n");
8186 8671 cmd->Status = EXT_STATUS_NO_MEMORY;
8187 8672 cmd->ResponseLen = 0;
8188 8673 return;
8189 8674 }
8190 8675 pkt = kmem_zalloc(sizeof (ql_mbx_iocb_t), KM_SLEEP);
8191 8676 if (pkt == NULL) {
8192 8677 EL(ha, "failed, kmem_zalloc\n");
|
↓ open down ↓ |
42 lines elided |
↑ open up ↑ |
8193 8678 kmem_free(dma_mem, sizeof (dma_mem_t));
8194 8679 ql_restart_hba(ha);
8195 8680 cmd->Status = EXT_STATUS_NO_MEMORY;
8196 8681 cmd->ResponseLen = 0;
8197 8682 return;
8198 8683 }
8199 8684
8200 8685 /* Get DMA memory for the IOCB */
8201 8686 if (ql_get_dma_mem(ha, dma_mem, fw.TotalByteCount, LITTLE_ENDIAN_DMA,
8202 8687 QL_DMA_DATA_ALIGN) != QL_SUCCESS) {
8203 - cmn_err(CE_WARN, "%s(%d): request queue DMA memory "
8204 - "alloc failed", QL_NAME, ha->instance);
8688 + cmn_err(CE_WARN, "%srequest queue DMA memory "
8689 + "alloc failed", QL_NAME);
8205 8690 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8206 8691 kmem_free(dma_mem, sizeof (dma_mem_t));
8207 8692 ql_restart_hba(ha);
8208 8693 cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
8209 8694 cmd->ResponseLen = 0;
8210 8695 return;
8211 8696 }
8212 8697
8213 8698 /* Get firmware data. */
8214 8699 if (ql_get_buffer_data((caddr_t)(uintptr_t)fw.pFwDataBytes, dma_mem->bp,
8215 8700 fw.TotalByteCount, mode) != fw.TotalByteCount) {
8216 8701 EL(ha, "failed, get_buffer_data\n");
8217 8702 ql_free_dma_resource(ha, dma_mem);
8218 8703 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8219 8704 kmem_free(dma_mem, sizeof (dma_mem_t));
8220 8705 ql_restart_hba(ha);
8221 8706 cmd->Status = EXT_STATUS_COPY_ERR;
8222 8707 cmd->ResponseLen = 0;
8223 8708 return;
8224 8709 }
8225 8710
8226 8711 /* Sync DMA buffer. */
8227 8712 (void) ddi_dma_sync(dma_mem->dma_handle, 0, dma_mem->size,
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
8228 8713 DDI_DMA_SYNC_FORDEV);
8229 8714
8230 8715 pkt->mvfy.entry_type = VERIFY_MENLO_TYPE;
8231 8716 pkt->mvfy.entry_count = 1;
8232 8717 pkt->mvfy.options_status = (uint16_t)LE_16(fw.Flags);
8233 8718 ptr32 = dma_mem->bp;
8234 8719 pkt->mvfy.fw_version = LE_32(ptr32[2]);
8235 8720 pkt->mvfy.fw_size = LE_32(fw.TotalByteCount);
8236 8721 pkt->mvfy.fw_sequence_size = LE_32(fw.TotalByteCount);
8237 8722 pkt->mvfy.dseg_count = LE_16(1);
8238 - pkt->mvfy.dseg_0_address[0] = (uint32_t)
8723 + pkt->mvfy.dseg.address[0] = (uint32_t)
8239 8724 LE_32(LSD(dma_mem->cookie.dmac_laddress));
8240 - pkt->mvfy.dseg_0_address[1] = (uint32_t)
8725 + pkt->mvfy.dseg.address[1] = (uint32_t)
8241 8726 LE_32(MSD(dma_mem->cookie.dmac_laddress));
8242 - pkt->mvfy.dseg_0_length = LE_32(fw.TotalByteCount);
8727 + pkt->mvfy.dseg.length = LE_32(fw.TotalByteCount);
8243 8728
8244 8729 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, sizeof (ql_mbx_iocb_t));
8245 8730 LITTLE_ENDIAN_16(&pkt->mvfy.options_status);
8246 8731 LITTLE_ENDIAN_16(&pkt->mvfy.failure_code);
8247 8732
8248 8733 if (rval != QL_SUCCESS || (pkt->mvfy.entry_status & 0x3c) != 0 ||
8249 8734 pkt->mvfy.options_status != CS_COMPLETE) {
8250 8735 /* Command error */
8251 8736 EL(ha, "failed, status=%xh, es=%xh, cs=%xh, fc=%xh\n", rval,
8252 8737 pkt->mvfy.entry_status & 0x3c, pkt->mvfy.options_status,
8253 8738 pkt->mvfy.failure_code);
8254 8739 cmd->Status = EXT_STATUS_ERR;
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
8255 8740 cmd->DetailStatus = rval != QL_SUCCESS ? rval :
8256 8741 QL_FUNCTION_FAILED;
8257 8742 cmd->ResponseLen = 0;
8258 8743 }
8259 8744
8260 8745 ql_free_dma_resource(ha, dma_mem);
8261 8746 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8262 8747 kmem_free(dma_mem, sizeof (dma_mem_t));
8263 8748 ql_restart_hba(ha);
8264 8749
8265 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8750 + QL_PRINT_9(ha, "done\n");
8266 8751 }
8267 8752
8268 8753 /*
8269 8754 * ql_menlo_manage_info
8270 8755 * Get Menlo manage info.
8271 8756 *
8272 8757 * Input:
8273 8758 * ha: adapter state pointer.
8274 8759 * bp: buffer address.
8275 8760 * mode: flags
8276 8761 *
8277 8762 * Returns:
8278 8763 *
8279 8764 * Context:
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
8280 8765 * Kernel context.
8281 8766 */
8282 8767 static void
8283 8768 ql_menlo_manage_info(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8284 8769 {
8285 8770 ql_mbx_iocb_t *pkt;
8286 8771 dma_mem_t *dma_mem = NULL;
8287 8772 EXT_MENLO_MANAGE_INFO info;
8288 8773 int rval;
8289 8774
8290 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
8775 + QL_PRINT_9(ha, "started\n");
8291 8776
8292 8777
8293 8778 /* The call is only supported for Schultz right now */
8294 - if (CFG_IST(ha, CFG_CTRL_8081)) {
8779 + if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
8295 8780 ql_get_xgmac_statistics(ha, cmd, mode);
8296 - QL_PRINT_9(CE_CONT, "(%d): CFG_CTRL_81XX done\n",
8297 - ha->instance);
8781 + QL_PRINT_9(ha, "CFG_FCOE_SUPPORT done\n");
8298 8782 return;
8299 8783 }
8300 8784
8301 - if (!CFG_IST(ha, CFG_CTRL_8081) || !CFG_IST(ha, CFG_CTRL_MENLO)) {
8785 + if (!CFG_IST(ha, CFG_CTRL_MENLO)) {
8302 8786 EL(ha, "failed, invalid request for HBA\n");
8303 8787 cmd->Status = EXT_STATUS_INVALID_REQUEST;
8304 8788 cmd->ResponseLen = 0;
8305 8789 return;
8306 8790 }
8307 8791
8308 8792 /* Verify the size of request structure. */
8309 8793 if (cmd->RequestLen < sizeof (EXT_MENLO_MANAGE_INFO)) {
8310 8794 /* Return error */
8311 8795 EL(ha, "RequestLen=%d < %d\n", cmd->RequestLen,
8312 8796 sizeof (EXT_MENLO_MANAGE_INFO));
8313 8797 cmd->Status = EXT_STATUS_INVALID_PARAM;
8314 8798 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
8315 8799 cmd->ResponseLen = 0;
8316 8800 return;
8317 8801 }
8318 8802
8319 8803 /* Get manage info request. */
8320 8804 if (ddi_copyin((caddr_t)(uintptr_t)cmd->RequestAdr,
8321 8805 (caddr_t)&info, sizeof (EXT_MENLO_MANAGE_INFO), mode) != 0) {
8322 8806 EL(ha, "failed, ddi_copyin\n");
8323 8807 cmd->Status = EXT_STATUS_COPY_ERR;
8324 8808 cmd->ResponseLen = 0;
8325 8809 return;
8326 8810 }
8327 8811
8328 8812 /* Allocate packet. */
8329 8813 pkt = kmem_zalloc(sizeof (ql_mbx_iocb_t), KM_SLEEP);
8330 8814 if (pkt == NULL) {
8331 8815 EL(ha, "failed, kmem_zalloc\n");
8332 8816 ql_restart_driver(ha);
8333 8817 cmd->Status = EXT_STATUS_NO_MEMORY;
8334 8818 cmd->ResponseLen = 0;
8335 8819 return;
8336 8820 }
8337 8821
8338 8822 pkt->mdata.entry_type = MENLO_DATA_TYPE;
8339 8823 pkt->mdata.entry_count = 1;
8340 8824 pkt->mdata.options_status = (uint16_t)LE_16(info.Operation);
8341 8825
8342 8826 /* Get DMA memory for the IOCB */
8343 8827 if (info.Operation == MENLO_OP_READ_MEM ||
8344 8828 info.Operation == MENLO_OP_WRITE_MEM) {
8345 8829 pkt->mdata.total_byte_count = LE_32(info.TotalByteCount);
8346 8830 pkt->mdata.parameter_1 =
8347 8831 LE_32(info.Parameters.ap.MenloMemory.StartingAddr);
8348 8832 dma_mem = (dma_mem_t *)kmem_zalloc(sizeof (dma_mem_t),
|
↓ open down ↓ |
37 lines elided |
↑ open up ↑ |
8349 8833 KM_SLEEP);
8350 8834 if (dma_mem == NULL) {
8351 8835 EL(ha, "failed, kmem_zalloc\n");
8352 8836 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8353 8837 cmd->Status = EXT_STATUS_NO_MEMORY;
8354 8838 cmd->ResponseLen = 0;
8355 8839 return;
8356 8840 }
8357 8841 if (ql_get_dma_mem(ha, dma_mem, info.TotalByteCount,
8358 8842 LITTLE_ENDIAN_DMA, QL_DMA_DATA_ALIGN) != QL_SUCCESS) {
8359 - cmn_err(CE_WARN, "%s(%d): request queue DMA memory "
8360 - "alloc failed", QL_NAME, ha->instance);
8843 + cmn_err(CE_WARN, "%srequest queue DMA memory "
8844 + "alloc failed", QL_NAME);
8361 8845 kmem_free(dma_mem, sizeof (dma_mem_t));
8362 8846 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8363 8847 cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
8364 8848 cmd->ResponseLen = 0;
8365 8849 return;
8366 8850 }
8367 8851 if (info.Operation == MENLO_OP_WRITE_MEM) {
8368 8852 /* Get data. */
8369 8853 if (ql_get_buffer_data(
8370 8854 (caddr_t)(uintptr_t)info.pDataBytes,
8371 8855 dma_mem->bp, info.TotalByteCount, mode) !=
8372 8856 info.TotalByteCount) {
8373 8857 EL(ha, "failed, get_buffer_data\n");
8374 8858 ql_free_dma_resource(ha, dma_mem);
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
8375 8859 kmem_free(dma_mem, sizeof (dma_mem_t));
8376 8860 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8377 8861 cmd->Status = EXT_STATUS_COPY_ERR;
8378 8862 cmd->ResponseLen = 0;
8379 8863 return;
8380 8864 }
8381 8865 (void) ddi_dma_sync(dma_mem->dma_handle, 0,
8382 8866 dma_mem->size, DDI_DMA_SYNC_FORDEV);
8383 8867 }
8384 8868 pkt->mdata.dseg_count = LE_16(1);
8385 - pkt->mdata.dseg_0_address[0] = (uint32_t)
8869 + pkt->mdata.dseg.address[0] = (uint32_t)
8386 8870 LE_32(LSD(dma_mem->cookie.dmac_laddress));
8387 - pkt->mdata.dseg_0_address[1] = (uint32_t)
8871 + pkt->mdata.dseg.address[1] = (uint32_t)
8388 8872 LE_32(MSD(dma_mem->cookie.dmac_laddress));
8389 - pkt->mdata.dseg_0_length = LE_32(info.TotalByteCount);
8873 + pkt->mdata.dseg.length = LE_32(info.TotalByteCount);
8390 8874 } else if (info.Operation & MENLO_OP_CHANGE_CONFIG) {
8391 8875 pkt->mdata.parameter_1 =
8392 8876 LE_32(info.Parameters.ap.MenloConfig.ConfigParamID);
8393 8877 pkt->mdata.parameter_2 =
8394 8878 LE_32(info.Parameters.ap.MenloConfig.ConfigParamData0);
8395 8879 pkt->mdata.parameter_3 =
8396 8880 LE_32(info.Parameters.ap.MenloConfig.ConfigParamData1);
8397 8881 } else if (info.Operation & MENLO_OP_GET_INFO) {
8398 8882 pkt->mdata.parameter_1 =
8399 8883 LE_32(info.Parameters.ap.MenloInfo.InfoDataType);
8400 8884 pkt->mdata.parameter_2 =
8401 8885 LE_32(info.Parameters.ap.MenloInfo.InfoContext);
8402 8886 }
8403 8887
8404 8888 rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, sizeof (ql_mbx_iocb_t));
8405 8889 LITTLE_ENDIAN_16(&pkt->mdata.options_status);
8406 8890 LITTLE_ENDIAN_16(&pkt->mdata.failure_code);
8407 8891
8408 8892 if (rval != QL_SUCCESS || (pkt->mdata.entry_status & 0x3c) != 0 ||
8409 8893 pkt->mdata.options_status != CS_COMPLETE) {
8410 8894 /* Command error */
8411 8895 EL(ha, "failed, status=%xh, es=%xh, cs=%xh, fc=%xh\n", rval,
8412 8896 pkt->mdata.entry_status & 0x3c, pkt->mdata.options_status,
8413 8897 pkt->mdata.failure_code);
8414 8898 cmd->Status = EXT_STATUS_ERR;
8415 8899 cmd->DetailStatus = rval != QL_SUCCESS ? rval :
8416 8900 QL_FUNCTION_FAILED;
8417 8901 cmd->ResponseLen = 0;
8418 8902 } else if (info.Operation == MENLO_OP_READ_MEM) {
8419 8903 (void) ddi_dma_sync(dma_mem->dma_handle, 0, dma_mem->size,
8420 8904 DDI_DMA_SYNC_FORKERNEL);
8421 8905 if (ql_send_buffer_data((caddr_t)(uintptr_t)info.pDataBytes,
8422 8906 dma_mem->bp, info.TotalByteCount, mode) !=
|
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
8423 8907 info.TotalByteCount) {
8424 8908 cmd->Status = EXT_STATUS_COPY_ERR;
8425 8909 cmd->ResponseLen = 0;
8426 8910 }
8427 8911 }
8428 8912
8429 8913 ql_free_dma_resource(ha, dma_mem);
8430 8914 kmem_free(dma_mem, sizeof (dma_mem_t));
8431 8915 kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8432 8916
8433 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
8917 + QL_PRINT_9(ha, "done\n");
8434 8918 }
8435 8919
8436 8920 /*
8437 8921 * ql_suspend_hba
8438 8922 * Suspends all adapter ports.
8439 8923 *
8440 8924 * Input:
8441 8925 * ha: adapter state pointer.
8442 8926 * options: BIT_0 --> leave driver stalled on exit if
8443 8927 * failed.
8444 8928 *
8445 8929 * Returns:
8446 8930 * ql local function return status code.
8447 8931 *
8448 8932 * Context:
8449 8933 * Kernel context.
8450 8934 */
8451 8935 static int
8452 8936 ql_suspend_hba(ql_adapter_state_t *ha, uint32_t opt)
8453 8937 {
8454 8938 ql_adapter_state_t *ha2;
8455 8939 ql_link_t *link;
8456 8940 int rval = QL_SUCCESS;
8457 8941
8458 8942 /* Quiesce I/O on all adapter ports */
8459 8943 for (link = ql_hba.first; link != NULL; link = link->next) {
8460 8944 ha2 = link->base_address;
8461 8945
8462 8946 if (ha2->fru_hba_index != ha->fru_hba_index) {
8463 8947 continue;
8464 8948 }
8465 8949
8466 8950 if ((rval = ql_stall_driver(ha2, opt)) != QL_SUCCESS) {
8467 8951 EL(ha, "ql_stall_driver status=%xh\n", rval);
8468 8952 break;
8469 8953 }
8470 8954 }
8471 8955
8472 8956 return (rval);
8473 8957 }
8474 8958
8475 8959 /*
8476 8960 * ql_restart_hba
8477 8961 * Restarts adapter.
8478 8962 *
8479 8963 * Input:
8480 8964 * ha: adapter state pointer.
8481 8965 *
8482 8966 * Context:
8483 8967 * Kernel context.
8484 8968 */
8485 8969 static void
8486 8970 ql_restart_hba(ql_adapter_state_t *ha)
8487 8971 {
8488 8972 ql_adapter_state_t *ha2;
8489 8973 ql_link_t *link;
8490 8974
8491 8975 /* Resume I/O on all adapter ports */
8492 8976 for (link = ql_hba.first; link != NULL; link = link->next) {
8493 8977 ha2 = link->base_address;
8494 8978
8495 8979 if (ha2->fru_hba_index != ha->fru_hba_index) {
8496 8980 continue;
8497 8981 }
8498 8982
8499 8983 ql_restart_driver(ha2);
8500 8984 }
8501 8985 }
8502 8986
8503 8987 /*
8504 8988 * ql_get_vp_cnt_id
8505 8989 * Retrieves pci config space data
8506 8990 *
8507 8991 * Input:
8508 8992 * ha: adapter state pointer.
8509 8993 * cmd: Local EXT_IOCTL cmd struct pointer.
8510 8994 * mode: flags.
8511 8995 *
8512 8996 * Returns:
8513 8997 * None, request status indicated in cmd->Status.
8514 8998 *
8515 8999 * Context:
8516 9000 * Kernel context.
8517 9001 *
|
↓ open down ↓ |
74 lines elided |
↑ open up ↑ |
8518 9002 */
8519 9003 static void
8520 9004 ql_get_vp_cnt_id(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8521 9005 {
8522 9006 ql_adapter_state_t *vha;
8523 9007 PEXT_VPORT_ID_CNT ptmp_vp;
8524 9008 int id = 0;
8525 9009 int rval;
8526 9010 char name[MAXPATHLEN];
8527 9011
8528 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9012 + QL_PRINT_9(ha, "started\n");
8529 9013
8530 9014 /*
8531 9015 * To be backward compatible with older API
8532 9016 * check for the size of old EXT_VPORT_ID_CNT
8533 9017 */
8534 9018 if (cmd->ResponseLen < sizeof (EXT_VPORT_ID_CNT) &&
8535 9019 (cmd->ResponseLen != EXT_OLD_VPORT_ID_CNT_SIZE)) {
8536 9020 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
8537 9021 cmd->DetailStatus = sizeof (EXT_VPORT_ID_CNT);
8538 9022 EL(ha, "failed, ResponseLen < EXT_VPORT_ID_CNT, Len=%xh\n",
8539 9023 cmd->ResponseLen);
8540 9024 cmd->ResponseLen = 0;
8541 9025 return;
8542 9026 }
8543 9027
8544 9028 ptmp_vp = (EXT_VPORT_ID_CNT *)
8545 9029 kmem_zalloc(sizeof (EXT_VPORT_ID_CNT), KM_SLEEP);
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
8546 9030 if (ptmp_vp == NULL) {
8547 9031 EL(ha, "failed, kmem_zalloc\n");
8548 9032 cmd->ResponseLen = 0;
8549 9033 return;
8550 9034 }
8551 9035 vha = ha->vp_next;
8552 9036 while (vha != NULL) {
8553 9037 ptmp_vp->VpCnt++;
8554 9038 ptmp_vp->VpId[id] = vha->vp_index;
8555 9039 (void) ddi_pathname(vha->dip, name);
8556 - (void) strcpy((char *)ptmp_vp->vp_path[id], name);
9040 + (void) strncpy((char *)ptmp_vp->vp_path[id], name,
9041 + (sizeof (ptmp_vp->vp_path[id]) -1));
8557 9042 ptmp_vp->VpDrvInst[id] = (int32_t)vha->instance;
8558 9043 id++;
8559 9044 vha = vha->vp_next;
8560 9045 }
8561 9046 rval = ddi_copyout((void *)ptmp_vp,
8562 9047 (void *)(uintptr_t)(cmd->ResponseAdr),
8563 9048 cmd->ResponseLen, mode);
8564 9049 if (rval != 0) {
8565 9050 cmd->Status = EXT_STATUS_COPY_ERR;
8566 9051 cmd->ResponseLen = 0;
8567 9052 EL(ha, "failed, ddi_copyout\n");
8568 9053 } else {
8569 9054 cmd->ResponseLen = sizeof (EXT_VPORT_ID_CNT);
8570 - QL_PRINT_9(CE_CONT, "(%d): done, vport_cnt=%d\n",
9055 + QL_PRINT_9(ha, "done, vport_cnt=%d\n",
8571 9056 ha->instance, ptmp_vp->VpCnt);
8572 9057 }
8573 -
9058 + kmem_free(ptmp_vp, sizeof (EXT_VPORT_ID_CNT));
8574 9059 }
8575 9060
8576 9061 /*
8577 9062 * ql_vp_ioctl
8578 9063 * Performs all EXT_CC_VPORT_CMD functions.
8579 9064 *
8580 9065 * Input:
8581 9066 * ha: adapter state pointer.
8582 9067 * cmd: Local EXT_IOCTL cmd struct pointer.
8583 9068 * mode: flags.
8584 9069 *
8585 9070 * Returns:
8586 9071 * None, request status indicated in cmd->Status.
8587 9072 *
8588 9073 * Context:
8589 9074 * Kernel context.
8590 9075 */
8591 9076 static void
8592 9077 ql_vp_ioctl(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8593 9078 {
8594 - QL_PRINT_9(CE_CONT, "(%d): started, cmd=%d\n", ha->instance,
9079 + QL_PRINT_9(ha, "started, cmd=%d\n",
8595 9080 cmd->SubCode);
8596 9081
8597 9082 /* case off on command subcode */
8598 9083 switch (cmd->SubCode) {
8599 9084 case EXT_VF_SC_VPORT_GETINFO:
8600 9085 ql_qry_vport(ha, cmd, mode);
8601 9086 break;
8602 9087 default:
8603 9088 /* function not supported. */
8604 9089 cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
8605 9090 EL(ha, "failed, Unsupported Subcode=%xh\n",
8606 9091 cmd->SubCode);
8607 9092 break;
8608 9093 }
8609 9094
8610 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9095 + QL_PRINT_9(ha, "done\n");
8611 9096 }
8612 9097
8613 9098 /*
8614 9099 * ql_qry_vport
8615 9100 * Performs EXT_VF_SC_VPORT_GETINFO subfunction.
8616 9101 *
8617 9102 * Input:
8618 9103 * ha: adapter state pointer.
8619 9104 * cmd: EXT_IOCTL cmd struct pointer.
8620 9105 * mode: flags.
8621 9106 *
8622 9107 * Returns:
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
8623 9108 * None, request status indicated in cmd->Status.
8624 9109 *
8625 9110 * Context:
8626 9111 * Kernel context.
8627 9112 */
8628 9113 static void
8629 9114 ql_qry_vport(ql_adapter_state_t *vha, EXT_IOCTL *cmd, int mode)
8630 9115 {
8631 9116 ql_adapter_state_t *tmp_vha;
8632 9117 EXT_VPORT_INFO tmp_vport = {0};
8633 - int max_vport;
8634 9118
8635 - QL_PRINT_9(CE_CONT, "(%d): started\n", vha->instance);
9119 + QL_PRINT_9(vha, "started\n", vha->instance);
8636 9120
8637 9121 if (cmd->ResponseLen < sizeof (EXT_VPORT_INFO)) {
8638 9122 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
8639 9123 cmd->DetailStatus = sizeof (EXT_VPORT_INFO);
8640 9124 EL(vha, "failed, ResponseLen < EXT_VPORT_INFO, Len=%xh\n",
8641 9125 cmd->ResponseLen);
8642 9126 cmd->ResponseLen = 0;
8643 9127 return;
8644 9128 }
8645 9129
8646 9130 /* Fill in the vport information. */
8647 9131 bcopy(vha->loginparams.node_ww_name.raw_wwn, tmp_vport.wwnn,
8648 9132 EXT_DEF_WWN_NAME_SIZE);
8649 9133 bcopy(vha->loginparams.nport_ww_name.raw_wwn, tmp_vport.wwpn,
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
8650 9134 EXT_DEF_WWN_NAME_SIZE);
8651 9135 tmp_vport.state = vha->state;
8652 9136 tmp_vport.id = vha->vp_index;
8653 9137
8654 9138 tmp_vha = vha->pha->vp_next;
8655 9139 while (tmp_vha != NULL) {
8656 9140 tmp_vport.used++;
8657 9141 tmp_vha = tmp_vha->vp_next;
8658 9142 }
8659 9143
8660 - max_vport = (CFG_IST(vha, CFG_CTRL_2422) ? MAX_24_VIRTUAL_PORTS :
8661 - MAX_25_VIRTUAL_PORTS);
8662 - if (max_vport > tmp_vport.used) {
8663 - tmp_vport.free = max_vport - tmp_vport.used;
9144 + if (vha->max_vports > tmp_vport.used) {
9145 + tmp_vport.free = vha->max_vports - tmp_vport.used;
8664 9146 }
8665 9147
8666 9148 if (ddi_copyout((void *)&tmp_vport,
8667 9149 (void *)(uintptr_t)(cmd->ResponseAdr),
8668 9150 sizeof (EXT_VPORT_INFO), mode) != 0) {
8669 9151 cmd->Status = EXT_STATUS_COPY_ERR;
8670 9152 cmd->ResponseLen = 0;
8671 9153 EL(vha, "failed, ddi_copyout\n");
8672 9154 } else {
8673 9155 cmd->ResponseLen = sizeof (EXT_VPORT_INFO);
8674 - QL_PRINT_9(CE_CONT, "(%d): done\n", vha->instance);
9156 + QL_PRINT_9(vha, "done\n", vha->instance);
8675 9157 }
8676 9158 }
8677 9159
8678 9160 /*
8679 9161 * ql_access_flash
8680 9162 * Performs all EXT_CC_ACCESS_FLASH_OS functions.
8681 9163 *
8682 9164 * Input:
8683 9165 * pi: port info pointer.
8684 9166 * cmd: Local EXT_IOCTL cmd struct pointer.
8685 9167 * mode: flags.
8686 9168 *
8687 9169 * Returns:
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
8688 9170 * None, request status indicated in cmd->Status.
8689 9171 *
8690 9172 * Context:
8691 9173 * Kernel context.
8692 9174 */
8693 9175 static void
8694 9176 ql_access_flash(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8695 9177 {
8696 9178 int rval;
8697 9179
8698 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9180 + QL_PRINT_9(ha, "started\n");
8699 9181
9182 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1) &&
9183 + ql_stall_driver(ha, 0) != QL_SUCCESS) {
9184 + EL(ha, "ql_stall_driver failed\n");
9185 + ql_restart_driver(ha);
9186 + cmd->Status = EXT_STATUS_BUSY;
9187 + cmd->ResponseLen = 0;
9188 + return;
9189 + }
9190 +
8700 9191 switch (cmd->SubCode) {
8701 9192 case EXT_SC_FLASH_READ:
8702 9193 if ((rval = ql_flash_fcode_dump(ha,
8703 9194 (void *)(uintptr_t)(cmd->ResponseAdr),
8704 9195 (size_t)(cmd->ResponseLen), cmd->Reserved1, mode)) != 0) {
8705 9196 cmd->Status = EXT_STATUS_COPY_ERR;
8706 9197 cmd->ResponseLen = 0;
8707 9198 EL(ha, "flash_fcode_dump status=%xh\n", rval);
8708 9199 }
8709 9200 break;
8710 9201 case EXT_SC_FLASH_WRITE:
8711 9202 if ((rval = ql_r_m_w_flash(ha,
8712 9203 (void *)(uintptr_t)(cmd->RequestAdr),
8713 9204 (size_t)(cmd->RequestLen), cmd->Reserved1, mode)) !=
8714 9205 QL_SUCCESS) {
8715 9206 cmd->Status = EXT_STATUS_COPY_ERR;
8716 9207 cmd->ResponseLen = 0;
8717 9208 EL(ha, "r_m_w_flash status=%xh\n", rval);
8718 9209 } else {
8719 9210 /* Reset caches on all adapter instances. */
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
8720 9211 ql_update_flash_caches(ha);
8721 9212 }
8722 9213 break;
8723 9214 default:
8724 9215 EL(ha, "unknown subcode=%xh\n", cmd->SubCode);
8725 9216 cmd->Status = EXT_STATUS_ERR;
8726 9217 cmd->ResponseLen = 0;
8727 9218 break;
8728 9219 }
8729 9220
8730 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9221 + /* Resume I/O */
9222 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_1)) {
9223 + EL(ha, "isp_abort_needed for restart\n");
9224 + ql_awaken_task_daemon(ha, NULL, ISP_ABORT_NEEDED,
9225 + DRIVER_STALL);
9226 + }
9227 +
9228 + QL_PRINT_9(ha, "done\n");
8731 9229 }
8732 9230
8733 9231 /*
8734 9232 * ql_reset_cmd
8735 9233 * Performs all EXT_CC_RESET_FW_OS functions.
8736 9234 *
8737 9235 * Input:
8738 9236 * ha: adapter state pointer.
8739 9237 * cmd: Local EXT_IOCTL cmd struct pointer.
8740 9238 *
8741 9239 * Returns:
8742 9240 * None, request status indicated in cmd->Status.
8743 9241 *
8744 9242 * Context:
8745 9243 * Kernel context.
8746 9244 */
8747 9245 static void
8748 9246 ql_reset_cmd(ql_adapter_state_t *ha, EXT_IOCTL *cmd)
8749 9247 {
8750 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9248 + uint8_t timer;
8751 9249
9250 + QL_PRINT_9(ha, "started\n");
9251 +
8752 9252 switch (cmd->SubCode) {
8753 9253 case EXT_SC_RESET_FC_FW:
8754 - EL(ha, "isp_abort_needed\n");
8755 - ql_awaken_task_daemon(ha, NULL, ISP_ABORT_NEEDED, 0);
9254 + if (CFG_IST(ha, CFG_CTRL_82XX)) {
9255 + (void) ql_8021_reset_fw(ha);
9256 + } else {
9257 + EL(ha, "isp_abort_needed\n");
9258 + ql_awaken_task_daemon(ha, NULL, ISP_ABORT_NEEDED, 0);
9259 + }
9260 + for (timer = 180; timer; timer--) {
9261 + ql_awaken_task_daemon(ha, NULL, 0, 0);
9262 + /* Delay for 1 second. */
9263 + delay(100);
9264 + if (!(ha->task_daemon_flags & (ISP_ABORT_NEEDED |
9265 + ABORT_ISP_ACTIVE | LOOP_RESYNC_NEEDED |
9266 + LOOP_RESYNC_ACTIVE))) {
9267 + break;
9268 + }
9269 + }
8756 9270 break;
8757 9271 case EXT_SC_RESET_MPI_FW:
8758 - if (!(CFG_IST(ha, CFG_CTRL_81XX))) {
9272 + if (!(CFG_IST(ha, CFG_CTRL_8081))) {
8759 9273 EL(ha, "invalid request for HBA\n");
8760 9274 cmd->Status = EXT_STATUS_INVALID_REQUEST;
8761 9275 cmd->ResponseLen = 0;
8762 9276 } else {
9277 + ADAPTER_STATE_LOCK(ha);
9278 + ha->flags |= DISABLE_NIC_FW_DMP;
9279 + ADAPTER_STATE_UNLOCK(ha);
9280 +
8763 9281 /* Wait for I/O to stop and daemon to stall. */
8764 9282 if (ql_suspend_hba(ha, 0) != QL_SUCCESS) {
8765 9283 EL(ha, "ql_suspend_hba failed\n");
8766 9284 cmd->Status = EXT_STATUS_BUSY;
8767 9285 cmd->ResponseLen = 0;
8768 9286 } else if (ql_restart_mpi(ha) != QL_SUCCESS) {
8769 9287 cmd->Status = EXT_STATUS_ERR;
8770 9288 cmd->ResponseLen = 0;
8771 9289 } else {
8772 - uint8_t timer;
8773 9290 /*
8774 9291 * While the restart_mpi mailbox cmd may be
8775 9292 * done the MPI is not. Wait at least 6 sec. or
8776 9293 * exit if the loop comes up.
8777 9294 */
8778 9295 for (timer = 6; timer; timer--) {
8779 9296 if (!(ha->task_daemon_flags &
8780 9297 LOOP_DOWN)) {
8781 9298 break;
8782 9299 }
8783 9300 /* Delay for 1 second. */
8784 9301 ql_delay(ha, 1000000);
8785 9302 }
8786 9303 }
8787 9304 ql_restart_hba(ha);
9305 +
9306 + ADAPTER_STATE_LOCK(ha);
9307 + ha->flags &= ~DISABLE_NIC_FW_DMP;
9308 + ADAPTER_STATE_UNLOCK(ha);
8788 9309 }
8789 9310 break;
8790 9311 default:
8791 9312 EL(ha, "unknown subcode=%xh\n", cmd->SubCode);
8792 9313 cmd->Status = EXT_STATUS_ERR;
8793 9314 cmd->ResponseLen = 0;
8794 9315 break;
8795 9316 }
8796 9317
8797 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9318 + QL_PRINT_9(ha, "done\n");
8798 9319 }
8799 9320
8800 9321 /*
8801 9322 * ql_get_dcbx_parameters
8802 9323 * Get DCBX parameters.
8803 9324 *
8804 9325 * Input:
8805 9326 * ha: adapter state pointer.
8806 9327 * cmd: User space CT arguments pointer.
8807 9328 * mode: flags.
8808 9329 */
8809 9330 static void
8810 9331 ql_get_dcbx_parameters(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8811 9332 {
8812 9333 uint8_t *tmp_buf;
8813 9334 int rval;
8814 9335
8815 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9336 + QL_PRINT_9(ha, "started\n");
8816 9337
8817 - if (!(CFG_IST(ha, CFG_CTRL_8081))) {
9338 + if (!(CFG_IST(ha, CFG_FCOE_SUPPORT))) {
8818 9339 EL(ha, "invalid request for HBA\n");
8819 9340 cmd->Status = EXT_STATUS_INVALID_REQUEST;
8820 9341 cmd->ResponseLen = 0;
8821 9342 return;
8822 9343 }
8823 9344
8824 9345 /* Allocate memory for command. */
8825 9346 tmp_buf = kmem_zalloc(EXT_DEF_DCBX_PARAM_BUF_SIZE, KM_SLEEP);
8826 9347 if (tmp_buf == NULL) {
8827 9348 EL(ha, "failed, kmem_zalloc\n");
8828 9349 cmd->Status = EXT_STATUS_NO_MEMORY;
8829 9350 cmd->ResponseLen = 0;
8830 9351 return;
8831 9352 }
8832 9353 /* Send command */
8833 9354 rval = ql_get_dcbx_params(ha, EXT_DEF_DCBX_PARAM_BUF_SIZE,
8834 9355 (caddr_t)tmp_buf);
8835 9356 if (rval != QL_SUCCESS) {
8836 9357 /* error */
8837 9358 EL(ha, "failed, get_dcbx_params_mbx=%xh\n", rval);
8838 9359 kmem_free(tmp_buf, EXT_DEF_DCBX_PARAM_BUF_SIZE);
8839 9360 cmd->Status = EXT_STATUS_ERR;
8840 9361 cmd->ResponseLen = 0;
8841 9362 return;
8842 9363 }
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
8843 9364
8844 9365 /* Copy the response */
8845 9366 if (ql_send_buffer_data((caddr_t)tmp_buf,
8846 9367 (caddr_t)(uintptr_t)cmd->ResponseAdr,
8847 9368 EXT_DEF_DCBX_PARAM_BUF_SIZE, mode) != EXT_DEF_DCBX_PARAM_BUF_SIZE) {
8848 9369 EL(ha, "failed, ddi_copyout\n");
8849 9370 cmd->Status = EXT_STATUS_COPY_ERR;
8850 9371 cmd->ResponseLen = 0;
8851 9372 } else {
8852 9373 cmd->ResponseLen = EXT_DEF_DCBX_PARAM_BUF_SIZE;
8853 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9374 + QL_PRINT_9(ha, "done\n");
8854 9375 }
8855 9376 kmem_free(tmp_buf, EXT_DEF_DCBX_PARAM_BUF_SIZE);
8856 9377
8857 9378 }
8858 9379
8859 9380 /*
8860 9381 * ql_qry_cna_port
8861 9382 * Performs EXT_SC_QUERY_CNA_PORT subfunction.
8862 9383 *
8863 9384 * Input:
8864 9385 * ha: adapter state pointer.
8865 9386 * cmd: EXT_IOCTL cmd struct pointer.
8866 9387 * mode: flags.
8867 9388 *
8868 9389 * Returns:
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
8869 9390 * None, request status indicated in cmd->Status.
8870 9391 *
8871 9392 * Context:
8872 9393 * Kernel context.
8873 9394 */
8874 9395 static void
8875 9396 ql_qry_cna_port(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
8876 9397 {
8877 9398 EXT_CNA_PORT cna_port = {0};
8878 9399
8879 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9400 + QL_PRINT_9(ha, "started\n");
8880 9401
8881 - if (!(CFG_IST(ha, CFG_CTRL_8081))) {
9402 + if (!(CFG_IST(ha, CFG_FCOE_SUPPORT))) {
8882 9403 EL(ha, "invalid request for HBA\n");
8883 9404 cmd->Status = EXT_STATUS_INVALID_REQUEST;
8884 9405 cmd->ResponseLen = 0;
8885 9406 return;
8886 9407 }
8887 9408
8888 9409 if (cmd->ResponseLen < sizeof (EXT_CNA_PORT)) {
8889 9410 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
8890 9411 cmd->DetailStatus = sizeof (EXT_CNA_PORT);
8891 9412 EL(ha, "failed, ResponseLen < EXT_CNA_PORT, Len=%xh\n",
8892 9413 cmd->ResponseLen);
8893 9414 cmd->ResponseLen = 0;
8894 9415 return;
8895 9416 }
8896 9417
8897 9418 cna_port.VLanId = ha->fcoe_vlan_id;
8898 9419 cna_port.FabricParam = ha->fabric_params;
8899 9420 bcopy(ha->fcoe_vnport_mac, cna_port.VNPortMACAddress,
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
8900 9421 EXT_DEF_MAC_ADDRESS_SIZE);
8901 9422
8902 9423 if (ddi_copyout((void *)&cna_port,
8903 9424 (void *)(uintptr_t)(cmd->ResponseAdr),
8904 9425 sizeof (EXT_CNA_PORT), mode) != 0) {
8905 9426 cmd->Status = EXT_STATUS_COPY_ERR;
8906 9427 cmd->ResponseLen = 0;
8907 9428 EL(ha, "failed, ddi_copyout\n");
8908 9429 } else {
8909 9430 cmd->ResponseLen = sizeof (EXT_CNA_PORT);
8910 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9431 + QL_PRINT_9(ha, "done\n");
8911 9432 }
8912 9433 }
8913 9434
8914 9435 /*
8915 9436 * ql_qry_adapter_versions
8916 9437 * Performs EXT_SC_QUERY_ADAPTER_VERSIONS subfunction.
8917 9438 *
8918 9439 * Input:
8919 9440 * ha: adapter state pointer.
8920 9441 * cmd: EXT_IOCTL cmd struct pointer.
8921 9442 * mode: flags.
8922 9443 *
8923 9444 * Returns:
8924 9445 * None, request status indicated in cmd->Status.
8925 9446 *
8926 9447 * Context:
|
↓ open down ↓ |
6 lines elided |
↑ open up ↑ |
8927 9448 * Kernel context.
8928 9449 */
8929 9450 static void
8930 9451 ql_qry_adapter_versions(ql_adapter_state_t *ha, EXT_IOCTL *cmd,
8931 9452 int mode)
8932 9453 {
8933 9454 uint8_t is_8142, mpi_cap;
8934 9455 uint32_t ver_len, transfer_size;
8935 9456 PEXT_ADAPTERREGIONVERSION padapter_ver = NULL;
8936 9457
8937 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9458 + QL_PRINT_9(ha, "started\n");
8938 9459
8939 9460 /* 8142s do not have a EDC PHY firmware. */
8940 9461 mpi_cap = (uint8_t)(ha->mpi_capability_list >> 8);
8941 9462
8942 9463 is_8142 = 0;
8943 9464 /* Sizeof (Length + Reserved) = 8 Bytes */
8944 9465 if (mpi_cap == 0x02 || mpi_cap == 0x04) {
8945 9466 ver_len = (sizeof (EXT_REGIONVERSION) * (NO_OF_VERSIONS - 1))
8946 9467 + 8;
8947 9468 is_8142 = 1;
8948 9469 } else {
8949 9470 ver_len = (sizeof (EXT_REGIONVERSION) * NO_OF_VERSIONS) + 8;
8950 9471 }
8951 9472
8952 9473 /* Allocate local memory for EXT_ADAPTERREGIONVERSION */
8953 9474 padapter_ver = (EXT_ADAPTERREGIONVERSION *)kmem_zalloc(ver_len,
8954 9475 KM_SLEEP);
8955 9476
8956 9477 if (padapter_ver == NULL) {
8957 9478 EL(ha, "failed, kmem_zalloc\n");
8958 9479 cmd->Status = EXT_STATUS_NO_MEMORY;
8959 9480 cmd->ResponseLen = 0;
8960 9481 return;
8961 9482 }
8962 9483
8963 9484 padapter_ver->Length = 1;
8964 9485 /* Copy MPI version */
8965 9486 padapter_ver->RegionVersion[0].Region =
8966 9487 EXT_OPT_ROM_REGION_MPI_RISC_FW;
8967 9488 padapter_ver->RegionVersion[0].Version[0] =
8968 9489 ha->mpi_fw_major_version;
8969 9490 padapter_ver->RegionVersion[0].Version[1] =
8970 9491 ha->mpi_fw_minor_version;
8971 9492 padapter_ver->RegionVersion[0].Version[2] =
8972 9493 ha->mpi_fw_subminor_version;
8973 9494 padapter_ver->RegionVersion[0].VersionLength = 3;
8974 9495 padapter_ver->RegionVersion[0].Location = RUNNING_VERSION;
8975 9496
8976 9497 if (!is_8142) {
8977 9498 padapter_ver->RegionVersion[1].Region =
8978 9499 EXT_OPT_ROM_REGION_EDC_PHY_FW;
8979 9500 padapter_ver->RegionVersion[1].Version[0] =
8980 9501 ha->phy_fw_major_version;
8981 9502 padapter_ver->RegionVersion[1].Version[1] =
8982 9503 ha->phy_fw_minor_version;
8983 9504 padapter_ver->RegionVersion[1].Version[2] =
8984 9505 ha->phy_fw_subminor_version;
8985 9506 padapter_ver->RegionVersion[1].VersionLength = 3;
8986 9507 padapter_ver->RegionVersion[1].Location = RUNNING_VERSION;
8987 9508 padapter_ver->Length = NO_OF_VERSIONS;
8988 9509 }
8989 9510
8990 9511 if (cmd->ResponseLen < ver_len) {
8991 9512 EL(ha, "failed, ResponseLen < ver_len, ",
8992 9513 "RespLen=%xh ver_len=%xh\n", cmd->ResponseLen, ver_len);
8993 9514 /* Calculate the No. of valid versions being returned. */
8994 9515 padapter_ver->Length = (uint32_t)
8995 9516 ((cmd->ResponseLen - 8) / sizeof (EXT_REGIONVERSION));
8996 9517 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
8997 9518 cmd->DetailStatus = ver_len;
8998 9519 transfer_size = cmd->ResponseLen;
8999 9520 } else {
9000 9521 transfer_size = ver_len;
|
↓ open down ↓ |
53 lines elided |
↑ open up ↑ |
9001 9522 }
9002 9523
9003 9524 if (ddi_copyout((void *)padapter_ver,
9004 9525 (void *)(uintptr_t)(cmd->ResponseAdr),
9005 9526 transfer_size, mode) != 0) {
9006 9527 cmd->Status = EXT_STATUS_COPY_ERR;
9007 9528 cmd->ResponseLen = 0;
9008 9529 EL(ha, "failed, ddi_copyout\n");
9009 9530 } else {
9010 9531 cmd->ResponseLen = ver_len;
9011 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9532 + QL_PRINT_9(ha, "done\n");
9012 9533 }
9013 9534
9014 9535 kmem_free(padapter_ver, ver_len);
9015 9536 }
9016 9537
9017 9538 /*
9018 9539 * ql_get_xgmac_statistics
9019 9540 * Get XgMac information
9020 9541 *
9021 9542 * Input:
9022 9543 * ha: adapter state pointer.
9023 9544 * cmd: EXT_IOCTL cmd struct pointer.
9024 9545 * mode: flags.
9025 9546 *
9026 9547 * Returns:
9027 9548 * None, request status indicated in cmd->Status.
9028 9549 *
9029 9550 * Context:
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
9030 9551 * Kernel context.
9031 9552 */
9032 9553 static void
9033 9554 ql_get_xgmac_statistics(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
9034 9555 {
9035 9556 int rval;
9036 9557 uint32_t size;
9037 9558 int8_t *tmp_buf;
9038 9559 EXT_MENLO_MANAGE_INFO info;
9039 9560
9040 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9561 + QL_PRINT_9(ha, "started\n");
9041 9562
9042 9563 /* Verify the size of request structure. */
9043 9564 if (cmd->RequestLen < sizeof (EXT_MENLO_MANAGE_INFO)) {
9044 9565 /* Return error */
9045 9566 EL(ha, "RequestLen=%d < %d\n", cmd->RequestLen,
9046 9567 sizeof (EXT_MENLO_MANAGE_INFO));
9047 9568 cmd->Status = EXT_STATUS_INVALID_PARAM;
9048 9569 cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
9049 9570 cmd->ResponseLen = 0;
9050 9571 return;
9051 9572 }
9052 9573
9053 9574 /* Get manage info request. */
9054 9575 if (ddi_copyin((caddr_t)(uintptr_t)cmd->RequestAdr,
9055 9576 (caddr_t)&info, sizeof (EXT_MENLO_MANAGE_INFO), mode) != 0) {
9056 9577 EL(ha, "failed, ddi_copyin\n");
9057 9578 cmd->Status = EXT_STATUS_COPY_ERR;
9058 9579 cmd->ResponseLen = 0;
9059 9580 return;
9060 9581 }
9061 9582
9062 9583 size = info.TotalByteCount;
9063 9584 if (!size) {
9064 9585 /* parameter error */
9065 9586 cmd->Status = EXT_STATUS_INVALID_PARAM;
9066 9587 cmd->DetailStatus = 0;
9067 9588 EL(ha, "failed, size=%xh\n", size);
9068 9589 cmd->ResponseLen = 0;
9069 9590 return;
9070 9591 }
9071 9592
9072 9593 /* Allocate memory for command. */
9073 9594 tmp_buf = kmem_zalloc(size, KM_SLEEP);
9074 9595 if (tmp_buf == NULL) {
9075 9596 EL(ha, "failed, kmem_zalloc\n");
9076 9597 cmd->Status = EXT_STATUS_NO_MEMORY;
9077 9598 cmd->ResponseLen = 0;
9078 9599 return;
9079 9600 }
9080 9601
9081 9602 if (!(info.Operation & MENLO_OP_GET_INFO)) {
9082 9603 EL(ha, "Invalid request for 81XX\n");
9083 9604 kmem_free(tmp_buf, size);
9084 9605 cmd->Status = EXT_STATUS_ERR;
9085 9606 cmd->ResponseLen = 0;
9086 9607 return;
9087 9608 }
9088 9609
9089 9610 rval = ql_get_xgmac_stats(ha, size, (caddr_t)tmp_buf);
9090 9611
9091 9612 if (rval != QL_SUCCESS) {
9092 9613 /* error */
9093 9614 EL(ha, "failed, get_xgmac_stats =%xh\n", rval);
9094 9615 kmem_free(tmp_buf, size);
9095 9616 cmd->Status = EXT_STATUS_ERR;
9096 9617 cmd->ResponseLen = 0;
|
↓ open down ↓ |
46 lines elided |
↑ open up ↑ |
9097 9618 return;
9098 9619 }
9099 9620
9100 9621 if (ql_send_buffer_data(tmp_buf, (caddr_t)(uintptr_t)info.pDataBytes,
9101 9622 size, mode) != size) {
9102 9623 EL(ha, "failed, ddi_copyout\n");
9103 9624 cmd->Status = EXT_STATUS_COPY_ERR;
9104 9625 cmd->ResponseLen = 0;
9105 9626 } else {
9106 9627 cmd->ResponseLen = info.TotalByteCount;
9107 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9628 + QL_PRINT_9(ha, "done\n");
9108 9629 }
9109 9630 kmem_free(tmp_buf, size);
9110 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9631 + QL_PRINT_9(ha, "done\n");
9111 9632 }
9112 9633
9113 9634 /*
9114 9635 * ql_get_fcf_list
9115 9636 * Get FCF list.
9116 9637 *
9117 9638 * Input:
9118 9639 * ha: adapter state pointer.
9119 9640 * cmd: User space CT arguments pointer.
9120 9641 * mode: flags.
9121 9642 */
9122 9643 static void
9123 9644 ql_get_fcf_list(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
9124 9645 {
9125 9646 uint8_t *tmp_buf;
9126 9647 int rval;
9127 9648 EXT_FCF_LIST fcf_list = {0};
9128 9649 ql_fcf_list_desc_t mb_fcf_list = {0};
9129 9650
9130 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9651 + QL_PRINT_9(ha, "started\n");
9131 9652
9132 - if (!(CFG_IST(ha, CFG_CTRL_81XX))) {
9653 + if (!(CFG_IST(ha, CFG_FCOE_SUPPORT))) {
9133 9654 EL(ha, "invalid request for HBA\n");
9134 9655 cmd->Status = EXT_STATUS_INVALID_REQUEST;
9135 9656 cmd->ResponseLen = 0;
9136 9657 return;
9137 9658 }
9138 9659 /* Get manage info request. */
9139 9660 if (ddi_copyin((caddr_t)(uintptr_t)cmd->RequestAdr,
9140 9661 (caddr_t)&fcf_list, sizeof (EXT_FCF_LIST), mode) != 0) {
9141 9662 EL(ha, "failed, ddi_copyin\n");
9142 9663 cmd->Status = EXT_STATUS_COPY_ERR;
9143 9664 cmd->ResponseLen = 0;
9144 9665 return;
9145 9666 }
9146 9667
9147 9668 if (!(fcf_list.BufSize)) {
9148 9669 /* Return error */
9149 9670 EL(ha, "failed, fcf_list BufSize is=%xh\n",
9150 9671 fcf_list.BufSize);
9151 9672 cmd->Status = EXT_STATUS_INVALID_PARAM;
9152 9673 cmd->ResponseLen = 0;
9153 9674 return;
9154 9675 }
9155 9676 /* Allocate memory for command. */
9156 9677 tmp_buf = kmem_zalloc(fcf_list.BufSize, KM_SLEEP);
9157 9678 if (tmp_buf == NULL) {
9158 9679 EL(ha, "failed, kmem_zalloc\n");
9159 9680 cmd->Status = EXT_STATUS_NO_MEMORY;
9160 9681 cmd->ResponseLen = 0;
9161 9682 return;
9162 9683 }
9163 9684 /* build the descriptor */
9164 9685 if (fcf_list.Options) {
9165 9686 mb_fcf_list.options = FCF_LIST_RETURN_ONE;
9166 9687 } else {
9167 9688 mb_fcf_list.options = FCF_LIST_RETURN_ALL;
9168 9689 }
9169 9690 mb_fcf_list.fcf_index = (uint16_t)fcf_list.FcfIndex;
9170 9691 mb_fcf_list.buffer_size = fcf_list.BufSize;
9171 9692
9172 9693 /* Send command */
9173 9694 rval = ql_get_fcf_list_mbx(ha, &mb_fcf_list, (caddr_t)tmp_buf);
9174 9695 if (rval != QL_SUCCESS) {
9175 9696 /* error */
9176 9697 EL(ha, "failed, get_fcf_list_mbx=%xh\n", rval);
9177 9698 kmem_free(tmp_buf, fcf_list.BufSize);
9178 9699 cmd->Status = EXT_STATUS_ERR;
9179 9700 cmd->ResponseLen = 0;
9180 9701 return;
9181 9702 }
|
↓ open down ↓ |
39 lines elided |
↑ open up ↑ |
9182 9703
9183 9704 /* Copy the response */
9184 9705 if (ql_send_buffer_data((caddr_t)tmp_buf,
9185 9706 (caddr_t)(uintptr_t)cmd->ResponseAdr,
9186 9707 fcf_list.BufSize, mode) != fcf_list.BufSize) {
9187 9708 EL(ha, "failed, ddi_copyout\n");
9188 9709 cmd->Status = EXT_STATUS_COPY_ERR;
9189 9710 cmd->ResponseLen = 0;
9190 9711 } else {
9191 9712 cmd->ResponseLen = mb_fcf_list.buffer_size;
9192 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9713 + QL_PRINT_9(ha, "done\n");
9193 9714 }
9194 9715
9195 9716 kmem_free(tmp_buf, fcf_list.BufSize);
9196 9717 }
9197 9718
9198 9719 /*
9199 9720 * ql_get_resource_counts
9200 9721 * Get Resource counts:
9201 9722 *
9202 9723 * Input:
9203 9724 * ha: adapter state pointer.
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
9204 9725 * cmd: User space CT arguments pointer.
9205 9726 * mode: flags.
9206 9727 */
9207 9728 static void
9208 9729 ql_get_resource_counts(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
9209 9730 {
9210 9731 int rval;
9211 9732 ql_mbx_data_t mr;
9212 9733 EXT_RESOURCE_CNTS tmp_rc_cnt = {0};
9213 9734
9214 - QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
9735 + QL_PRINT_9(ha, "started\n");
9215 9736
9216 - if (!(CFG_IST(ha, CFG_CTRL_242581))) {
9217 - EL(ha, "invalid request for HBA\n");
9218 - cmd->Status = EXT_STATUS_INVALID_REQUEST;
9219 - cmd->ResponseLen = 0;
9220 - return;
9221 - }
9222 -
9223 9737 if (cmd->ResponseLen < sizeof (EXT_RESOURCE_CNTS)) {
9224 9738 cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
9225 9739 cmd->DetailStatus = sizeof (EXT_RESOURCE_CNTS);
9226 9740 EL(ha, "failed, ResponseLen < EXT_RESOURCE_CNTS, "
9227 9741 "Len=%xh\n", cmd->ResponseLen);
9228 9742 cmd->ResponseLen = 0;
9229 9743 return;
9230 9744 }
9231 9745
9232 9746 rval = ql_get_resource_cnts(ha, &mr);
9233 9747 if (rval != QL_SUCCESS) {
9234 9748 EL(ha, "resource cnt mbx failed\n");
9235 9749 cmd->Status = EXT_STATUS_ERR;
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
9236 9750 cmd->ResponseLen = 0;
9237 9751 return;
9238 9752 }
9239 9753
9240 9754 tmp_rc_cnt.OrgTgtXchgCtrlCnt = (uint32_t)mr.mb[1];
9241 9755 tmp_rc_cnt.CurTgtXchgCtrlCnt = (uint32_t)mr.mb[2];
9242 9756 tmp_rc_cnt.CurXchgCtrlCnt = (uint32_t)mr.mb[3];
9243 9757 tmp_rc_cnt.OrgXchgCtrlCnt = (uint32_t)mr.mb[6];
9244 9758 tmp_rc_cnt.CurIocbBufCnt = (uint32_t)mr.mb[7];
9245 9759 tmp_rc_cnt.OrgIocbBufCnt = (uint32_t)mr.mb[10];
9246 - tmp_rc_cnt.NoOfSupVPs = (uint32_t)mr.mb[11];
9247 - tmp_rc_cnt.NoOfSupFCFs = (uint32_t)mr.mb[12];
9760 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
9761 + tmp_rc_cnt.NoOfSupVPs = (uint32_t)mr.mb[11];
9762 + }
9763 + if (CFG_IST(ha, CFG_FCOE_SUPPORT)) {
9764 + tmp_rc_cnt.NoOfSupFCFs = (uint32_t)mr.mb[12];
9765 + }
9248 9766
9249 9767 rval = ddi_copyout((void *)&tmp_rc_cnt,
9250 9768 (void *)(uintptr_t)(cmd->ResponseAdr),
9251 9769 sizeof (EXT_RESOURCE_CNTS), mode);
9252 9770 if (rval != 0) {
9253 9771 cmd->Status = EXT_STATUS_COPY_ERR;
9254 9772 cmd->ResponseLen = 0;
9255 9773 EL(ha, "failed, ddi_copyout\n");
9256 9774 } else {
9257 9775 cmd->ResponseLen = sizeof (EXT_RESOURCE_CNTS);
9258 - QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
9776 + QL_PRINT_9(ha, "done\n");
9259 9777 }
9778 +}
9779 +
9780 +/*
9781 + * ql_get_temperature
9782 + * Get ASIC temperature data
9783 + *
9784 + * Input:
9785 + * ha: adapter state pointer.
9786 + * cmd: EXT_IOCTL cmd struct pointer.
9787 + * mode: flags
9788 + *
9789 + * Returns:
9790 + * None, request status indicated in cmd->Status.
9791 + *
9792 + * Context:
9793 + * Kernel context.
9794 + */
9795 +static void
9796 +ql_get_temperature(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
9797 +{
9798 + ql_mbx_data_t mr;
9799 + int rval = 0;
9800 + EXT_BOARD_TEMP board_temp = {0};
9801 +
9802 + QL_PRINT_9(ha, "started\n");
9803 +
9804 + if (!(ha->fw_ext_attributes & TEMP_SUPPORT_ISP)) {
9805 + EL(ha, "invalid request for HBA\n");
9806 + cmd->Status = EXT_STATUS_INVALID_REQUEST;
9807 + cmd->ResponseLen = 0;
9808 + return;
9809 + }
9810 +
9811 + if (cmd->ResponseLen < sizeof (EXT_BOARD_TEMP)) {
9812 + cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
9813 + cmd->DetailStatus = sizeof (EXT_BOARD_TEMP);
9814 + EL(ha, "failed, ResponseLen < EXT_BOARD_TEMP, "
9815 + "Len=%xh \n", cmd->ResponseLen);
9816 + cmd->ResponseLen = 0;
9817 + return;
9818 + }
9819 +
9820 + switch (cmd->SubCode) {
9821 + case EXT_SC_GET_BOARD_TEMP:
9822 + rval = ql_get_temp(ha, &mr);
9823 + if (rval != QL_SUCCESS) {
9824 + /* error */
9825 + EL(ha, "failed, get_temperature_mbx=%xh\n", rval);
9826 + cmd->Status = EXT_STATUS_ERR;
9827 + cmd->ResponseLen = 0;
9828 + break;
9829 + }
9830 + board_temp.IntTemp = mr.mb[1];
9831 +
9832 + rval = ddi_copyout((void *)&board_temp,
9833 + (void *)(uintptr_t)(cmd->ResponseAdr),
9834 + sizeof (EXT_BOARD_TEMP), mode);
9835 + if (rval != 0) {
9836 + cmd->Status = EXT_STATUS_COPY_ERR;
9837 + cmd->ResponseLen = 0;
9838 + EL(ha, "failed, ddi_copyout\n");
9839 + } else {
9840 + cmd->ResponseLen = sizeof (EXT_BOARD_TEMP);
9841 + }
9842 + break;
9843 + default:
9844 + EL(ha, "unknown subcode=%xh\n", cmd->SubCode);
9845 + cmd->Status = EXT_STATUS_ERR;
9846 + cmd->ResponseLen = 0;
9847 + break;
9848 + }
9849 +
9850 + QL_PRINT_9(ha, "done\n");
9851 +}
9852 +
9853 +/*
9854 + * ql_dump_cmd
9855 + * Performs all EXT_CC_DUMP_OS functions.
9856 + *
9857 + * Input:
9858 + * ha: adapter state pointer.
9859 + * cmd: Local EXT_IOCTL cmd struct pointer.
9860 + *
9861 + * Returns:
9862 + * None, request status indicated in cmd->Status.
9863 + *
9864 + * Context:
9865 + * Kernel context.
9866 + */
9867 +static void
9868 +ql_dump_cmd(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
9869 +{
9870 + caddr_t dump;
9871 + uint32_t sdm_valid_dump = 0;
9872 + int rval = 0;
9873 +
9874 + QL_PRINT_9(ha, "started\n");
9875 +
9876 + if (ha->ql_dump_state & QL_DUMP_VALID &&
9877 + !(ha->ql_dump_state & QL_DUMP_UPLOADED) &&
9878 + ha->ql_dump_state != NULL) {
9879 + sdm_valid_dump = 1;
9880 + } else {
9881 + EL(ha, "dump does not exist for instance %d (%x, %p)\n",
9882 + ha->instance, ha->ql_dump_state, ha->ql_dump_ptr);
9883 + }
9884 +
9885 + cmd->Status = EXT_STATUS_OK;
9886 + cmd->DetailStatus = 0;
9887 +
9888 + switch (cmd->SubCode) {
9889 + case EXT_SC_DUMP_SIZE:
9890 + cmd->ResponseLen = 0;
9891 + if (sdm_valid_dump) {
9892 + cmd->DetailStatus = ha->risc_dump_size;
9893 + }
9894 + break;
9895 + case EXT_SC_DUMP_READ:
9896 + if (!sdm_valid_dump) {
9897 + cmd->Status = EXT_STATUS_INVALID_REQUEST;
9898 + cmd->ResponseLen = 0;
9899 + break;
9900 + }
9901 +
9902 + if (cmd->ResponseLen < ha->risc_dump_size) {
9903 + cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
9904 + cmd->DetailStatus = ha->risc_dump_size;
9905 + EL(ha, "failed, ResponseLen < %x, "
9906 + "Len=%xh\n", ha->risc_dump_size,
9907 + cmd->ResponseLen);
9908 + break;
9909 + }
9910 +
9911 + ADAPTER_STATE_LOCK(ha);
9912 + ha->flags |= DISABLE_NIC_FW_DMP;
9913 + ADAPTER_STATE_UNLOCK(ha);
9914 +
9915 + QL_DUMP_LOCK(ha);
9916 +
9917 + dump = kmem_zalloc(ha->risc_dump_size, KM_SLEEP);
9918 + cmd->ResponseLen = (uint32_t)ql_ascii_fw_dump(ha, dump);
9919 +
9920 + if ((rval = ddi_copyout((void *)dump,
9921 + (void *)(uintptr_t)(cmd->ResponseAdr), cmd->ResponseLen,
9922 + mode)) != 0) {
9923 + ha->ql_dump_state &= ~QL_DUMP_UPLOADED;
9924 + EL(ha, "failed, ddi_copyout\n");
9925 + cmd->Status = EXT_STATUS_COPY_ERR;
9926 + cmd->ResponseLen = 0;
9927 + } else {
9928 + ha->ql_dump_state |= QL_DUMP_UPLOADED;
9929 + }
9930 +
9931 + kmem_free(dump, ha->risc_dump_size);
9932 +
9933 + QL_DUMP_UNLOCK(ha);
9934 +
9935 + ADAPTER_STATE_LOCK(ha);
9936 + ha->flags &= ~DISABLE_NIC_FW_DMP;
9937 + ADAPTER_STATE_UNLOCK(ha);
9938 + break;
9939 + case EXT_SC_DUMP_TRIGGER:
9940 + cmd->ResponseLen = 0;
9941 +
9942 + ADAPTER_STATE_LOCK(ha);
9943 + ha->flags |= DISABLE_NIC_FW_DMP;
9944 + ADAPTER_STATE_UNLOCK(ha);
9945 +
9946 + if (sdm_valid_dump) {
9947 + cmd->Status = EXT_STATUS_INVALID_REQUEST;
9948 + EL(ha, "Existing dump file needs to be retrieved.\n");
9949 + } else {
9950 + rval = ql_dump_firmware(ha);
9951 +
9952 + if (rval != QL_SUCCESS && rval != QL_DATA_EXISTS) {
9953 + cmd->Status = EXT_STATUS_ERR;
9954 + }
9955 + }
9956 +
9957 + ADAPTER_STATE_LOCK(ha);
9958 + ha->flags &= ~DISABLE_NIC_FW_DMP;
9959 + ADAPTER_STATE_UNLOCK(ha);
9960 + break;
9961 + default:
9962 + EL(ha, "unknown subcode=%xh\n", cmd->SubCode);
9963 + cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
9964 + cmd->ResponseLen = 0;
9965 + break;
9966 + }
9967 +
9968 + QL_PRINT_9(ha, "done\n");
9969 +}
9970 +
9971 +/*
9972 + * ql_serdes_reg
9973 + * Performs all EXT_CC_SERDES_REG_OP functions.
9974 + *
9975 + * Input:
9976 + * ha: adapter state pointer.
9977 + * cmd: EXT_IOCTL cmd struct pointer.
9978 + * mode: flags
9979 + *
9980 + * Returns:
9981 + * None, request status indicated in cmd->Status.
9982 + *
9983 + * Context:
9984 + * Kernel context.
9985 + */
9986 +static void
9987 +ql_serdes_reg(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
9988 +{
9989 + ql_mbx_data_t mr = {0};
9990 + int rval = 0;
9991 + EXT_SERDES_REG serdes_reg = {0};
9992 +
9993 + QL_PRINT_9(ha, "started\n");
9994 +
9995 + /* Check if request valid for HBA */
9996 + if (!(CFG_IST(ha, CFG_SERDES_SUPPORT))) {
9997 + EL(ha, "invalid request for HBA\n");
9998 + cmd->Status = EXT_STATUS_INVALID_REQUEST;
9999 + cmd->ResponseLen = 0;
10000 + return;
10001 + }
10002 +
10003 + /* Copy in the request structure. */
10004 + if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
10005 + (void *)&serdes_reg, sizeof (EXT_SERDES_REG), mode) != 0) {
10006 + EL(ha, "failed, ddi_copyin\n");
10007 + cmd->Status = EXT_STATUS_COPY_ERR;
10008 + cmd->ResponseLen = 0;
10009 + return;
10010 + }
10011 +
10012 + switch (cmd->SubCode) {
10013 + case EXT_SC_WRITE_SERDES_REG:
10014 + mr.mb[1] = serdes_reg.addr;
10015 + mr.mb[2] = LSB(serdes_reg.val);
10016 + mr.mb[3] = 0;
10017 + mr.mb[4] = MSB(serdes_reg.val);
10018 + if ((rval = ql_write_serdes(ha, &mr)) != QL_SUCCESS) {
10019 + /* error */
10020 + EL(ha, "failed, write_serdes_mbx=%xh\n", rval);
10021 + cmd->Status = EXT_STATUS_ERR;
10022 + cmd->ResponseLen = 0;
10023 + break;
10024 + } else {
10025 + cmd->Status = EXT_STATUS_OK;
10026 + }
10027 + break;
10028 + case EXT_SC_READ_SERDES_REG:
10029 + /* Verify the size of response structure. */
10030 + if (cmd->ResponseLen < sizeof (EXT_SERDES_REG)) {
10031 + cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
10032 + cmd->DetailStatus = sizeof (EXT_SERDES_REG);
10033 + EL(ha, "failed, ResponseLen < EXT_SERDES_REG, "
10034 + "Len=%xh \n", cmd->ResponseLen);
10035 + cmd->ResponseLen = 0;
10036 + break;
10037 + }
10038 + mr.mb[1] = serdes_reg.addr;
10039 + if ((rval = ql_read_serdes(ha, &mr)) != QL_SUCCESS) {
10040 + /* error */
10041 + EL(ha, "failed, read_serdes_mbx=%xh\n", rval);
10042 + cmd->Status = EXT_STATUS_ERR;
10043 + cmd->ResponseLen = 0;
10044 + break;
10045 + }
10046 + serdes_reg.val = CHAR_TO_SHORT(LSB(mr.mb[1]), LSB(mr.mb[2]));
10047 + /* Copy back the response data */
10048 + if (ddi_copyout((void *)&serdes_reg,
10049 + (void *)(uintptr_t)(cmd->ResponseAdr),
10050 + sizeof (EXT_SERDES_REG), mode) != 0) {
10051 + cmd->Status = EXT_STATUS_COPY_ERR;
10052 + cmd->ResponseLen = 0;
10053 + EL(ha, "failed, ddi_copyout\n");
10054 + } else {
10055 + cmd->Status = EXT_STATUS_OK;
10056 + cmd->ResponseLen = sizeof (EXT_SERDES_REG);
10057 + }
10058 + break;
10059 + default:
10060 + /* Subcode not supported. */
10061 + EL(ha, "unknown subcode=%xh\n", cmd->SubCode);
10062 + cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
10063 + cmd->ResponseLen = 0;
10064 + break;
10065 + }
10066 +
10067 + QL_PRINT_9(ha, "done\n");
10068 +}
10069 +
10070 +/*
10071 + * ql_serdes_reg_ex
10072 + * Performs all EXT_CC_SERDES_REG_OP_EX functions.
10073 + *
10074 + * Input:
10075 + * ha: adapter state pointer.
10076 + * cmd: EXT_IOCTL cmd struct pointer.
10077 + * mode: flags
10078 + *
10079 + * Returns:
10080 + * None, request status indicated in cmd->Status.
10081 + *
10082 + * Context:
10083 + * Kernel context.
10084 + */
10085 +static void
10086 +ql_serdes_reg_ex(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
10087 +{
10088 + ql_mbx_data_t mr = {0};
10089 + int rval = 0;
10090 + EXT_SERDES_REG_EX serdes_reg_ex = {0};
10091 +
10092 + QL_PRINT_9(ha, "started\n");
10093 +
10094 + /* Check if request valid for HBA */
10095 + if (!(CFG_IST(ha, CFG_SERDES_SUPPORT))) {
10096 + EL(ha, "invalid request for HBA\n");
10097 + cmd->Status = EXT_STATUS_INVALID_REQUEST;
10098 + cmd->ResponseLen = 0;
10099 + return;
10100 + }
10101 +
10102 + /* Copy in the request structure. */
10103 + if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
10104 + (void *)&serdes_reg_ex, sizeof (EXT_SERDES_REG_EX), mode) != 0) {
10105 + EL(ha, "failed, ddi_copyin\n");
10106 + cmd->Status = EXT_STATUS_COPY_ERR;
10107 + cmd->ResponseLen = 0;
10108 + return;
10109 + }
10110 +
10111 + switch (cmd->SubCode) {
10112 + case EXT_SC_WRITE_SERDES_REG:
10113 + mr.mb[3] = LSW(serdes_reg_ex.addr);
10114 + mr.mb[4] = MSW(serdes_reg_ex.addr);
10115 + mr.mb[5] = LSW(serdes_reg_ex.val);
10116 + mr.mb[6] = MSW(serdes_reg_ex.val);
10117 + if ((rval = ql_write_serdes(ha, &mr)) != QL_SUCCESS) {
10118 + /* error */
10119 + EL(ha, "failed, write_serdes_mbx=%xh\n", rval);
10120 + cmd->Status = EXT_STATUS_ERR;
10121 + cmd->ResponseLen = 0;
10122 + break;
10123 + } else {
10124 + cmd->Status = EXT_STATUS_OK;
10125 + }
10126 + break;
10127 + case EXT_SC_READ_SERDES_REG:
10128 + /* Verify the size of response structure. */
10129 + if (cmd->ResponseLen < sizeof (EXT_SERDES_REG_EX)) {
10130 + cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
10131 + cmd->DetailStatus = sizeof (EXT_SERDES_REG_EX);
10132 + EL(ha, "failed, ResponseLen < EXT_SERDES_REG_EX, "
10133 + "Len=%xh\n", cmd->ResponseLen);
10134 + cmd->ResponseLen = 0;
10135 + break;
10136 + }
10137 + mr.mb[3] = LSW(serdes_reg_ex.addr);
10138 + mr.mb[4] = MSW(serdes_reg_ex.addr);
10139 + if ((rval = ql_read_serdes(ha, &mr)) != QL_SUCCESS) {
10140 + /* error */
10141 + EL(ha, "failed, read_serdes_mbx=%xh\n", rval);
10142 + cmd->Status = EXT_STATUS_ERR;
10143 + cmd->ResponseLen = 0;
10144 + break;
10145 + }
10146 + serdes_reg_ex.val = SHORT_TO_LONG(mr.mb[1], mr.mb[2]);
10147 + /* Copy back the response data */
10148 + if (ddi_copyout((void *)&serdes_reg_ex,
10149 + (void *)(uintptr_t)(cmd->ResponseAdr),
10150 + sizeof (EXT_SERDES_REG_EX), mode) != 0) {
10151 + cmd->Status = EXT_STATUS_COPY_ERR;
10152 + cmd->ResponseLen = 0;
10153 + EL(ha, "failed, ddi_copyout\n");
10154 + } else {
10155 + cmd->Status = EXT_STATUS_OK;
10156 + cmd->ResponseLen = sizeof (EXT_SERDES_REG_EX);
10157 + }
10158 + break;
10159 + default:
10160 + /* Subcode not supported. */
10161 + EL(ha, "unknown subcode=%xh\n", cmd->SubCode);
10162 + cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
10163 + cmd->ResponseLen = 0;
10164 + break;
10165 + }
10166 +
10167 + QL_PRINT_9(ha, "done\n");
10168 +}
10169 +
10170 +/*
10171 + * ql_els_passthru
10172 + * IOCTL for extended link service passthru command.
10173 + *
10174 + * Input:
10175 + * ha: adapter state pointer.
10176 + * cmd: User space CT arguments pointer.
10177 + * mode: flags.
10178 + *
10179 + * Returns:
10180 + * None, request status indicated in cmd->Status.
10181 + *
10182 + * Context:
10183 + * Kernel context.
10184 + */
10185 +static void
10186 +ql_els_passthru(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
10187 +{
10188 + ql_mbx_iocb_t *pkt;
10189 + dma_mem_t *dma_mem;
10190 + caddr_t bp, pld;
10191 + uint32_t pkt_size, pld_byte_cnt, cmd_size, *long_ptr;
10192 + EXT_ELS_PT_REQ *pt_req;
10193 + boolean_t local_hba = B_FALSE;
10194 + ql_tgt_t *tq = NULL;
10195 + port_id_t tmp_fcid;
10196 + int rval;
10197 + uint16_t comp_status;
10198 +
10199 + QL_PRINT_9(ha, "started\n");
10200 +
10201 + if (DRIVER_SUSPENDED(ha)) {
10202 + EL(ha, "failed, LOOP_NOT_READY\n");
10203 + cmd->Status = EXT_STATUS_BUSY;
10204 + cmd->ResponseLen = 0;
10205 + return;
10206 + }
10207 +
10208 + if (cmd->RequestLen < sizeof (EXT_ELS_PT_REQ)) {
10209 + /* parameter error */
10210 + EL(ha, "failed, RequestLen < EXT_ELS_PT_REQ, Len=%xh\n",
10211 + cmd->RequestLen);
10212 + cmd->Status = EXT_STATUS_INVALID_PARAM;
10213 + cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
10214 + cmd->ResponseLen = 0;
10215 + return;
10216 + }
10217 +
10218 + /* Allocate memory for command. */
10219 + bp = kmem_zalloc(cmd->RequestLen, KM_SLEEP);
10220 +
10221 + if (ddi_copyin((void*)(uintptr_t)cmd->RequestAdr,
10222 + bp, cmd->RequestLen, mode) != 0) {
10223 + EL(ha, "failed, ddi_copyin\n");
10224 + kmem_free(bp, cmd->RequestLen);
10225 + cmd->Status = EXT_STATUS_COPY_ERR;
10226 + cmd->ResponseLen = 0;
10227 + return;
10228 + }
10229 + pt_req = (EXT_ELS_PT_REQ *)bp;
10230 +
10231 + QL_PRINT_9(ha, "EXT_ELS_PT_REQ\n");
10232 + QL_DUMP_9((uint8_t *)pt_req, 8, sizeof (EXT_ELS_PT_REQ));
10233 +
10234 + /* Find loop ID of the device */
10235 + if (pt_req->ValidMask & EXT_DEF_WWPN_VALID) {
10236 + if (bcmp(ha->loginparams.nport_ww_name.raw_wwn, pt_req->WWPN,
10237 + EXT_DEF_WWN_NAME_SIZE) == 0) {
10238 + local_hba = B_TRUE;
10239 + } else {
10240 + tq = ql_find_port(ha, pt_req->WWPN, QLNT_PORT);
10241 + }
10242 + } else if (pt_req->ValidMask & EXT_DEF_PID_VALID) {
10243 + /*
10244 + * Copy caller's d_id to tmp space.
10245 + */
10246 + bcopy(&pt_req->Id[1], tmp_fcid.r.d_id,
10247 + EXT_DEF_PORTID_SIZE_ACTUAL);
10248 + BIG_ENDIAN_24(&tmp_fcid.r.d_id[0]);
10249 +
10250 + if (bcmp((void *)&ha->d_id, (void *)tmp_fcid.r.d_id,
10251 + EXT_DEF_PORTID_SIZE_ACTUAL) == 0) {
10252 + local_hba = B_TRUE;
10253 + } else {
10254 + tq = ql_find_port(ha, (uint8_t *)tmp_fcid.r.d_id,
10255 + QLNT_PID);
10256 + }
10257 + } else if (pt_req->ValidMask & EXT_DEF_WWNN_VALID) {
10258 + if (bcmp(ha->loginparams.node_ww_name.raw_wwn, pt_req->WWNN,
10259 + EXT_DEF_WWN_NAME_SIZE) == 0) {
10260 + local_hba = B_TRUE;
10261 + } else {
10262 + tq = ql_find_port(ha, pt_req->WWNN, QLNT_NODE);
10263 + }
10264 + }
10265 +
10266 + if (local_hba == B_TRUE) {
10267 + EL(ha, "failed, els to adapter\n");
10268 + kmem_free(bp, cmd->RequestLen);
10269 + cmd->Status = EXT_STATUS_ERR;
10270 + cmd->ResponseLen = 0;
10271 + return;
10272 + }
10273 +
10274 + if (tq == NULL) {
10275 + /* no matching device */
10276 + EL(ha, "failed, device not found\n");
10277 + kmem_free(bp, cmd->RequestLen);
10278 + cmd->Status = EXT_STATUS_DEV_NOT_FOUND;
10279 + cmd->DetailStatus = EXT_DSTATUS_TARGET;
10280 + cmd->ResponseLen = 0;
10281 + return;
10282 + }
10283 +
10284 + /* Allocate a DMA Memory Descriptor */
10285 + dma_mem = (dma_mem_t *)kmem_zalloc(sizeof (dma_mem_t), KM_SLEEP);
10286 + if (dma_mem == NULL) {
10287 + EL(ha, "failed, kmem_zalloc\n");
10288 + kmem_free(bp, cmd->RequestLen);
10289 + cmd->Status = EXT_STATUS_NO_MEMORY;
10290 + cmd->ResponseLen = 0;
10291 + return;
10292 + }
10293 + /* Determine maximum buffer size. */
10294 + cmd_size = cmd->RequestLen - sizeof (EXT_ELS_PT_REQ);
10295 + pld_byte_cnt = cmd_size < cmd->ResponseLen ? cmd->ResponseLen :
10296 + cmd_size;
10297 + pld = (caddr_t)(bp + sizeof (EXT_ELS_PT_REQ));
10298 +
10299 + /* Allocate command block. */
10300 + pkt_size = (uint32_t)(sizeof (ql_mbx_iocb_t));
10301 + pkt = kmem_zalloc(pkt_size, KM_SLEEP);
10302 + if (pkt == NULL) {
10303 + EL(ha, "failed, kmem_zalloc\n");
10304 + kmem_free(dma_mem, sizeof (dma_mem_t));
10305 + kmem_free(bp, cmd->RequestLen);
10306 + cmd->Status = EXT_STATUS_NO_MEMORY;
10307 + cmd->ResponseLen = 0;
10308 + return;
10309 + }
10310 +
10311 + /* Get DMA memory for the payload */
10312 + if (ql_get_dma_mem(ha, dma_mem, pld_byte_cnt, LITTLE_ENDIAN_DMA,
10313 + QL_DMA_RING_ALIGN) != QL_SUCCESS) {
10314 + cmn_err(CE_WARN, "%sDMA memory alloc failed", QL_NAME);
10315 + kmem_free(pkt, pkt_size);
10316 + kmem_free(dma_mem, sizeof (dma_mem_t));
10317 + kmem_free(bp, cmd->RequestLen);
10318 + cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
10319 + cmd->ResponseLen = 0;
10320 + return;
10321 + }
10322 +
10323 + /* Copy out going payload data to IOCB DMA buffer. */
10324 + ddi_rep_put8(dma_mem->acc_handle, (uint8_t *)pld,
10325 + (uint8_t *)dma_mem->bp, cmd_size, DDI_DEV_AUTOINCR);
10326 +
10327 + /* Sync IOCB DMA buffer. */
10328 + (void) ddi_dma_sync(dma_mem->dma_handle, 0, cmd_size,
10329 + DDI_DMA_SYNC_FORDEV);
10330 +
10331 + /*
10332 + * Setup IOCB
10333 + */
10334 + if (CFG_IST(ha, CFG_ISP_FW_TYPE_2)) {
10335 + pkt->els.entry_type = ELS_PASSTHRU_TYPE;
10336 + pkt->els.entry_count = 1;
10337 +
10338 + /* Set loop ID */
10339 + pkt->els.n_port_hdl = tq->loop_id;
10340 +
10341 + /* Set cmd/response data segment counts. */
10342 + pkt->els.xmt_dseg_count = LE_16(1);
10343 + pkt->els.vp_index = ha->vp_index;
10344 + pkt->els.rcv_dseg_count = LE_16(1);
10345 +
10346 + pkt->els.els_cmd_opcode = pld[0];
10347 +
10348 + pkt->els.d_id_7_0 = tq->d_id.b.al_pa;
10349 + pkt->els.d_id_15_8 = tq->d_id.b.area;
10350 + pkt->els.d_id_23_16 = tq->d_id.b.domain;
10351 +
10352 + pkt->els.s_id_7_0 = ha->d_id.b.al_pa;
10353 + pkt->els.s_id_15_8 = ha->d_id.b.area;
10354 + pkt->els.s_id_23_16 = ha->d_id.b.domain;
10355 +
10356 + /* Load rsp byte count. */
10357 + pkt->els.rcv_payld_data_bcnt = LE_32(cmd->ResponseLen);
10358 +
10359 + /* Load cmd byte count. */
10360 + pkt->els.xmt_payld_data_bcnt = LE_32(cmd_size);
10361 +
10362 + long_ptr = (uint32_t *)&pkt->els.dseg;
10363 +
10364 + /* Load MS command entry data segments. */
10365 + *long_ptr++ = (uint32_t)
10366 + LE_32(LSD(dma_mem->cookie.dmac_laddress));
10367 + *long_ptr++ = (uint32_t)
10368 + LE_32(MSD(dma_mem->cookie.dmac_laddress));
10369 + *long_ptr++ = LE_32(cmd_size);
10370 +
10371 + /* Load MS response entry data segments. */
10372 + *long_ptr++ = (uint32_t)
10373 + LE_32(LSD(dma_mem->cookie.dmac_laddress));
10374 + *long_ptr++ = (uint32_t)
10375 + LE_32(MSD(dma_mem->cookie.dmac_laddress));
10376 + *long_ptr = LE_32(cmd->ResponseLen);
10377 +
10378 + rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt,
10379 + sizeof (ql_mbx_iocb_t));
10380 +
10381 + comp_status = (uint16_t)LE_16(pkt->sts24.comp_status);
10382 + if (rval == QL_SUCCESS && comp_status == CS_DATA_UNDERRUN) {
10383 + comp_status = CS_COMPLETE;
10384 + }
10385 + if (rval != QL_SUCCESS ||
10386 + (pkt->sts24.entry_status & 0x3c) != 0 ||
10387 + comp_status != CS_COMPLETE) {
10388 + EL(ha, "failed, I/O timeout, cs=%xh, es=%xh, "
10389 + "rval=%xh\n",
10390 + comp_status, pkt->sts24.entry_status, rval);
10391 + ql_free_dma_resource(ha, dma_mem);
10392 + kmem_free(pkt, pkt_size);
10393 + kmem_free(dma_mem, sizeof (dma_mem_t));
10394 + kmem_free(bp, cmd->RequestLen);
10395 + cmd->Status = EXT_STATUS_ERR;
10396 + cmd->ResponseLen = 0;
10397 + return;
10398 + }
10399 + } else {
10400 + pkt->ms.entry_type = MS_TYPE;
10401 + pkt->ms.entry_count = 1;
10402 +
10403 + /* Set loop ID */
10404 + if (CFG_IST(ha, CFG_EXT_FW_INTERFACE)) {
10405 + pkt->ms.loop_id_l = LSB(tq->loop_id);
10406 + pkt->ms.loop_id_h = MSB(tq->loop_id);
10407 + } else {
10408 + pkt->ms.loop_id_h = LSB(tq->loop_id);
10409 + }
10410 +
10411 + pkt->ms.control_flags_h = CF_ELS_PASSTHROUGH;
10412 +
10413 + /* Set ISP command timeout. */
10414 + pkt->ms.timeout = LE_16(120);
10415 +
10416 + /* Set data segment counts. */
10417 + pkt->ms.cmd_dseg_count_l = 1;
10418 + pkt->ms.total_dseg_count = LE_16(2);
10419 +
10420 + /* Response total byte count. */
10421 + pkt->ms.resp_byte_count = LE_32(cmd->ResponseLen);
10422 + pkt->ms.dseg[1].length = LE_32(cmd->ResponseLen);
10423 +
10424 + /* Command total byte count. */
10425 + pkt->ms.cmd_byte_count = LE_32(cmd_size);
10426 + pkt->ms.dseg[0].length = LE_32(cmd_size);
10427 +
10428 + /* Load command/response data segments. */
10429 + pkt->ms.dseg[0].address[0] = (uint32_t)
10430 + LE_32(LSD(dma_mem->cookie.dmac_laddress));
10431 + pkt->ms.dseg[0].address[1] = (uint32_t)
10432 + LE_32(MSD(dma_mem->cookie.dmac_laddress));
10433 + pkt->ms.dseg[1].address[0] = (uint32_t)
10434 + LE_32(LSD(dma_mem->cookie.dmac_laddress));
10435 + pkt->ms.dseg[1].address[1] = (uint32_t)
10436 + LE_32(MSD(dma_mem->cookie.dmac_laddress));
10437 +
10438 + rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt,
10439 + sizeof (ql_mbx_iocb_t));
10440 +
10441 + comp_status = (uint16_t)LE_16(pkt->sts.comp_status);
10442 + if (rval == QL_SUCCESS && comp_status == CS_DATA_UNDERRUN) {
10443 + comp_status = CS_COMPLETE;
10444 + }
10445 + if (rval != QL_SUCCESS ||
10446 + (pkt->sts.entry_status & 0x7e) != 0 ||
10447 + comp_status != CS_COMPLETE) {
10448 + EL(ha, "failed, I/O timeout, cs=%xh, es=%xh, "
10449 + "rval=%xh\n",
10450 + comp_status, pkt->sts.entry_status, rval);
10451 + ql_free_dma_resource(ha, dma_mem);
10452 + kmem_free(pkt, pkt_size);
10453 + kmem_free(dma_mem, sizeof (dma_mem_t));
10454 + kmem_free(bp, cmd->RequestLen);
10455 + cmd->Status = EXT_STATUS_ERR;
10456 + cmd->ResponseLen = 0;
10457 + return;
10458 + }
10459 + }
10460 +
10461 + /* Sync payload DMA buffer. */
10462 + (void) ddi_dma_sync(dma_mem->dma_handle, 0, cmd->ResponseLen,
10463 + DDI_DMA_SYNC_FORKERNEL);
10464 +
10465 + if (ql_send_buffer_data(dma_mem->bp,
10466 + (caddr_t)(uintptr_t)cmd->ResponseAdr,
10467 + cmd->ResponseLen, mode) != cmd->ResponseLen) {
10468 + cmd->Status = EXT_STATUS_COPY_ERR;
10469 + EL(ha, "failed, ddi_copyout\n");
10470 + } else {
10471 + QL_PRINT_9(ha, "els_rsp\n");
10472 + QL_DUMP_9(pld, 8, cmd->ResponseLen);
10473 + cmd->Status = EXT_STATUS_OK;
10474 + QL_PRINT_9(ha, "done\n");
10475 + }
10476 +
10477 + ql_free_dma_resource(ha, dma_mem);
10478 + kmem_free(pkt, pkt_size);
10479 + kmem_free(dma_mem, sizeof (dma_mem_t));
10480 + kmem_free(bp, cmd->RequestLen);
10481 +}
10482 +
10483 +/*
10484 + * ql_flash_update_caps
10485 + * IOCTL for flash update capabilities command.
10486 + *
10487 + * Input:
10488 + * ha: adapter state pointer.
10489 + * cmd: User space CT arguments pointer.
10490 + * mode: flags.
10491 + *
10492 + * Returns:
10493 + * None, request status indicated in cmd->Status.
10494 + *
10495 + * Context:
10496 + * Kernel context.
10497 + */
10498 +static void
10499 +ql_flash_update_caps(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
10500 +{
10501 + int rval;
10502 + uint64_t cb;
10503 + EXT_FLASH_UPDATE_CAPS caps = {0};
10504 +
10505 + QL_PRINT_9(ha, "started\n");
10506 +
10507 + cb = LONG_TO_LLONG(ha->fw_attributes, ha->fw_ext_attributes);
10508 +
10509 + switch (cmd->SubCode) {
10510 + case EXT_SC_GET_FLASH_UPDATE_CAPS:
10511 + if (cmd->ResponseLen < sizeof (EXT_FLASH_UPDATE_CAPS)) {
10512 + cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
10513 + cmd->DetailStatus = sizeof (EXT_FLASH_UPDATE_CAPS);
10514 + EL(ha, "failed, ResponseLen < 0x%x, Len=0x%x\n",
10515 + sizeof (EXT_FLASH_UPDATE_CAPS), cmd->ResponseLen);
10516 + cmd->ResponseLen = 0;
10517 + return;
10518 + }
10519 + caps.Capabilities = cb;
10520 + caps.OutageDuration = 300; /* seconds */
10521 +
10522 + rval = ddi_copyout((void *)&caps,
10523 + (void *)(uintptr_t)(cmd->ResponseAdr),
10524 + sizeof (EXT_FLASH_UPDATE_CAPS), mode);
10525 + if (rval != 0) {
10526 + cmd->Status = EXT_STATUS_COPY_ERR;
10527 + cmd->ResponseLen = 0;
10528 + EL(ha, "failed, ddi_copyout\n");
10529 + } else {
10530 + cmd->ResponseLen = sizeof (EXT_FLASH_UPDATE_CAPS);
10531 + }
10532 + break;
10533 + case EXT_SC_SET_FLASH_UPDATE_CAPS:
10534 + if (cmd->RequestLen < sizeof (EXT_FLASH_UPDATE_CAPS)) {
10535 + /* parameter error */
10536 + EL(ha, "failed, RequestLen < EXT_FLASH_UPDATE_CAPS, "
10537 + "Len=%xh\n", cmd->RequestLen);
10538 + cmd->Status = EXT_STATUS_INVALID_PARAM;
10539 + cmd->DetailStatus = EXT_DSTATUS_REQUEST_LEN;
10540 + cmd->ResponseLen = 0;
10541 + return;
10542 + }
10543 +
10544 + /* Copy in the request structure. */
10545 + if (ddi_copyin((void *)(uintptr_t)cmd->RequestAdr,
10546 + (void *)&caps, sizeof (EXT_FLASH_UPDATE_CAPS), mode) != 0) {
10547 + EL(ha, "failed, ddi_copyin\n");
10548 + cmd->Status = EXT_STATUS_COPY_ERR;
10549 + cmd->ResponseLen = 0;
10550 + return;
10551 + }
10552 +
10553 + if (cb != caps.Capabilities || caps.OutageDuration < 300) {
10554 + cmd->Status = EXT_STATUS_ERR;
10555 + cmd->ResponseLen = 0;
10556 + }
10557 + break;
10558 + default:
10559 + /* Subcode not supported. */
10560 + EL(ha, "unknown subcode=%xh\n", cmd->SubCode);
10561 + cmd->Status = EXT_STATUS_UNSUPPORTED_SUBCODE;
10562 + cmd->ResponseLen = 0;
10563 + break;
10564 + }
10565 +
10566 + QL_PRINT_9(ha, "done\n");
10567 +}
10568 +
10569 +/*
10570 + * ql_get_bbcr_data
10571 + * IOCTL for get buffer to buffer credits command.
10572 + *
10573 + * Input:
10574 + * ha: adapter state pointer.
10575 + * cmd: User space CT arguments pointer.
10576 + * mode: flags.
10577 + *
10578 + * Returns:
10579 + * None, request status indicated in cmd->Status.
10580 + *
10581 + * Context:
10582 + * Kernel context.
10583 + */
10584 +static void
10585 +ql_get_bbcr_data(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
10586 +{
10587 + int rval;
10588 + ql_mbx_data_t mr;
10589 + EXT_BBCR_DATA bb = {0};
10590 +
10591 + QL_PRINT_9(ha, "started\n");
10592 +
10593 + if (cmd->ResponseLen < sizeof (EXT_BBCR_DATA)) {
10594 + cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
10595 + cmd->DetailStatus = sizeof (EXT_BBCR_DATA);
10596 + EL(ha, "failed, ResponseLen < 0x%x, Len=0x%x\n",
10597 + sizeof (EXT_BBCR_DATA), cmd->ResponseLen);
10598 + cmd->ResponseLen = 0;
10599 + return;
10600 + }
10601 +
10602 + if (!(CFG_IST(ha, CFG_BBCR_SUPPORT))) {
10603 + EL(ha, "invalid request for HBA\n");
10604 + cmd->Status = EXT_STATUS_INVALID_REQUEST;
10605 + cmd->ResponseLen = 0;
10606 + return;
10607 + }
10608 + if (ha->task_daemon_flags & LOOP_DOWN) {
10609 + rval = ql_get_adapter_id(ha, &mr);
10610 + ha->bbcr_initial = LSB(mr.mb[15]);
10611 + ha->bbcr_runtime = MSB(mr.mb[15]);
10612 + bb.ConfiguredBBSCN = ha->bbcr_initial & BBCR_INITIAL_MASK;
10613 + bb.NegotiatedBBSCN = ha->bbcr_runtime & BBCR_RUNTIME_MASK;
10614 + bb.Status = EXT_DEF_BBCR_STATUS_UNKNOWN;
10615 + bb.State = EXT_DEF_BBCR_STATE_OFFLINE;
10616 + if (rval == 0x4005) {
10617 + bb.mbx1 = mr.mb[1];
10618 + }
10619 + } else {
10620 + bb.ConfiguredBBSCN = ha->bbcr_initial & BBCR_INITIAL_MASK;
10621 + bb.NegotiatedBBSCN = ha->bbcr_runtime & BBCR_RUNTIME_MASK;
10622 +
10623 + if (bb.ConfiguredBBSCN) {
10624 + bb.Status = EXT_DEF_BBCR_STATUS_ENABLED;
10625 + if (bb.NegotiatedBBSCN &&
10626 + !(ha->bbcr_runtime & BBCR_RUNTIME_REJECT)) {
10627 + bb.State = EXT_DEF_BBCR_STATE_ONLINE;
10628 + } else {
10629 + bb.State = EXT_DEF_BBCR_STATE_OFFLINE;
10630 + if (ha->bbcr_runtime & BBCR_RUNTIME_REJECT) {
10631 + bb.OfflineReasonCode =
10632 + EXT_DEF_BBCR_REASON_LOGIN_REJECT;
10633 + } else {
10634 + bb.OfflineReasonCode =
10635 + EXT_DEF_BBCR_REASON_SWITCH;
10636 + }
10637 + }
10638 + } else {
10639 + bb.Status = EXT_DEF_BBCR_STATUS_DISABLED;
10640 + }
10641 + }
10642 +
10643 + rval = ddi_copyout((void *)&bb, (void *)(uintptr_t)(cmd->ResponseAdr),
10644 + sizeof (EXT_BBCR_DATA), mode);
10645 + if (rval != 0) {
10646 + cmd->Status = EXT_STATUS_COPY_ERR;
10647 + cmd->ResponseLen = 0;
10648 + EL(ha, "failed, ddi_copyout\n");
10649 + } else {
10650 + cmd->ResponseLen = sizeof (EXT_BBCR_DATA);
10651 + }
10652 +
10653 + QL_PRINT_9(ha, "done\n");
10654 +}
10655 +
10656 +/*
10657 + * ql_get_priv_stats
10658 + * Performs EXT_SC_GET_PRIV_STATS subcommand. of EXT_CC_GET_DATA.
10659 + *
10660 + * Input:
10661 + * ha: adapter state pointer.
10662 + * cmd: Local EXT_IOCTL cmd struct pointer.
10663 + * mode: flags.
10664 + *
10665 + * Returns:
10666 + * None, request status indicated in cmd->Status.
10667 + *
10668 + * Context:
10669 + * Kernel context.
10670 + */
10671 +static void
10672 +ql_get_priv_stats(ql_adapter_state_t *ha, EXT_IOCTL *cmd, int mode)
10673 +{
10674 + uint8_t *ls;
10675 + int rval;
10676 + int retry = 10;
10677 +
10678 + QL_PRINT_9(ha, "started\n");
10679 +
10680 + while (ha->task_daemon_flags & (DRIVER_STALL | ABORT_ISP_ACTIVE |
10681 + LOOP_RESYNC_ACTIVE)) {
10682 + ql_delay(ha, 10000000); /* 10 second delay */
10683 +
10684 + retry--;
10685 +
10686 + if (retry == 0) { /* effectively 100 seconds */
10687 + EL(ha, "failed, LOOP_NOT_READY\n");
10688 + cmd->Status = EXT_STATUS_BUSY;
10689 + cmd->ResponseLen = 0;
10690 + return;
10691 + }
10692 + }
10693 +
10694 + /* Allocate memory for command. */
10695 + ls = kmem_zalloc(cmd->ResponseLen, KM_SLEEP);
10696 +
10697 + /*
10698 + * I think these are supposed to be port statistics
10699 + * the loop ID or port ID should be in cmd->Instance.
10700 + */
10701 + rval = ql_get_status_counts(ha,
10702 + ha->task_daemon_flags & LOOP_DOWN ? 0xFF : ha->loop_id,
10703 + cmd->ResponseLen, (caddr_t)ls, 0);
10704 + if (rval != QL_SUCCESS) {
10705 + EL(ha, "failed, get_link_status=%xh, id=%xh\n", rval,
10706 + ha->loop_id);
10707 + cmd->Status = EXT_STATUS_MAILBOX;
10708 + cmd->DetailStatus = rval;
10709 + cmd->ResponseLen = 0;
10710 + } else {
10711 + rval = ddi_copyout((void *)&ls,
10712 + (void *)(uintptr_t)cmd->ResponseAdr, cmd->ResponseLen,
10713 + mode);
10714 + if (rval != 0) {
10715 + EL(ha, "failed, ddi_copyout\n");
10716 + cmd->Status = EXT_STATUS_COPY_ERR;
10717 + cmd->ResponseLen = 0;
10718 + }
10719 + }
10720 +
10721 + kmem_free(ls, cmd->ResponseLen);
10722 +
10723 + QL_PRINT_9(ha, "done\n");
9260 10724 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX