?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / uts / sun / io / socal.c
blob084c59f0d5d48157c69cc3f1bb315df3cf99bfc7
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved.
28 */
29
30 /*
31 * socal - Serial Optical Channel Arbitrated Loop host adapter driver.
32 */
33
34 #include <sys/types.h>
35 #include <sys/note.h>
36 #include <sys/devops.h>
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/user.h>
40 #include <sys/buf.h>
41 #include <sys/ioctl.h>
42 #include <sys/uio.h>
43 #include <sys/fcntl.h>
44
45 #include <sys/cmn_err.h>
46 #include <sys/stropts.h>
47 #include <sys/kmem.h>
48
49 #include <sys/errno.h>
50 #include <sys/open.h>
51 #include <sys/varargs.h>
52 #include <sys/var.h>
53 #include <sys/thread.h>
54 #include <sys/debug.h>
55 #include <sys/cpu.h>
56 #include <sys/autoconf.h>
57 #include <sys/conf.h>
58 #include <sys/stat.h>
59
60 #include <sys/file.h>
61 #include <sys/syslog.h>
62
63 #include <sys/ddi.h>
64 #include <sys/sunddi.h>
65 #include <sys/ddi_impldefs.h>
66 #include <sys/ksynch.h>
67 #include <sys/ddidmareq.h>
68 #include <sys/dditypes.h>
69 #include <sys/ethernet.h>
70 #include <sys/socalreg.h>
71 #include <sys/socalmap.h>
72 #include <sys/fc4/fcal.h>
73 #include <sys/socal_cq_defs.h>
74 #include <sys/fc4/fcal_linkapp.h>
75 #include <sys/fc4/fcal_transport.h>
76 #include <sys/socalio.h>
77 #include <sys/socalvar.h>
78
79 /*
80 * Local Macros
81 */
82
83 #ifdef DEBUG
84 #define SOCAL_DEBUG 1
85 #else
86 #define SOCAL_DEBUG 0
87 #endif
88 static uchar_t socal_xrambuf[0x40000];
89 static int socal_core = SOCAL_TAKE_CORE;
90 #if SOCAL_DEBUG > 0 && !defined(lint)
91 static int soc_debug = SOCAL_DEBUG;
92 static int socal_read_stale_data = 0;
93 #define DEBUGF(level, args) \
94 if (soc_debug >= (level)) cmn_err args;
95 #define SOCALDEBUG(level, args) \
96 if (soc_debug >= level) args;
97 #else
98 #define DEBUGF(level, args) /* Nothing */
99 #define SOCALDEBUG(level, args) /* Nothing */
100 #endif
101
102
103 /* defines for properties */
104 #define SOCAL_PORT_NO_PROP "socal_port"
105 #define SOCAL_ALT_PORT_NO_PROP "port#"
106
107 /* for socal_force_reset() */
108 #define RESET_PORT 1
109 #define DONT_RESET_PORT 0
110
111 /*
112 * Driver Entry points.
113 */
114 static int socal_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
115 static int socal_bus_ctl(dev_info_t *dip, dev_info_t *rip,
116 ddi_ctl_enum_t op, void *a, void *v);
117 static int socal_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
118 static int socal_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd,
119 void *arg, void **result);
120 static unsigned int socal_intr(caddr_t arg);
121 static unsigned int socal_dummy_intr(caddr_t arg);
122 static int socal_open(dev_t *devp, int flag, int otyp,
123 cred_t *cred_p);
124 static int socal_close(dev_t dev, int flag, int otyp,
125 cred_t *cred_p);
126 static int socal_ioctl(dev_t dev, int cmd, intptr_t arg,
127 int mode, cred_t *cred_p, int *rval_p);
128
129 /*
130 * FC_AL transport functions.
131 */
132 static uint_t socal_transport(fcal_packet_t *, fcal_sleep_t, int);
133 static uint_t socal_transport_poll(fcal_packet_t *, uint_t, int);
134 static uint_t socal_lilp_map(void *, uint_t, uint32_t, uint_t);
135 static uint_t socal_force_lip(void *, uint_t, uint_t, uint_t);
136 static uint_t socal_force_offline(void *, uint_t, uint_t);
137 static uint_t socal_abort_cmd(void *, uint_t, fcal_packet_t *, uint_t);
138 static uint_t socal_doit(fcal_packet_t *, socal_port_t *, int,
139 void (*)(), int, int, uint_t *);
140 static uint_t socal_els(void *, uint_t, uint_t, uint_t,
141 void (*callback)(), void *, caddr_t, caddr_t *, uint_t);
142 static uint_t socal_bypass_dev(void *, uint_t, uint_t);
143 static void socal_force_reset(void *, uint_t, uint_t);
144 static void socal_add_ulp(void *, uint_t, uchar_t, void (*)(),
145 void (*)(), void (*)(), void *);
146 static void socal_remove_ulp(void *, uint_t, uchar_t, void *);
147 static void socal_take_core(void *);
148
149 /*
150 * Driver internal functions.
151 */
152 static void socal_intr_solicited(socal_state_t *, uint32_t srq);
153 static void socal_intr_unsolicited(socal_state_t *, uint32_t urq);
154 static void socal_lilp_map_done(fcal_packet_t *);
155 static void socal_force_lip_done(fcal_packet_t *);
156 static void socal_force_offline_done(fcal_packet_t *);
157 static void socal_abort_done(fcal_packet_t *);
158 static void socal_bypass_dev_done(fcal_packet_t *);
159 static fcal_packet_t *socal_packet_alloc(socal_state_t *, fcal_sleep_t);
160 static void socal_packet_free(fcal_packet_t *);
161 static void socal_disable(socal_state_t *socalp);
162 static void socal_init_transport_interface(socal_state_t *socalp);
163 static int socal_cqalloc_init(socal_state_t *socalp, uint32_t index);
164 static void socal_cqinit(socal_state_t *socalp, uint32_t index);
165 static int socal_start(socal_state_t *socalp);
166 static void socal_doreset(socal_state_t *socalp);
167 static int socal_dodetach(dev_info_t *dip);
168 static int socal_diag_request(socal_state_t *socalp, uint32_t port,
169 uint_t *diagcode, uint32_t cmd);
170 static void socal_download_ucode(socal_state_t *socalp);
171 static void socal_init_cq_desc(socal_state_t *socalp);
172 static void socal_init_wwn(socal_state_t *socalp);
173 static void socal_enable(socal_state_t *socalp);
174 static int socal_establish_pool(socal_state_t *socalp, uint32_t poolid);
175 static int socal_add_pool_buffer(socal_state_t *socalp, uint32_t poolid);
176 static int socal_issue_adisc(socal_state_t *socalp, uint32_t port, uint32_t
177 dest, la_els_adisc_t *adisc_pl, uint32_t polled);
178 static int socal_issue_lbf(socal_state_t *socalp, uint32_t port,
179 uchar_t *flb_pl, size_t length, uint32_t polled);
180 static int socal_issue_rls(socal_state_t *socalp, uint32_t port, uint32_t
181 dest, la_els_rls_reply_t *rls_pl, uint32_t polled);
182 static void socal_us_els(socal_state_t *, cqe_t *, caddr_t);
183 static fcal_packet_t *socal_els_alloc(socal_state_t *, uint32_t, uint32_t,
184 uint32_t, uint32_t, caddr_t *, uint32_t);
185 static fcal_packet_t *socal_lbf_alloc(socal_state_t *, uint32_t,
186 uint32_t, uint32_t, caddr_t *, uint32_t);
187 static void socal_els_free(socal_priv_cmd_t *);
188 static void socal_lbf_free(socal_priv_cmd_t *);
189 static int socal_getmap(socal_state_t *socalp, uint32_t port, caddr_t arg,
190 uint32_t polled, int);
191 static void socal_flush_overflowq(socal_state_t *, int, int);
192 static void socal_deferred_intr(void *);
193 static void socal_fix_harda(socal_state_t *socalp, int port);
194
195 /*
196 * SOC+ Circular Queue Management routines.
197 */
198 static int socal_cq_enque(socal_state_t *, socal_port_t *, cqe_t *, int,
199 fcal_sleep_t, fcal_packet_t *, int);
200
201 /*
202 * Utility functions
203 */
204 static void socal_disp_err(socal_state_t *, uint_t level, char *mid, char *msg);
205 static void socal_wcopy(uint_t *, uint_t *, int);
206
207 /*
208 * Set this bit to enable 64-bit sus mode
209 */
210 static int socal_64bitsbus = 1;
211
212 /*
213 * Default soc dma limits
214 */
215
216 static ddi_dma_lim_t default_socallim = {
217 (ulong_t)0, (ulong_t)0xffffffff, (uint_t)0xffffffff,
218 DEFAULT_BURSTSIZE | BURST32 | BURST64, 1, (25*1024)
219 };
220
221 static struct ddi_dma_attr socal_dma_attr = {
222 DMA_ATTR_V0, /* version */
223 (unsigned long long)0, /* addr_lo */
224 (unsigned long long)0xffffffff, /* addr_hi */
225 (unsigned long long)0xffffffff, /* count max */
226 (unsigned long long)4, /* align */
227 DEFAULT_BURSTSIZE | BURST32 | BURST64, /* burst size */
228 1, /* minxfer */
229 (unsigned long long)0xffffffff, /* maxxfer */
230 (unsigned long long)0xffffffff, /* seg */
231 1, /* sgllen */
232 4, /* granularity */
233 0 /* flags */
234 };
235
236 static struct ddi_device_acc_attr socal_acc_attr = {
237 (ushort_t)DDI_DEVICE_ATTR_V0, /* version */
238 (uchar_t)DDI_STRUCTURE_BE_ACC, /* endian flags */
239 (uchar_t)DDI_STRICTORDER_ACC /* data order */
240 };
241
242 static struct fcal_transport_ops socal_transport_ops = {
243 socal_transport,
244 socal_transport_poll,
245 socal_lilp_map,
246 socal_force_lip,
247 socal_abort_cmd,
248 socal_els,
249 socal_bypass_dev,
250 socal_force_reset,
251 socal_add_ulp,
252 socal_remove_ulp,
253 socal_take_core
254 };
255
256 /*
257 * Table used for setting the burst size in the soc+ config register
258 */
259 static int socal_burst32_table[] = {
260 SOCAL_CR_BURST_4,
261 SOCAL_CR_BURST_4,
262 SOCAL_CR_BURST_4,
263 SOCAL_CR_BURST_4,
264 SOCAL_CR_BURST_16,
265 SOCAL_CR_BURST_32,
266 SOCAL_CR_BURST_64
267 };
268
269 /*
270 * Table for setting the burst size for 64-bit sbus mode in soc+'s CR
271 */
272 static int socal_burst64_table[] = {
273 (SOCAL_CR_BURST_8 << 8),
274 (SOCAL_CR_BURST_8 << 8),
275 (SOCAL_CR_BURST_8 << 8),
276 (SOCAL_CR_BURST_8 << 8),
277 (SOCAL_CR_BURST_8 << 8),
278 (SOCAL_CR_BURST_32 << 8),
279 (SOCAL_CR_BURST_64 << 8),
280 (SOCAL_CR_BURST_128 << 8)
281 };
282
283 /*
284 * Tables used to define the sizes of the Circular Queues
285 *
286 * To conserve DVMA/IOPB space, we make some of these queues small...
287 */
288 static int socal_req_entries[] = {
289 SOCAL_SMALL_CQ_ENTRIES, /* Error (reset, lip) requests */
290 SOCAL_MAX_CQ_ENTRIES, /* Most commands */
291 0, /* Not currently used */
292 0 /* Not currently used */
293 };
294
295 static int socal_rsp_entries[] = {
296 SOCAL_MAX_CQ_ENTRIES, /* Solicited "SOC_OK" responses */
297 SOCAL_SMALL_CQ_ENTRIES, /* Solicited error responses */
298 0, /* Unsolicited responses */
299 0 /* Not currently used */
300 };
301
302 /*
303 * Bus ops vector
304 */
305
306 static struct bus_ops socal_bus_ops = {
307 BUSO_REV, /* rev */
308 nullbusmap, /* int (*bus_map)() */
309 0, /* ddi_intrspec_t (*bus_get_intrspec)(); */
310 0, /* int (*bus_add_intrspec)(); */
311 0, /* void (*bus_remove_intrspec)(); */
312 i_ddi_map_fault, /* int (*bus_map_fault)() */
313 0, /* int (*bus_dma_map)() */
314 ddi_dma_allochdl,
315 ddi_dma_freehdl,
316 ddi_dma_bindhdl,
317 ddi_dma_unbindhdl,
318 ddi_dma_flush,
319 ddi_dma_win,
320 ddi_dma_mctl, /* int (*bus_dma_ctl)() */
321 socal_bus_ctl, /* int (*bus_ctl)() */
322 ddi_bus_prop_op, /* int (*bus_prop_op*)() */
323 };
324
325 static struct cb_ops socal_cb_ops = {
326 socal_open, /* int (*cb_open)() */
327 socal_close, /* int (*cb_close)() */
328 nodev, /* int (*cb_strategy)() */
329 nodev, /* int (*cb_print)() */
330 nodev, /* int (*cb_dump)() */
331 nodev, /* int (*cb_read)() */
332 nodev, /* int (*cb_write)() */
333 socal_ioctl, /* int (*cb_ioctl)() */
334 nodev, /* int (*cb_devmap)() */
335 nodev, /* int (*cb_mmap)() */
336 nodev, /* int (*cb_segmap)() */
337 nochpoll, /* int (*cb_chpoll)() */
338 ddi_prop_op, /* int (*cb_prop_op)() */
339 0, /* struct streamtab *cb_str */
340 D_MP|D_NEW|D_HOTPLUG, /* cb_flag */
341 CB_REV, /* rev */
342 nodev, /* int (*cb_aread)() */
343 nodev /* int (*cb_awrite)() */
344 };
345
346 /*
347 * Soc driver ops structure.
348 */
349
350 static struct dev_ops socal_ops = {
351 DEVO_REV, /* devo_rev, */
352 0, /* refcnt */
353 socal_getinfo, /* get_dev_info */
354 nulldev, /* identify */
355 nulldev, /* probe */
356 socal_attach, /* attach */
357 socal_detach, /* detach */
358 nodev, /* reset */
359 &socal_cb_ops, /* driver operations */
360 &socal_bus_ops, /* bus operations */
361 NULL, /* power */
362 ddi_quiesce_not_supported, /* quiesce */
363 };
364
365 /*
366 * Driver private variables.
367 */
368
369 static void *socal_soft_state_p = NULL;
370 static ddi_dma_lim_t *socallim = NULL;
371
372 static uchar_t socal_switch_to_alpa[] = {
373 0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda, 0xd9, 0xd6,
374 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce, 0xcd, 0xcc, 0xcb, 0xca,
375 0xc9, 0xc7, 0xc6, 0xc5, 0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5,
376 0xb4, 0xb3, 0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9,
377 0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b, 0x98, 0x97,
378 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7c, 0x7a, 0x79,
379 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b,
380 0x6a, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
381 0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a,
382 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c, 0x3a, 0x39, 0x36, 0x35,
383 0x34, 0x33, 0x32, 0x31, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29,
384 0x27, 0x26, 0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
385 0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
386 };
387
388 /*
389 * Firmware related externs
390 */
391 extern uint32_t socal_ucode[];
392 extern size_t socal_ucode_size;
393
394 /*
395 * This is the loadable module wrapper: "module configuration section".
396 */
397
398 #include <sys/modctl.h>
399 extern struct mod_ops mod_driverops;
400
401 /*
402 * Module linkage information for the kernel.
403 */
404 #define SOCAL_NAME "SOC+ FC-AL Host Adapter Driver"
405 static char socal_version[] = "1.62 08/19/2008";
406 static struct modldrv modldrv = {
407 &mod_driverops, /* Type of module. This one is a driver */
408 SOCAL_NAME,
409 &socal_ops, /* driver ops */
410 };
411
412 static struct modlinkage modlinkage = {
413 MODREV_1, (void *)&modldrv, NULL
414 };
415
416 /*
417 * This is the module initialization/completion routines
418 */
419
420 #if !defined(lint)
421 static char socal_initmsg[] = "socal _init: socal.c\t1.62\t08/19/2008\n";
422 #endif
423
424 int
425 _init(void)
426 {
427 int stat;
428
429 DEBUGF(4, (CE_CONT, socal_initmsg));
430
431 /* Allocate soft state. */
432 stat = ddi_soft_state_init(&socal_soft_state_p,
433 sizeof (socal_state_t), SOCAL_INIT_ITEMS);
434 if (stat != 0)
435 return (stat);
436
437 /* Install the module */
438 stat = mod_install(&modlinkage);
439 if (stat != 0)
440 ddi_soft_state_fini(&socal_soft_state_p);
441
442 DEBUGF(4, (CE_CONT, "socal: _init: return=%d\n", stat));
443 return (stat);
444 }
445
446 int
447 _fini(void)
448 {
449 int stat;
450
451 if ((stat = mod_remove(&modlinkage)) != 0)
452 return (stat);
453
454 DEBUGF(4, (CE_CONT, "socal: _fini: \n"));
455
456 ddi_soft_state_fini(&socal_soft_state_p);
457
458 DEBUGF(4, (CE_CONT, "socal: _fini: return=%d\n", stat));
459 return (stat);
460 }
461
462 int
463 _info(struct modinfo *modinfop)
464 {
465 return (mod_info(&modlinkage, modinfop));
466 }
467
468
469 int
470 socal_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
471 {
472 int instance;
473 socal_state_t *socalp;
474 struct ether_addr ourmacaddr;
475 socal_port_t *porta, *portb;
476 char buf[MAXPATHLEN];
477 char *cptr, *wwn;
478 int y;
479 int i, j;
480 int burstsize;
481 short s;
482 int loop_id;
483
484 int rval;
485
486
487 instance = ddi_get_instance(dip);
488
489 DEBUGF(4, (CE_CONT, "socal%d entering attach: cmd=%x\n", instance,
490 cmd));
491
492 if (cmd == DDI_RESUME) {
493 if ((socalp = ddi_get_driver_private(dip)) == NULL)
494 return (DDI_FAILURE);
495
496 if (!socalp->socal_shutdown) {
497 /* our work is already done */
498 return (DDI_SUCCESS);
499 }
500 if (socal_start(socalp) != FCAL_SUCCESS) {
501 return (DDI_FAILURE);
502 }
503 DEBUGF(4, (CE_CONT, "socal%d resumed\n", instance));
504 return (DDI_SUCCESS);
505 }
506
507 if (cmd != DDI_ATTACH) {
508 return (DDI_FAILURE);
509 }
510
511 if (ddi_dev_is_sid(dip) != DDI_SUCCESS) {
512 cmn_err(CE_WARN, "socal%d probe: Not self-identifying",
513 instance);
514 return (DDI_FAILURE);
515 }
516
517 /* If we are in a slave-slot, then we can't be used. */
518 if (ddi_slaveonly(dip) == DDI_SUCCESS) {
519 cmn_err(CE_WARN,
520 "socal%d attach failed: device in slave-only slot",
521 instance);
522 return (DDI_FAILURE);
523 }
524
525 if (ddi_intr_hilevel(dip, 0)) {
526 /*
527 * Interrupt number '0' is a high-level interrupt.
528 * At this point you either add a special interrupt
529 * handler that triggers a soft interrupt at a lower level,
530 * or - more simply and appropriately here - you just
531 * fail the attach.
532 */
533 cmn_err(CE_WARN,
534 "socal%d attach failed: hilevel interrupt unsupported",
535 instance);
536 return (DDI_FAILURE);
537 }
538
539 /* Allocate soft state. */
540 if (ddi_soft_state_zalloc(socal_soft_state_p, instance)
541 != DDI_SUCCESS) {
542 cmn_err(CE_WARN, "socal%d attach failed: alloc soft state",
543 instance);
544 return (DDI_FAILURE);
545 }
546 DEBUGF(4, (CE_CONT, "socal%d attach: allocated soft state\n",
547 instance));
548
549 /*
550 * Initialize the state structure.
551 */
552 socalp = ddi_get_soft_state(socal_soft_state_p, instance);
553 if (socalp == (socal_state_t *)NULL) {
554 cmn_err(CE_WARN, "socal%d attach failed: bad soft state",
555 instance);
556 return (DDI_FAILURE);
557 }
558 DEBUGF(4, (CE_CONT, "socal%d: attach: soc soft state ptr=0x%p\n",
559 instance, socalp));
560
561 socalp->dip = dip;
562 socallim = &default_socallim;
563 porta = &socalp->port_state[0];
564 portb = &socalp->port_state[1];
565
566 /* Get the full path name for displaying error messages */
567 cptr = ddi_pathname(dip, buf);
568 (void) strcpy(socalp->socal_name, cptr);
569
570 porta->sp_unsol_cb = NULL;
571 portb->sp_unsol_cb = NULL;
572 porta->sp_port = 0;
573 portb->sp_port = 1;
574 porta->sp_board = socalp;
575 portb->sp_board = socalp;
576
577 porta->sp_lilpmap_valid = 0;
578 portb->sp_lilpmap_valid = 0;
579
580 /*
581 * If an hard loop-id property is present, then the port is going
582 * to be used in target-mode so set the target-mode flag.
583 */
584 loop_id = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
585 "port0-loop-id", 127);
586 if (loop_id >= 0 && loop_id <= 126) {
587 porta->sp_status |= PORT_TARGET_MODE;
588 porta->sp_hard_alpa = socal_switch_to_alpa[loop_id];
589 } else porta->sp_hard_alpa = 0xfe;
590
591 loop_id = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
592 "port1-loop-id", 127);
593 if (loop_id >= 0 && loop_id <= 126) {
594 portb->sp_status |= PORT_TARGET_MODE;
595 portb->sp_hard_alpa = socal_switch_to_alpa[loop_id];
596 } else portb->sp_hard_alpa = 0xfe;
597
598 /* Get out Node wwn and calculate port wwns */
599 rval = ddi_prop_op(DDI_DEV_T_ANY, dip,
600 PROP_LEN_AND_VAL_ALLOC, DDI_PROP_DONTPASS |
601 DDI_PROP_CANSLEEP, "wwn", (caddr_t)&wwn, &i);
602
603 if ((rval != DDI_PROP_SUCCESS) || (i < FC_WWN_SIZE) ||
604 (bcmp(wwn, "00000000", FC_WWN_SIZE) == 0)) {
605 (void) localetheraddr((struct ether_addr *)NULL, &ourmacaddr);
606
607 bcopy((caddr_t)&ourmacaddr, (caddr_t)&s, sizeof (short));
608 socalp->socal_n_wwn.w.wwn_hi = s;
609 bcopy((caddr_t)&ourmacaddr+2,
610 (caddr_t)&socalp->socal_n_wwn.w.wwn_lo,
611 sizeof (uint_t));
612 socalp->socal_n_wwn.w.naa_id = NAA_ID_IEEE;
613 socalp->socal_n_wwn.w.nport_id = 0;
614 } else {
615 bcopy((caddr_t)wwn, (caddr_t)&socalp->socal_n_wwn, FC_WWN_SIZE);
616 }
617
618 if (rval == DDI_SUCCESS)
619 kmem_free((void *)wwn, i);
620
621 for (i = 0; i < FC_WWN_SIZE; i++) {
622 (void) sprintf(&socalp->socal_stats.node_wwn[i << 1],
623 "%02x", socalp->socal_n_wwn.raw_wwn[i]);
624 }
625 DEBUGF(4, (CE_CONT, "socal%d attach: node wwn: %s\n",
626 instance, socalp->socal_stats.node_wwn));
627
628 bcopy((caddr_t)&socalp->socal_n_wwn, (caddr_t)&porta->sp_p_wwn,
629 sizeof (la_wwn_t));
630 bcopy((caddr_t)&socalp->socal_n_wwn, (caddr_t)&portb->sp_p_wwn,
631 sizeof (la_wwn_t));
632 porta->sp_p_wwn.w.naa_id = NAA_ID_IEEE_EXTENDED;
633 portb->sp_p_wwn.w.naa_id = NAA_ID_IEEE_EXTENDED;
634 porta->sp_p_wwn.w.nport_id = instance*2;
635 portb->sp_p_wwn.w.nport_id = instance*2+1;
636
637 for (i = 0; i < FC_WWN_SIZE; i++) {
638 (void) sprintf(&socalp->socal_stats.port_wwn[0][i << 1],
639 "%02x", porta->sp_p_wwn.raw_wwn[i]);
640 (void) sprintf(&socalp->socal_stats.port_wwn[1][i << 1],
641 "%02x", portb->sp_p_wwn.raw_wwn[i]);
642 }
643 DEBUGF(4, (CE_CONT, "socal%d attach: porta wwn: %s\n",
644 instance, socalp->socal_stats.port_wwn[0]));
645 DEBUGF(4, (CE_CONT, "socal%d attach: portb wwn: %s\n",
646 instance, socalp->socal_stats.port_wwn[1]));
647
648 if ((porta->sp_transport = (fcal_transport_t *)
649 kmem_zalloc(sizeof (fcal_transport_t), KM_SLEEP)) == NULL) {
650 socal_disp_err(socalp, CE_WARN, "attach.4011",
651 "attach failed: unable to alloc xport struct");
652 goto fail;
653 }
654
655 if ((portb->sp_transport = (fcal_transport_t *)
656 kmem_zalloc(sizeof (fcal_transport_t), KM_SLEEP)) == NULL) {
657 socal_disp_err(socalp, CE_WARN, "attach.4012",
658 "attach failed: unable to alloc xport struct");
659 goto fail;
660 }
661 DEBUGF(4, (CE_CONT, "socal%d attach: allocated transport structs\n",
662 instance));
663
664 /*
665 * Map the external ram and registers for SOC+.
666 * Note: Soc+ sbus host adapter provides 3 register definition
667 * but on-board Soc+'s may have only one register definition.
668 */
669 if ((ddi_dev_nregs(dip, &i) == DDI_SUCCESS) && (i == 1)) {
670 /* Map XRAM */
671 if (ddi_map_regs(dip, 0, &socalp->socal_xrp, 0, 0)
672 != DDI_SUCCESS) {
673 socalp->socal_xrp = NULL;
674 socal_disp_err(socalp, CE_WARN, "attach.4020",
675 "attach failed: unable to map XRAM");
676 goto fail;
677 }
678 /* Map registers */
679 socalp->socal_rp = (socal_reg_t *)(socalp->socal_xrp +
680 SOCAL_XRAM_SIZE);
681 } else {
682 /* Map EEPROM */
683 if (ddi_map_regs(dip, 0, &socalp->socal_eeprom, 0, 0) !=
684 DDI_SUCCESS) {
685 socalp->socal_eeprom = NULL;
686 socal_disp_err(socalp, CE_WARN, "attach.4010",
687 "attach failed: unable to map eeprom");
688 goto fail;
689 }
690 DEBUGF(4, (CE_CONT, "socal%d attach: mapped eeprom 0x%p\n",
691 instance, socalp->socal_eeprom));
692 /* Map XRAM */
693 if (ddi_map_regs(dip, 1, &socalp->socal_xrp, 0, 0) !=
694 DDI_SUCCESS) {
695 socalp->socal_xrp = NULL;
696 socal_disp_err(socalp, CE_WARN, "attach.4020",
697 "attach failed: unable to map XRAM");
698 goto fail;
699 }
700 DEBUGF(4, (CE_CONT, "socal%d attach: mapped xram 0x%p\n",
701 instance, socalp->socal_xrp));
702 /* Map registers */
703 if (ddi_map_regs(dip, 2, (caddr_t *)&socalp->socal_rp, 0, 0) !=
704 DDI_SUCCESS) {
705 socalp->socal_rp = NULL;
706 socal_disp_err(socalp, CE_WARN, "attach.4030",
707 "attach failed: unable to map registers");
708 goto fail;
709 }
710 DEBUGF(4, (CE_CONT, "socal%d attach: mapped regs 0x%p\n",
711 instance, socalp->socal_rp));
712 }
713 /*
714 * Check to see we really have a SOC+ Host Adapter card installed
715 */
716 if (ddi_peek32(dip, (int32_t *)&socalp->socal_rp->socal_csr.w,
717 (int32_t *)NULL) != DDI_SUCCESS) {
718 socal_disp_err(socalp, CE_WARN, "attach.4040",
719 "attach failed: unable to access status register");
720 goto fail;
721 }
722 /* now that we have our registers mapped make sure soc+ reset */
723 socal_disable(socalp);
724
725 /* try defacing a spot in XRAM */
726 if (ddi_poke32(dip, (int32_t *)(socalp->socal_xrp + SOCAL_XRAM_UCODE),
727 0xdefaced) != DDI_SUCCESS) {
728 socal_disp_err(socalp, CE_WARN, "attach.4050",
729 "attach failed: unable to write host adapter XRAM");
730 goto fail;
731 }
732
733 /* see if it stayed defaced */
734 if (ddi_peek32(dip, (int32_t *)(socalp->socal_xrp + SOCAL_XRAM_UCODE),
735 (int32_t *)&y)
736 != DDI_SUCCESS) {
737 socal_disp_err(socalp, CE_WARN, "attach.4051",
738 "attach failed: unable to access host adapter XRAM");
739 goto fail;
740 }
741
742 #ifdef DEBUG
743 for (i = 0; i < 4; i++) {
744 socalp->socal_rp->socal_cr.w &=
745 ~SOCAL_CR_EXTERNAL_RAM_BANK_MASK;
746 socalp->socal_rp->socal_cr.w |= i<<24;
747 cptr = (char *)(socal_xrambuf + (i*0x10000));
748 bcopy((caddr_t)socalp->socal_xrp, (caddr_t)cptr, 0x10000);
749 }
750 socalp->socal_rp->socal_cr.w &= ~SOCAL_CR_EXTERNAL_RAM_BANK_MASK;
751 #endif
752
753 DEBUGF(4, (CE_CONT, "socal%d attach: read xram\n", instance));
754
755 if (y != 0xdefaced) {
756 socal_disp_err(socalp, CE_WARN, "attach.4052",
757 "attach failed: read/write mismatch in XRAM");
758 goto fail;
759 }
760
761 /* Point to the SOC XRAM CQ Descriptor locations. */
762 socalp->xram_reqp = (soc_cq_t *)(socalp->socal_xrp +
763 SOCAL_XRAM_REQ_DESC);
764 socalp->xram_rspp = (soc_cq_t *)(socalp->socal_xrp +
765 SOCAL_XRAM_RSP_DESC);
766
767 if ((socalp->socal_ksp = kstat_create("socal", instance, "statistics",
768 "controller", KSTAT_TYPE_RAW, sizeof (struct socal_stats),
769 KSTAT_FLAG_VIRTUAL)) == NULL) {
770 socal_disp_err(socalp, CE_WARN, "attach.4053",
771 "unable to create kstats");
772 } else {
773 socalp->socal_stats.version = 2;
774 (void) sprintf(socalp->socal_stats.drvr_name,
775 "%s: %s", SOCAL_NAME, socal_version);
776 socalp->socal_stats.pstats[0].port = 0;
777 socalp->socal_stats.pstats[1].port = 1;
778 socalp->socal_ksp->ks_data = (void *)&socalp->socal_stats;
779 kstat_install(socalp->socal_ksp);
780 }
781
782 /*
783 * Install a dummy interrupt routine.
784 */
785 if (ddi_add_intr(dip,
786 (uint_t)0,
787 &socalp->iblkc,
788 &socalp->idevc,
789 socal_dummy_intr,
790 (caddr_t)socalp) != DDI_SUCCESS) {
791 socal_disp_err(socalp, CE_WARN, "attach.4060",
792 "attach failed: unable to install interrupt handler");
793 goto fail;
794 }
795
796 ddi_set_driver_private(dip, socalp);
797
798 /* initialize the interrupt mutex */
799 mutex_init(&socalp->k_imr_mtx, NULL, MUTEX_DRIVER,
800 (void *)socalp->iblkc);
801
802 mutex_init(&socalp->board_mtx, NULL, MUTEX_DRIVER,
803 (void *)socalp->iblkc);
804 mutex_init(&socalp->ioctl_mtx, NULL, MUTEX_DRIVER,
805 (void *)socalp->iblkc);
806
807 /* initialize the abort mutex */
808 mutex_init(&socalp->abort_mtx, NULL, MUTEX_DRIVER,
809 (void *)socalp->iblkc);
810
811 cv_init(&socalp->board_cv, NULL, CV_DRIVER, NULL);
812 DEBUGF(4, (CE_CONT,
813 "socal%d: attach: inited imr mutex, board mutex, board cv\n",
814 instance));
815
816 /* init the port mutexes */
817 mutex_init(&porta->sp_mtx, NULL, MUTEX_DRIVER, socalp->iblkc);
818 cv_init(&porta->sp_cv, NULL, CV_DRIVER, NULL);
819 mutex_init(&portb->sp_mtx, NULL, MUTEX_DRIVER, socalp->iblkc);
820 cv_init(&portb->sp_cv, NULL, CV_DRIVER, NULL);
821 DEBUGF(4, (CE_CONT, "socal%d: attach: inited port mutexes and cvs\n",
822 instance));
823
824 /* get local copy of service params */
825 socal_wcopy((uint_t *)socalp->socal_xrp + SOCAL_XRAM_SERV_PARAMS,
826 (uint_t *)socalp->socal_service_params, SOCAL_SVC_LENGTH);
827 DEBUGF(4, (CE_CONT, "socal%d: attach: got service params\n", instance));
828 /*
829 * Initailize the FCAL transport interface.
830 */
831 socal_init_transport_interface(socalp);
832 DEBUGF(4, (CE_CONT, "socal%d: attach: initalized transport interface\n",
833 instance));
834
835 /*
836 * Allocate request and response queues and init their mutexs.
837 */
838 for (i = 0; i < SOCAL_N_CQS; i++) {
839 if (socal_cqalloc_init(socalp, i) != FCAL_SUCCESS) {
840 goto fail;
841 }
842 }
843 DEBUGF(4, (CE_CONT, "socal%d: attach: allocated cqs\n", instance));
844
845 /*
846 * Adjust the burst size we'll use.
847 */
848 burstsize = ddi_dma_burstsizes(socalp->request[0].skc_dhandle);
849 DEBUGF(4, (CE_CONT, "socal%d: attach: burstsize = 0x%x\n",
850 instance, burstsize));
851 j = burstsize & BURSTSIZE_MASK;
852 for (i = 0; socal_burst32_table[i] != SOCAL_CR_BURST_64; i++)
853 if (!(j >>= 1)) break;
854
855 socalp->socal_cfg = (socalp->socal_cfg & ~SOCAL_CR_SBUS_BURST_SIZE_MASK)
856 | socal_burst32_table[i];
857
858 if (socal_64bitsbus) {
859 if (ddi_dma_set_sbus64(socalp->request[0].skc_dhandle,
860 socal_dma_attr.dma_attr_burstsizes | BURST128) ==
861 DDI_SUCCESS) {
862 DEBUGF(4, (CE_CONT, "socal%d: enabled 64 bit sbus\n",
863 instance));
864 socalp->socal_cfg |= SOCAL_CR_SBUS_ENHANCED;
865 burstsize = ddi_dma_burstsizes(socalp->request[0].
866 skc_dhandle);
867 DEBUGF(4, (CE_CONT, "socal%d: attach: 64bit burstsize = 0x%x\n",
868 instance, burstsize));
869 j = burstsize & BURSTSIZE_MASK;
870 for (i = 0; socal_burst64_table[i] !=
871 (SOCAL_CR_BURST_128 << 8); i++)
872 if (!(j >>= 1))
873 break;
874
875 socalp->socal_cfg = (socalp->socal_cfg &
876 ~SOCAL_CR_SBUS_BURST_SIZE_64BIT_MASK) |
877 socal_burst64_table[i];
878 }
879 }
880
881 ddi_remove_intr(dip, 0, socalp->iblkc);
882 socalp->iblkc = (void *)NULL;
883 /*
884 * Install the interrupt routine.
885 */
886 if (ddi_add_intr(dip,
887 (uint_t)0,
888 &socalp->iblkc,
889 &socalp->idevc,
890 socal_intr,
891 (caddr_t)socalp) != DDI_SUCCESS) {
892 socal_disp_err(socalp, CE_WARN, "attach.4060",
893 "attach failed: unable to install interrupt handler");
894 goto fail;
895 }
896
897 DEBUGF(4, (CE_CONT, "socal%d: attach: set config reg %x\n",
898 instance, socalp->socal_cfg));
899
900 if (ddi_create_minor_node(dip, SOCAL_PORTA_NAME, S_IFCHR,
901 instance*N_SOCAL_NPORTS, SOCAL_NT_PORT, 0) != DDI_SUCCESS)
902 goto fail;
903 if (ddi_create_minor_node(dip, SOCAL_PORTB_NAME, S_IFCHR,
904 instance*N_SOCAL_NPORTS+1, SOCAL_NT_PORT, 0) != DDI_SUCCESS)
905 goto fail;
906
907 if (socal_start(socalp) != FCAL_SUCCESS)
908 goto fail;
909 DEBUGF(4, (CE_CONT, "socal%d: attach: soc+ started\n", instance));
910
911 ddi_report_dev(dip);
912
913 DEBUGF(2, (CE_CONT, "socal%d: attach O.K.\n\n", instance));
914
915 return (DDI_SUCCESS);
916
917 fail:
918 DEBUGF(4, (CE_CONT, "socal%d: attach: DDI_FAILURE\n", instance));
919
920 /* Make sure soc reset */
921 socal_disable(socalp);
922
923 /* let detach do the dirty work */
924 (void) socal_dodetach(dip);
925
926 return (DDI_FAILURE);
927 }
928
929 static int
930 socal_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
931 {
932 int resp;
933 socal_state_t *socalp;
934 int i;
935
936
937 switch (cmd) {
938
939 case DDI_SUSPEND:
940 DEBUGF(4, (CE_CONT, "socal: suspend called\n"));
941
942 if ((socalp = ddi_get_driver_private(dip)) == NULL)
943 return (DDI_FAILURE);
944
945 /*
946 * If any of the ports are in target-mode, don't suspend
947 */
948 for (i = 0; i < N_SOCAL_NPORTS; i++) {
949 if (socalp->port_state[i].sp_status & PORT_TARGET_MODE)
950 return (DDI_FAILURE);
951 }
952
953 /* do not restart socal after reset */
954 socal_force_reset((void *)socalp, 0, DONT_RESET_PORT);
955
956 return (DDI_SUCCESS);
957
958 case DDI_DETACH:
959 DEBUGF(4, (CE_CONT, "socal: detach called\n"));
960 resp = socal_dodetach(dip);
961 if (resp == DDI_SUCCESS)
962 ddi_set_driver_private(dip, NULL);
963 return (resp);
964
965 default:
966 return (DDI_FAILURE);
967 }
968 }
969
970 static int
971 socal_dodetach(dev_info_t *dip)
972 {
973
974 int instance = ddi_get_instance(dip);
975 int i;
976 socal_state_t *socalp;
977 socal_port_t *portp;
978 socal_unsol_cb_t *cb, *cbn = NULL;
979
980 /* Get the soft state struct. */
981 if ((socalp = ddi_get_soft_state(socal_soft_state_p, instance)) == 0) {
982 return (DDI_FAILURE);
983 }
984
985 /*
986 * If somebody is still attached to us from above fail
987 * detach.
988 */
989 mutex_enter(&socalp->board_mtx);
990 if (socalp->socal_busy > 0) {
991 mutex_exit(&socalp->board_mtx);
992 return (DDI_FAILURE);
993 }
994 /* mark socal_busy = -1 to disallow sftm attach */
995 socalp->socal_busy = -1;
996 mutex_exit(&socalp->board_mtx);
997
998 /* Make sure soc+ reset */
999 mutex_enter(&socalp->k_imr_mtx);
1000 socal_disable(socalp);
1001 mutex_exit(&socalp->k_imr_mtx);
1002
1003 /* remove soc+ interrupt */
1004 if (socalp->iblkc != (void *)NULL) {
1005 ddi_remove_intr(dip, (uint_t)0, socalp->iblkc);
1006 DEBUGF(2, (CE_CONT,
1007 "socal%d: detach: Removed SOC+ interrupt from ddi\n",
1008 instance));
1009 }
1010
1011 for (i = 0; i < N_SOCAL_NPORTS; i++) {
1012 portp = &socalp->port_state[i];
1013 mutex_destroy(&portp->sp_mtx);
1014 cv_destroy(&portp->sp_cv);
1015 mutex_destroy(&portp->sp_transport->fcal_mtx);
1016 cv_destroy(&portp->sp_transport->fcal_cv);
1017 kmem_free((void *)portp->sp_transport,
1018 sizeof (fcal_transport_t));
1019 for (cb = portp->sp_unsol_cb; cb != (socal_unsol_cb_t *)NULL;
1020 cb = cbn) {
1021 cbn = cb->next;
1022 kmem_free((void *)cb, sizeof (socal_unsol_cb_t));
1023 }
1024 portp->sp_unsol_cb = (socal_unsol_cb_t *)NULL;
1025 }
1026
1027 /*
1028 * Free request queues, if allocated
1029 */
1030 for (i = 0; i < SOCAL_N_CQS; i++) {
1031 /* Free the queues and destroy their mutexes. */
1032 mutex_destroy(&socalp->request[i].skc_mtx);
1033 mutex_destroy(&socalp->response[i].skc_mtx);
1034 cv_destroy(&socalp->request[i].skc_cv);
1035 cv_destroy(&socalp->response[i].skc_cv);
1036
1037 if (socalp->request[i].skc_dhandle) {
1038 (void) ddi_dma_unbind_handle(socalp->
1039 request[i].skc_dhandle);
1040 ddi_dma_free_handle(&socalp->request[i].skc_dhandle);
1041 }
1042 if (socalp->request[i].skc_cq_raw) {
1043 ddi_dma_mem_free(&socalp->request[i].skc_acchandle);
1044 socalp->request[i].skc_cq_raw = NULL;
1045 socalp->request[i].skc_cq = NULL;
1046 }
1047 if (socalp->response[i].skc_dhandle) {
1048 (void) ddi_dma_unbind_handle(socalp->
1049 response[i].skc_dhandle);
1050 ddi_dma_free_handle(&socalp->response[i].skc_dhandle);
1051 }
1052 if (socalp->response[i].skc_cq_raw) {
1053 ddi_dma_mem_free(&socalp->response[i].skc_acchandle);
1054 socalp->response[i].skc_cq_raw = NULL;
1055 socalp->response[i].skc_cq = NULL;
1056 }
1057 if (socalp->request[i].deferred_intr_timeoutid) {
1058 (void) untimeout(socalp->
1059 request[i].deferred_intr_timeoutid);
1060 }
1061 if (socalp->response[i].deferred_intr_timeoutid) {
1062 (void) untimeout(socalp->
1063 response[i].deferred_intr_timeoutid);
1064 }
1065 }
1066
1067 mutex_destroy(&socalp->abort_mtx);
1068 mutex_destroy(&socalp->board_mtx);
1069 mutex_destroy(&socalp->ioctl_mtx);
1070 cv_destroy(&socalp->board_cv);
1071
1072 /*
1073 * Free soc data buffer pool
1074 */
1075 if (socalp->pool_dhandle) {
1076 (void) ddi_dma_unbind_handle(socalp->pool_dhandle);
1077 ddi_dma_free_handle(&socalp->pool_dhandle);
1078 }
1079 if (socalp->pool) {
1080 ddi_dma_mem_free(&socalp->pool_acchandle);
1081 }
1082
1083 /* release register maps */
1084 /* Unmap EEPROM */
1085 if (socalp->socal_eeprom != NULL) {
1086 ddi_unmap_regs(dip, 0, &socalp->socal_eeprom, 0, 0);
1087 }
1088
1089 /* Unmap XRAM */
1090 if (socalp->socal_xrp != NULL) {
1091 ddi_unmap_regs(dip, 1, &socalp->socal_xrp, 0, 0);
1092 }
1093
1094 /* Unmap registers */
1095 if (socalp->socal_rp != NULL) {
1096 ddi_unmap_regs(dip, 2, (caddr_t *)&socalp->socal_rp, 0, 0);
1097 }
1098
1099 if (socalp->socal_ksp != NULL)
1100 kstat_delete(socalp->socal_ksp);
1101
1102 mutex_destroy(&socalp->k_imr_mtx);
1103
1104 ddi_remove_minor_node(dip, NULL);
1105
1106 ddi_soft_state_free(socal_soft_state_p, instance);
1107
1108 return (DDI_SUCCESS);
1109 }
1110
1111
1112 int
1113 socal_bus_ctl(dev_info_t *dip, dev_info_t *rip, ddi_ctl_enum_t op,
1114 void *a, void *v)
1115 {
1116 int port;
1117
1118
1119 switch (op) {
1120 case DDI_CTLOPS_REPORTDEV:
1121 port = ddi_getprop(DDI_DEV_T_ANY, rip, DDI_PROP_DONTPASS,
1122 SOCAL_PORT_NO_PROP, -1);
1123 if ((port < 0) || (port > 1)) {
1124 port = ddi_getprop(DDI_DEV_T_ANY, rip,
1125 DDI_PROP_DONTPASS, SOCAL_ALT_PORT_NO_PROP, -1);
1126 }
1127 /* log text identifying this driver (d) & its child (r) */
1128 cmn_err(CE_CONT, "?%s%d at %s%d: socal_port %d\n",
1129 ddi_driver_name(rip), ddi_get_instance(rip),
1130 ddi_driver_name(dip), ddi_get_instance(dip),
1131 port);
1132 break;
1133
1134 case DDI_CTLOPS_INITCHILD: {
1135 dev_info_t *child_dip = (dev_info_t *)a;
1136 char name[MAXNAMELEN];
1137 socal_state_t *socalp;
1138
1139 if ((socalp = ddi_get_driver_private(dip)) == NULL)
1140 return (DDI_FAILURE);
1141
1142 port = ddi_getprop(DDI_DEV_T_ANY, child_dip,
1143 DDI_PROP_DONTPASS, SOCAL_PORT_NO_PROP, -1);
1144
1145 if ((port < 0) || (port > 1)) {
1146 port = ddi_getprop(DDI_DEV_T_ANY, child_dip,
1147 DDI_PROP_DONTPASS, SOCAL_ALT_PORT_NO_PROP, -1);
1148 if ((port < 0) || (port > 1)) {
1149 return (DDI_NOT_WELL_FORMED);
1150 }
1151 }
1152 mutex_enter(&socalp->board_mtx);
1153 mutex_enter(&socalp->port_state[port].sp_mtx);
1154 if (socalp->port_state[port].sp_status &
1155 (PORT_CHILD_INIT | PORT_TARGET_MODE)) {
1156 mutex_exit(&socalp->port_state[port].sp_mtx);
1157 mutex_exit(&socalp->board_mtx);
1158 return (DDI_FAILURE);
1159 }
1160 socalp->socal_busy++;
1161 socalp->port_state[port].sp_status |= PORT_CHILD_INIT;
1162 mutex_exit(&socalp->port_state[port].sp_mtx);
1163 mutex_exit(&socalp->board_mtx);
1164 ddi_set_parent_data(child_dip,
1165 socalp->port_state[port].sp_transport);
1166 (void) sprintf((char *)name, "%x,0", port);
1167 ddi_set_name_addr(child_dip, name);
1168 break;
1169 }
1170
1171 case DDI_CTLOPS_UNINITCHILD: {
1172 dev_info_t *child_dip = (dev_info_t *)a;
1173 socal_state_t *socalp;
1174
1175 socalp = ddi_get_driver_private(dip);
1176 port = ddi_getprop(DDI_DEV_T_ANY, child_dip,
1177 DDI_PROP_DONTPASS, SOCAL_PORT_NO_PROP, -1);
1178
1179 if ((port < 0) || (port > 1)) {
1180 port = ddi_getprop(DDI_DEV_T_ANY, child_dip,
1181 DDI_PROP_DONTPASS, SOCAL_ALT_PORT_NO_PROP, -1);
1182 if ((port < 0) || (port > 1)) {
1183 return (DDI_NOT_WELL_FORMED);
1184 }
1185 }
1186
1187 ddi_set_parent_data(child_dip, NULL);
1188 (void) ddi_set_name_addr(child_dip, NULL);
1189 mutex_enter(&socalp->board_mtx);
1190 mutex_enter(&socalp->port_state[port].sp_mtx);
1191 socalp->socal_busy--;
1192 socalp->port_state[port].sp_status &= ~PORT_CHILD_INIT;
1193 mutex_exit(&socalp->port_state[port].sp_mtx);
1194 mutex_exit(&socalp->board_mtx);
1195
1196 break;
1197 }
1198
1199 case DDI_CTLOPS_IOMIN: {
1200 int val;
1201
1202 val = *((int *)v);
1203 val = maxbit(val, socallim->dlim_minxfer);
1204 /*
1205 * The 'arg' value of nonzero indicates 'streaming' mode.
1206 * If in streaming mode, pick the largest of our burstsizes
1207 * available and say that that is our minimum value (modulo
1208 * what minxfer is).
1209 */
1210 if ((int)(uintptr_t)a) {
1211 val = maxbit(val,
1212 1<<(ddi_fls(socallim->dlim_burstsizes)-1));
1213 } else {
1214 val = maxbit(val,
1215 1<<(ddi_ffs(socallim->dlim_burstsizes)-1));
1216 }
1217
1218 *((int *)v) = val;
1219 return (ddi_ctlops(dip, rip, op, a, v));
1220 }
1221
1222 /*
1223 * These ops are not available on this nexus.
1224 */
1225
1226 case DDI_CTLOPS_DMAPMAPC:
1227 case DDI_CTLOPS_REGSIZE:
1228 case DDI_CTLOPS_NREGS:
1229 case DDI_CTLOPS_AFFINITY:
1230 case DDI_CTLOPS_SIDDEV:
1231 case DDI_CTLOPS_POKE:
1232 case DDI_CTLOPS_PEEK:
1233 return (DDI_FAILURE);
1234
1235 case DDI_CTLOPS_SLAVEONLY:
1236 case DDI_CTLOPS_REPORTINT:
1237 default:
1238 /*
1239 * Remaining requests get passed up to our parent
1240 */
1241 DEBUGF(2, (CE_CONT, "%s%d: op (%d) from %s%d\n",
1242 ddi_get_name(dip), ddi_get_instance(dip),
1243 op, ddi_get_name(rip), ddi_get_instance(rip)));
1244 return (ddi_ctlops(dip, rip, op, a, v));
1245 }
1246
1247 return (DDI_SUCCESS);
1248 }
1249
1250
1251 /*ARGSUSED*/
1252 /*
1253 * int
1254 * socal_getinfo() - Given the device number, return the devinfo
1255 * pointer or the instance number. Note: this routine must be
1256 * successful on DDI_INFO_DEVT2INSTANCE even before attach.
1257 */
1258 int
1259 socal_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
1260 void **result)
1261 {
1262 int instance;
1263 socal_state_t *socalp;
1264
1265 instance = getminor((dev_t)arg) / 2;
1266
1267 switch (cmd) {
1268 case DDI_INFO_DEVT2DEVINFO:
1269 socalp = ddi_get_soft_state(socal_soft_state_p, instance);
1270 if (socalp)
1271 *result = socalp->dip;
1272 else
1273 *result = NULL;
1274 break;
1275
1276 case DDI_INFO_DEVT2INSTANCE:
1277 *result = (void *)(uintptr_t)instance;
1278 break;
1279
1280 default:
1281 return (DDI_FAILURE);
1282 }
1283
1284 return (DDI_SUCCESS);
1285 }
1286
1287 /*ARGSUSED*/
1288 int
1289 socal_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
1290 {
1291 int instance = getminor(*devp)/2;
1292 socal_state_t *socalp =
1293 ddi_get_soft_state(socal_soft_state_p, instance);
1294 socal_port_t *port_statep;
1295 int port;
1296
1297 if (socalp == NULL)
1298 return (ENXIO);
1299
1300 port = getminor(*devp)%2;
1301 port_statep = &socalp->port_state[port];
1302
1303 mutex_enter(&port_statep->sp_mtx);
1304 port_statep->sp_status |= PORT_OPEN;
1305 mutex_exit(&port_statep->sp_mtx);
1306 DEBUGF(2, (CE_CONT,
1307 "socal%d: open of port %d\n", instance, port));
1308 return (0);
1309 }
1310
1311 /*ARGSUSED*/
1312 int
1313 socal_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
1314 {
1315 int instance = getminor(dev)/2;
1316 socal_state_t *socalp =
1317 ddi_get_soft_state(socal_soft_state_p, instance);
1318 socal_port_t *port_statep;
1319 int port;
1320
1321 port = getminor(dev)%2;
1322 port_statep = &socalp->port_state[port];
1323
1324 mutex_enter(&port_statep->sp_mtx);
1325 port_statep->sp_status &= ~PORT_OPEN;
1326 mutex_exit(&port_statep->sp_mtx);
1327 DEBUGF(2, (CE_CONT,
1328 "socal%d: clsoe of port %d\n", instance, port));
1329 return (0);
1330 }
1331
1332 /*ARGSUSED*/
1333 int
1334 socal_ioctl(dev_t dev,
1335 int cmd, intptr_t arg, int mode, cred_t *cred_p, int *rval_p)
1336 {
1337 int instance = getminor(dev)/2;
1338 socal_state_t *socalp =
1339 ddi_get_soft_state(socal_soft_state_p, instance);
1340 int port;
1341 socal_port_t *port_statep;
1342 int i;
1343 uint_t r;
1344 int offset;
1345 int retval = FCAL_SUCCESS;
1346 la_els_adisc_t *adisc_pl;
1347 la_els_rls_reply_t *rls_pl;
1348 dev_info_t *dip;
1349 char *buffer, tmp[10];
1350 struct socal_fm_version ver;
1351 #ifdef _MULTI_DATAMODEL
1352 struct socal_fm_version32 {
1353 uint_t fcode_ver_len;
1354 uint_t mcode_ver_len;
1355 uint_t prom_ver_len;
1356 caddr32_t fcode_ver;
1357 caddr32_t mcode_ver;
1358 caddr32_t prom_ver;
1359 } ver32;
1360 uint_t dm32 = 0;
1361 #endif
1362
1363 uchar_t *flb_pl;
1364 flb_hdr_t *flb_hdr;
1365 uint_t flb_size;
1366
1367 if (socalp == NULL)
1368 return (ENXIO);
1369
1370 DEBUGF(4, (CE_CONT, "socal%d ioctl: got command %x\n", instance, cmd));
1371 port = getminor(dev)%2;
1372
1373 switch (cmd) {
1374 case FCIO_FCODE_MCODE_VERSION:
1375 #ifdef _MULTI_DATAMODEL
1376 switch (ddi_model_convert_from(mode & FMODELS)) {
1377 case DDI_MODEL_ILP32:
1378 dm32 = 1;
1379 if (ddi_copyin((caddr_t)arg,
1380 (caddr_t)&ver32, sizeof (ver32),
1381 mode) == -1)
1382 return (EFAULT);
1383 ver.fcode_ver_len =
1384 ver32.fcode_ver_len;
1385 ver.mcode_ver_len =
1386 ver32.mcode_ver_len;
1387 ver.prom_ver_len =
1388 ver32.prom_ver_len;
1389 ver.fcode_ver =
1390 (caddr_t)(uintptr_t)ver32.fcode_ver;
1391 ver.mcode_ver =
1392 (caddr_t)(uintptr_t)ver32.mcode_ver;
1393 ver.prom_ver =
1394 (caddr_t)(uintptr_t)ver32.prom_ver;
1395 break;
1396 case DDI_MODEL_NONE:
1397 if (ddi_copyin((caddr_t)arg,
1398 (caddr_t)&ver, sizeof (ver),
1399 mode) == -1)
1400 return (EFAULT);
1401 }
1402 #else /* _MULTI_DATAMODEL */
1403 if (ddi_copyin((caddr_t)arg, (caddr_t)&ver,
1404 sizeof (ver), mode) == -1)
1405 return (EFAULT);
1406 #endif /* _MULTI_DATAMODEL */
1407 dip = socalp->dip;
1408 if (ddi_prop_op(DDI_DEV_T_ANY, dip,
1409 PROP_LEN_AND_VAL_ALLOC, DDI_PROP_DONTPASS |
1410 DDI_PROP_CANSLEEP, "version", (caddr_t)&buffer,
1411 &i) != DDI_PROP_SUCCESS)
1412 return (EIO);
1413 if (i < ver.fcode_ver_len)
1414 ver.fcode_ver_len = i;
1415 if (ddi_copyout((caddr_t)buffer,
1416 (caddr_t)ver.fcode_ver, ver.fcode_ver_len,
1417 mode) == -1) {
1418 kmem_free((caddr_t)buffer, i);
1419 return (EFAULT);
1420 }
1421 kmem_free((caddr_t)buffer, i);
1422 if (socalp->socal_eeprom) {
1423 for (i = 0; i < SOCAL_N_CQS; i++) {
1424 mutex_enter(
1425 &socalp->request[i].skc_mtx);
1426 mutex_enter(
1427 &socalp->response[i].skc_mtx);
1428 }
1429 i = socalp->socal_rp->socal_cr.w;
1430 socalp->socal_rp->socal_cr.w &=
1431 ~SOCAL_CR_EEPROM_BANK_MASK;
1432 socalp->socal_rp->socal_cr.w |= 3 << 16;
1433 if (ver.prom_ver_len > 10)
1434 ver.prom_ver_len = 10;
1435 bcopy((caddr_t)socalp->socal_eeprom + (unsigned)
1436 0xfff6, tmp, 10);
1437 socalp->socal_rp->socal_cr.w = i;
1438 for (i = SOCAL_N_CQS-1; i >= 0; i--) {
1439 mutex_exit(&socalp->request[i].skc_mtx);
1440 mutex_exit(
1441 &socalp->response[i].skc_mtx);
1442 }
1443 if (ddi_copyout((caddr_t)tmp,
1444 (caddr_t)ver.prom_ver,
1445 ver.prom_ver_len, mode) == -1)
1446 return (EFAULT);
1447 } else {
1448 ver.prom_ver_len = 0;
1449 }
1450 ver.mcode_ver_len = 0;
1451 #ifdef _MULTI_DATAMODEL
1452 if (dm32) {
1453 ver32.fcode_ver_len = ver.fcode_ver_len;
1454 ver32.mcode_ver_len = ver.mcode_ver_len;
1455 ver32.prom_ver_len = ver.prom_ver_len;
1456 ver32.fcode_ver = (caddr32_t)(uintptr_t)
1457 ver.fcode_ver;
1458 ver32.mcode_ver = (caddr32_t)(uintptr_t)
1459 ver.mcode_ver;
1460 ver32.prom_ver = (caddr32_t)(uintptr_t)
1461 ver.prom_ver;
1462 if (ddi_copyout((caddr_t)&ver32,
1463 (caddr_t)arg, sizeof (ver32),
1464 mode) == -1)
1465 return (EFAULT);
1466 } else
1467 #endif /* _MULTI_DATAMODEL */
1468 if (ddi_copyout((caddr_t)&ver, (caddr_t)arg,
1469 sizeof (struct socal_fm_version), mode) == -1)
1470 return (EFAULT);
1471 break;
1472 case FCIO_LOADUCODE:
1473 mutex_enter(&socalp->k_imr_mtx);
1474 socal_disable(socalp);
1475 mutex_exit(&socalp->k_imr_mtx);
1476 if (copyin((caddr_t)arg, (caddr_t)socal_ucode, 0x10000)
1477 == -1)
1478 return (EFAULT);
1479 /* restart socal after resetting */
1480 (void) socal_force_reset((void *)socalp, 0,
1481 RESET_PORT);
1482 break;
1483 case FCIO_DUMPXRAM:
1484 for (i = 0; i < SOCAL_N_CQS; i++) {
1485 mutex_enter(&socalp->request[i].skc_mtx);
1486 mutex_enter(&socalp->response[i].skc_mtx);
1487 }
1488 for (i = 0; i < 4; i++) {
1489 offset = arg+(0x10000 * i);
1490 socalp->socal_rp->socal_cr.w &=
1491 ~SOCAL_CR_EXTERNAL_RAM_BANK_MASK;
1492 socalp->socal_rp->socal_cr.w |= i<<24;
1493 (void) copyout((caddr_t)socalp->socal_xrp,
1494 (caddr_t)(uintptr_t)offset, 0x10000);
1495 }
1496 socalp->socal_rp->socal_cr.w &=
1497 ~SOCAL_CR_EXTERNAL_RAM_BANK_MASK;
1498 for (i = SOCAL_N_CQS-1; i >= 0; i--) {
1499 mutex_exit(&socalp->request[i].skc_mtx);
1500 mutex_exit(&socalp->response[i].skc_mtx);
1501 }
1502 break;
1503 #ifdef DEBUG
1504 case FCIO_DUMPXRAMBUF:
1505 (void) copyout((caddr_t)socal_xrambuf, (caddr_t)arg,
1506 0x40000);
1507 break;
1508 #endif
1509 case FCIO_GETMAP:
1510 mutex_enter(&socalp->ioctl_mtx);
1511 if (socal_getmap(socalp, port, (caddr_t)arg, 0, 0) ==
1512 -1)
1513 retval = FCAL_ALLOC_FAILED;
1514 mutex_exit(&socalp->ioctl_mtx);
1515 break;
1516 case FCIO_BYPASS_DEV:
1517 mutex_enter(&socalp->ioctl_mtx);
1518 retval = socal_bypass_dev((void *)socalp, port, arg);
1519 mutex_exit(&socalp->ioctl_mtx);
1520 break;
1521 case FCIO_FORCE_LIP:
1522 mutex_enter(&socalp->ioctl_mtx);
1523 retval = socal_force_lip((void *)socalp, port, 0,
1524 FCAL_FORCE_LIP);
1525 mutex_exit(&socalp->ioctl_mtx);
1526 break;
1527 case FCIO_FORCE_OFFLINE:
1528 mutex_enter(&socalp->ioctl_mtx);
1529 retval = socal_force_offline((void *)socalp, port, 0);
1530 mutex_exit(&socalp->ioctl_mtx);
1531 break;
1532 case FCIO_ADISC_ELS:
1533 {
1534 if ((adisc_pl =
1535 (la_els_adisc_t *)kmem_zalloc(
1536 sizeof (la_els_adisc_t),
1537 KM_NOSLEEP)) == NULL)
1538 return (ENOMEM);
1539
1540 if (copyin((caddr_t)arg, (caddr_t)adisc_pl,
1541 sizeof (la_els_adisc_t)) == -1) {
1542 kmem_free((void *)adisc_pl,
1543 sizeof (la_els_adisc_t));
1544 return (EFAULT);
1545 }
1546 mutex_enter(&socalp->ioctl_mtx);
1547 retval = socal_issue_adisc(socalp, port,
1548 adisc_pl->nport_id,
1549 adisc_pl, 0);
1550 mutex_exit(&socalp->ioctl_mtx);
1551
1552 if (retval == FCAL_SUCCESS) {
1553 if (copyout((caddr_t)adisc_pl, (caddr_t)arg,
1554 sizeof (la_els_adisc_t)) == -1) {
1555 kmem_free((void *)adisc_pl,
1556 sizeof (la_els_adisc_t));
1557 return (EFAULT);
1558 }
1559 }
1560
1561 kmem_free((void *)adisc_pl, sizeof (la_els_adisc_t));
1562 break;
1563 }
1564 case FCIO_LINKSTATUS:
1565 {
1566 int dest;
1567 if ((rls_pl =
1568 (la_els_rls_reply_t *)
1569 kmem_zalloc(sizeof (la_els_rls_reply_t),
1570 KM_NOSLEEP)) == NULL)
1571 return (ENOMEM);
1572
1573 if (copyin((caddr_t)arg, (caddr_t)rls_pl,
1574 sizeof (la_els_rls_reply_t)) == -1) {
1575 kmem_free((void *)rls_pl,
1576 sizeof (la_els_rls_reply_t));
1577 return (EFAULT);
1578 }
1579 dest = (rls_pl->mbz[0] << 16) + (rls_pl->mbz[1] << 8) +
1580 rls_pl->mbz[2];
1581 mutex_enter(&socalp->ioctl_mtx);
1582 retval = socal_issue_rls(socalp, port, dest,
1583 rls_pl, 0);
1584 mutex_exit(&socalp->ioctl_mtx);
1585
1586 if (retval == FCAL_SUCCESS) {
1587 if (copyout((caddr_t)rls_pl, (caddr_t)arg,
1588 sizeof (la_els_rls_reply_t)) == -1) {
1589 kmem_free((void *)rls_pl,
1590 sizeof (la_els_rls_reply_t));
1591 return (EFAULT);
1592 }
1593 }
1594 kmem_free((void *)rls_pl, sizeof (la_els_rls_reply_t));
1595 break;
1596 }
1597 case FCIO_LOOPBACK_INTERNAL:
1598 /*
1599 * If userland doesn't provide a location for a return
1600 * value the driver will permanently offline the port,
1601 * ignoring any checks for devices on the loop.
1602 */
1603 mutex_enter(&socalp->ioctl_mtx);
1604 if (arg == 0) {
1605 port_statep = &socalp->port_state[port];
1606 mutex_enter(&port_statep->sp_mtx);
1607 if (port_statep->sp_status & PORT_DISABLED) {
1608 /* Already disabled */
1609 mutex_exit(&port_statep->sp_mtx);
1610 mutex_exit(&socalp->ioctl_mtx);
1611 return (EALREADY);
1612 }
1613 port_statep->sp_status |= PORT_DISABLED;
1614 mutex_exit(&port_statep->sp_mtx);
1615 }
1616 retval = socal_diag_request((void *)socalp, port, &r,
1617 SOC_DIAG_INT_LOOP);
1618 mutex_exit(&socalp->ioctl_mtx);
1619 if (arg == 0) break;
1620 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1621 == -1)
1622 return (EFAULT);
1623 break;
1624 case FCIO_LOOPBACK_MANUAL:
1625 mutex_enter(&socalp->ioctl_mtx);
1626 port_statep = &socalp->port_state[port];
1627 mutex_enter(&port_statep->sp_mtx);
1628 if (port_statep->sp_status & PORT_DISABLED) {
1629 mutex_exit(&port_statep->sp_mtx);
1630 mutex_exit(&socalp->ioctl_mtx);
1631 return (EBUSY);
1632 }
1633 mutex_exit(&port_statep->sp_mtx);
1634 retval = socal_diag_request((void *)socalp, port, &r,
1635 SOC_DIAG_EXT_LOOP);
1636 mutex_exit(&socalp->ioctl_mtx);
1637 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1638 == -1)
1639 return (EFAULT);
1640 break;
1641 case FCIO_NO_LOOPBACK:
1642 mutex_enter(&socalp->ioctl_mtx);
1643 port_statep = &socalp->port_state[port];
1644 mutex_enter(&port_statep->sp_mtx);
1645 /* Do not allow online if we're disabled */
1646 if (port_statep->sp_status & PORT_DISABLED) {
1647 if (arg != 0) {
1648 mutex_exit(&port_statep->sp_mtx);
1649 mutex_exit(&socalp->ioctl_mtx);
1650 /*
1651 * It's permanently disabled -- Need to
1652 * enable it first
1653 */
1654 return (EBUSY);
1655 }
1656 /* This was a request to online. */
1657 port_statep->sp_status &= ~PORT_DISABLED;
1658 }
1659 mutex_exit(&port_statep->sp_mtx);
1660 retval = socal_diag_request((void *)socalp, port, &r,
1661 SOC_DIAG_REM_LOOP);
1662 mutex_exit(&socalp->ioctl_mtx);
1663 if (arg == 0) break;
1664 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1665 == -1)
1666 return (EFAULT);
1667 break;
1668 case FCIO_DIAG_NOP:
1669 mutex_enter(&socalp->ioctl_mtx);
1670 retval = socal_diag_request((void *)socalp, port, &r,
1671 SOC_DIAG_NOP);
1672 mutex_exit(&socalp->ioctl_mtx);
1673 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1674 == -1)
1675 return (EFAULT);
1676 break;
1677 case FCIO_DIAG_XRAM:
1678 mutex_enter(&socalp->ioctl_mtx);
1679 retval = socal_diag_request((void *)socalp, port, &r,
1680 SOC_DIAG_XRAM_TEST);
1681 mutex_exit(&socalp->ioctl_mtx);
1682 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1683 == -1)
1684 return (EFAULT);
1685 break;
1686 case FCIO_DIAG_SOC:
1687 mutex_enter(&socalp->ioctl_mtx);
1688 retval = socal_diag_request((void *)socalp, port, &r,
1689 SOC_DIAG_SOC_TEST);
1690 mutex_exit(&socalp->ioctl_mtx);
1691 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1692 == -1)
1693 return (EFAULT);
1694 break;
1695 case FCIO_DIAG_HCB:
1696 mutex_enter(&socalp->ioctl_mtx);
1697 retval = socal_diag_request((void *)socalp, port, &r,
1698 SOC_DIAG_HCB_TEST);
1699 mutex_exit(&socalp->ioctl_mtx);
1700 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1701 == -1)
1702 return (EFAULT);
1703 break;
1704 case FCIO_DIAG_SOCLB:
1705 mutex_enter(&socalp->ioctl_mtx);
1706 retval = socal_diag_request((void *)socalp, port, &r,
1707 SOC_DIAG_SOCLB_TEST);
1708 mutex_exit(&socalp->ioctl_mtx);
1709 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1710 == -1)
1711 return (EFAULT);
1712 break;
1713 case FCIO_DIAG_SRDSLB:
1714 mutex_enter(&socalp->ioctl_mtx);
1715 retval = socal_diag_request((void *)socalp, port, &r,
1716 SOC_DIAG_SRDSLB_TEST);
1717 mutex_exit(&socalp->ioctl_mtx);
1718 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1719 == -1)
1720 return (EFAULT);
1721 break;
1722 case FCIO_DIAG_EXTLB:
1723 mutex_enter(&socalp->ioctl_mtx);
1724 retval = socal_diag_request((void *)socalp, port, &r,
1725 SOC_DIAG_EXTOE_TEST);
1726 mutex_exit(&socalp->ioctl_mtx);
1727 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1728 == -1)
1729 return (EFAULT);
1730 break;
1731 case FCIO_DIAG_RAW:
1732 if (copyin((caddr_t)arg, (caddr_t)&i, sizeof (uint_t))
1733 == -1)
1734 return (EFAULT);
1735 mutex_enter(&socalp->ioctl_mtx);
1736 retval = socal_diag_request((void *)socalp, port, &r,
1737 (uint_t)i);
1738 mutex_exit(&socalp->ioctl_mtx);
1739 if (copyout((caddr_t)&r, (caddr_t)arg, sizeof (uint_t))
1740 == -1)
1741 return (EFAULT);
1742 break;
1743 case FCIO_LOOPBACK_FRAME:
1744 if ((flb_hdr = (flb_hdr_t *)kmem_zalloc(sizeof (flb_hdr_t),
1745 KM_NOSLEEP)) == NULL)
1746 return (ENOMEM);
1747
1748 if (copyin((caddr_t)arg,
1749 (caddr_t)flb_hdr, sizeof (flb_hdr_t)) == -1) {
1750 kmem_free((void *)flb_hdr, sizeof (flb_hdr_t));
1751 return (EFAULT);
1752 }
1753
1754 flb_size = flb_hdr->length;
1755
1756 if ((flb_pl =
1757 (uchar_t *)kmem_zalloc(flb_size, KM_NOSLEEP)) == NULL)
1758 return (ENOMEM);
1759
1760 if (copyin((caddr_t)(arg + sizeof (flb_hdr_t)),
1761 (caddr_t)flb_pl, flb_size) == -1) {
1762 kmem_free((void *)flb_pl, flb_size);
1763 return (EFAULT);
1764 }
1765 mutex_enter(&socalp->ioctl_mtx);
1766 retval = socal_issue_lbf(socalp, port, flb_pl,
1767 flb_size, 1);
1768 mutex_exit(&socalp->ioctl_mtx);
1769
1770 if (retval == FCAL_SUCCESS) {
1771 if (copyout((caddr_t)flb_pl,
1772 (caddr_t)(arg + sizeof (flb_hdr_t) +
1773 flb_hdr->max_length), flb_size) == -1) {
1774 kmem_free((void *)flb_pl, flb_size);
1775 kmem_free((void *)flb_hdr, sizeof (flb_hdr_t));
1776 return (EFAULT);
1777 }
1778 }
1779
1780 kmem_free((void *)flb_pl, flb_size);
1781 kmem_free((void *)flb_hdr, sizeof (flb_hdr_t));
1782 break;
1783 default:
1784 return (ENOTTY);
1785
1786 }
1787 switch (retval) {
1788 case FCAL_SUCCESS:
1789 return (0);
1790 case FCAL_ALLOC_FAILED:
1791 return (ENOMEM);
1792 case FCAL_STATUS_DIAG_BUSY:
1793 return (EALREADY);
1794 case FCAL_STATUS_DIAG_INVALID:
1795 return (EINVAL);
1796 default:
1797 return (EIO);
1798 }
1799
1800 }
1801
1802 /*
1803 * Function name : socal_disable()
1804 *
1805 * Return Values : none
1806 *
1807 * Description : Reset the soc+
1808 *
1809 * Context : Can be called from different kernel process threads.
1810 * Can be called by interrupt thread.
1811 *
1812 * Note: before calling this, the interface should be locked down
1813 * so that it is guaranteed that no other threads are accessing
1814 * the hardware.
1815 */
1816 static void
1817 socal_disable(socal_state_t *socalp)
1818 {
1819 #if !defined(lint)
1820 int i;
1821 #endif
1822 /* Don't touch the hardware if the registers aren't mapped */
1823 if (!socalp->socal_rp)
1824 return;
1825
1826 socalp->socal_rp->socal_imr = socalp->socal_k_imr = 0;
1827 socalp->socal_rp->socal_csr.w = SOCAL_CSR_SOFT_RESET;
1828 #if !defined(lint)
1829 i = socalp->socal_rp->socal_csr.w;
1830 #endif
1831 DEBUGF(9, (CE_CONT, "csr.w = %x\n", i));
1832 }
1833
1834 /*
1835 * Function name : socal_init_transport_interface()
1836 *
1837 * Return Values : none
1838 *
1839 * Description : Fill up the fcal_tranpsort struct for ULPs
1840 *
1841 *
1842 * Note: Only called during attach, so no protection
1843 */
1844 static void
1845 socal_init_transport_interface(socal_state_t *socalp)
1846 {
1847 int i;
1848 fcal_transport_t *xport;
1849
1850 for (i = 0; i < N_SOCAL_NPORTS; i++) {
1851 xport = socalp->port_state[i].sp_transport;
1852 mutex_init(&xport->fcal_mtx, NULL, MUTEX_DRIVER,
1853 (void *)(socalp->iblkc));
1854
1855 cv_init(&xport->fcal_cv, NULL, CV_DRIVER, NULL);
1856
1857 xport->fcal_handle = (void *)socalp;
1858 xport->fcal_dmalimp = socallim;
1859 xport->fcal_iblock = socalp->iblkc;
1860 xport->fcal_dmaattr = &socal_dma_attr;
1861 xport->fcal_accattr = &socal_acc_attr;
1862 xport->fcal_loginparms = socalp->socal_service_params;
1863 bcopy((caddr_t)&socalp->socal_n_wwn,
1864 (caddr_t)&xport->fcal_n_wwn, sizeof (la_wwn_t));
1865 bcopy((caddr_t)&socalp->port_state[i].sp_p_wwn,
1866 (caddr_t)&xport->fcal_p_wwn, sizeof (la_wwn_t));
1867 xport->fcal_portno = i;
1868 xport->fcal_cmdmax = SOCAL_MAX_XCHG;
1869 xport->fcal_ops = &socal_transport_ops;
1870 }
1871 }
1872
1873 /*
1874 * static int
1875 * socal_cqalloc_init() - Inialize the circular queue tables.
1876 * Also, init the locks that are associated with the tables.
1877 *
1878 * Returns: FCAL_SUCCESS, if able to init properly.
1879 * FCAL_FAILURE, if unable to init properly.
1880 */
1881
1882 static int
1883 socal_cqalloc_init(socal_state_t *socalp, uint32_t index)
1884 {
1885 uint32_t cq_size;
1886 size_t real_len;
1887 uint_t ccount;
1888 socal_kcq_t *cqp;
1889 int req_bound = 0, rsp_bound = 0;
1890
1891 /*
1892 * Initialize the Request and Response Queue locks.
1893 */
1894
1895 mutex_init(&socalp->request[index].skc_mtx, NULL, MUTEX_DRIVER,
1896 (void *)socalp->iblkc);
1897 mutex_init(&socalp->response[index].skc_mtx, NULL, MUTEX_DRIVER,
1898 (void *)socalp->iblkc);
1899 cv_init(&socalp->request[index].skc_cv, NULL, CV_DRIVER, NULL);
1900 cv_init(&socalp->response[index].skc_cv, NULL, CV_DRIVER, NULL);
1901
1902 /* Allocate DVMA resources for the Request Queue. */
1903 cq_size = socal_req_entries[index] * sizeof (cqe_t);
1904 if (cq_size) {
1905 cqp = &socalp->request[index];
1906
1907 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
1908 DDI_DMA_DONTWAIT, NULL,
1909 &cqp->skc_dhandle) != DDI_SUCCESS) {
1910 socal_disp_err(socalp, CE_WARN, "driver.4020",
1911 "!alloc of dma handle failed");
1912 goto fail;
1913 }
1914
1915 if (ddi_dma_mem_alloc(cqp->skc_dhandle,
1916 cq_size + SOCAL_CQ_ALIGN, &socal_acc_attr,
1917 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
1918 (caddr_t *)&cqp->skc_cq_raw, &real_len,
1919 &cqp->skc_acchandle) != DDI_SUCCESS) {
1920 socal_disp_err(socalp, CE_WARN, "driver.4030",
1921 "!alloc of dma space failed");
1922 goto fail;
1923 }
1924
1925 if (real_len < (cq_size + SOCAL_CQ_ALIGN)) {
1926 socal_disp_err(socalp, CE_WARN, "driver.4035",
1927 "!alloc of dma space failed");
1928 goto fail;
1929 }
1930 cqp->skc_cq = (cqe_t *)(((uintptr_t)cqp->skc_cq_raw +
1931 (uintptr_t)SOCAL_CQ_ALIGN - 1) &
1932 ((uintptr_t)(~(SOCAL_CQ_ALIGN-1))));
1933
1934 if (ddi_dma_addr_bind_handle(cqp->skc_dhandle,
1935 (struct as *)NULL, (caddr_t)cqp->skc_cq, cq_size,
1936 DDI_DMA_RDWR | DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT,
1937 NULL, &cqp->skc_dcookie, &ccount) != DDI_DMA_MAPPED) {
1938 socal_disp_err(socalp, CE_WARN, "driver.4040",
1939 "!bind of dma handle failed");
1940 goto fail;
1941 }
1942
1943 req_bound = 1;
1944 if (ccount != 1) {
1945 socal_disp_err(socalp, CE_WARN, "driver.4045",
1946 "!bind of dma handle failed");
1947 goto fail;
1948 }
1949
1950 } else {
1951 socalp->request[index].skc_cq_raw = NULL;
1952 socalp->request[index].skc_cq = (cqe_t *)NULL;
1953 socalp->request[index].skc_dhandle = 0;
1954 }
1955
1956 /* Allocate DVMA resources for the response Queue. */
1957 cq_size = socal_rsp_entries[index] * sizeof (cqe_t);
1958 if (cq_size) {
1959 cqp = &socalp->response[index];
1960
1961 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
1962 DDI_DMA_DONTWAIT, NULL,
1963 &cqp->skc_dhandle) != DDI_SUCCESS) {
1964 socal_disp_err(socalp, CE_WARN, "driver.4050",
1965 "!alloc of dma handle failed");
1966 goto fail;
1967 }
1968
1969 if (ddi_dma_mem_alloc(cqp->skc_dhandle,
1970 cq_size + SOCAL_CQ_ALIGN, &socal_acc_attr,
1971 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
1972 (caddr_t *)&cqp->skc_cq_raw, &real_len,
1973 &cqp->skc_acchandle) != DDI_SUCCESS) {
1974 socal_disp_err(socalp, CE_WARN, "driver.4060",
1975 "!alloc of dma space failed");
1976 goto fail;
1977 }
1978
1979 if (real_len < (cq_size + SOCAL_CQ_ALIGN)) {
1980 socal_disp_err(socalp, CE_WARN, "driver.4065",
1981 "!alloc of dma space failed");
1982 goto fail;
1983 }
1984
1985 cqp->skc_cq = (cqe_t *)(((uintptr_t)cqp->skc_cq_raw +
1986 (uintptr_t)SOCAL_CQ_ALIGN - 1) &
1987 ((uintptr_t)(~(SOCAL_CQ_ALIGN-1))));
1988
1989 if (ddi_dma_addr_bind_handle(cqp->skc_dhandle,
1990 (struct as *)NULL, (caddr_t)cqp->skc_cq, cq_size,
1991 DDI_DMA_RDWR | DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT,
1992 NULL, &cqp->skc_dcookie, &ccount) != DDI_DMA_MAPPED) {
1993 socal_disp_err(socalp, CE_WARN, "driver.4070",
1994 "!bind of dma handle failed");
1995 goto fail;
1996 }
1997
1998 rsp_bound = 1;
1999 if (ccount != 1) {
2000 socal_disp_err(socalp, CE_WARN, "driver.4075",
2001 "!bind of dma handle failed");
2002 goto fail;
2003 }
2004
2005 } else {
2006 socalp->response[index].skc_cq_raw = NULL;
2007 socalp->response[index].skc_cq = (cqe_t *)NULL;
2008 socalp->response[index].skc_dhandle = 0;
2009 }
2010
2011 /*
2012 * Initialize the queue pointers
2013 */
2014 socal_cqinit(socalp, index);
2015
2016 return (FCAL_SUCCESS);
2017 fail:
2018 if (socalp->request[index].skc_dhandle) {
2019 if (req_bound)
2020 (void) ddi_dma_unbind_handle(socalp->
2021 request[index].skc_dhandle);
2022 ddi_dma_free_handle(&socalp->request[index].skc_dhandle);
2023 }
2024 if (socalp->request[index].skc_cq_raw)
2025 ddi_dma_mem_free(&socalp->request[index].skc_acchandle);
2026
2027 if (socalp->response[index].skc_dhandle) {
2028 if (rsp_bound)
2029 (void) ddi_dma_unbind_handle(socalp->
2030 response[index].skc_dhandle);
2031 ddi_dma_free_handle(&socalp->response[index].skc_dhandle);
2032 }
2033 if (socalp->response[index].skc_cq_raw)
2034 ddi_dma_mem_free(&socalp->response[index].skc_acchandle);
2035
2036 socalp->request[index].skc_dhandle = NULL;
2037 socalp->response[index].skc_dhandle = NULL;
2038 socalp->request[index].skc_cq_raw = NULL;
2039 socalp->request[index].skc_cq = NULL;
2040 socalp->response[index].skc_cq_raw = NULL;
2041 socalp->response[index].skc_cq = NULL;
2042 mutex_destroy(&socalp->request[index].skc_mtx);
2043 mutex_destroy(&socalp->response[index].skc_mtx);
2044 cv_destroy(&socalp->request[index].skc_cv);
2045 cv_destroy(&socalp->response[index].skc_cv);
2046 return (FCAL_FAILURE);
2047
2048 }
2049
2050 /*
2051 * socal_cqinit() - initializes the driver's circular queue pointers, etc.
2052 */
2053
2054 static void
2055 socal_cqinit(socal_state_t *socalp, uint32_t index)
2056 {
2057 socal_kcq_t *kcq_req = &socalp->request[index];
2058 socal_kcq_t *kcq_rsp = &socalp->response[index];
2059
2060 /*
2061 * Initialize the Request and Response Queue pointers
2062 */
2063 kcq_req->skc_seqno = 1;
2064 kcq_rsp->skc_seqno = 1;
2065 kcq_req->skc_in = 0;
2066 kcq_rsp->skc_in = 0;
2067 kcq_req->skc_out = 0;
2068 kcq_rsp->skc_out = 0;
2069 kcq_req->skc_last_index = socal_req_entries[index] - 1;
2070 kcq_rsp->skc_last_index = socal_rsp_entries[index] - 1;
2071 kcq_req->skc_full = 0;
2072 kcq_rsp->deferred_intr_timeoutid = 0;
2073 kcq_req->skc_socalp = socalp;
2074 kcq_rsp->skc_socalp = socalp;
2075
2076 kcq_req->skc_xram_cqdesc =
2077 (socalp->xram_reqp + (index * sizeof (struct cq))/8);
2078 kcq_rsp->skc_xram_cqdesc =
2079 (socalp->xram_rspp + (index * sizeof (struct cq))/8);
2080
2081 /* Clear out memory we have allocated */
2082 if (kcq_req->skc_cq != NULL)
2083 bzero((caddr_t)kcq_req->skc_cq,
2084 socal_req_entries[index] * sizeof (cqe_t));
2085 if (kcq_rsp->skc_cq != NULL)
2086 bzero((caddr_t)kcq_rsp->skc_cq,
2087 socal_rsp_entries[index] * sizeof (cqe_t));
2088 }
2089
2090
2091 static int
2092 socal_start(socal_state_t *socalp)
2093 {
2094 uint_t r;
2095
2096 if (!socalp)
2097 return (FCAL_FAILURE);
2098
2099 socal_download_ucode(socalp);
2100 socal_init_cq_desc(socalp);
2101 socal_init_wwn(socalp);
2102
2103 mutex_enter(&socalp->port_state[0].sp_mtx);
2104 socalp->port_state[0].sp_status
2105 &= (PORT_OPEN|PORT_CHILD_INIT|PORT_DISABLED|PORT_TARGET_MODE);
2106 socalp->port_state[0].sp_status |= PORT_OFFLINE;
2107 mutex_exit(&socalp->port_state[0].sp_mtx);
2108
2109 mutex_enter(&socalp->port_state[1].sp_mtx);
2110 socalp->port_state[1].sp_status
2111 &= (PORT_OPEN|PORT_CHILD_INIT|PORT_DISABLED|PORT_TARGET_MODE);
2112 socalp->port_state[1].sp_status |= PORT_OFFLINE;
2113 mutex_exit(&socalp->port_state[1].sp_mtx);
2114
2115 socal_enable(socalp);
2116 /* Make sure disabled ports stay disabled. */
2117 if (socalp->port_state[0].sp_status & PORT_DISABLED)
2118 (void) socal_diag_request((void *)socalp, 0, &r,
2119 SOC_DIAG_INT_LOOP);
2120 if (socalp->port_state[1].sp_status & PORT_DISABLED)
2121 (void) socal_diag_request((void *)socalp, 1, &r,
2122 SOC_DIAG_INT_LOOP);
2123
2124 mutex_enter(&socalp->k_imr_mtx);
2125 socalp->socal_shutdown = 0;
2126 mutex_exit(&socalp->k_imr_mtx);
2127
2128 mutex_enter(&socalp->board_mtx);
2129 if (socal_establish_pool(socalp, 1) != FCAL_SUCCESS) {
2130 mutex_exit(&socalp->board_mtx);
2131 return (FCAL_FAILURE);
2132 }
2133 if (socal_add_pool_buffer(socalp, 1) != FCAL_SUCCESS) {
2134 mutex_exit(&socalp->board_mtx);
2135 return (FCAL_FAILURE);
2136 }
2137
2138 mutex_exit(&socalp->board_mtx);
2139 return (FCAL_SUCCESS);
2140 }
2141
2142 static void
2143 socal_doreset(socal_state_t *socalp)
2144 {
2145 int i;
2146 socal_port_t *port_statep;
2147 socal_unsol_cb_t *scbp;
2148
2149 for (i = 0; i < SOCAL_N_CQS; i++) {
2150 mutex_enter(&socalp->request[i].skc_mtx);
2151 mutex_enter(&socalp->response[i].skc_mtx);
2152 }
2153
2154 mutex_enter(&socalp->k_imr_mtx);
2155 socal_disable(socalp);
2156
2157 if (socalp->pool_dhandle) {
2158 (void) ddi_dma_unbind_handle(socalp->pool_dhandle);
2159 ddi_dma_free_handle(&socalp->pool_dhandle);
2160 }
2161
2162 if (socalp->pool)
2163 ddi_dma_mem_free(&socalp->pool_acchandle);
2164
2165 socalp->pool_dhandle = NULL;
2166 socalp->pool = NULL;
2167
2168 for (i = 0; i < SOCAL_N_CQS; i++)
2169 socal_cqinit(socalp, i);
2170
2171 for (i = 0; i < N_SOCAL_NPORTS; i++) {
2172 port_statep = &socalp->port_state[i];
2173
2174 mutex_enter(&port_statep->sp_mtx);
2175 port_statep->sp_status &= ~ (PORT_STATUS_MASK |
2176 PORT_LILP_PENDING | PORT_LIP_PENDING |
2177 PORT_ABORT_PENDING | PORT_BYPASS_PENDING |
2178 PORT_ELS_PENDING);
2179 mutex_exit(&port_statep->sp_mtx);
2180 }
2181
2182 mutex_exit(&socalp->k_imr_mtx);
2183
2184 for (i = SOCAL_N_CQS-1; i >= 0; i--) {
2185 mutex_exit(&socalp->request[i].skc_mtx);
2186 mutex_exit(&socalp->response[i].skc_mtx);
2187 }
2188
2189 for (i = 0; i < N_SOCAL_NPORTS; i++) {
2190 for (scbp = socalp->port_state[i].sp_unsol_cb; scbp;
2191 scbp = scbp->next)
2192 (scbp->statec_cb)(scbp->arg, FCAL_STATE_RESET);
2193 }
2194
2195 for (i = 0; i < SOCAL_N_CQS; i++) {
2196 mutex_enter(&socalp->request[i].skc_mtx);
2197 mutex_enter(&socalp->response[i].skc_mtx);
2198 }
2199
2200
2201 for (i = 0; i < SOCAL_N_CQS; i++) {
2202 socalp->request[i].skc_overflowh = NULL;
2203 if (socalp->request[i].skc_full & SOCAL_SKC_SLEEP)
2204 cv_broadcast(&socalp->request[i].skc_cv);
2205 }
2206
2207 for (i = SOCAL_N_CQS-1; i >= 0; i--) {
2208 mutex_exit(&socalp->request[i].skc_mtx);
2209 mutex_exit(&socalp->response[i].skc_mtx);
2210 }
2211
2212 }
2213
2214
2215 /*
2216 * Function name : socal_download_ucode ()
2217 *
2218 * Return Values :
2219 *
2220 * Description : Copies firmware from code that has been linked into
2221 * the socal module into the soc+'s XRAM. Prints the date
2222 * string
2223 *
2224 */
2225 static void
2226 socal_download_ucode(socal_state_t *socalp)
2227 {
2228 uint_t fw_len = 0;
2229 uint_t date_str[16];
2230 auto char buf[256];
2231
2232 fw_len = (uint_t)socal_ucode_size;
2233
2234 /* Copy the firmware image */
2235 socal_wcopy((uint_t *)&socal_ucode,
2236 (uint_t *)socalp->socal_xrp, fw_len);
2237
2238 socal_fix_harda(socalp, 0);
2239 socal_fix_harda(socalp, 1);
2240
2241 /* Get the date string from the firmware image */
2242 socal_wcopy((uint_t *)(socalp->socal_xrp+SOCAL_XRAM_FW_DATE_STR),
2243 date_str, sizeof (date_str));
2244 date_str[sizeof (date_str) / sizeof (uint_t) - 1] = 0;
2245
2246 if (*(caddr_t)date_str != '\0') {
2247 (void) sprintf(buf,
2248 "!Downloading host adapter, fw date code: %s\n",
2249 (caddr_t)date_str);
2250 socal_disp_err(socalp, CE_CONT, "driver.1010", buf);
2251 (void) strcpy(socalp->socal_stats.fw_revision,
2252 (char *)date_str);
2253 } else {
2254 (void) sprintf(buf,
2255 "!Downloading host adapter fw, "
2256 "date code: <not available>\n");
2257 socal_disp_err(socalp, CE_CONT, "driver.3010", buf);
2258 (void) strcpy(socalp->socal_stats.fw_revision,
2259 "<Not Available>");
2260 }
2261 }
2262
2263 /*
2264 * Function name : socal_disp_err()
2265 *
2266 * Return Values : none
2267 *
2268 * Description : displays an error message on the system console
2269 * with the full device pathname displayed
2270 */
2271 static void
2272 socal_disp_err(
2273 socal_state_t *socalp,
2274 uint_t level,
2275 char *mid,
2276 char *msg)
2277 {
2278 char c;
2279 int instance;
2280
2281 instance = ddi_get_instance(socalp->dip);
2282
2283 c = *msg;
2284
2285 if (c == '!') /* log only */
2286 cmn_err(level,
2287 "!ID[SUNWssa.socal.%s] socal%d: %s", mid, instance, msg+1);
2288 else if (c == '?') /* boot message - log && maybe console */
2289 cmn_err(level,
2290 "?ID[SUNWssa.socal.%s] socal%d: %s", mid, instance, msg+1);
2291 else if (c == '^') /* console only */
2292 cmn_err(level, "^socal%d: %s", instance, msg+1);
2293 else { /* log and console */
2294 cmn_err(level, "^socal%d: %s", instance, msg);
2295 cmn_err(level, "!ID[SUNWssa.socal.%s] socal%d: %s", mid,
2296 instance, msg);
2297 }
2298 }
2299
2300 /*
2301 * Function name : socal_init_cq_desc()
2302 *
2303 * Return Values : none
2304 *
2305 * Description : Initializes the request and response queue
2306 * descriptors in the SOC+'s XRAM
2307 *
2308 * Context : Should only be called during initialiation when
2309 * the SOC+ is reset.
2310 */
2311 static void
2312 socal_init_cq_desc(socal_state_t *socalp)
2313 {
2314 soc_cq_t que_desc[SOCAL_N_CQS];
2315 uint32_t i;
2316
2317 /*
2318 * Finish CQ table initialization and give the descriptor
2319 * table to the soc+. Note that we don't use all of the queues
2320 * provided by the hardware, but we make sure we initialize the
2321 * quantities in the unused fields in the hardware to zeroes.
2322 */
2323
2324 /*
2325 * Do request queues
2326 */
2327 for (i = 0; i < SOCAL_N_CQS; i++) {
2328 if (socal_req_entries[i]) {
2329 que_desc[i].cq_address =
2330 (uint32_t)socalp->request[i].
2331 skc_dcookie.dmac_address;
2332 que_desc[i].cq_last_index = socal_req_entries[i] - 1;
2333 } else {
2334 que_desc[i].cq_address = (uint32_t)0;
2335 que_desc[i].cq_last_index = 0;
2336 }
2337 que_desc[i].cq_in = 0;
2338 que_desc[i].cq_out = 0;
2339 que_desc[i].cq_seqno = 1; /* required by SOC+ microcode */
2340 }
2341
2342 /* copy to XRAM */
2343 socal_wcopy((uint_t *)que_desc, /* pointer to kernel copy */
2344 (uint_t *)socalp->xram_reqp, /* pointer to xram location */
2345 SOCAL_N_CQS * sizeof (soc_cq_t));
2346
2347 /*
2348 * Do response queues
2349 */
2350 for (i = 0; i < SOCAL_N_CQS; i++) {
2351 if (socal_rsp_entries[i]) {
2352 que_desc[i].cq_last_index = socal_rsp_entries[i] - 1;
2353 que_desc[i].cq_address =
2354 (uint32_t)socalp->response[i].
2355 skc_dcookie.dmac_address;
2356
2357 } else {
2358 que_desc[i].cq_address = 0;
2359 que_desc[i].cq_last_index = 0;
2360 }
2361 }
2362
2363 /* copy to XRAM */
2364 socal_wcopy((uint_t *)que_desc, /* pointer to kernel copy */
2365 (uint_t *)socalp->xram_rspp, /* pointer to xram location */
2366 SOCAL_N_CQS * sizeof (soc_cq_t));
2367 }
2368
2369 static void
2370 socal_init_wwn(socal_state_t *socalp)
2371 {
2372 /* copy the node wwn to xram */
2373 socal_wcopy((uint_t *)&socalp->socal_n_wwn,
2374 (uint_t *)(socalp->socal_xrp +
2375 SOCAL_XRAM_NODE_WWN), sizeof (la_wwn_t));
2376
2377 /* copy port a's wwn to xram */
2378 socal_wcopy((uint_t *)&socalp->port_state[0].sp_p_wwn,
2379 (uint_t *)(socalp->socal_xrp + SOCAL_XRAM_PORTA_WWN),
2380 sizeof (la_wwn_t));
2381
2382 /* copy port b's wwn to xram */
2383 socal_wcopy((uint_t *)&socalp->port_state[1].sp_p_wwn,
2384 (uint_t *)(socalp->socal_xrp + SOCAL_XRAM_PORTB_WWN),
2385 sizeof (la_wwn_t));
2386
2387 /*
2388 * need to avoid deadlock by assuring no other thread grabs both of
2389 * these at once
2390 */
2391 mutex_enter(&socalp->port_state[0].sp_transport->fcal_mtx);
2392 mutex_enter(&socalp->port_state[1].sp_transport->fcal_mtx);
2393
2394 socal_wcopy((uint_t *)(socalp->socal_xrp + SOCAL_XRAM_SERV_PARAMS),
2395 (uint_t *)&socalp->socal_service_params, SOCAL_SVC_LENGTH);
2396 mutex_exit(&socalp->port_state[1].sp_transport->fcal_mtx);
2397 mutex_exit(&socalp->port_state[0].sp_transport->fcal_mtx);
2398 }
2399
2400 static void
2401 socal_enable(socal_state_t *socalp)
2402 {
2403 DEBUGF(2, (CE_CONT, "socal%d: enable:\n",
2404 ddi_get_instance(socalp->dip)));
2405
2406 socalp->socal_rp->socal_cr.w = socalp->socal_cfg;
2407 socalp->socal_rp->socal_csr.w = SOCAL_CSR_SOCAL_TO_HOST;
2408
2409 socalp->socal_k_imr = (uint32_t)SOCAL_CSR_SOCAL_TO_HOST |
2410 SOCAL_CSR_SLV_ACC_ERR;
2411 socalp->socal_rp->socal_imr = (uint32_t)socalp->socal_k_imr;
2412 }
2413
2414 /*
2415 * static int
2416 * socal_establish_pool() - this routine tells the SOC+ of a buffer pool
2417 * to place LINK ctl application data as it arrives.
2418 *
2419 * Returns:
2420 * FCAL_SUCCESS, upon establishing the pool.
2421 * FCAL_FAILURE, if unable to establish the pool.
2422 */
2423
2424 static int
2425 socal_establish_pool(socal_state_t *socalp, uint32_t poolid)
2426 {
2427 soc_pool_request_t *prq;
2428 int result;
2429
2430 if ((prq =
2431 (soc_pool_request_t *)kmem_zalloc(sizeof (soc_pool_request_t),
2432 KM_NOSLEEP)) == NULL)
2433 return (FCAL_FAILURE);
2434 /*
2435 * Fill in the request structure.
2436 */
2437 prq->spr_soc_hdr.sh_request_token = 1;
2438 prq->spr_soc_hdr.sh_flags = SOC_FC_HEADER | SOC_UNSOLICITED |
2439 SOC_NO_RESPONSE;
2440 prq->spr_soc_hdr.sh_class = 0;
2441 prq->spr_soc_hdr.sh_seg_cnt = 1;
2442 prq->spr_soc_hdr.sh_byte_cnt = 0;
2443
2444 prq->spr_pool_id = poolid;
2445 prq->spr_header_mask = SOCPR_MASK_RCTL;
2446 prq->spr_buf_size = SOCAL_POOL_SIZE;
2447 prq->spr_n_entries = 0;
2448
2449 prq->spr_fc_frame_hdr.r_ctl = R_CTL_ELS_REQ;
2450 prq->spr_fc_frame_hdr.d_id = 0;
2451 prq->spr_fc_frame_hdr.s_id = 0;
2452 prq->spr_fc_frame_hdr.type = 0;
2453 prq->spr_fc_frame_hdr.f_ctl = 0;
2454 prq->spr_fc_frame_hdr.seq_id = 0;
2455 prq->spr_fc_frame_hdr.df_ctl = 0;
2456 prq->spr_fc_frame_hdr.seq_cnt = 0;
2457 prq->spr_fc_frame_hdr.ox_id = 0;
2458 prq->spr_fc_frame_hdr.rx_id = 0;
2459 prq->spr_fc_frame_hdr.ro = 0;
2460
2461 prq->spr_cqhdr.cq_hdr_count = 1;
2462 prq->spr_cqhdr.cq_hdr_type = CQ_TYPE_ADD_POOL;
2463 prq->spr_cqhdr.cq_hdr_flags = 0;
2464 prq->spr_cqhdr.cq_hdr_seqno = 0;
2465
2466 /* Enque the request. */
2467 result = socal_cq_enque(socalp, NULL, (cqe_t *)prq, CQ_REQUEST_1,
2468 FCAL_NOSLEEP, NULL, 0);
2469 kmem_free((void *)prq, sizeof (soc_pool_request_t));
2470 return (result);
2471
2472 }
2473
2474
2475 /*
2476 * static int
2477 * soc_add_pool_buffer() - this routine tells the SOC+ to add one buffer
2478 * to an established pool of buffers
2479 *
2480 * Returns:
2481 * DDI_SUCCESS, upon establishing the pool.
2482 * DDI_FAILURE, if unable to establish the pool.
2483 */
2484
2485 static int
2486 socal_add_pool_buffer(socal_state_t *socalp, uint32_t poolid)
2487 {
2488 soc_data_request_t *drq;
2489 int result;
2490 size_t real_len;
2491 int bound = 0;
2492 uint_t ccount;
2493
2494 if ((drq =
2495 (soc_data_request_t *)kmem_zalloc(sizeof (soc_data_request_t),
2496 KM_NOSLEEP)) == NULL)
2497 return (FCAL_FAILURE);
2498
2499 /* Allocate DVMA resources for the buffer pool */
2500 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
2501 DDI_DMA_DONTWAIT, NULL, &socalp->pool_dhandle) != DDI_SUCCESS)
2502 goto fail;
2503
2504 if (ddi_dma_mem_alloc(socalp->pool_dhandle, SOCAL_POOL_SIZE,
2505 &socal_acc_attr, DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
2506 (caddr_t *)&socalp->pool, &real_len, &socalp->pool_acchandle)
2507 != DDI_SUCCESS)
2508 goto fail;
2509
2510 if (real_len < SOCAL_POOL_SIZE)
2511 goto fail;
2512
2513 if (ddi_dma_addr_bind_handle(socalp->pool_dhandle, (struct as *)NULL,
2514 (caddr_t)socalp->pool, SOCAL_POOL_SIZE,
2515 DDI_DMA_READ | DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT,
2516 NULL, &socalp->pool_dcookie, &ccount) != DDI_DMA_MAPPED)
2517 goto fail;
2518
2519 bound = 1;
2520 if (ccount != 1)
2521 goto fail;
2522
2523 /*
2524 * Fill in the request structure.
2525 */
2526 drq->sdr_soc_hdr.sh_request_token = poolid;
2527 drq->sdr_soc_hdr.sh_flags = SOC_UNSOLICITED | SOC_NO_RESPONSE;
2528 drq->sdr_soc_hdr.sh_class = 0;
2529 drq->sdr_soc_hdr.sh_seg_cnt = 1;
2530 drq->sdr_soc_hdr.sh_byte_cnt = 0;
2531
2532 drq->sdr_dataseg[0].fc_base =
2533 (uint32_t)socalp->pool_dcookie.dmac_address;
2534 drq->sdr_dataseg[0].fc_count = SOCAL_POOL_SIZE;
2535 drq->sdr_dataseg[1].fc_base = 0;
2536 drq->sdr_dataseg[1].fc_count = 0;
2537 drq->sdr_dataseg[2].fc_base = 0;
2538 drq->sdr_dataseg[2].fc_count = 0;
2539 drq->sdr_dataseg[3].fc_base = 0;
2540 drq->sdr_dataseg[3].fc_count = 0;
2541 drq->sdr_dataseg[4].fc_base = 0;
2542 drq->sdr_dataseg[4].fc_count = 0;
2543 drq->sdr_dataseg[5].fc_base = 0;
2544 drq->sdr_dataseg[5].fc_count = 0;
2545
2546 drq->sdr_cqhdr.cq_hdr_count = 1;
2547 drq->sdr_cqhdr.cq_hdr_type = CQ_TYPE_ADD_BUFFER;
2548 drq->sdr_cqhdr.cq_hdr_flags = 0;
2549 drq->sdr_cqhdr.cq_hdr_seqno = 0;
2550
2551 /* Transport the request. */
2552 result = socal_cq_enque(socalp, NULL, (cqe_t *)drq, CQ_REQUEST_1,
2553 FCAL_NOSLEEP, NULL, 0);
2554 kmem_free((void *)drq, sizeof (soc_data_request_t));
2555 return (result);
2556
2557 fail:
2558 socal_disp_err(socalp, CE_WARN, "driver.4110",
2559 "!Buffer pool DVMA alloc failed");
2560 if (socalp->pool_dhandle) {
2561 if (bound)
2562 (void) ddi_dma_unbind_handle(socalp->pool_dhandle);
2563 ddi_dma_free_handle(&socalp->pool_dhandle);
2564 }
2565 if (socalp->pool)
2566 ddi_dma_mem_free(&socalp->pool_acchandle);
2567 socalp->pool_dhandle = NULL;
2568 return (FCAL_FAILURE);
2569 }
2570
2571 static uint_t
2572 socal_transport(fcal_packet_t *fcalpkt, fcal_sleep_t sleep, int req_q_no)
2573 {
2574 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
2575 socal_port_t *port_statep;
2576 #if defined(DEBUG) && !defined(lint)
2577 int instance = ddi_get_instance(socalp->dip);
2578 #endif
2579 int port;
2580 soc_request_t *sp = (soc_request_t *)&fcalpkt->fcal_socal_request;
2581
2582 if (sp->sr_soc_hdr.sh_flags & SOC_PORT_B)
2583 port = 1;
2584 else
2585 port = 0;
2586 port_statep = &socalp->port_state[port];
2587
2588 DEBUGF(4, (CE_CONT, "socal%d: transport: packet, sleep = %p, %d\n",
2589 instance, fcalpkt, sleep));
2590
2591 fcalpkt->fcal_cmd_state = 0;
2592 fcalpkt->fcal_pkt_flags &= ~(FCFLAG_COMPLETE | FCFLAG_ABORTING);
2593
2594 return (socal_cq_enque(socalp, port_statep, (cqe_t *)sp,
2595 req_q_no, sleep, fcalpkt, 0));
2596 }
2597
2598 /*
2599 * Function name : socal_cq_enque()
2600 *
2601 * Return Values :
2602 * FCAL_TRANSPORT_SUCCESS, if able to que the entry.
2603 * FCAL_TRANSPORT_QFULL, if queue full & sleep not set
2604 * FCAL_TRANSPORT_UNAVAIL if this port down
2605 *
2606 * Description : Enqueues an entry into the solicited request
2607 * queue
2608 *
2609 * Context :
2610 */
2611
2612 /*ARGSUSED*/
2613 static int
2614 socal_cq_enque(socal_state_t *socalp, socal_port_t *port_statep, cqe_t *cqe,
2615 int rqix, fcal_sleep_t sleep, fcal_packet_t *to_queue,
2616 int mtxheld)
2617 {
2618 #if defined(DEBUG) && !defined(lint)
2619 int instance = ddi_get_instance(socalp->dip);
2620 #endif
2621 socal_kcq_t *kcq;
2622 cqe_t *sp;
2623 uint_t bitmask, wmask;
2624 uchar_t out;
2625 uchar_t s_out;
2626 longlong_t *p, *q;
2627
2628 kcq = &socalp->request[rqix];
2629
2630 bitmask = SOCAL_CSR_1ST_H_TO_S << rqix;
2631 wmask = SOCAL_CSR_SOCAL_TO_HOST | bitmask;
2632 p = (longlong_t *)cqe;
2633
2634 /*
2635 * Since we're only reading we don't need a mutex.
2636 */
2637 if (socalp->socal_shutdown) {
2638 return (FCAL_TRANSPORT_UNAVAIL);
2639 }
2640 /*
2641 * Get a token early. That way we won't sleep
2642 * in id32_alloc() with a mutex held.
2643 */
2644 if (to_queue) {
2645 if ((to_queue->fcal_socal_request.sr_soc_hdr.sh_request_token =
2646 SOCAL_ID_GET(to_queue, mtxheld ? FCAL_NOSLEEP :
2647 sleep)) == NULL) {
2648 return (FCAL_TRANSPORT_QFULL);
2649 }
2650 }
2651 /*
2652 * Grab lock for request queue.
2653 */
2654
2655 if (!mtxheld)
2656 mutex_enter(&kcq->skc_mtx);
2657
2658 /*
2659 * Determine if the queue is full
2660 */
2661
2662 do {
2663
2664 if (kcq->skc_full) {
2665 /*
2666 * If soc's queue full, then we wait for an interrupt
2667 * telling us we are not full.
2668 */
2669
2670 if (to_queue) {
2671 to_queue->fcal_pkt_next = NULL;
2672 if (!kcq->skc_overflowh) {
2673 DEBUGF(2, (CE_CONT,
2674 "socal%d: cq_enque: request "
2675 "que %d is full\n",
2676 instance, rqix));
2677 kcq->skc_overflowh = to_queue;
2678 socalp->socal_stats.qfulls++;
2679 } else
2680 kcq->skc_overflowt->fcal_pkt_next = to_queue;
2681 kcq->skc_overflowt = to_queue;
2682
2683 mutex_enter(&socalp->k_imr_mtx);
2684 socalp->socal_rp->socal_imr =
2685 (socalp->socal_k_imr |= bitmask);
2686 mutex_exit(&socalp->k_imr_mtx);
2687 to_queue->fcal_cmd_state |= FCAL_CMD_IN_TRANSPORT;
2688 if (!mtxheld)
2689 mutex_exit(&kcq->skc_mtx);
2690 return (FCAL_TRANSPORT_SUCCESS);
2691 }
2692
2693 if (!mtxheld)
2694 mutex_exit(&kcq->skc_mtx);
2695 return (FCAL_TRANSPORT_QFULL);
2696 }
2697
2698 if (((kcq->skc_in + 1) & kcq->skc_last_index)
2699 == (out = kcq->skc_out)) {
2700 /*
2701 * get SOC+'s copy of out to update our copy of out
2702 */
2703 s_out =
2704 SOCAL_REQUESTQ_INDEX(rqix, socalp->socal_rp->socal_reqp.w);
2705 DEBUGF(2, (CE_CONT,
2706 "socal%d: cq_enque: &XRAM cq_in: 0x%p s_out.out 0x%x\n",
2707 instance, &kcq->skc_xram_cqdesc->cq_in, s_out));
2708
2709 kcq->skc_out = out = s_out;
2710 /* if soc+'s que still full set flag */
2711 kcq->skc_full = ((((kcq->skc_in + 1) &
2712 kcq->skc_last_index) == out)) ? SOCAL_SKC_FULL : 0;
2713 }
2714
2715 } while (kcq->skc_full);
2716
2717 /* Now enque the entry. */
2718 sp = &(kcq->skc_cq[kcq->skc_in]);
2719 cqe->cqe_hdr.cq_hdr_seqno = kcq->skc_seqno;
2720
2721 /* Give the entry to the SOC. */
2722 q = (longlong_t *)sp;
2723 *q++ = *p++;
2724 *q++ = *p++;
2725 *q++ = *p++;
2726 *q++ = *p++;
2727 *q++ = *p++;
2728 *q++ = *p++;
2729 *q++ = *p++;
2730 *q = *p;
2731 (void) ddi_dma_sync(kcq->skc_dhandle, (int)((caddr_t)sp -
2732 (caddr_t)kcq->skc_cq), sizeof (cqe_t), DDI_DMA_SYNC_FORDEV);
2733 if (to_queue)
2734 to_queue->fcal_cmd_state |= FCAL_CMD_IN_TRANSPORT;
2735
2736 /*
2737 * Update circular queue and ring SOC's doorbell.
2738 */
2739 kcq->skc_in++;
2740 if ((kcq->skc_in & kcq->skc_last_index) == 0) {
2741 kcq->skc_in = 0;
2742 kcq->skc_seqno++;
2743 }
2744
2745 socalp->socal_rp->socal_csr.w = wmask | (kcq->skc_in << 24);
2746 /* Let lock go for request queue. */
2747 if (!mtxheld)
2748 mutex_exit(&kcq->skc_mtx);
2749
2750 return (FCAL_TRANSPORT_SUCCESS);
2751 }
2752
2753 static uint_t
2754 socal_transport_poll(fcal_packet_t *fcalpkt, uint_t timeout, int req_q_no)
2755 {
2756 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
2757 register volatile socal_reg_t *socalreg = socalp->socal_rp;
2758 uint_t csr;
2759 socal_port_t *port_statep;
2760 int port;
2761 soc_request_t *sp = (soc_request_t *)&fcalpkt->fcal_socal_request;
2762 uint32_t retval;
2763 clock_t ticker, t;
2764
2765 /* make the timeout meaningful */
2766 timeout = drv_usectohz(timeout);
2767 if (sp->sr_soc_hdr.sh_flags & SOC_PORT_B)
2768 port = 1;
2769 else
2770 port = 0;
2771 port_statep = &socalp->port_state[port];
2772
2773 fcalpkt->fcal_cmd_state = 0;
2774 fcalpkt->fcal_pkt_flags &= ~(FCFLAG_COMPLETE | FCFLAG_ABORTING);
2775
2776 ticker = ddi_get_lbolt();
2777
2778 if ((retval = socal_cq_enque(socalp, port_statep, (cqe_t *)sp,
2779 req_q_no, FCAL_NOSLEEP, fcalpkt, 0)) != FCAL_TRANSPORT_SUCCESS) {
2780 return (retval);
2781 } else {
2782 while (!(fcalpkt->fcal_cmd_state & FCAL_CMD_COMPLETE)) {
2783 drv_usecwait(SOCAL_NOINTR_POLL_DELAY_TIME);
2784 t = ddi_get_lbolt();
2785 if ((ticker + timeout) < t)
2786 return (FCAL_TRANSPORT_TIMEOUT);
2787 csr = socalreg->socal_csr.w;
2788 if ((SOCAL_INTR_CAUSE(socalp, csr)) &
2789 SOCAL_CSR_RSP_QUE_0) {
2790 socal_intr_solicited(socalp, 0);
2791 }
2792 }
2793 }
2794 return (FCAL_TRANSPORT_SUCCESS);
2795 }
2796
2797 static uint_t
2798 socal_doit(fcal_packet_t *fcalpkt, socal_port_t *port_statep, int polled,
2799 void (*func)(), int timo, int flag, uint_t *diagcode)
2800 {
2801 clock_t lb;
2802 uint32_t retval, status;
2803 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
2804
2805 if (polled) {
2806 fcalpkt->fcal_pkt_comp = NULL;
2807 status = socal_transport_poll(fcalpkt, timo, CQ_REQUEST_0);
2808 } else {
2809 fcalpkt->fcal_pkt_comp = func;
2810 mutex_enter(&port_statep->sp_mtx);
2811 port_statep->sp_status |= flag;
2812 if ((status = socal_transport(fcalpkt, FCAL_NOSLEEP,
2813 CQ_REQUEST_0)) == FCAL_TRANSPORT_SUCCESS) {
2814 lb = ddi_get_lbolt();
2815 while (!(fcalpkt->fcal_cmd_state & FCAL_CMD_COMPLETE)) {
2816 if ((retval = cv_timedwait(&port_statep->sp_cv,
2817 &port_statep->sp_mtx,
2818 lb+drv_usectohz(timo))) == -1) {
2819 status = FCAL_TRANSPORT_TIMEOUT;
2820 break;
2821 }
2822 }
2823 }
2824 port_statep->sp_status &= ~flag;
2825 mutex_exit(&port_statep->sp_mtx);
2826 }
2827
2828 switch (status) {
2829 case FCAL_TRANSPORT_SUCCESS:
2830 status = fcalpkt->fcal_pkt_status;
2831 if (diagcode)
2832 *diagcode = fcalpkt->fcal_diag_status;
2833 switch (status) {
2834 case FCAL_STATUS_ABORT_FAILED:
2835 if (flag == PORT_ABORT_PENDING)
2836 retval = FCAL_ABORT_FAILED;
2837 break;
2838 case FCAL_STATUS_OK:
2839 if (flag == PORT_ABORT_PENDING)
2840 retval = FCAL_ABORT_FAILED;
2841 else
2842 retval = FCAL_SUCCESS;
2843 break;
2844 case FCAL_STATUS_OLD_PORT:
2845 retval = FCAL_OLD_PORT;
2846 break;
2847 case FCAL_STATUS_ERR_OFFLINE:
2848 retval = FCAL_OFFLINE;
2849 break;
2850 case FCAL_STATUS_ABORTED:
2851 retval = FCAL_ABORTED;
2852 port_statep->sp_board->
2853 socal_stats.pstats[port_statep
2854 ->sp_port].abts_ok++;
2855 break;
2856 case FCAL_STATUS_BAD_XID:
2857 retval = FCAL_BAD_ABORT;
2858 break;
2859 case FCAL_STATUS_BAD_DID:
2860 retval = FCAL_BAD_PARAMS;
2861 break;
2862 case FCAL_STATUS_DIAG_BUSY:
2863 case FCAL_STATUS_DIAG_INVALID:
2864 retval = status;
2865 break;
2866 default:
2867 retval = FCAL_LINK_ERROR;
2868 }
2869 break;
2870 case FCAL_TRANSPORT_TIMEOUT:
2871 if (flag == PORT_LIP_PENDING ||
2872 flag == PORT_LILP_PENDING) {
2873 if (socal_core &&
2874 (socal_core & SOCAL_FAILED_LIP)) {
2875 socal_core = 0;
2876 socal_take_core(socalp);
2877 }
2878 socal_disp_err(socalp, CE_WARN, "link.6040",
2879 "SOCAL:Forcing SOC+ reset as LIP timed out\n");
2880 /* restart socal after resetting */
2881 (void) socal_force_reset(port_statep->sp_board,
2882 polled, RESET_PORT);
2883 }
2884 else
2885 (void) socal_force_lip(port_statep->sp_board,
2886 port_statep->sp_port, polled,
2887 FCAL_FORCE_LIP);
2888 retval = FCAL_TIMEOUT;
2889 break;
2890 case FCAL_TRANSPORT_FAILURE:
2891 case FCAL_BAD_PACKET:
2892 case FCAL_TRANSPORT_UNAVAIL:
2893 case FCAL_TRANSPORT_QFULL:
2894 retval = status;
2895 break;
2896 default:
2897 retval = FCAL_LINK_ERROR;
2898 }
2899 socal_packet_free(fcalpkt);
2900 return (retval);
2901 }
2902
2903 static uint_t
2904 socal_lilp_map(void *ssp, uint_t port, uint32_t bufid, uint_t polled)
2905 {
2906 fcal_packet_t *fcalpkt;
2907 soc_data_request_t *sdr;
2908 socal_state_t *socalp = (socal_state_t *)ssp;
2909 socal_port_t *port_statep = &socalp->port_state[port];
2910
2911 if ((fcalpkt =
2912 socal_packet_alloc(socalp, polled ? FCAL_NOSLEEP : FCAL_SLEEP))
2913 == (fcal_packet_t *)NULL)
2914 return (FCAL_ALLOC_FAILED);
2915
2916 sdr = (soc_data_request_t *)&fcalpkt->fcal_socal_request;
2917 if (port)
2918 sdr->sdr_soc_hdr.sh_flags = SOC_PORT_B;
2919 sdr->sdr_soc_hdr.sh_seg_cnt = 1;
2920 sdr->sdr_soc_hdr.sh_byte_cnt = 132;
2921 sdr->sdr_dataseg[0].fc_base = bufid;
2922 sdr->sdr_dataseg[0].fc_count = 132;
2923 sdr->sdr_cqhdr.cq_hdr_count = 1;
2924 sdr->sdr_cqhdr.cq_hdr_type = CQ_TYPE_REPORT_MAP;
2925 fcalpkt->fcal_pkt_cookie = (void *)socalp;
2926
2927 return (socal_doit(fcalpkt, port_statep, polled, socal_lilp_map_done,
2928 SOCAL_LILP_TIMEOUT, PORT_LILP_PENDING, NULL));
2929 }
2930
2931 static uint_t
2932 socal_force_lip(void *ssp, uint_t port, uint_t polled, uint_t lip_req)
2933 {
2934 fcal_packet_t *fcalpkt;
2935 soc_cmdonly_request_t *scr;
2936 socal_state_t *socalp = (socal_state_t *)ssp;
2937 socal_port_t *port_statep = &socalp->port_state[port];
2938
2939
2940 if (lip_req == FCAL_NO_LIP) {
2941 mutex_enter(&port_statep->sp_mtx);
2942 if ((port_statep->sp_status & PORT_ONLINE_LOOP) &&
2943 (port_statep->sp_unsol_cb->statec_cb != NULL)) {
2944 mutex_exit(&port_statep->sp_mtx);
2945 (*port_statep->sp_unsol_cb->statec_cb)
2946 (port_statep->sp_unsol_cb->arg,
2947 FCAL_STATUS_LOOP_ONLINE);
2948 return (FCAL_SUCCESS);
2949
2950 } else
2951 mutex_exit(&port_statep->sp_mtx);
2952 }
2953 socalp->socal_stats.pstats[port].lips++;
2954 if ((fcalpkt =
2955 socal_packet_alloc(socalp, polled ? FCAL_NOSLEEP : FCAL_SLEEP))
2956 == (fcal_packet_t *)NULL)
2957 return (FCAL_ALLOC_FAILED);
2958
2959 scr = (soc_cmdonly_request_t *)&fcalpkt->fcal_socal_request;
2960 if (port)
2961 scr->scr_soc_hdr.sh_flags = SOC_PORT_B;
2962 scr->scr_cqhdr.cq_hdr_count = 1;
2963 scr->scr_cqhdr.cq_hdr_type = CQ_TYPE_REQUEST_LIP;
2964
2965 fcalpkt->fcal_pkt_cookie = (void *)socalp;
2966 return (socal_doit(fcalpkt, port_statep, polled, socal_force_lip_done,
2967 SOCAL_LIP_TIMEOUT, PORT_LIP_PENDING, NULL));
2968 }
2969
2970 static uint_t
2971 socal_abort_cmd(void *ssp, uint_t port, fcal_packet_t *fcalpkt, uint_t polled)
2972 {
2973 fcal_packet_t *fcalpkt2, *fpkt;
2974 soc_cmdonly_request_t *scr, *tscr;
2975 socal_state_t *socalp = (socal_state_t *)ssp;
2976 socal_port_t *port_statep = &socalp->port_state[port];
2977 socal_kcq_t *kcq;
2978
2979 socalp->socal_stats.pstats[port].abts++;
2980 kcq = &socalp->request[CQ_REQUEST_1];
2981 mutex_enter(&kcq->skc_mtx);
2982 fcalpkt2 = kcq->skc_overflowh;
2983 fpkt = NULL;
2984 while (fcalpkt2 != NULL) {
2985 if (fcalpkt2 == fcalpkt) {
2986 if (fpkt == NULL)
2987 kcq->skc_overflowh = fcalpkt->fcal_pkt_next;
2988 else {
2989 fpkt->fcal_pkt_next = fcalpkt->fcal_pkt_next;
2990 if (kcq->skc_overflowt == fcalpkt)
2991 kcq->skc_overflowt = fpkt;
2992 }
2993 mutex_exit(&kcq->skc_mtx);
2994 socalp->socal_stats.pstats[port].abts_ok++;
2995 SOCAL_ID_FREE(fcalpkt->fcal_socal_request.
2996 sr_soc_hdr.sh_request_token);
2997 return (FCAL_ABORTED);
2998 } else {
2999 fpkt = fcalpkt2;
3000 fcalpkt2 = fcalpkt2->fcal_pkt_next;
3001 }
3002 }
3003 mutex_exit(&kcq->skc_mtx);
3004 if ((fcalpkt2 =
3005 socal_packet_alloc(socalp, polled ? FCAL_NOSLEEP : FCAL_SLEEP))
3006 == (fcal_packet_t *)NULL)
3007 return (FCAL_ALLOC_FAILED);
3008
3009 mutex_enter(&socalp->abort_mtx);
3010 /* Too late? */
3011 if (fcalpkt->fcal_pkt_flags & FCFLAG_COMPLETE) {
3012 socal_packet_free(fcalpkt2);
3013 mutex_exit(&socalp->abort_mtx);
3014 return (FCAL_ABORTED);
3015 /* I lied. So shoot me. */
3016 }
3017 /* Mark packet as being aborted and put it in the abort pending list. */
3018 fcalpkt->fcal_pkt_flags |= FCFLAG_ABORTING;
3019
3020 scr = (soc_cmdonly_request_t *)&fcalpkt2->fcal_socal_request;
3021 tscr = (soc_cmdonly_request_t *)&fcalpkt->fcal_socal_request;
3022 scr->scr_soc_hdr.sh_byte_cnt = tscr->scr_soc_hdr.sh_request_token;
3023 scr->scr_cqhdr.cq_hdr_count = 1;
3024 scr->scr_cqhdr.cq_hdr_type = CQ_TYPE_REQUEST_ABORT;
3025 if (port)
3026 scr->scr_soc_hdr.sh_flags = SOC_PORT_B;
3027 fcalpkt2->fcal_pkt_cookie = (void *)socalp;
3028 mutex_exit(&socalp->abort_mtx);
3029
3030 return (socal_doit(fcalpkt2, port_statep, polled, socal_abort_done,
3031 SOCAL_ABORT_TIMEOUT, PORT_ABORT_PENDING, NULL));
3032 }
3033
3034 /*ARGSUSED*/
3035 static uint_t
3036 socal_els(void *ssp, uint_t port, uint_t elscode, uint_t dest,
3037 void (*callback)(), void *arg, caddr_t reqpl, caddr_t *rsppl,
3038 uint_t sleep)
3039 {
3040 return (FCAL_TRANSPORT_FAILURE);
3041 }
3042
3043 static uint_t
3044 socal_bypass_dev(void *ssp, uint_t port, uint_t dest)
3045 {
3046 fcal_packet_t *fcalpkt;
3047 soc_cmdonly_request_t *scr;
3048 socal_state_t *socalp = (socal_state_t *)ssp;
3049 socal_port_t *port_statep = &socalp->port_state[port];
3050
3051 if ((fcalpkt =
3052 socal_packet_alloc(socalp, FCAL_SLEEP))
3053 == (fcal_packet_t *)NULL)
3054 return (FCAL_ALLOC_FAILED);
3055
3056 scr = (soc_cmdonly_request_t *)&fcalpkt->fcal_socal_request;
3057 if (port)
3058 scr->scr_soc_hdr.sh_flags = SOC_PORT_B;
3059 scr->scr_soc_hdr.sh_byte_cnt = dest;
3060 scr->scr_cqhdr.cq_hdr_count = 1;
3061 scr->scr_cqhdr.cq_hdr_type = CQ_TYPE_BYPASS_DEV;
3062 return (socal_doit(fcalpkt, port_statep, 0, socal_bypass_dev_done,
3063 SOCAL_BYPASS_TIMEOUT, PORT_BYPASS_PENDING, NULL));
3064 }
3065
3066
3067 /*ARGSUSED*/
3068 static void
3069 socal_force_reset(void *ssp, uint_t port, uint_t restart)
3070 {
3071 socal_state_t *socalp = (socal_state_t *)ssp;
3072
3073 mutex_enter(&socalp->k_imr_mtx);
3074 if (socalp->socal_shutdown) {
3075 mutex_exit(&socalp->k_imr_mtx);
3076 return;
3077 } else {
3078 socalp->socal_shutdown = 1;
3079 mutex_exit(&socalp->k_imr_mtx);
3080 }
3081 socalp->socal_stats.resets++;
3082 socal_doreset(socalp);
3083 if (restart) {
3084 if (socal_start(socalp) != FCAL_SUCCESS) {
3085 cmn_err(CE_WARN, "socal: start failed.\n");
3086 }
3087 }
3088 }
3089
3090
3091 static void
3092 socal_add_ulp(void *ssp, uint_t port, uchar_t type,
3093 void (*ulp_statec_callback)(), void (*ulp_els_callback)(),
3094 void (*ulp_data_callback)(), void *arg)
3095 {
3096 socal_state_t *socalp = (socal_state_t *)ssp;
3097 socal_port_t *port_statep = &socalp->port_state[port];
3098 socal_unsol_cb_t *cbentry;
3099
3100 mutex_enter(&port_statep->sp_mtx);
3101 for (cbentry = port_statep->sp_unsol_cb; cbentry;
3102 cbentry = cbentry->next) {
3103 if (cbentry->type == type) {
3104 cbentry->statec_cb = ulp_statec_callback;
3105 cbentry->els_cb = ulp_els_callback;
3106 cbentry->data_cb = ulp_data_callback;
3107 cbentry->arg = arg;
3108 mutex_exit(&port_statep->sp_mtx);
3109 return;
3110 }
3111 }
3112 mutex_exit(&port_statep->sp_mtx);
3113 if ((cbentry =
3114 (socal_unsol_cb_t *)kmem_zalloc(sizeof (socal_unsol_cb_t),
3115 KM_SLEEP)) == (socal_unsol_cb_t *)NULL) {
3116 return;
3117 }
3118 mutex_enter(&port_statep->sp_mtx);
3119 cbentry->statec_cb = ulp_statec_callback;
3120 cbentry->els_cb = ulp_els_callback;
3121 cbentry->data_cb = ulp_data_callback;
3122 cbentry->arg = arg;
3123 cbentry->type = type;
3124
3125 cbentry->next = port_statep->sp_unsol_cb;
3126 port_statep->sp_unsol_cb = cbentry;
3127 mutex_exit(&port_statep->sp_mtx);
3128 }
3129
3130
3131 /*
3132 * remove a ULP with matching type and arg
3133 */
3134 static void
3135 socal_remove_ulp(void *ssp, uint_t port, uchar_t type, void *arg)
3136 {
3137 socal_state_t *socalp = (socal_state_t *)ssp;
3138 socal_port_t *port_statep;
3139 socal_unsol_cb_t *cbentry;
3140 socal_unsol_cb_t *p_cbentry;
3141
3142
3143 ASSERT(ssp != NULL);
3144 port_statep = &socalp->port_state[port];
3145 ASSERT(port_statep != NULL);
3146
3147 /* scan the list of unsolicited callback entries */
3148 mutex_enter(&port_statep->sp_mtx);
3149 p_cbentry = NULL;
3150 for (cbentry = port_statep->sp_unsol_cb;
3151 cbentry != NULL;
3152 p_cbentry = cbentry, cbentry = cbentry->next) {
3153 if ((cbentry->type != type) || (cbentry->arg != arg)) {
3154 continue; /* this entry doesn't match */
3155 }
3156 /* found entry to remove */
3157 if (port_statep->sp_unsol_cb == cbentry) {
3158 /* remove first entry in list */
3159 port_statep->sp_unsol_cb = cbentry->next;
3160 } else {
3161 /* remove other entry in list */
3162 if (p_cbentry)
3163 p_cbentry->next = cbentry->next;
3164 }
3165 kmem_free((void *)cbentry, sizeof (socal_unsol_cb_t));
3166 DEBUGF(2, (CE_CONT, "socal port %d ULP removed\n", port));
3167 break;
3168 }
3169 mutex_exit(&port_statep->sp_mtx);
3170 }
3171
3172
3173 /*
3174 * static unsigned int
3175 * socal_intr() - this is the interrupt routine for the SOC. Process all
3176 * possible incoming interrupts from the soc device.
3177 */
3178
3179 static unsigned int
3180 socal_intr(caddr_t arg)
3181 {
3182 socal_state_t *socalp = (socal_state_t *)arg;
3183 register volatile socal_reg_t *socalreg = socalp->socal_rp;
3184 unsigned csr;
3185 int cause = 0;
3186 #if !defined(lint)
3187 int instance = ddi_get_instance(socalp->dip);
3188 #endif
3189 int i, j, request;
3190 char full;
3191 struct fcal_packet *fpkt, *nfpkt;
3192
3193 csr = socalreg->socal_csr.w;
3194 cause = (int)SOCAL_INTR_CAUSE(socalp, csr);
3195
3196 DEBUGF(2, (CE_CONT,
3197 "socal%d: intr: csr: 0x%x cause: 0x%x\n",
3198 instance, csr, cause));
3199
3200 if (!cause) {
3201 socalp->socal_on_intr = 0;
3202 return (DDI_INTR_UNCLAIMED);
3203 }
3204
3205 socalp->socal_on_intr = 1;
3206
3207 while (cause) {
3208
3209 /*
3210 * Process the unsolicited messages first in case there are some
3211 * high priority async events that we should act on.
3212 *
3213 */
3214
3215 if (cause & SOCAL_CSR_RSP_QUE_1) {
3216 socal_intr_unsolicited(socalp, 1);
3217 DEBUGF(4, (CE_CONT, "socal%d intr: did unsolicited\n", instance));
3218 }
3219
3220 if (cause & SOCAL_CSR_RSP_QUE_0) {
3221 socal_intr_solicited(socalp, 0);
3222 DEBUGF(4, (CE_CONT, "socal%d intr: did solicited\n", instance));
3223 }
3224
3225 /*
3226 * for use with token-only response queues in the future
3227 * if (cause & SOCAL_CSR_RSP_QUE_0) {
3228 * socal_intr_solicited(socalp, 0);
3229 * }
3230 */
3231
3232
3233 /*
3234 * Process any request interrupts
3235 * We only allow request interrupts when the request
3236 * queue is full and we are waiting so we can enque
3237 * another command.
3238 */
3239 if ((request = (cause & SOCAL_CSR_HOST_TO_SOCAL)) != 0) {
3240 socalp->socal_stats.reqq_intrs++;
3241 for (i = SOCAL_CSR_1ST_H_TO_S, j = 0; j < SOCAL_N_CQS;
3242 j++, i <<= 1) {
3243 if (request & i) {
3244 socal_kcq_t *kcq = &socalp->request[j];
3245
3246 if (kcq->skc_full) {
3247 mutex_enter(&kcq->skc_mtx);
3248 full = kcq->skc_full;
3249 kcq->skc_full = 0;
3250 while ((fpkt = kcq->skc_overflowh) != NULL) {
3251 nfpkt = fpkt->fcal_pkt_next;
3252 fpkt->fcal_pkt_next = NULL;
3253 kcq->skc_overflowh = nfpkt;
3254 if (socal_cq_enque(socalp, (socal_port_t *)
3255 fpkt->fcal_pkt_cookie,
3256 (cqe_t *)&fpkt->fcal_socal_request,
3257 j, FCAL_NOSLEEP, NULL, 1) !=
3258 FCAL_TRANSPORT_SUCCESS) {
3259 break;
3260 }
3261 }
3262 if (!kcq->skc_overflowh) {
3263 if (full & SOCAL_SKC_SLEEP)
3264 cv_broadcast(&kcq->skc_cv);
3265
3266 /* Disable this queue's intrs */
3267 DEBUGF(2, (CE_CONT,
3268 "socal%d: req que %d overflow cleared\n",
3269 instance, j));
3270 mutex_enter(&socalp->k_imr_mtx);
3271 socalp->socal_rp->socal_imr =
3272 (socalp->socal_k_imr &= ~i);
3273 mutex_exit(&socalp->k_imr_mtx);
3274 }
3275 mutex_exit(&kcq->skc_mtx);
3276 }
3277 }
3278 }
3279 }
3280 csr = socalreg->socal_csr.w;
3281 cause = (int)SOCAL_INTR_CAUSE(socalp, csr);
3282 DEBUGF(4, (CE_CONT, "socal%d intr: did request queues\n", instance));
3283
3284 }
3285
3286 socalp->socal_on_intr = 0;
3287 return (DDI_INTR_CLAIMED);
3288 }
3289
3290 static void
3291 socal_intr_solicited(socal_state_t *socalp, uint32_t srq)
3292 {
3293 socal_kcq_t *kcq;
3294 volatile socal_kcq_t *kcqv;
3295 soc_response_t *srp;
3296 cqe_t *cqe;
3297 uint_t status, i;
3298 fcal_packet_t *fcalpkt = NULL;
3299 soc_header_t *shp;
3300 register volatile socal_reg_t *socalreg = socalp->socal_rp;
3301 caddr_t src, dst;
3302 uchar_t index_in;
3303 cq_hdr_t *cq_hdr;
3304 char val;
3305 int port;
3306
3307 #if defined(DEBUG) && !defined(lint)
3308 int instance = ddi_get_instance(socalp->dip);
3309 #endif
3310 auto char buf[80];
3311
3312 kcq = &socalp->response[srq];
3313 kcqv = (volatile socal_kcq_t *)kcq;
3314 DEBUGF(4, (CE_CONT, "socal%d intr_sol: entered \n", instance));
3315
3316 /*
3317 * Grab lock for request queue.
3318 */
3319 mutex_enter(&kcq->skc_mtx);
3320
3321 /*
3322 * Process as many response queue entries as we can.
3323 */
3324 cqe = &(kcq->skc_cq[kcqv->skc_out]);
3325
3326 index_in = SOCAL_RESPONSEQ_INDEX(srq, socalreg->socal_rspp.w);
3327
3328 if (index_in == kcqv->skc_out) {
3329 socalreg->socal_csr.w = ((kcqv->skc_out << 24) |
3330 (SOCAL_CSR_SOCAL_TO_HOST & ~SOCAL_CSR_RSP_QUE_0));
3331
3332 /* make sure the write completed */
3333 i = socalreg->socal_csr.w;
3334
3335 index_in = SOCAL_RESPONSEQ_INDEX(srq, socalreg->socal_rspp.w);
3336 }
3337
3338 kcqv->skc_in = index_in;
3339
3340 while (kcqv->skc_out != index_in) {
3341 /* Find out where the newest entry lives in the queue */
3342 (void) ddi_dma_sync(kcq->skc_dhandle, 0, 0,
3343 DDI_DMA_SYNC_FORKERNEL);
3344
3345 srp = (soc_response_t *)cqe;
3346 port = srp->sr_soc_hdr.sh_flags & SOC_PORT_B;
3347 shp = &srp->sr_soc_hdr;
3348 cq_hdr = &srp->sr_cqhdr;
3349 /*
3350 * It turns out that on faster CPU's we have a problem where
3351 * the soc interrupts us before the response has been DMA'ed
3352 * in. This should not happen but does !!. So to workaround
3353 * the problem for now, check the sequence # of the response.
3354 * If it does not match with what we have, we must be
3355 * reading stale data
3356 */
3357 if (cq_hdr->cq_hdr_seqno != kcqv->skc_seqno) {
3358 #if defined(DEBUG) && !defined(lint)
3359 socal_read_stale_data++;
3360 #endif
3361 if (kcq->deferred_intr_timeoutid) {
3362 mutex_exit(&kcq->skc_mtx);
3363 return;
3364 } else {
3365 kcq->skc_saved_out = kcqv->skc_out;
3366 kcq->skc_saved_seqno = kcqv->skc_seqno;
3367 kcq->deferred_intr_timeoutid = timeout(
3368 socal_deferred_intr, (caddr_t)kcq,
3369 drv_usectohz(10000));
3370 mutex_exit(&kcq->skc_mtx);
3371 return;
3372 }
3373 }
3374
3375 fcalpkt = (fcal_packet_t *)
3376 SOCAL_ID_LOOKUP(shp->sh_request_token);
3377
3378 if ((socal_core & SOCAL_TAKE_CORE) && ddi_peek8(socalp->dip,
3379 (char *)fcalpkt, &val) != DDI_SUCCESS) {
3380 cmn_err(CE_WARN, "bad token = %p\n", (void *)fcalpkt);
3381 mutex_exit(&kcq->skc_mtx);
3382 socal_take_core(socalp);
3383 }
3384
3385 if ((fcalpkt == (fcal_packet_t *)NULL) ||
3386 (fcalpkt->fcal_magic != FCALP_MAGIC)) {
3387 (void) sprintf(buf, "!invalid FC packet; \n\
3388 in, out, seqno = 0x%x, 0x%x, 0x%x\n",
3389 kcqv->skc_in, kcqv->skc_out, kcqv->skc_seqno);
3390 socal_disp_err(socalp, CE_WARN, "link.4060", buf);
3391 DEBUGF(4, (CE_CONT,
3392 "\tsoc CR: 0x%x SAE: 0x%x CSR: 0x%x IMR: 0x%x\n",
3393 socalreg->socal_cr.w,
3394 socalreg->socal_sae.w,
3395 socalreg->socal_csr.w,
3396 socalreg->socal_imr));
3397 /*
3398 * Update response queue ptrs and soc registers.
3399 */
3400 kcqv->skc_out++;
3401 if ((kcqv->skc_out & kcq->skc_last_index) == 0) {
3402 kcqv->skc_out = 0;
3403 kcqv->skc_seqno++;
3404 }
3405
3406 } else {
3407
3408 DEBUGF(2, (CE_CONT, "packet 0x%p complete\n",
3409 fcalpkt));
3410 status = srp->sr_soc_status;
3411 fcalpkt->fcal_pkt_status = status;
3412 DEBUGF(2, (CE_CONT, "SOC status: 0x%x\n", status));
3413 /*
3414 * map soc status codes to
3415 * transport status codes
3416 */
3417
3418 ASSERT((fcalpkt->fcal_cmd_state & FCAL_CMD_COMPLETE)
3419 == 0);
3420 mutex_enter(&socalp->abort_mtx);
3421 fcalpkt->fcal_pkt_flags |= FCFLAG_COMPLETE;
3422 mutex_exit(&socalp->abort_mtx);
3423
3424 /*
3425 * Copy the response frame header (if there is one)
3426 * so that the upper levels can use it. Note that,
3427 * for now, we'll copy the header only if there was
3428 * some sort of non-OK status, to save the PIO reads
3429 * required to get the header from the host adapter's
3430 * xRAM.
3431 */
3432 if (((status != FCAL_STATUS_OK) ||
3433 (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags
3434 & SOC_RESP_HEADER)) &&
3435 (srp->sr_soc_hdr.sh_flags & SOC_FC_HEADER)) {
3436 src = (caddr_t)&srp->sr_fc_frame_hdr;
3437 dst = (caddr_t)&fcalpkt->fcal_resp_hdr;
3438 bcopy(src, dst, sizeof (fc_frame_header_t));
3439 fcalpkt->fcal_pkt_flags |= FCFLAG_RESP_HEADER;
3440 i = srp->sr_soc_hdr.sh_flags & SOC_PORT_B ?
3441 1 : 0;
3442 if ((status != FCAL_STATUS_OK) &&
3443 (status <= FCAL_STATUS_MAX_STATUS)) {
3444 socalp->socal_stats.pstats[i].
3445 resp_status[status]++;
3446 } else {
3447 socalp->socal_stats.pstats[i].
3448 resp_status[FCAL_STATUS_ERROR]++;
3449 }
3450 } else if (status == FCAL_STATUS_OK) {
3451 fcalpkt->fcal_socal_request.
3452 sr_soc_hdr.sh_byte_cnt =
3453 shp->sh_byte_cnt;
3454 }
3455 fcalpkt->fcal_diag_status =
3456 (uint32_t)srp->sr_dataseg.fc_base;
3457 fcalpkt->fcal_ncmds = srp->sr_ncmds;
3458
3459 /*
3460 * Update response queue ptrs and soc registers.
3461 */
3462 kcqv->skc_out++;
3463 if ((kcqv->skc_out & kcq->skc_last_index) == 0) {
3464 kcqv->skc_out = 0;
3465 kcqv->skc_seqno++;
3466 }
3467
3468 /* For incmplt DMA offline loop by loopback */
3469 if (fcalpkt->fcal_pkt_status ==
3470 FCAL_STATUS_INCOMPLETE_DMA_ERR) {
3471 socal_port_t *port_statep;
3472 uint_t r;
3473
3474 /*
3475 * Give up the mutex to avoid a deadlock
3476 * with the loopback routine.
3477 */
3478 mutex_exit(&kcq->skc_mtx);
3479
3480 port_statep = &socalp->port_state[port];
3481 mutex_enter(&port_statep->sp_mtx);
3482 if (port_statep->sp_status &
3483 PORT_DISABLED) {
3484 /* Already disabled */
3485 mutex_exit(&port_statep->sp_mtx);
3486 } else {
3487 port_statep->sp_status |=
3488 PORT_DISABLED;
3489 mutex_exit(&port_statep->sp_mtx);
3490 (void) socal_diag_request(
3491 (void *)socalp, port,
3492 &r, SOC_DIAG_INT_LOOP);
3493 }
3494 /* reacquire mutex */
3495 mutex_enter(&kcq->skc_mtx);
3496 }
3497
3498 /*
3499 * Complete the packet *ONLY* if it not being aborted
3500 * or the abort has already completed. Otherwise it is
3501 * not safe to free the ID.
3502 */
3503 mutex_enter(&socalp->abort_mtx);
3504 if (!(fcalpkt->fcal_pkt_flags & FCFLAG_ABORTING)) {
3505 /*
3506 * Call the completion routine
3507 */
3508 SOCAL_ID_FREE(shp->sh_request_token);
3509 if (fcalpkt->fcal_pkt_comp != NULL) {
3510 fcalpkt->fcal_cmd_state |=
3511 FCAL_CMD_COMPLETE;
3512
3513 /*
3514 * Give up the mutex to avoid a
3515 * deadlock with the callback routine.
3516 */
3517 mutex_exit(&socalp->abort_mtx);
3518 mutex_exit(&kcq->skc_mtx);
3519
3520 /* callback */
3521 (*fcalpkt->fcal_pkt_comp)(fcalpkt);
3522
3523 /* reacquire mutex */
3524 mutex_enter(&kcq->skc_mtx);
3525 } else {
3526 fcalpkt->fcal_cmd_state |=
3527 FCAL_CMD_COMPLETE;
3528 mutex_exit(&socalp->abort_mtx);
3529 }
3530 } else {
3531 mutex_exit(&socalp->abort_mtx);
3532 }
3533 }
3534
3535
3536 if (kcq->skc_cq == NULL)
3537 /*
3538 * This action averts a potential PANIC scenario
3539 * where the SUSPEND code flow grabbed the kcq->skc_mtx
3540 * when we let it go, to call our completion routine,
3541 * and "initialized" the response queue. We exit our
3542 * processing loop here, thereby averting a PANIC due
3543 * to a NULL de-reference from the response queue.
3544 *
3545 * Note that this is an interim measure that needs
3546 * to be revisited when this driver is next revised
3547 * for enhanced performance.
3548 */
3549 break;
3550
3551 /*
3552 * We need to re-read the input and output pointers in
3553 * case a polling routine should process some entries
3554 * from the response queue while we're doing a callback
3555 * routine with the response queue mutex dropped.
3556 */
3557 cqe = &(kcq->skc_cq[kcqv->skc_out]);
3558 index_in = SOCAL_RESPONSEQ_INDEX(srq, socalreg->socal_rspp.w);
3559
3560 /*
3561 * Mess around with the hardware if we think we've run out
3562 * of entries in the queue, just to make sure we've read
3563 * all entries that are available.
3564 */
3565
3566 socalreg->socal_csr.w = ((kcqv->skc_out << 24) |
3567 (SOCAL_CSR_SOCAL_TO_HOST & ~SOCAL_CSR_RSP_QUE_0));
3568
3569 /* Make sure the csr write has completed */
3570 i = socalreg->socal_csr.w;
3571 DEBUGF(9, (CE_CONT, "csr.w = %x\n", i));
3572
3573 /*
3574 * Update our idea of where the host adapter has placed
3575 * the most recent entry in the response queue and resync
3576 * the response queue
3577 */
3578 index_in = SOCAL_RESPONSEQ_INDEX(srq, socalreg->socal_rspp.w);
3579
3580 kcqv->skc_in = index_in;
3581 }
3582
3583 /* Drop lock for request queue. */
3584 mutex_exit(&kcq->skc_mtx);
3585 }
3586
3587 /*
3588 * Function name : socal_intr_unsolicited()
3589 *
3590 * Return Values : none
3591 *
3592 * Description : Processes entries in the unsolicited response
3593 * queue
3594 *
3595 * The SOC+ will give us an unsolicited response
3596 * whenever its status changes: OFFLINE, ONLINE,
3597 * or in response to a packet arriving from an originator.
3598 *
3599 * When message requests come in they will be placed in our
3600 * buffer queue or in the next "inline" packet by the SOC hardware.
3601 *
3602 * Context : Unsolicited interrupts must be masked
3603 */
3604
3605 static void
3606 socal_intr_unsolicited(socal_state_t *socalp, uint32_t urq)
3607 {
3608 socal_kcq_t *kcq;
3609 volatile socal_kcq_t *kcqv;
3610 soc_response_t *srp;
3611 volatile cqe_t *cqe;
3612 int port;
3613 register uchar_t t_index, t_seqno;
3614 register volatile socal_reg_t *socalreg = socalp->socal_rp;
3615 volatile cqe_t *cqe_cont = NULL;
3616 uint_t i;
3617 int hdr_count;
3618 int status;
3619 ushort_t flags;
3620 auto char buf[256];
3621 socal_port_t *port_statep;
3622 #if defined(DEBUG) && !defined(lint)
3623 int instance = ddi_get_instance(socalp->dip);
3624 #endif
3625 uchar_t index_in;
3626 socal_unsol_cb_t *cblist;
3627
3628 kcq = &socalp->response[urq];
3629 kcqv = (volatile socal_kcq_t *)kcq;
3630
3631 /*
3632 * Grab lock for response queue.
3633 */
3634 mutex_enter(&kcq->skc_mtx);
3635
3636 cqe = (volatile cqe_t *)&(kcq->skc_cq[kcqv->skc_out]);
3637
3638 index_in = SOCAL_RESPONSEQ_INDEX(urq, socalreg->socal_rspp.w);
3639
3640 kcqv->skc_in = index_in;
3641
3642 while (kcqv->skc_out != index_in) {
3643 (void) ddi_dma_sync(kcq->skc_dhandle, 0, 0,
3644 DDI_DMA_SYNC_FORKERNEL);
3645
3646 /* Check for continuation entries */
3647 if ((hdr_count = cqe->cqe_hdr.cq_hdr_count) != 1) {
3648
3649 t_seqno = kcqv->skc_seqno;
3650 t_index = kcqv->skc_out + hdr_count;
3651
3652 i = index_in;
3653 if (kcqv->skc_out > index_in)
3654 i += kcq->skc_last_index + 1;
3655
3656 /*
3657 * If we think the continuation entries haven't yet
3658 * arrived, try once more before giving up
3659 */
3660 if (i < t_index) {
3661
3662 socalreg->socal_csr.w =
3663 ((kcqv->skc_out << 24) |
3664 (SOCAL_CSR_SOCAL_TO_HOST & ~SOCAL_CSR_RSP_QUE_1));
3665
3666 /* Make sure the csr write has completed */
3667 i = socalreg->socal_csr.w;
3668
3669 /*
3670 * Update our idea of where the host adapter has placed
3671 * the most recent entry in the response queue
3672 */
3673 i = index_in = SOCAL_RESPONSEQ_INDEX(urq,
3674 socalreg->socal_rspp.w);
3675 if (kcqv->skc_out > index_in)
3676 i += kcq->skc_last_index + 1;
3677
3678 /*
3679 * Exit if the continuation entries haven't yet
3680 * arrived
3681 */
3682 if (i < t_index)
3683 break;
3684 }
3685
3686 if (t_index > kcq->skc_last_index) {
3687 t_seqno++;
3688 t_index &= kcq->skc_last_index;
3689 }
3690
3691 cqe_cont = (volatile cqe_t *)
3692 &(kcq->skc_cq[t_index ? t_index - 1 :
3693 kcq->skc_last_index]);
3694
3695
3696 /* A cq_hdr_count > 2 is illegal; throw away the response */
3697
3698 /*
3699 * XXX - should probably throw out as many entries as the
3700 * hdr_cout tells us there are
3701 */
3702 if (hdr_count != 2) {
3703 socal_disp_err(socalp, CE_WARN, "driver.4030",
3704 "!too many continuation entries");
3705 DEBUGF(4, (CE_CONT,
3706 "socal%d: soc+ unsolicited entry count = %d\n",
3707 instance, cqe->cqe_hdr.cq_hdr_count));
3708
3709 if ((++t_index & kcq->skc_last_index) == 0) {
3710 t_index = 0;
3711 t_seqno++;
3712 }
3713 kcqv->skc_out = t_index;
3714 kcqv->skc_seqno = t_seqno;
3715
3716 cqe = &(kcq->skc_cq[kcqv->skc_out]);
3717 cqe_cont = NULL;
3718 continue;
3719 }
3720 }
3721
3722 /*
3723 * Update unsolicited response queue ptrs
3724 */
3725 kcqv->skc_out++;
3726 if ((kcqv->skc_out & kcq->skc_last_index) == 0) {
3727 kcqv->skc_out = 0;
3728 kcqv->skc_seqno++;
3729 }
3730
3731 if (cqe_cont != NULL) {
3732 kcqv->skc_out++;
3733 if ((kcqv->skc_out & kcq->skc_last_index) == 0) {
3734 kcqv->skc_out = 0;
3735 kcqv->skc_seqno++;
3736 }
3737 }
3738
3739 if (index_in == kcqv->skc_out) {
3740 socalreg->socal_csr.w = ((kcqv->skc_out << 24) |
3741 (SOCAL_CSR_SOCAL_TO_HOST & ~SOCAL_CSR_RSP_QUE_1));
3742
3743 /* Make sure the csr write has completed */
3744 i = socalreg->socal_csr.w;
3745 }
3746
3747 srp = (soc_response_t *)cqe;
3748 flags = srp->sr_soc_hdr.sh_flags;
3749 port = flags & SOC_PORT_B;
3750 port_statep = &socalp->port_state[port];
3751
3752 /*
3753 * XXX need to deal buffer pool entries here
3754 */
3755 switch (flags & ~SOC_PORT_B) {
3756 case SOC_UNSOLICITED | SOC_FC_HEADER:
3757
3758 srp = (soc_response_t *)cqe;
3759
3760 switch (srp->sr_fc_frame_hdr.r_ctl & R_CTL_ROUTING) {
3761 case R_CTL_EXTENDED_SVC:
3762 /*
3763 * Extended Link Services frame received
3764 */
3765 socalp->socal_stats.pstats[port].els_rcvd++;
3766 socal_us_els(socalp, (cqe_t *)cqe, (caddr_t)cqe_cont);
3767
3768 /* do callbacks to any interested ULPs */
3769 mutex_enter(&port_statep->sp_mtx);
3770 for (cblist = port_statep->sp_unsol_cb; cblist;
3771 cblist = cblist->next) {
3772 if (cblist->els_cb) {
3773 mutex_exit(&port_statep->sp_mtx);
3774 mutex_exit(&kcq->skc_mtx);
3775 cblist->els_cb(cblist->arg,
3776 (cqe_t *)cqe,
3777 (caddr_t)cqe_cont);
3778 mutex_enter(&kcq->skc_mtx);
3779 mutex_enter(&port_statep->sp_mtx);
3780 }
3781 }
3782 mutex_exit(&port_statep->sp_mtx);
3783 break;
3784 case R_CTL_BASIC_SVC:
3785 (void) sprintf(buf,
3786 "!unsupported Link Service command: 0x%x",
3787 srp->sr_fc_frame_hdr.type);
3788 socal_disp_err(socalp, CE_WARN, "link.4020", buf);
3789 break;
3790 case R_CTL_DEVICE_DATA:
3791 switch (srp->sr_fc_frame_hdr.type) {
3792 default:
3793 mutex_enter(&port_statep->sp_mtx);
3794 status = 1;
3795 for (cblist = port_statep->sp_unsol_cb; cblist;
3796 cblist = cblist->next) {
3797 if (cblist->data_cb &&
3798 (cblist->type ==
3799 srp->sr_fc_frame_hdr.type)) {
3800 mutex_exit(&port_statep->sp_mtx);
3801 mutex_exit(&kcq->skc_mtx);
3802 cblist->data_cb(cblist->arg,
3803 (cqe_t *)cqe, (caddr_t)cqe_cont);
3804 mutex_enter(&kcq->skc_mtx);
3805 mutex_enter(&port_statep->sp_mtx);
3806 status = 0;
3807 }
3808 }
3809 mutex_exit(&port_statep->sp_mtx);
3810
3811 if (status == 0)
3812 break;
3813
3814 (void) sprintf(buf,
3815 "!unknown FC-4 command: 0x%x",
3816 srp->sr_fc_frame_hdr.type);
3817 socal_disp_err(socalp, CE_WARN,
3818 "link.4030", buf);
3819 break;
3820 }
3821 break;
3822 default:
3823 (void) sprintf(buf, "!unsupported FC frame R_CTL: 0x%x",
3824 srp->sr_fc_frame_hdr.r_ctl);
3825 socal_disp_err(socalp, CE_WARN, "link.4040", buf);
3826 break;
3827 }
3828 break;
3829
3830 case SOC_STATUS: {
3831
3832 /*
3833 * Note that only the lsbyte of the status has
3834 * interesting information...
3835 */
3836 status = srp->sr_soc_status;
3837
3838 switch (status) {
3839
3840 case FCAL_STATUS_ONLINE:
3841 (void) sprintf(buf,
3842 "!port %d: Fibre Channel is ONLINE\n", port);
3843 socal_disp_err(socalp, CE_CONT, "link.6010",
3844 buf);
3845 mutex_enter(&port_statep->sp_mtx);
3846 port_statep->sp_status &= ~PORT_STATUS_MASK;
3847 port_statep->sp_status |= PORT_ONLINE;
3848 mutex_exit(&port_statep->sp_mtx);
3849 socalp->socal_stats.pstats[port].onlines++;
3850 DEBUGF(4, (CE_CONT,
3851 "socal%d intr_unsol: ONLINE intr\n",
3852 instance));
3853 break;
3854
3855 case FCAL_STATUS_LOOP_ONLINE:
3856 (void) sprintf(buf,
3857 "!port %d: Fibre Channel Loop is ONLINE\n",
3858 port);
3859 socal_disp_err(socalp, CE_CONT, "link.6010",
3860 buf);
3861 mutex_enter(&port_statep->sp_mtx);
3862 port_statep->sp_status &= ~PORT_STATUS_MASK;
3863 port_statep->sp_status |= PORT_ONLINE_LOOP;
3864 mutex_exit(&port_statep->sp_mtx);
3865 socalp->socal_stats.pstats[port].online_loops++;
3866 DEBUGF(4, (CE_CONT,
3867 "socal%d intr_unsol: ONLINE-LOOP intr\n",
3868 instance));
3869 break;
3870
3871 case FCAL_STATUS_ERR_OFFLINE:
3872 /*
3873 * SOC and Responder will both flush
3874 * all active commands.
3875 * So I don't have to do anything
3876 * until it comes back online.
3877 */
3878 (void) sprintf(buf,
3879 "!port %d: Fibre Channel is OFFLINE\n", port);
3880 socal_disp_err(socalp, CE_CONT, "link.5010",
3881 buf);
3882
3883 mutex_enter(&port_statep->sp_mtx);
3884 port_statep->sp_status &= ~PORT_STATUS_MASK;
3885 port_statep->sp_status |= PORT_OFFLINE;
3886 port_statep->sp_lilpmap_valid = 0;
3887 mutex_exit(&port_statep->sp_mtx);
3888 socalp->socal_stats.pstats[port].offlines++;
3889 DEBUGF(4, (CE_CONT,
3890 "socal%d intr_unsol: OFFLINE intr\n",
3891 instance));
3892
3893 break;
3894 default:
3895 (void) sprintf(buf, "!unknown status: 0x%x\n",
3896 status);
3897 socal_disp_err(socalp, CE_WARN, "link.3020",
3898 buf);
3899 }
3900 mutex_exit(&kcq->skc_mtx);
3901 mutex_enter(&port_statep->sp_mtx);
3902 for (cblist = port_statep->sp_unsol_cb; cblist;
3903 cblist = cblist->next) {
3904 if (cblist->statec_cb) {
3905 mutex_exit(&port_statep->sp_mtx);
3906 (*cblist->statec_cb)(cblist->arg,
3907 status);
3908 mutex_enter(&port_statep->sp_mtx);
3909 }
3910 }
3911 mutex_exit(&port_statep->sp_mtx);
3912 if (status == FCAL_STATUS_ERR_OFFLINE) {
3913 socal_flush_overflowq(socalp, port,
3914 CQ_REQUEST_0);
3915 socal_flush_overflowq(socalp, port,
3916 CQ_REQUEST_1);
3917 }
3918 mutex_enter(&kcq->skc_mtx);
3919 break;
3920 }
3921 default:
3922 (void) sprintf(buf, "!unexpected state: flags: 0x%x\n",
3923 flags);
3924 socal_disp_err(socalp, CE_WARN, "link.4050", buf);
3925 DEBUGF(4, (CE_CONT,
3926 "\tsoc CR: 0x%x SAE: 0x%x CSR: 0x%x IMR: 0x%x\n",
3927 socalp->socal_rp->socal_cr.w,
3928 socalp->socal_rp->socal_sae.w,
3929 socalp->socal_rp->socal_csr.w,
3930 socalp->socal_rp->socal_imr));
3931 }
3932
3933
3934 if (kcq->skc_cq == NULL)
3935 /*
3936 * This action averts a potential PANIC scenario
3937 * where the SUSPEND code flow grabbed the kcq->skc_mtx
3938 * when we let it go, to call our completion routine,
3939 * and "initialized" the response queue. We exit our
3940 * processing loop here, thereby averting a PANIC due
3941 * to a NULL de-reference from the response queue.
3942 *
3943 * Note that this is an interim measure that needs
3944 * to be revisited when this driver is next revised
3945 * for enhanced performance.
3946 */
3947 break;
3948
3949 /*
3950 * We need to re-read the input and output pointers in
3951 * case a polling routine should process some entries
3952 * from the response queue while we're doing a callback
3953 * routine with the response queue mutex dropped.
3954 */
3955 cqe = &(kcq->skc_cq[kcqv->skc_out]);
3956 index_in = SOCAL_RESPONSEQ_INDEX(urq, socalreg->socal_rspp.w);
3957 cqe_cont = NULL;
3958
3959 /*
3960 * Mess around with the hardware if we think we've run out
3961 * of entries in the queue, just to make sure we've read
3962 * all entries that are available.
3963 */
3964 if (index_in == kcqv->skc_out) {
3965
3966 socalreg->socal_csr.w =
3967 ((kcqv->skc_out << 24) |
3968 (SOCAL_CSR_SOCAL_TO_HOST & ~SOCAL_CSR_RSP_QUE_1));
3969
3970 /* Make sure the csr write has completed */
3971 i = socalreg->socal_csr.w;
3972
3973 /*
3974 * Update our idea of where the host adapter has placed
3975 * the most recent entry in the response queue
3976 */
3977 index_in =
3978 SOCAL_RESPONSEQ_INDEX(urq, socalreg->socal_rspp.w);
3979 }
3980
3981 socalp->socal_stats.pstats[port].unsol_resps++;
3982
3983 kcqv->skc_in = index_in;
3984
3985 }
3986
3987 /* Release lock for response queue. */
3988 mutex_exit(&kcq->skc_mtx);
3989 }
3990
3991 /*
3992 * socal_us_els() - This function handles unsolicited extended link
3993 * service responses received from the soc.
3994 */
3995 static void
3996 socal_us_els(socal_state_t *socalp, cqe_t *cqe, caddr_t payload)
3997 {
3998 soc_response_t *srp = (soc_response_t *)cqe;
3999 els_payload_t *els = (els_payload_t *)payload;
4000 int i;
4001 char *bp;
4002 auto char buf[256];
4003
4004 /*
4005 * There should be a CQE continuation entry for all
4006 * extended link services
4007 */
4008 if ((els == NULL) || ((i = srp->sr_soc_hdr.sh_byte_cnt) == 0)) {
4009 socal_disp_err(socalp, CE_WARN, "link.4010",
4010 "!incomplete continuation entry");
4011 return;
4012 }
4013
4014 /* Quietly impose a maximum byte count */
4015 if (i > SOC_CQE_PAYLOAD)
4016 i = SOC_CQE_PAYLOAD;
4017 i -= sizeof (union els_cmd_u);
4018
4019 /*
4020 * Decode the LS_Command code
4021 */
4022 switch (els->els_cmd.c.ls_command) {
4023 case LA_ELS_DISPLAY:
4024 els->els_data[i] = '\0'; /* terminate the string */
4025 for (bp = (char *)&(els->els_data[0]); *bp; bp++) {
4026 /* squash newlines */
4027 if (*bp == '\n') *bp = ' ';
4028 }
4029 (void) sprintf(buf, "!message: %s\n", els->els_data);
4030 socal_disp_err(socalp, CE_CONT, "link.1010", buf);
4031 break;
4032
4033 default:
4034 DEBUGF(3, (CE_CONT, "!unknown LS_Command, %x\n",
4035 els->els_cmd.i));
4036 break;
4037 }
4038
4039 }
4040
4041 /*ARGSUSED*/
4042 static fcal_packet_t *
4043 socal_packet_alloc(socal_state_t *socalp, fcal_sleep_t sleep)
4044 {
4045 int flag;
4046 fcal_packet_t *pkt;
4047
4048 if (sleep == FCAL_SLEEP)
4049 flag = KM_SLEEP;
4050 else
4051 flag = KM_NOSLEEP;
4052
4053 pkt = (fcal_packet_t *)kmem_zalloc(sizeof (fcal_packet_t), flag);
4054
4055 if (pkt != (fcal_packet_t *)NULL)
4056 pkt->fcal_magic = FCALP_MAGIC;
4057
4058 return (pkt);
4059 }
4060
4061 static void
4062 socal_packet_free(fcal_packet_t *fcalpkt)
4063 {
4064 kmem_free((void *)fcalpkt, sizeof (fcal_packet_t));
4065 }
4066
4067 static void
4068 socal_lilp_map_done(fcal_packet_t *fcalpkt)
4069 {
4070 uint32_t port;
4071 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4072
4073 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4074 port = 1;
4075 else
4076 port = 0;
4077 mutex_enter(&socalp->port_state[port].sp_mtx);
4078 socalp->port_state[port].sp_status &= ~PORT_LILP_PENDING;
4079 cv_broadcast(&socalp->port_state[port].sp_cv);
4080 mutex_exit(&socalp->port_state[port].sp_mtx);
4081 }
4082
4083 static void
4084 socal_force_lip_done(fcal_packet_t *fcalpkt)
4085 {
4086 uint32_t port;
4087 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4088
4089 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4090 port = 1;
4091 else
4092 port = 0;
4093 mutex_enter(&socalp->port_state[port].sp_mtx);
4094 socalp->port_state[port].sp_status &= ~PORT_LIP_PENDING;
4095 cv_broadcast(&socalp->port_state[port].sp_cv);
4096 mutex_exit(&socalp->port_state[port].sp_mtx);
4097 }
4098
4099 static void
4100 socal_adisc_done(fcal_packet_t *fcalpkt)
4101 {
4102 uint32_t port;
4103 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4104
4105 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4106 port = 1;
4107 else
4108 port = 0;
4109 mutex_enter(&socalp->port_state[port].sp_mtx);
4110 socalp->port_state[port].sp_status &= ~PORT_ADISC_PENDING;
4111 cv_broadcast(&socalp->port_state[port].sp_cv);
4112 mutex_exit(&socalp->port_state[port].sp_mtx);
4113 }
4114
4115 static void
4116 socal_lbf_done(fcal_packet_t *fcalpkt)
4117 {
4118 uint32_t port;
4119 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4120
4121 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4122 port = 1;
4123 else
4124 port = 0;
4125 mutex_enter(&socalp->port_state[port].sp_mtx);
4126 socalp->port_state[port].sp_status &= ~PORT_LBF_PENDING;
4127 cv_broadcast(&socalp->port_state[port].sp_cv);
4128 mutex_exit(&socalp->port_state[port].sp_mtx);
4129 }
4130
4131 static void
4132 socal_rls_done(fcal_packet_t *fcalpkt)
4133 {
4134 uint32_t port;
4135 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4136
4137 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4138 port = 1;
4139 else
4140 port = 0;
4141 mutex_enter(&socalp->port_state[port].sp_mtx);
4142 socalp->port_state[port].sp_status &= ~PORT_RLS_PENDING;
4143 cv_broadcast(&socalp->port_state[port].sp_cv);
4144 mutex_exit(&socalp->port_state[port].sp_mtx);
4145 }
4146
4147 static void
4148 socal_force_offline_done(fcal_packet_t *fcalpkt)
4149 {
4150 uint32_t port;
4151 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4152
4153 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4154 port = 1;
4155 else
4156 port = 0;
4157 mutex_enter(&socalp->port_state[port].sp_mtx);
4158 socalp->port_state[port].sp_status &= ~PORT_OFFLINE_PENDING;
4159 cv_broadcast(&socalp->port_state[port].sp_cv);
4160 mutex_exit(&socalp->port_state[port].sp_mtx);
4161 }
4162
4163 static void
4164 socal_abort_done(fcal_packet_t *fcalpkt)
4165 {
4166 uint32_t port;
4167 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4168 soc_header_t *shp =
4169 (soc_header_t *)&fcalpkt->fcal_socal_request.sr_soc_hdr;
4170 fcal_packet_t *target = (fcal_packet_t *)
4171 SOCAL_ID_LOOKUP(shp->sh_request_token);
4172
4173 mutex_enter(&socalp->abort_mtx);
4174 ASSERT(target->fcal_pkt_flags & FCFLAG_ABORTING);
4175 if (!(target->fcal_pkt_flags & FCFLAG_COMPLETE)) {
4176 SOCAL_ID_FREE(shp->sh_request_token);
4177 }
4178 mutex_exit(&socalp->abort_mtx);
4179 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4180 port = 1;
4181 else
4182 port = 0;
4183 mutex_enter(&socalp->port_state[port].sp_mtx);
4184 socalp->port_state[port].sp_status &= ~PORT_ABORT_PENDING;
4185 cv_broadcast(&socalp->port_state[port].sp_cv);
4186 mutex_exit(&socalp->port_state[port].sp_mtx);
4187 }
4188
4189 static void
4190 socal_bypass_dev_done(fcal_packet_t *fcalpkt)
4191 {
4192 uint32_t port;
4193 socal_state_t *socalp = (socal_state_t *)fcalpkt->fcal_pkt_cookie;
4194 if (fcalpkt->fcal_socal_request.sr_soc_hdr.sh_flags & SOC_PORT_B)
4195 port = 1;
4196 else
4197 port = 0;
4198 mutex_enter(&socalp->port_state[port].sp_mtx);
4199 socalp->port_state[port].sp_status &= ~PORT_BYPASS_PENDING;
4200 cv_broadcast(&socalp->port_state[port].sp_cv);
4201 mutex_exit(&socalp->port_state[port].sp_mtx);
4202 }
4203
4204 /*ARGSUSED*/
4205 static unsigned int
4206 socal_dummy_intr(caddr_t arg)
4207 {
4208 return (DDI_INTR_UNCLAIMED);
4209 }
4210
4211 static int
4212 socal_diag_request(socal_state_t *socalp, uint32_t port, uint_t *diagcode,
4213 uint32_t cmd)
4214 {
4215 fcal_packet_t *fcalpkt;
4216 soc_diag_request_t *sdr;
4217 socal_port_t *port_statep = &socalp->port_state[port];
4218 struct fcal_lilp_map map;
4219
4220 /* Grabbing the state mutex is totally unnecessary.... */
4221 if (!(port_statep->sp_status & PORT_DISABLED)) {
4222 if (socal_getmap(socalp, port, (caddr_t)&map, 0, FKIOCTL)
4223 != -1) {
4224 if (map.lilp_length != 1 && ((port_statep->sp_status &
4225 PORT_ONLINE_LOOP) && cmd != SOC_DIAG_REM_LOOP))
4226 return (FCAL_TRANSPORT_UNAVAIL);
4227 }
4228 }
4229 if ((fcalpkt = socal_packet_alloc(socalp, FCAL_SLEEP))
4230 == (fcal_packet_t *)NULL)
4231 return (FCAL_ALLOC_FAILED);
4232 sdr = (soc_diag_request_t *)&fcalpkt->fcal_socal_request;
4233 if (port)
4234 sdr->sdr_soc_hdr.sh_flags = SOC_PORT_B;
4235 sdr->sdr_diag_cmd = cmd;
4236 sdr->sdr_cqhdr.cq_hdr_count = 1;
4237 sdr->sdr_cqhdr.cq_hdr_type = CQ_TYPE_DIAGNOSTIC;
4238 fcalpkt->fcal_pkt_cookie = (void *)socalp;
4239 return (socal_doit(fcalpkt, port_statep, 1, NULL,
4240 SOCAL_DIAG_TIMEOUT, 0, diagcode));
4241 }
4242
4243 static uint_t
4244 socal_force_offline(void *ssp, uint_t port, uint_t polled)
4245 {
4246 fcal_packet_t *fcalpkt;
4247 soc_cmdonly_request_t *scr;
4248 socal_state_t *socalp = (socal_state_t *)ssp;
4249 socal_port_t *port_statep = &socalp->port_state[port];
4250
4251 if ((fcalpkt =
4252 socal_packet_alloc(socalp, polled ? FCAL_NOSLEEP : FCAL_SLEEP))
4253 == (fcal_packet_t *)NULL)
4254 return (FCAL_ALLOC_FAILED);
4255
4256 scr = (soc_cmdonly_request_t *)&fcalpkt->fcal_socal_request;
4257 if (port)
4258 scr->scr_soc_hdr.sh_flags = SOC_PORT_B;
4259 scr->scr_cqhdr.cq_hdr_count = 1;
4260 scr->scr_cqhdr.cq_hdr_type = CQ_TYPE_OFFLINE;
4261 fcalpkt->fcal_pkt_cookie = (void *)socalp;
4262 return (socal_doit(fcalpkt, port_statep, 0, socal_force_offline_done,
4263 SOCAL_OFFLINE_TIMEOUT, PORT_OFFLINE_PENDING, NULL));
4264 }
4265
4266 static int
4267 socal_issue_adisc(socal_state_t *socalp, uint32_t port, uint32_t dest,
4268 la_els_adisc_t *payload, uint32_t polled)
4269 {
4270 int retval;
4271 la_els_adisc_t *buf;
4272 fcal_packet_t *fcalpkt;
4273 socal_port_t *port_statep;
4274 socal_priv_cmd_t *privp;
4275
4276 port_statep = &socalp->port_state[port];
4277
4278 if ((fcalpkt =
4279 socal_els_alloc(socalp, port, dest, sizeof (la_els_adisc_t),
4280 sizeof (la_els_adisc_t), (caddr_t *)&privp, polled))
4281 == (fcal_packet_t *)NULL)
4282 return (FCAL_ALLOC_FAILED);
4283
4284 privp = (socal_priv_cmd_t *)fcalpkt->fcal_pkt_private;
4285 buf = (la_els_adisc_t *)privp->cmd;
4286 buf->ls_code = LA_ELS_ADISC;
4287 buf->mbz[0] = 0;
4288 buf->mbz[1] = 0;
4289 buf->mbz[2] = 0;
4290 buf->hard_address = 0;
4291 bcopy((caddr_t)&port_statep->sp_p_wwn,
4292 (caddr_t)&buf->port_wwn, sizeof (buf->port_wwn));
4293 bcopy((caddr_t)&socalp->socal_n_wwn,
4294 (caddr_t)&buf->node_wwn, sizeof (buf->node_wwn));
4295 buf->nport_id = fcalpkt->fcal_socal_request.sr_fc_frame_hdr.s_id;
4296 (void) ddi_dma_sync(privp->cmd_handle, 0, 0, DDI_DMA_SYNC_FORDEV);
4297
4298 retval = socal_doit(fcalpkt, port_statep, 0, socal_adisc_done,
4299 SOCAL_ADISC_TIMEOUT, PORT_ADISC_PENDING, NULL);
4300 if (retval == FCAL_SUCCESS) {
4301 (void) ddi_dma_sync(privp->rsp_handle, 0, 0,
4302 DDI_DMA_SYNC_FORKERNEL);
4303 bcopy(privp->rsp, (caddr_t)payload, sizeof (la_els_adisc_t));
4304 }
4305 privp->fapktp = NULL;
4306 socal_els_free(privp);
4307 return (retval);
4308 }
4309
4310 static int
4311 socal_issue_lbf(socal_state_t *socalp, uint32_t port,
4312 uchar_t *payload, size_t length, uint32_t polled)
4313 {
4314 int retval;
4315 fcal_packet_t *fcalpkt;
4316 socal_port_t *port_statep;
4317 socal_priv_cmd_t *privp;
4318
4319 port_statep = &socalp->port_state[port];
4320
4321 if ((fcalpkt = socal_lbf_alloc(socalp, port, length, length,
4322 (caddr_t *)&privp, polled)) == (fcal_packet_t *)NULL)
4323 return (FCAL_ALLOC_FAILED);
4324
4325 privp = (socal_priv_cmd_t *)fcalpkt->fcal_pkt_private;
4326 bcopy((caddr_t)payload, privp->cmd, length);
4327 (void) ddi_dma_sync(privp->cmd_handle, 0, 0, DDI_DMA_SYNC_FORDEV);
4328
4329 retval = socal_doit(fcalpkt, port_statep, polled, socal_lbf_done,
4330 SOCAL_LBF_TIMEOUT, PORT_LBF_PENDING, NULL);
4331
4332 if (retval == FCAL_SUCCESS) {
4333 (void) ddi_dma_sync(privp->rsp_handle, 0, 0,
4334 DDI_DMA_SYNC_FORKERNEL);
4335 bcopy(privp->rsp, (caddr_t)payload, length);
4336 }
4337 privp->fapktp = NULL;
4338 socal_lbf_free(privp);
4339 return (retval);
4340 }
4341
4342 static int
4343 socal_issue_rls(socal_state_t *socalp, uint32_t port, uint32_t dest,
4344 la_els_rls_reply_t *payload, uint32_t polled)
4345 {
4346 int retval;
4347 la_els_rls_t *buf;
4348 fcal_packet_t *fcalpkt;
4349 socal_port_t *port_statep;
4350 socal_priv_cmd_t *privp;
4351 uint32_t arg;
4352
4353 port_statep = &socalp->port_state[port];
4354
4355 if (dest == socal_getmap(socalp, port, NULL, 0, 0)) {
4356 /* load up the the struct with the local lesb */
4357 struct la_els_rjt *rsp = (struct la_els_rjt *)payload;
4358
4359 rsp->ls_code = LA_ELS_RJT;
4360 rsp->mbz[0] = 0;
4361 rsp->mbz[1] = 0;
4362 rsp->mbz[2] = 0;
4363 rsp->reason_code = RJT_UNSUPPORTED;
4364 rsp->reserved = 0;
4365 rsp->explanation = 0;
4366 rsp->vendor = 0;
4367 return (FCAL_SUCCESS);
4368 }
4369
4370 if ((fcalpkt =
4371 socal_els_alloc(socalp, port, dest, sizeof (la_els_rls_t),
4372 sizeof (la_els_rls_reply_t), (caddr_t *)&privp, polled))
4373 == (fcal_packet_t *)NULL)
4374 return (FCAL_ALLOC_FAILED);
4375
4376 privp = (socal_priv_cmd_t *)fcalpkt->fcal_pkt_private;
4377
4378 if (payload->link_failure & 0xff000000)
4379 arg = payload->link_failure;
4380 else
4381 arg = dest;
4382
4383 buf = (la_els_rls_t *)privp->cmd;
4384 buf->ls_code = LA_ELS_RLS;
4385 buf->mbz[0] = 0;
4386 buf->mbz[1] = 0;
4387 buf->mbz[2] = 0;
4388 buf->reserved = 0;
4389 buf->nport_id[0] = (arg >> 16) & 0xff;
4390 buf->nport_id[1] = (arg >> 8) & 0xff;
4391 buf->nport_id[2] = arg & 0xff;
4392 (void) ddi_dma_sync(privp->cmd_handle, 0, 0, DDI_DMA_SYNC_FORDEV);
4393
4394 retval = socal_doit(fcalpkt, port_statep, 0, socal_rls_done,
4395 SOCAL_RLS_TIMEOUT, PORT_RLS_PENDING, NULL);
4396 if (retval == FCAL_SUCCESS) {
4397 (void) ddi_dma_sync(privp->rsp_handle, 0, 0,
4398 DDI_DMA_SYNC_FORKERNEL);
4399 bcopy(privp->rsp, (caddr_t)payload,
4400 sizeof (la_els_rls_reply_t));
4401 }
4402 privp->fapktp = NULL;
4403 socal_els_free(privp);
4404 return (retval);
4405 }
4406
4407 fcal_packet_t *
4408 socal_els_alloc(socal_state_t *socalp, uint32_t port, uint32_t dest,
4409 uint32_t cmd_size, uint32_t rsp_size, caddr_t *rprivp, uint32_t polled)
4410 {
4411 struct fcal_packet *fcalpkt;
4412 ddi_dma_cookie_t ccookie;
4413 ddi_dma_cookie_t rcookie;
4414 socal_priv_cmd_t *privp;
4415 ddi_dma_handle_t chandle = NULL;
4416 ddi_dma_handle_t rhandle = NULL;
4417 ddi_acc_handle_t cacchandle;
4418 ddi_acc_handle_t racchandle;
4419 soc_request_t *srp;
4420 fc_frame_header_t *fhp;
4421 uint_t ccount, cmd_bound = 0, rsp_bound = 0;
4422 size_t real_len;
4423 caddr_t cmd;
4424 caddr_t rsp;
4425 uint32_t ouralpa;
4426
4427 if ((fcalpkt =
4428 socal_packet_alloc(socalp, polled ? FCAL_NOSLEEP : FCAL_SLEEP))
4429 == (fcal_packet_t *)NULL)
4430 return (NULL);
4431
4432 if ((privp =
4433 (socal_priv_cmd_t *)kmem_zalloc(sizeof (socal_priv_cmd_t),
4434 polled ? KM_NOSLEEP : KM_SLEEP)) == (socal_priv_cmd_t *)NULL) {
4435 goto fail;
4436 }
4437
4438 rprivp = (caddr_t *)&privp;
4439
4440 fcalpkt->fcal_pkt_private = (caddr_t)privp;
4441 privp->fapktp = (void *)fcalpkt;
4442
4443 if ((ouralpa = socal_getmap(socalp, port, NULL, 0, 0)) == -1)
4444 goto fail;
4445
4446 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
4447 DDI_DMA_DONTWAIT, NULL, &chandle) != DDI_SUCCESS)
4448 goto fail;
4449 privp->cmd_handle = chandle;
4450
4451 if (ddi_dma_mem_alloc(chandle, cmd_size, &socal_acc_attr,
4452 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
4453 (caddr_t *)&cmd, &real_len, &cacchandle) != DDI_SUCCESS)
4454 goto fail;
4455 privp->cmd = cmd;
4456 privp->cmd_acchandle = cacchandle;
4457
4458 if (real_len < cmd_size)
4459 goto fail;
4460
4461 if (ddi_dma_addr_bind_handle(chandle, (struct as *)NULL,
4462 (caddr_t)cmd, cmd_size,
4463 DDI_DMA_WRITE | DDI_DMA_CONSISTENT,
4464 DDI_DMA_DONTWAIT, NULL, &ccookie, &ccount)
4465 != DDI_DMA_MAPPED)
4466 goto fail;
4467 cmd_bound = 1;
4468 if (ccount != 1)
4469 goto fail;
4470
4471 if (rsp_size) {
4472 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
4473 DDI_DMA_DONTWAIT, NULL, &rhandle) != DDI_SUCCESS)
4474 goto fail;
4475
4476 privp->rsp_handle = rhandle;
4477 if (ddi_dma_mem_alloc(rhandle, rsp_size, &socal_acc_attr,
4478 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
4479 &rsp, &real_len, &racchandle) != DDI_SUCCESS)
4480 goto fail;
4481 privp->rsp = rsp;
4482 privp->rsp_acchandle = racchandle;
4483 if (real_len < rsp_size)
4484 goto fail;
4485
4486 if (ddi_dma_addr_bind_handle(rhandle, (struct as *)NULL,
4487 rsp, rsp_size,
4488 DDI_DMA_READ | DDI_DMA_CONSISTENT,
4489 DDI_DMA_DONTWAIT, NULL, &rcookie, &ccount)
4490 != DDI_DMA_MAPPED)
4491 goto fail;
4492
4493 rsp_bound = 1;
4494 if (ccount != 1)
4495 goto fail;
4496 }
4497
4498 srp = (soc_request_t *)&fcalpkt->fcal_socal_request;
4499 srp->sr_soc_hdr.sh_flags = SOC_FC_HEADER;
4500 if (port)
4501 srp->sr_soc_hdr.sh_flags |= SOC_PORT_B;
4502 srp->sr_soc_hdr.sh_class = 3;
4503 srp->sr_soc_hdr.sh_byte_cnt = cmd_size;
4504 srp->sr_dataseg[0].fc_base = (uint32_t)ccookie.dmac_address;
4505 srp->sr_dataseg[0].fc_count = cmd_size;
4506 if (rsp_size == 0) {
4507 srp->sr_soc_hdr.sh_seg_cnt = 1;
4508 } else {
4509 srp->sr_soc_hdr.sh_seg_cnt = 2;
4510 srp->sr_dataseg[1].fc_base = (uint32_t)rcookie.dmac_address;
4511 srp->sr_dataseg[1].fc_count = rsp_size;
4512 }
4513 srp->sr_cqhdr.cq_hdr_count = 1;
4514 /* this will potentially be overwritten by the calling function */
4515 srp->sr_cqhdr.cq_hdr_type = CQ_TYPE_SIMPLE;
4516
4517 fcalpkt->fcal_pkt_cookie = (void *)socalp;
4518
4519 /* Fill in the Fabric Channel Header */
4520 fhp = &srp->sr_fc_frame_hdr;
4521 fhp->r_ctl = R_CTL_ELS_REQ;
4522 fhp->d_id = dest;
4523 fhp->s_id = ouralpa;
4524 fhp->type = TYPE_EXTENDED_LS;
4525 fhp->f_ctl = F_CTL_SEQ_INITIATIVE | F_CTL_FIRST_SEQ;
4526 fhp->seq_id = 0;
4527 fhp->df_ctl = 0;
4528 fhp->seq_cnt = 0;
4529 fhp->ox_id = 0xffff;
4530 fhp->rx_id = 0xffff;
4531 fhp->ro = 0;
4532 return (fcalpkt);
4533 fail:
4534 socal_packet_free(fcalpkt);
4535 if (privp) {
4536 if (privp->cmd_handle) {
4537 if (cmd_bound)
4538 (void) ddi_dma_unbind_handle(privp->cmd_handle);
4539 ddi_dma_free_handle(&privp->cmd_handle);
4540 }
4541 if (privp->cmd)
4542 ddi_dma_mem_free(&privp->cmd_acchandle);
4543 if (privp->rsp_handle) {
4544 if (rsp_bound)
4545 (void) ddi_dma_unbind_handle(privp->rsp_handle);
4546 ddi_dma_free_handle(&privp->rsp_handle);
4547 }
4548 if (privp->rsp)
4549 ddi_dma_mem_free(&privp->rsp_acchandle);
4550
4551 kmem_free(privp, sizeof (*privp));
4552 }
4553 return (NULL);
4554 }
4555
4556 fcal_packet_t *
4557 socal_lbf_alloc(socal_state_t *socalp, uint32_t port,
4558 uint32_t cmd_size, uint32_t rsp_size, caddr_t *rprivp,
4559 uint32_t polled)
4560 {
4561 struct fcal_packet *fcalpkt;
4562 ddi_dma_cookie_t ccookie;
4563 ddi_dma_cookie_t rcookie;
4564 socal_priv_cmd_t *privp;
4565 ddi_dma_handle_t chandle = NULL;
4566 ddi_dma_handle_t rhandle = NULL;
4567 ddi_acc_handle_t cacchandle;
4568 ddi_acc_handle_t racchandle;
4569 soc_request_t *srp;
4570 fc_frame_header_t *fhp;
4571 uint_t ccount, cmd_bound = 0, rsp_bound = 0;
4572 size_t real_len;
4573 caddr_t cmd;
4574 caddr_t rsp;
4575
4576 if ((fcalpkt =
4577 socal_packet_alloc(socalp, polled ? FCAL_NOSLEEP : FCAL_SLEEP))
4578 == (fcal_packet_t *)NULL)
4579 return (NULL);
4580
4581 if ((privp =
4582 (socal_priv_cmd_t *)kmem_zalloc(sizeof (socal_priv_cmd_t),
4583 polled ? KM_NOSLEEP : KM_SLEEP)) == (socal_priv_cmd_t *)NULL) {
4584 goto fail;
4585 }
4586
4587 rprivp = (caddr_t *)&privp;
4588
4589 fcalpkt->fcal_pkt_private = (caddr_t)privp;
4590 privp->fapktp = (void *)fcalpkt;
4591
4592 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
4593 DDI_DMA_DONTWAIT, NULL, &chandle) != DDI_SUCCESS)
4594 goto fail;
4595 privp->cmd_handle = chandle;
4596
4597 if (ddi_dma_mem_alloc(chandle, cmd_size, &socal_acc_attr,
4598 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
4599 (caddr_t *)&cmd, &real_len, &cacchandle) != DDI_SUCCESS)
4600 goto fail;
4601 privp->cmd = cmd;
4602 privp->cmd_acchandle = cacchandle;
4603
4604 if (real_len < cmd_size)
4605 goto fail;
4606
4607 if (ddi_dma_addr_bind_handle(chandle, (struct as *)NULL,
4608 (caddr_t)cmd, cmd_size,
4609 DDI_DMA_WRITE | DDI_DMA_CONSISTENT,
4610 DDI_DMA_DONTWAIT, NULL, &ccookie, &ccount)
4611 != DDI_DMA_MAPPED)
4612 goto fail;
4613 cmd_bound = 1;
4614 if (ccount != 1)
4615 goto fail;
4616
4617 if (rsp_size) {
4618 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
4619 DDI_DMA_DONTWAIT, NULL, &rhandle) != DDI_SUCCESS)
4620 goto fail;
4621
4622 privp->rsp_handle = rhandle;
4623 if (ddi_dma_mem_alloc(rhandle, rsp_size, &socal_acc_attr,
4624 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
4625 &rsp, &real_len, &racchandle) != DDI_SUCCESS)
4626 goto fail;
4627
4628 privp->rsp = rsp;
4629 privp->rsp_acchandle = racchandle;
4630 if (real_len < rsp_size)
4631 goto fail;
4632
4633 if (ddi_dma_addr_bind_handle(rhandle, (struct as *)NULL,
4634 rsp, rsp_size,
4635 DDI_DMA_READ | DDI_DMA_CONSISTENT,
4636 DDI_DMA_DONTWAIT, NULL, &rcookie, &ccount)
4637 != DDI_DMA_MAPPED)
4638 goto fail;
4639
4640 rsp_bound = 1;
4641 if (ccount != 1)
4642 goto fail;
4643 }
4644
4645 srp = (soc_request_t *)&fcalpkt->fcal_socal_request;
4646 srp->sr_soc_hdr.sh_flags = SOC_FC_HEADER;
4647 if (port)
4648 srp->sr_soc_hdr.sh_flags |= SOC_PORT_B;
4649 srp->sr_soc_hdr.sh_class = 3;
4650 srp->sr_soc_hdr.sh_byte_cnt = cmd_size;
4651 srp->sr_dataseg[0].fc_base = (uint32_t)ccookie.dmac_address;
4652 srp->sr_dataseg[0].fc_count = cmd_size;
4653 if (rsp_size == 0) {
4654 srp->sr_soc_hdr.sh_seg_cnt = 1;
4655 } else {
4656 srp->sr_soc_hdr.sh_seg_cnt = 2;
4657 srp->sr_dataseg[1].fc_base = (uint32_t)rcookie.dmac_address;
4658 srp->sr_dataseg[1].fc_count = rsp_size;
4659 }
4660 srp->sr_cqhdr.cq_hdr_count = 1;
4661 /* this will potentially be overwritten by the calling function */
4662 srp->sr_cqhdr.cq_hdr_type = CQ_TYPE_SIMPLE;
4663
4664 fcalpkt->fcal_pkt_cookie = (void *)socalp;
4665
4666 /* Fill in the Fabric Channel Header */
4667 fhp = &srp->sr_fc_frame_hdr;
4668 fhp->r_ctl = R_CTL_SOLICITED_DATA;
4669 fhp->d_id = socalp->port_state[port].sp_src_id;
4670 fhp->s_id = socalp->port_state[port].sp_src_id;
4671 fhp->type = TYPE_SCSI_FCP;
4672 fhp->f_ctl = F_CTL_SEQ_INITIATIVE | F_CTL_FIRST_SEQ | F_CTL_LAST_SEQ;
4673 fhp->seq_id = 0;
4674 fhp->df_ctl = 0;
4675 fhp->seq_cnt = 0;
4676 fhp->ox_id = 0xffff;
4677 fhp->rx_id = 0xffff;
4678 fhp->ro = 0;
4679 return (fcalpkt);
4680 fail:
4681 socal_packet_free(fcalpkt);
4682 if (privp) {
4683 if (privp->cmd_handle) {
4684 if (cmd_bound)
4685 (void) ddi_dma_unbind_handle(privp->cmd_handle);
4686 ddi_dma_free_handle(&privp->cmd_handle);
4687 }
4688 if (privp->cmd)
4689 ddi_dma_mem_free(&privp->cmd_acchandle);
4690 if (privp->rsp_handle) {
4691 if (rsp_bound)
4692 (void) ddi_dma_unbind_handle(privp->rsp_handle);
4693 ddi_dma_free_handle(&privp->rsp_handle);
4694 }
4695 if (privp->rsp)
4696 ddi_dma_mem_free(&privp->rsp_acchandle);
4697
4698 kmem_free(privp, sizeof (*privp));
4699 }
4700 return (NULL);
4701 }
4702
4703 void
4704 socal_els_free(socal_priv_cmd_t *privp)
4705 {
4706 fcal_packet_t *fcalpkt;
4707
4708 if (privp)
4709 fcalpkt = (fcal_packet_t *)privp->fapktp;
4710 else
4711 return;
4712
4713 (void) ddi_dma_unbind_handle(privp->cmd_handle);
4714 ddi_dma_free_handle(&privp->cmd_handle);
4715 ddi_dma_mem_free(&privp->cmd_acchandle);
4716
4717 if (privp->rsp_handle) {
4718 (void) ddi_dma_unbind_handle(privp->rsp_handle);
4719 ddi_dma_free_handle(&privp->rsp_handle);
4720 }
4721 if (privp->rsp)
4722 ddi_dma_mem_free(&privp->rsp_acchandle);
4723
4724 kmem_free(privp, sizeof (*privp));
4725 if (fcalpkt != NULL)
4726 socal_packet_free(fcalpkt);
4727 }
4728
4729 void
4730 socal_lbf_free(socal_priv_cmd_t *privp)
4731 {
4732 fcal_packet_t *fcalpkt;
4733
4734 if (privp)
4735 fcalpkt = (fcal_packet_t *)privp->fapktp;
4736 else
4737 return;
4738
4739 (void) ddi_dma_unbind_handle(privp->cmd_handle);
4740 ddi_dma_free_handle(&privp->cmd_handle);
4741 ddi_dma_mem_free(&privp->cmd_acchandle);
4742
4743 if (privp->rsp_handle) {
4744 (void) ddi_dma_unbind_handle(privp->rsp_handle);
4745 ddi_dma_free_handle(&privp->rsp_handle);
4746 }
4747
4748 if (privp->rsp)
4749 ddi_dma_mem_free(&privp->rsp_acchandle);
4750
4751 kmem_free(privp, sizeof (*privp));
4752 if (fcalpkt != NULL)
4753 socal_packet_free(fcalpkt);
4754 }
4755
4756 static int
4757 socal_getmap(socal_state_t *socalp, uint32_t port, caddr_t arg,
4758 uint32_t polled, int flags)
4759 {
4760 ddi_dma_cookie_t dcookie;
4761 ddi_dma_handle_t dhandle = NULL;
4762 ddi_acc_handle_t acchandle;
4763 size_t real_len, i;
4764 uint_t ccount;
4765 fcal_lilp_map_t *buf = NULL;
4766 int retval, bound = 0;
4767 socal_port_t *port_statep;
4768
4769 port_statep = &socalp->port_state[port];
4770
4771 if (port_statep->sp_lilpmap_valid) {
4772
4773 buf = &port_statep->sp_lilpmap; /* give from cache */
4774
4775 if (arg) {
4776 if (ddi_copyout(buf, (caddr_t)arg,
4777 sizeof (struct lilpmap), flags) == -1)
4778 return (-1);
4779 }
4780
4781 return (buf->lilp_myalpa);
4782 }
4783
4784 if (ddi_dma_alloc_handle(socalp->dip, &socal_dma_attr,
4785 DDI_DMA_DONTWAIT, NULL, &dhandle) != DDI_SUCCESS)
4786 goto getmap_fail;
4787
4788 i = sizeof (struct fcal_lilp_map);
4789
4790 if (ddi_dma_mem_alloc(dhandle, i, &socal_acc_attr,
4791 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
4792 (caddr_t *)&buf, &real_len, &acchandle) != DDI_SUCCESS)
4793 goto getmap_fail;
4794
4795 if (real_len < i)
4796 goto getmap_fail;
4797
4798 if (ddi_dma_addr_bind_handle(dhandle, (struct as *)NULL,
4799 (caddr_t)buf, i, DDI_DMA_READ | DDI_DMA_CONSISTENT,
4800 DDI_DMA_DONTWAIT, NULL, &dcookie, &ccount) != DDI_DMA_MAPPED)
4801 goto getmap_fail;
4802
4803 bound = 1;
4804 if (ccount != 1)
4805 goto getmap_fail;
4806
4807 retval = socal_lilp_map((void *)socalp, port,
4808 (uint32_t)dcookie.dmac_address, polled);
4809
4810 (void) ddi_dma_sync(dhandle, 0, 0, DDI_DMA_SYNC_FORKERNEL);
4811
4812 if (retval == FCAL_SUCCESS) {
4813 bcopy(buf, &port_statep->sp_lilpmap, sizeof (fcal_lilp_map_t));
4814
4815 mutex_enter(&port_statep->sp_mtx);
4816 port_statep->sp_src_id = buf->lilp_myalpa;
4817 port_statep->sp_lilpmap_valid = 1; /* cached */
4818 mutex_exit(&port_statep->sp_mtx);
4819
4820 if (arg) {
4821 if (ddi_copyout(buf, (caddr_t)arg,
4822 sizeof (struct lilpmap), flags) == -1)
4823 goto getmap_fail;
4824 }
4825
4826 retval = buf->lilp_myalpa;
4827 }
4828 else
4829 retval = -1;
4830
4831 (void) ddi_dma_unbind_handle(dhandle);
4832 ddi_dma_mem_free(&acchandle);
4833 ddi_dma_free_handle(&dhandle);
4834 return (retval);
4835
4836 getmap_fail:
4837 if (dhandle) {
4838 if (bound)
4839 (void) ddi_dma_unbind_handle(dhandle);
4840 ddi_dma_free_handle(&dhandle);
4841 }
4842 if (buf)
4843 ddi_dma_mem_free(&acchandle);
4844 return (-1);
4845 }
4846
4847 static void
4848 socal_wcopy(uint_t *h_src, uint_t *h_dest, int len)
4849 {
4850 int i;
4851 for (i = 0; i < len/4; i++) {
4852 *h_dest++ = *h_src++;
4853 }
4854 }
4855
4856 static void
4857 socal_flush_overflowq(socal_state_t *socalp, int port, int q_no)
4858 {
4859 socal_kcq_t *kcq;
4860 fcal_packet_t *fpkt1, *fpkt2, *head = NULL, *tmp;
4861
4862 kcq = &socalp->request[q_no];
4863 mutex_enter(&kcq->skc_mtx);
4864 fpkt2 = kcq->skc_overflowh;
4865 fpkt1 = NULL;
4866 while (fpkt2 != NULL) {
4867 if ((((soc_request_t *)&fpkt2->fcal_socal_request)
4868 ->sr_soc_hdr.sh_flags & SOC_PORT_B) == port) {
4869 if (fpkt1 == NULL)
4870 kcq->skc_overflowh = fpkt2->fcal_pkt_next;
4871 else {
4872 fpkt1->fcal_pkt_next = fpkt2->fcal_pkt_next;
4873 if (kcq->skc_overflowt == fpkt2)
4874 kcq->skc_overflowt = fpkt1;
4875 }
4876 tmp = fpkt2->fcal_pkt_next;
4877 fpkt2->fcal_pkt_next = head;
4878 head = fpkt2;
4879 fpkt2 = tmp;
4880 SOCAL_ID_FREE(head->fcal_socal_request.
4881 sr_soc_hdr.sh_request_token);
4882 } else {
4883 fpkt1 = fpkt2;
4884 fpkt2 = fpkt2->fcal_pkt_next;
4885 }
4886 }
4887 mutex_exit(&kcq->skc_mtx);
4888 fpkt2 = head;
4889 while (fpkt2 != NULL) {
4890 fpkt2->fcal_pkt_status = FCAL_STATUS_ERR_OFFLINE;
4891 fpkt2->fcal_cmd_state |= FCAL_CMD_COMPLETE;
4892 fpkt2->fcal_pkt_flags |= FCFLAG_COMPLETE;
4893 tmp = fpkt2->fcal_pkt_next;
4894 if (fpkt2->fcal_pkt_comp != NULL)
4895 (*fpkt2->fcal_pkt_comp)(fpkt2);
4896 fpkt2 = tmp;
4897 }
4898 }
4899
4900 static void
4901 socal_deferred_intr(void *arg)
4902 {
4903 socal_kcq_t *kcq = (socal_kcq_t *)arg;
4904 socal_state_t *socalp = kcq->skc_socalp;
4905
4906 ASSERT((socalp != NULL));
4907
4908 mutex_enter(&kcq->skc_mtx);
4909
4910 if ((kcq->skc_out != kcq->skc_saved_out) ||
4911 (kcq->skc_seqno != kcq->skc_saved_seqno)) {
4912 kcq->deferred_intr_timeoutid = 0;
4913 mutex_exit(&kcq->skc_mtx);
4914 return;
4915 }
4916
4917 if (socalp->socal_on_intr) {
4918 mutex_exit(&kcq->skc_mtx);
4919 kcq->deferred_intr_timeoutid = timeout(socal_deferred_intr,
4920 (caddr_t)kcq, drv_usectohz(10000));
4921 return;
4922 }
4923
4924 kcq->deferred_intr_timeoutid = 0;
4925 mutex_exit(&kcq->skc_mtx);
4926 socal_intr_solicited(socalp, 0);
4927 }
4928
4929 static void
4930 socal_take_core(void *arg)
4931 {
4932 socal_state_t *socalp = (socal_state_t *)arg;
4933 int i, instance;
4934
4935 socal_disable(socalp);
4936 for (i = 0; i < SOCAL_N_CQS; i++) {
4937 mutex_enter(&socalp->request[i].skc_mtx);
4938 mutex_enter(&socalp->response[i].skc_mtx);
4939 }
4940 for (i = 0; i < 4; i++) {
4941 socalp->socal_rp->socal_cr.w &=
4942 ~SOCAL_CR_EXTERNAL_RAM_BANK_MASK;
4943 socalp->socal_rp->socal_cr.w |= i<<24;
4944 (void) bcopy((caddr_t)socalp->socal_xrp,
4945 (caddr_t)&socal_xrambuf[i*0x10000], 0x10000);
4946 }
4947 for (i = 3; i >= 0; i--) {
4948 mutex_exit(&socalp->request[i].skc_mtx);
4949 mutex_exit(&socalp->response[i].skc_mtx);
4950 }
4951 instance = ddi_get_instance(socalp->dip);
4952 cmn_err(CE_PANIC,
4953 "socal take core (socal instance %d)", instance);
4954 }
4955
4956 /*
4957 * Preset AL_PA in hardware, if is told.
4958 */
4959 static void
4960 socal_fix_harda(socal_state_t *socalp, int port)
4961 {
4962 socal_port_t *portp = &socalp->port_state[port];
4963 uint_t *xrp = (uint_t *)socalp->socal_xrp;
4964 uint_t accum, harda;
4965
4966 harda = portp->sp_hard_alpa;
4967 accum = xrp[SOCAL_XRAM_PORTA_HRDA/4];
4968 if (port == 0) {
4969 accum &= 0x00FFFFFF;
4970 accum |= ((harda & 0xFF) << 24);
4971 } else {
4972 accum &= 0xFF00FFFF;
4973 accum |= ((harda & 0xFF) << 16);
4974 }
4975 xrp[SOCAL_XRAM_PORTA_HRDA/4] = accum;
4976 }
4977
4978 /*
4979 * Target-Mode attach function
4980 */
4981 fcal_transport_t *
4982 socal_sftm_attach(dev_t dev, int loop_id)
4983 {
4984 int instance = getminor(dev) / 2;
4985 int port = getminor(dev) % 2;
4986 int hard_alpa;
4987 char *name;
4988 socal_state_t *socalp;
4989
4990 /*
4991 * If the device is not a "socal" device, return
4992 */
4993 if ((name = ddi_major_to_name(getmajor(dev))) == NULL ||
4994 strcmp(name, "socal") != 0)
4995 return (NULL);
4996
4997 /*
4998 * If no soft state structure, return
4999 */
5000 socalp = ddi_get_soft_state(socal_soft_state_p, instance);
5001 if (socalp == NULL)
5002 return (NULL);
5003
5004 /*
5005 * If the port is already attached, return
5006 */
5007 if (socalp->port_state[port].sp_status & PORT_CHILD_INIT)
5008 return (NULL);
5009
5010 if (loop_id < 0 || loop_id > 126)
5011 return (NULL);
5012
5013 /* if this instance is detaching, don't attach */
5014 mutex_enter(&socalp->board_mtx);
5015 mutex_enter(&socalp->port_state[port].sp_mtx);
5016 if (socalp->socal_busy < 0) {
5017 mutex_exit(&socalp->port_state[port].sp_mtx);
5018 mutex_exit(&socalp->board_mtx);
5019 return (NULL);
5020 }
5021 socalp->socal_busy++;
5022 socalp->port_state[port].sp_status |= PORT_CHILD_INIT;
5023 mutex_exit(&socalp->port_state[port].sp_mtx);
5024 mutex_exit(&socalp->board_mtx);
5025
5026 /*
5027 * Since we keep the Hard Loop-id in two config files, warn the
5028 * user if they don't match.
5029 */
5030 hard_alpa = socal_switch_to_alpa[loop_id];
5031 if (hard_alpa != socalp->port_state[port].sp_hard_alpa) {
5032 socalp->port_state[port].sp_hard_alpa = hard_alpa;
5033 cmn_err(CE_WARN, "socal%d: Hard Loop-id mismatch - "
5034 "using Loop-id %d",
5035 instance, loop_id);
5036 }
5037
5038 return (socalp->port_state[port].sp_transport);
5039 }
5040
5041
5042 /*
5043 * Target-Mode detach function
5044 */
5045 int
5046 socal_sftm_detach(socal_state_t *socalp, int port)
5047 {
5048 mutex_enter(&socalp->board_mtx);
5049 socalp->socal_busy--;
5050 socalp->port_state[port].sp_status &= ~PORT_CHILD_INIT;
5051 mutex_exit(&socalp->board_mtx);
5052
5053 return (0);
5054 }
unleashed repo fork