?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'origin/master'
[unleashed/lotheac.git] / usr / src / uts / common / io / sbp2 / sbp2.c
blobff318d11f479505811f058d7ae71564239e5c2fb
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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * SBP2 module
28 */
29 #include <sys/param.h>
30 #include <sys/errno.h>
31 #include <sys/cred.h>
32 #include <sys/conf.h>
33 #include <sys/disp.h>
34 #include <sys/modctl.h>
35 #include <sys/stat.h>
36 #include <sys/stream.h>
37 #include <sys/strsubr.h>
38 #include <sys/strsun.h>
39 #include <sys/ddi.h>
40 #include <sys/sunddi.h>
41
42 #include <sys/sbp2/impl.h>
43 #include <sys/1394/ieee1212.h>
44
45 /* target routines */
46 static void sbp2_tgt_init_sobj(sbp2_tgt_t *);
47 static void sbp2_tgt_fini_sobj(sbp2_tgt_t *);
48 static int sbp2_tgt_init_params(sbp2_tgt_t *);
49 static int sbp2_tgt_init_luns(sbp2_tgt_t *, int);
50 static void sbp2_tgt_fini_luns(sbp2_tgt_t *);
51 static int sbp2_tgt_init_bus(sbp2_tgt_t *);
52 static void sbp2_tgt_fini_bus(sbp2_tgt_t *);
53 static int sbp2_tgt_mgt_request(sbp2_tgt_t *, int *);
54 static int sbp2_tgt_task_mgt_request(sbp2_tgt_t *, uint16_t, int, uint64_t,
55 int *);
56
57 /* lun routines */
58 static void sbp2_lun_logout_orb(sbp2_lun_t *, sbp2_tgt_t *, int *);
59 static boolean_t sbp2_lun_accepting_tasks(sbp2_lun_t *);
60
61 /* session routines */
62 static int sbp2_ses_init(sbp2_ses_t **, sbp2_lun_t *,
63 void (*)(void *, sbp2_task_t *), void *);
64 static void sbp2_ses_fini(sbp2_ses_t *);
65 static sbp2_task_t *sbp2_ses_orbp2task(sbp2_ses_t *, uint64_t);
66 static void sbp2_ses_append_task(sbp2_ses_t *, sbp2_task_t *);
67 static void sbp2_ses_reset_pending_tasks(sbp2_ses_t *, uint16_t);
68 static int sbp2_ses_reconnect_orb(sbp2_ses_t *, int *);
69
70 /* orb alloc routines */
71 static sbp2_bus_buf_t *sbp2_orb_freelist_get(sbp2_lun_t *, sbp2_task_t *, int);
72 static int sbp2_orb_freelist_put(sbp2_lun_t *, sbp2_bus_buf_t *);
73 static void sbp2_orb_freelist_destroy(sbp2_lun_t *);
74
75 /* fetch agent routines */
76 static int sbp2_agent_init(sbp2_agent_t *, uint64_t, sbp2_tgt_t *tp);
77 static void sbp2_agent_fini(sbp2_agent_t *);
78 static void sbp2_agent_acquire_locked(sbp2_agent_t *);
79 static void sbp2_agent_release_locked(sbp2_agent_t *);
80 static void sbp2_agent_acquire(sbp2_agent_t *);
81 static void sbp2_agent_release(sbp2_agent_t *);
82 static int sbp2_agent_keepalive(sbp2_agent_t *, int *);
83 static int sbp2_agent_doorbell(sbp2_agent_t *, int *);
84 static int sbp2_agent_write_orbp(sbp2_agent_t *, uint64_t, int *);
85 static int sbp2_agent_reset(sbp2_agent_t *, int *);
86
87 /* callbacks and timeouts */
88 static void sbp2_mgt_status_fifo_wb_cb(sbp2_bus_buf_t *, void *, mblk_t **);
89 static void sbp2_task_timeout(void *);
90 static void sbp2_status_fifo_wb_cb(sbp2_bus_buf_t *, void *, mblk_t **);
91
92 /* other */
93 static void sbp2_mgt_agent_acquire(sbp2_tgt_t *);
94 static void sbp2_mgt_agent_release(sbp2_tgt_t *);
95 static void sbp2_fetch_agent_acquire(sbp2_ses_t *);
96 static void sbp2_fetch_agent_release(sbp2_ses_t *);
97
98 extern struct mod_ops mod_miscops;
99
100 static struct modlmisc sbp2_modlmisc = {
101 &mod_miscops, /* module type */
102 "Serial Bus Protocol 2 module" /* module name */
103 };
104
105 static struct modlinkage sbp2_modlinkage = {
106 MODREV_1, (void *)&sbp2_modlmisc, NULL
107 };
108
109 /* tunables */
110 int sbp2_submit_reset_nretries = 3;
111 clock_t sbp2_submit_reset_delay = 10; /* microsec */
112
113 int sbp2_write_orbp_nretries = 3;
114 clock_t sbp2_write_orbp_delay = 10; /* microsec */
115
116 _NOTE(SCHEME_PROTECTS_DATA("unique per call", datab msgb))
117
118 /*
119 *
120 * --- loadable module entry points
121 *
122 */
123 int
124 _init(void)
125 {
126 return (mod_install(&sbp2_modlinkage));
127 }
128
129
130 int
131 _fini(void)
132 {
133 return (mod_remove(&sbp2_modlinkage));
134 }
135
136
137 int
138 _info(struct modinfo *modinfop)
139 {
140 return (mod_info(&sbp2_modlinkage, modinfop));
141 }
142
143 /*
144 *
145 * --- target routines
146 *
147 */
148 int
149 sbp2_tgt_init(void *bus_hdl, sbp2_bus_t *bus, int maxluns, sbp2_tgt_t **tpp)
150 {
151 sbp2_tgt_t *tp;
152 int ret;
153
154 tp = kmem_zalloc(sizeof (sbp2_tgt_t), KM_SLEEP);
155 tp->t_bus = bus;
156 tp->t_bus_hdl = bus_hdl;
157
158 sbp2_tgt_init_sobj(tp);
159
160 if ((ret = sbp2_cfgrom_parse(tp, &tp->t_cfgrom)) != SBP2_SUCCESS) {
161 sbp2_tgt_fini_sobj(tp);
162 kmem_free(tp, sizeof (sbp2_tgt_t));
163 return (SBP2_ECFGROM);
164 }
165
166 if ((ret = sbp2_tgt_init_params(tp)) != SBP2_SUCCESS) {
167 sbp2_cfgrom_free(tp, &tp->t_cfgrom);
168 sbp2_tgt_fini_sobj(tp);
169 kmem_free(tp, sizeof (sbp2_tgt_t));
170 return (ret);
171 }
172
173 if ((ret = sbp2_tgt_init_luns(tp, maxluns)) != SBP2_SUCCESS) {
174 sbp2_cfgrom_free(tp, &tp->t_cfgrom);
175 sbp2_tgt_fini_sobj(tp);
176 kmem_free(tp, sizeof (sbp2_tgt_t));
177 return (ret);
178 }
179
180 if ((ret = sbp2_tgt_init_bus(tp)) != SBP2_SUCCESS) {
181 sbp2_tgt_fini_luns(tp);
182 sbp2_cfgrom_free(tp, &tp->t_cfgrom);
183 sbp2_tgt_fini_sobj(tp);
184 kmem_free(tp, sizeof (sbp2_tgt_t));
185 return (ret);
186 }
187
188 *tpp = tp;
189 return (SBP2_SUCCESS);
190 }
191
192 void
193 sbp2_tgt_fini(sbp2_tgt_t *tp)
194 {
195 sbp2_tgt_fini_bus(tp);
196 sbp2_tgt_fini_luns(tp);
197 sbp2_cfgrom_free(tp, &tp->t_cfgrom);
198 sbp2_tgt_fini_sobj(tp);
199 kmem_free(tp, sizeof (sbp2_tgt_t));
200 }
201
202 static void
203 sbp2_tgt_init_sobj(sbp2_tgt_t *tp)
204 {
205 mutex_init(&tp->t_mutex, NULL, MUTEX_DRIVER, NULL);
206 cv_init(&tp->t_mgt_agent_cv, NULL, CV_DRIVER, NULL);
207 cv_init(&tp->t_mgt_status_cv, NULL, CV_DRIVER, NULL);
208 }
209
210 static void
211 sbp2_tgt_fini_sobj(sbp2_tgt_t *tp)
212 {
213 cv_destroy(&tp->t_mgt_status_cv);
214 cv_destroy(&tp->t_mgt_agent_cv);
215 mutex_destroy(&tp->t_mutex);
216 }
217
218 static int
219 sbp2_tgt_init_params(sbp2_tgt_t *tp)
220 {
221 sbp2_cfgrom_ent_t *root = &tp->t_cfgrom.cr_root;
222 sbp2_cfgrom_ent_t *ent;
223 uint32_t q;
224
225 /* MANAGEMENT_AGENT */
226 if ((ent = sbp2_cfgrom_ent_by_key(root, SBP2_KT_MGT_AGENT,
227 SBP2_KV_MGT_AGENT, 0)) == NULL) {
228 return (SBP2_ECFGROM);
229 }
230 tp->t_mgt_agent = SBP2_CSR_BASE(tp) + ent->ce_data.offset * 4;
231
232 /* Unit_Characteristics */
233 if ((ent = sbp2_cfgrom_ent_by_key(root, SBP2_KT_UNCHAR,
234 SBP2_KV_UNCHAR, 0)) == NULL) {
235 return (SBP2_ECFGROM);
236 }
237 q = ent->ce_data.imm;
238
239 /* units of 500 ms -> ms */
240 tp->t_mot = ((q & SBP2_UNCHAR_MOT) >> SBP2_UNCHAR_MOT_SHIFT) * 500;
241
242 /* quadlets -> bytes */
243 tp->t_orb_size = (q & SBP2_UNCHAR_ORB_SIZE) * 4;
244
245 /* some devices return incorrect values */
246 if (tp->t_mot < SBP2_MOT_MIN) {
247 tp->t_mot = SBP2_MOT_DFLT;
248 }
249 if (tp->t_orb_size < SBP2_ORB_SIZE_MIN) {
250 tp->t_orb_size = SBP2_ORB_SIZE_MIN;
251 }
252
253 return (SBP2_SUCCESS);
254 }
255
256
257 /*ARGSUSED*/
258 static int
259 sbp2_tgt_init_luns(sbp2_tgt_t *tp, int maxluns)
260 {
261 sbp2_cfgrom_ent_t *root = &tp->t_cfgrom.cr_root;
262 sbp2_cfgrom_ent_t *ent;
263 sbp2_lun_t *lp;
264 uint32_t q;
265
266 ASSERT(tp->t_nluns == 0);
267
268 tp->t_lun = kmem_zalloc(maxluns * sizeof (sbp2_lun_t), KM_SLEEP);
269 tp->t_nluns_alloc = maxluns;
270
271 /* search for Logical_Unit_Number's */
272 for (tp->t_nluns = 0; tp->t_nluns < maxluns; tp->t_nluns++) {
273 if ((ent = sbp2_cfgrom_ent_by_key(root, SBP2_KT_LUN,
274 SBP2_KV_LUN, tp->t_nluns)) == NULL) {
275 break;
276 }
277 q = ent->ce_data.imm;
278 lp = &tp->t_lun[tp->t_nluns];
279 lp->l_tgt = tp;
280 lp->l_lun = q & SBP2_LUN_NUM;
281 lp->l_type = (q & SBP2_LUN_TYPE) >> SBP2_LUN_TYPE_SHIFT;
282 mutex_init(&lp->l_orb_freelist.bl_mutex, NULL, MUTEX_DRIVER,
283 NULL);
284 }
285
286 if (tp->t_nluns > 0) {
287 return (SBP2_SUCCESS);
288 } else {
289 kmem_free(tp->t_lun, tp->t_nluns_alloc * sizeof (sbp2_lun_t));
290 return (SBP2_ECFGROM);
291 }
292
293 }
294
295
296 static void
297 sbp2_tgt_fini_luns(sbp2_tgt_t *tp)
298 {
299 int i;
300 sbp2_lun_t *lp;
301
302 /* destroy each lun */
303 for (i = 0; i < tp->t_nluns; i++) {
304 lp = &tp->t_lun[i];
305 sbp2_orb_freelist_destroy(lp);
306 mutex_destroy(&lp->l_orb_freelist.bl_mutex);
307 }
308
309 kmem_free(tp->t_lun, tp->t_nluns_alloc * sizeof (sbp2_lun_t));
310 }
311
312 /*
313 * initialize bus buffers and commands
314 */
315 static int
316 sbp2_tgt_init_bus(sbp2_tgt_t *tp)
317 {
318 int ret;
319
320 /*
321 * We serialize management requests and reuse the same buffers.
322 *
323 * mgt ORB
324 */
325 tp->t_mgt_orb_buf.bb_len =
326 SBP2_ORB_SIZE_ROUNDUP(tp, sizeof (sbp2_mgt_orb_t));
327 tp->t_mgt_orb_buf.bb_flags = SBP2_BUS_BUF_DMA | SBP2_BUS_BUF_RD;
328 if ((ret = SBP2_ALLOC_BUF(tp, &tp->t_mgt_orb_buf)) != SBP2_SUCCESS) {
329 sbp2_tgt_fini_bus(tp);
330 return (ret);
331 }
332
333 /*
334 * mgt status FIFO
335 */
336 tp->t_mgt_status_fifo_buf.bb_len = sizeof (sbp2_status_t);
337 tp->t_mgt_status_fifo_buf.bb_flags = SBP2_BUS_BUF_WR_POSTED;
338 tp->t_mgt_status_fifo_buf.bb_wb_cb = sbp2_mgt_status_fifo_wb_cb;
339 tp->t_mgt_status_fifo_buf.bb_sbp2_priv = tp;
340 if ((ret = SBP2_ALLOC_BUF(tp, &tp->t_mgt_status_fifo_buf)) !=
341 SBP2_SUCCESS) {
342 return (ret);
343 }
344
345 /*
346 * login response
347 */
348 tp->t_mgt_login_resp_buf.bb_len =
349 SBP2_ORB_SIZE_ROUNDUP(tp, sizeof (sbp2_login_resp_t));
350 /*
351 * read-only should have been sufficient here, but it causes
352 * DVMA errors on Grover, while read/write works just fine
353 */
354 tp->t_mgt_login_resp_buf.bb_flags = SBP2_BUS_BUF_DMA | SBP2_BUS_BUF_RW;
355 if ((ret = SBP2_ALLOC_BUF(tp, &tp->t_mgt_login_resp_buf)) !=
356 SBP2_SUCCESS) {
357 sbp2_tgt_fini_bus(tp);
358 return (ret);
359 }
360
361 /*
362 * allocate bus commands
363 */
364 if ((ret = SBP2_ALLOC_CMD(tp, &tp->t_mgt_cmd, 0)) != SBP2_SUCCESS) {
365 sbp2_tgt_fini_bus(tp);
366 return (ret);
367 }
368 if ((tp->t_mgt_cmd_data = allocb(8, BPRI_HI)) == NULL) {
369 sbp2_tgt_fini_bus(tp);
370 return (SBP2_ENOMEM);
371 }
372
373 return (SBP2_SUCCESS);
374 }
375
376 static void
377 sbp2_tgt_fini_bus(sbp2_tgt_t *tp)
378 {
379 if (tp->t_mgt_status_fifo_buf.bb_hdl != NULL) {
380 SBP2_FREE_BUF(tp, &tp->t_mgt_status_fifo_buf);
381 }
382 if (tp->t_mgt_orb_buf.bb_hdl != NULL) {
383 SBP2_FREE_BUF(tp, &tp->t_mgt_orb_buf);
384 }
385 if (tp->t_mgt_login_resp_buf.bb_hdl != NULL) {
386 SBP2_FREE_BUF(tp, &tp->t_mgt_login_resp_buf);
387 }
388 if (tp->t_mgt_cmd) {
389 SBP2_FREE_CMD(tp, tp->t_mgt_cmd);
390 tp->t_mgt_cmd = NULL;
391 }
392 if (tp->t_mgt_cmd_data) {
393 freeb(tp->t_mgt_cmd_data);
394 tp->t_mgt_cmd_data = NULL;
395 }
396 }
397
398 void
399 sbp2_tgt_disconnect(sbp2_tgt_t *tp)
400 {
401 sbp2_tgt_fini_bus(tp);
402 }
403
404 int
405 sbp2_tgt_reconnect(sbp2_tgt_t *tp)
406 {
407 return (sbp2_tgt_init_bus(tp));
408 }
409
410 /*
411 * send mgt ORB and wait for status
412 *
413 * mgt agent should be acquired
414 */
415 static int
416 sbp2_tgt_mgt_request(sbp2_tgt_t *tp, int *berr)
417 {
418 clock_t until;
419 int ret;
420
421 /*
422 * When a ctl operation happens from HAL - this could be 0!
423 * This will happen when a device is disconected and then
424 * reconnected. Note there are problems with not being able
425 * to detach/eject a target before unplugging. That can cause
426 * this to happen... This problem needs some work elseware!
427 * This just prevents a needless panic. If we return failure
428 * the target ultimatly will recover and is usable.
429 */
430 if (tp->t_mgt_cmd_data == 0) {
431 return (SBP2_FAILURE);
432 }
433
434 tp->t_mgt_status_rcvd = B_FALSE;
435
436 /* write ORB address into MANAGEMENT_AGENT */
437 SBP2_ADDR_SET(tp->t_mgt_cmd_data->b_rptr, tp->t_mgt_orb_buf.bb_baddr,
438 0);
439 tp->t_mgt_cmd_data->b_wptr = tp->t_mgt_cmd_data->b_rptr + 8;
440
441 if ((ret = SBP2_WB(tp, tp->t_mgt_cmd, tp->t_mgt_agent,
442 tp->t_mgt_cmd_data, 8, berr)) != SBP2_SUCCESS) {
443 return (ret);
444 }
445
446 /* wait for login response */
447 mutex_enter(&tp->t_mutex);
448 until = ddi_get_lbolt() + drv_usectohz(tp->t_mot * 1000);
449 ret = 1;
450
451 while (!tp->t_mgt_status_rcvd && (ret > 0)) {
452 ret = cv_timedwait(&tp->t_mgt_status_cv, &tp->t_mutex, until);
453 }
454
455 if (!tp->t_mgt_status_rcvd) {
456 ret = SBP2_ETIMEOUT;
457 } else if ((tp->t_mgt_status.st_param & SBP2_ST_RESP) ==
458 SBP2_ST_RESP_COMPLETE) {
459 ret = SBP2_SUCCESS;
460 } else {
461 ret = SBP2_FAILURE;
462 }
463 mutex_exit(&tp->t_mutex);
464
465 return (ret);
466 }
467
468 /*
469 * Send task management request, one of:
470 *
471 * ABORT TASK, ABORT TASK SET, LOGICAL UNIT RESET, TARGET RESET
472 */
473 static int
474 sbp2_tgt_task_mgt_request(sbp2_tgt_t *tp, uint16_t id, int func, uint64_t orbp,
475 int *berr)
476 {
477 sbp2_task_mgt_orb_t *torb;
478 int ret;
479
480 sbp2_mgt_agent_acquire(tp);
481
482 torb = (sbp2_task_mgt_orb_t *)tp->t_mgt_orb_buf.bb_kaddr;
483 bzero(torb, sizeof (sbp2_task_mgt_orb_t));
484 SBP2_ORBP_SET(torb->to_orb, orbp);
485 torb->to_params = SBP2_SWAP16(func | SBP2_ORB_NOTIFY |
486 SBP2_ORB_RQ_FMT_SBP2);
487 torb->to_login_id = SBP2_SWAP16(id);
488 SBP2_ADDR_SET(torb->to_status_fifo, tp->t_mgt_status_fifo_buf.bb_baddr,
489 0);
490
491 ret = sbp2_tgt_mgt_request(tp, berr);
492
493 sbp2_mgt_agent_release(tp);
494
495 return (ret);
496 }
497
498 int
499 sbp2_tgt_reset(sbp2_tgt_t *tp, int *berr)
500 {
501 sbp2_lun_t *lp = &tp->t_lun[0];
502 int ret;
503
504 /* issue TARGET RESET */
505 if ((ret = sbp2_tgt_task_mgt_request(tp, lp->l_login_resp.lr_login_id,
506 SBP2_ORB_MGT_FUNC_TARGET_RESET, 0, berr)) != SBP2_SUCCESS) {
507 return (ret);
508 }
509
510 return (SBP2_SUCCESS);
511 }
512
513 int
514 sbp2_tgt_get_cfgrom(sbp2_tgt_t *tp, sbp2_cfgrom_t **crpp)
515 {
516 *crpp = &tp->t_cfgrom;
517 return (SBP2_SUCCESS);
518 }
519
520 int
521 sbp2_tgt_get_lun_cnt(sbp2_tgt_t *tp)
522 {
523 return (tp->t_nluns);
524 }
525
526 sbp2_lun_t *
527 sbp2_tgt_get_lun(sbp2_tgt_t *tp, int num)
528 {
529 if (num < tp->t_nluns) {
530 return (&tp->t_lun[num]);
531 } else {
532 return (NULL);
533 }
534 }
535
536 /*
537 *
538 * --- lun routines
539 *
540 */
541 int
542 sbp2_lun_reset(sbp2_lun_t *lp, int *berr)
543 {
544 sbp2_tgt_t *tp = lp->l_tgt;
545 sbp2_ses_t *sp = lp->l_ses;
546 sbp2_task_t *task = NULL;
547 int ret;
548
549 /* issue LOGICAL UNIT RESET */
550 if ((ret = sbp2_tgt_task_mgt_request(tp, lp->l_login_resp.lr_login_id,
551 SBP2_ORB_MGT_FUNC_LUN_RESET, 0, berr)) != SBP2_SUCCESS) {
552 return (ret);
553 }
554
555 /* mark all pending tasks reset and notify the driver */
556 mutex_enter(&sp->s_task_mutex);
557 for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
558 if (task->ts_state < SBP2_TASK_COMP) {
559 task->ts_error = SBP2_TASK_ERR_LUN_RESET;
560 task->ts_state = SBP2_TASK_COMP;
561 }
562 }
563 mutex_exit(&sp->s_task_mutex);
564
565 sp->s_status_cb(sp->s_status_cb_arg, NULL);
566
567 return (SBP2_SUCCESS);
568 }
569
570 int
571 sbp2_lun_login(sbp2_lun_t *lp, sbp2_ses_t **spp,
572 void (*cb)(void *, sbp2_task_t *), void *cb_arg, int *berr)
573 {
574 sbp2_tgt_t *tp = lp->l_tgt;
575 sbp2_ses_t *sp;
576 sbp2_login_orb_t *lorb;
577 int ret;
578
579 if (cb == NULL) {
580 return (SBP2_EINVAL);
581 }
582
583 /* multiple sessions not supported yet */
584 if (lp->l_ses != NULL) {
585 return (SBP2_EALREADY);
586 }
587
588 if ((ret = sbp2_ses_init(&sp, lp, cb, cb_arg)) != SBP2_SUCCESS) {
589 return (ret);
590 }
591 lp->l_ses = sp;
592
593 sbp2_mgt_agent_acquire(tp);
594
595 /* prepare login ORB */
596 mutex_enter(&tp->t_mutex);
597 lorb = (sbp2_login_orb_t *)tp->t_mgt_orb_buf.bb_kaddr;
598 bzero(lorb, sizeof (sbp2_login_orb_t));
599 SBP2_ADDR_SET(lorb->lo_resp, tp->t_mgt_login_resp_buf.bb_baddr, 0);
600 lorb->lo_params = SBP2_SWAP16(SBP2_ORB_MGT_FUNC_LOGIN |
601 SBP2_ORB_LOGIN_EXCL | SBP2_ORB_NOTIFY | SBP2_ORB_RQ_FMT_SBP2);
602 lorb->lo_lun = SBP2_SWAP16(lp->l_lun);
603 lorb->lo_resp_len = SBP2_SWAP16(tp->t_mgt_login_resp_buf.bb_len);
604 SBP2_ADDR_SET(lorb->lo_status_fifo, sp->s_status_fifo_buf.bb_baddr, 0);
605
606 bzero(tp->t_mgt_login_resp_buf.bb_kaddr, sizeof (sbp2_login_resp_t));
607
608 lp->l_logged_in = B_FALSE;
609 mutex_exit(&tp->t_mutex);
610
611 /* send request */
612 if ((ret = sbp2_tgt_mgt_request(tp, berr)) != SBP2_SUCCESS) {
613 sbp2_mgt_agent_release(tp);
614 sbp2_ses_fini(lp->l_ses);
615 lp->l_ses = NULL;
616 return (ret);
617 }
618
619 /* retrieve response data (XXX sanity checks?) */
620 mutex_enter(&tp->t_mutex);
621 (void) SBP2_SYNC_BUF(tp, &tp->t_mgt_login_resp_buf, 0, 0,
622 DDI_DMA_SYNC_FORKERNEL);
623 bcopy(tp->t_mgt_login_resp_buf.bb_kaddr, &lp->l_login_resp,
624 sizeof (sbp2_login_resp_t));
625
626 /* convert from BE to native endianness */
627 SBP2_SWAP16_1(lp->l_login_resp.lr_len);
628 SBP2_SWAP16_1(lp->l_login_resp.lr_login_id);
629 SBP2_SWAP32_2(lp->l_login_resp.lr_cmd_agent);
630 SBP2_SWAP16_1(lp->l_login_resp.lr_reconnect_hold);
631 lp->l_login_resp.lr_reconnect_hold++;
632
633 sp->s_agent_offset = SBP2_ADDR2UINT64(lp->l_login_resp.lr_cmd_agent);
634
635 lp->l_logged_in = B_TRUE;
636 mutex_exit(&tp->t_mutex);
637
638 sbp2_mgt_agent_release(tp);
639
640 if ((ret = sbp2_agent_init(&sp->s_agent, sp->s_agent_offset, tp)) !=
641 SBP2_SUCCESS) {
642 sbp2_ses_fini(sp);
643 lp->l_ses = NULL;
644 return (ret);
645 }
646
647 *spp = lp->l_ses;
648 return (SBP2_SUCCESS);
649 }
650
651 /*ARGSUSED*/
652 int
653 sbp2_lun_logout(sbp2_lun_t *lp, sbp2_ses_t **sp, int *berr, boolean_t phys)
654 {
655 sbp2_tgt_t *tp = lp->l_tgt;
656
657 ASSERT(*sp == lp->l_ses);
658
659 mutex_enter(&tp->t_mutex);
660 if (lp->l_logged_in) {
661 lp->l_logged_in = B_FALSE;
662 /* do physical LOGOUT if requested */
663 if (phys) {
664 mutex_exit(&tp->t_mutex);
665 sbp2_lun_logout_orb(lp, tp, berr);
666 mutex_enter(&tp->t_mutex);
667 }
668 }
669
670 sbp2_agent_fini(&lp->l_ses->s_agent);
671 sbp2_ses_fini(lp->l_ses);
672 lp->l_ses = NULL;
673 *sp = NULL;
674 mutex_exit(&tp->t_mutex);
675
676 return (SBP2_SUCCESS);
677 }
678
679 /*
680 * Issue LOGOUT mgt orb and wait for response. We are not interested in
681 * the success at the time, since the device may be disconnected or hung,
682 * just trying to make the best effort.
683 */
684 static void
685 sbp2_lun_logout_orb(sbp2_lun_t *lp, sbp2_tgt_t *tp, int *berr)
686 {
687 sbp2_logout_orb_t *lorb;
688
689 sbp2_mgt_agent_acquire(tp);
690
691 /* prepare logout ORB */
692 lorb = (sbp2_logout_orb_t *)tp->t_mgt_orb_buf.bb_kaddr;
693 bzero(lorb, sizeof (sbp2_logout_orb_t));
694 lorb->lo_params = SBP2_SWAP16(SBP2_ORB_MGT_FUNC_LOGOUT |
695 SBP2_ORB_NOTIFY | SBP2_ORB_RQ_FMT_SBP2);
696 lorb->lo_login_id = SBP2_SWAP16(lp->l_login_resp.lr_login_id);
697 SBP2_ADDR_SET(lorb->lo_status_fifo, tp->t_mgt_status_fifo_buf.bb_baddr,
698 0);
699
700 /* send request */
701 (void) sbp2_tgt_mgt_request(tp, berr);
702
703 sbp2_mgt_agent_release(tp);
704 }
705
706 static boolean_t
707 sbp2_lun_accepting_tasks(sbp2_lun_t *lp)
708 {
709 sbp2_tgt_t *tp = lp->l_tgt;
710 boolean_t ret;
711
712 mutex_enter(&tp->t_mutex);
713 ret = ((lp->l_ses != NULL) && lp->l_logged_in && !lp->l_reconnecting);
714 mutex_exit(&tp->t_mutex);
715 return (ret);
716 }
717
718 /*
719 *
720 * --- session routines
721 *
722 */
723 static int
724 sbp2_ses_init(sbp2_ses_t **spp, sbp2_lun_t *lp,
725 void (*cb)(void *, sbp2_task_t *), void *cb_arg)
726 {
727 sbp2_tgt_t *tp = lp->l_tgt;
728 sbp2_ses_t *sp;
729 int ret;
730
731 sp = kmem_zalloc(sizeof (sbp2_ses_t), KM_SLEEP);
732
733 sp->s_tgt = tp;
734 sp->s_lun = lp;
735 sp->s_status_cb = cb;
736 sp->s_status_cb_arg = cb_arg;
737
738 mutex_init(&sp->s_mutex, NULL, MUTEX_DRIVER,
739 SBP2_GET_IBLOCK_COOKIE(tp));
740 mutex_init(&sp->s_task_mutex, NULL, MUTEX_DRIVER,
741 SBP2_GET_IBLOCK_COOKIE(tp));
742
743 /*
744 * status FIFO for block requests
745 */
746 sp->s_status_fifo_buf.bb_len = sizeof (sbp2_status_t);
747 sp->s_status_fifo_buf.bb_flags = SBP2_BUS_BUF_WR_POSTED;
748 sp->s_status_fifo_buf.bb_wb_cb = sbp2_status_fifo_wb_cb;
749 sp->s_status_fifo_buf.bb_sbp2_priv = sp;
750 if ((ret = SBP2_ALLOC_BUF(tp, &sp->s_status_fifo_buf)) !=
751 SBP2_SUCCESS) {
752 sbp2_ses_fini(sp);
753 return (ret);
754 }
755
756 *spp = sp;
757 return (SBP2_SUCCESS);
758 }
759
760
761 static void
762 sbp2_ses_fini(sbp2_ses_t *sp)
763 {
764 sbp2_tgt_t *tp = sp->s_lun->l_tgt;
765
766 if (sp->s_status_fifo_buf.bb_hdl != NULL) {
767 SBP2_FREE_BUF(tp, &sp->s_status_fifo_buf);
768 }
769
770 mutex_destroy(&sp->s_task_mutex);
771 mutex_destroy(&sp->s_mutex);
772
773 kmem_free(sp, sizeof (sbp2_ses_t));
774 }
775
776 int
777 sbp2_ses_reconnect(sbp2_ses_t *sp, int *berr, uint16_t nodeID)
778 {
779 sbp2_tgt_t *tp = sp->s_tgt;
780 sbp2_lun_t *lp = sp->s_lun;
781 int ret;
782
783 /* prevent new tasks from being submitted */
784 mutex_enter(&tp->t_mutex);
785 lp->l_reconnecting = B_TRUE;
786 mutex_exit(&tp->t_mutex);
787
788 /*
789 * From 10.5 Task management event matrix:
790 * Immediately upon detection of a bus reset, all command
791 * block fetch agents transition to the reset state and
792 * their associated task sets are cleared without
793 * the return of completion status.
794 *
795 * Reset pending tasks so we can retry them later.
796 */
797 sbp2_ses_reset_pending_tasks(sp, nodeID);
798
799 ret = sbp2_ses_reconnect_orb(sp, berr);
800
801 mutex_enter(&tp->t_mutex);
802 lp->l_reconnecting = B_FALSE;
803 mutex_exit(&tp->t_mutex);
804
805 return (ret);
806 }
807
808 /*
809 * Send reconnect ORB. If operation fails, set lp->l_logged_in = B_FALSE.
810 */
811 static int
812 sbp2_ses_reconnect_orb(sbp2_ses_t *sp, int *berr)
813 {
814 sbp2_tgt_t *tp = sp->s_tgt;
815 sbp2_lun_t *lp = sp->s_lun;
816 sbp2_agent_t *ap = &sp->s_agent;
817 sbp2_reconnect_orb_t *rorb;
818 int ret;
819
820 sbp2_mgt_agent_acquire(tp);
821
822 /* prepare login ORB */
823 rorb = (sbp2_reconnect_orb_t *)tp->t_mgt_orb_buf.bb_kaddr;
824 bzero(rorb, sizeof (sbp2_reconnect_orb_t));
825 rorb->ro_params = SBP2_SWAP16(SBP2_ORB_MGT_FUNC_RECONNECT |
826 SBP2_ORB_NOTIFY | SBP2_ORB_RQ_FMT_SBP2);
827 rorb->ro_login_id = SBP2_SWAP16(lp->l_login_resp.lr_login_id);
828 SBP2_ADDR_SET(rorb->ro_status_fifo, tp->t_mgt_status_fifo_buf.bb_baddr,
829 0);
830
831 /* send request */
832 if ((ret = sbp2_tgt_mgt_request(tp, berr)) != SBP2_SUCCESS) {
833 mutex_enter(&tp->t_mutex);
834 lp->l_logged_in = B_FALSE;
835 mutex_exit(&tp->t_mutex);
836 } else {
837 /* after successful reset fetch agent is in RESET state */
838 mutex_enter(&ap->a_mutex);
839 ap->a_state = SBP2_AGENT_STATE_RESET;
840 mutex_exit(&ap->a_mutex);
841 }
842
843 sbp2_mgt_agent_release(tp);
844
845 return (ret);
846 }
847
848
849 static sbp2_task_t *
850 sbp2_ses_orbp2task(sbp2_ses_t *sp, uint64_t orbp)
851 {
852 sbp2_task_t *task;
853
854 mutex_enter(&sp->s_task_mutex);
855 for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
856 if (task->ts_buf->bb_baddr == orbp) {
857 break;
858 }
859 }
860 mutex_exit(&sp->s_task_mutex);
861 return (task);
862 }
863
864 /*
865 * This is where tasks (command ORB's) are signalled to the target.
866 * 'task' argument is allowed to be NULL, in which case the task will be
867 * taken from the current task list.
868 *
869 * Tasks are signalled one at a time by writing into ORB_POINTER register.
870 * While SBP-2 allows dynamic task list updates and using DOORBELL register,
871 * some devices have bugs that prevent using this strategy: e.g. some LaCie
872 * HDD's can corrupt data. Data integrity is more important than performance.
873 */
874 int
875 sbp2_ses_submit_task(sbp2_ses_t *sp, sbp2_task_t *new_task)
876 {
877 sbp2_agent_t *ap = &sp->s_agent;
878 sbp2_tgt_t *tp = sp->s_tgt;
879 sbp2_task_t *task; /* task actually being submitted */
880 boolean_t callback;
881 timeout_id_t timeout_id;
882 int ret;
883
884 if (!sbp2_lun_accepting_tasks(sp->s_lun)) {
885 return (SBP2_ENODEV);
886 }
887
888 sbp2_agent_acquire(ap); /* serialize */
889
890 mutex_enter(&ap->a_mutex);
891
892 /* if task provided, append it to the list */
893 if (new_task != NULL) {
894 ASSERT(new_task->ts_state == SBP2_TASK_INIT);
895 sbp2_ses_append_task(sp, new_task);
896 }
897
898 /* if there is already a task in flight, exit */
899 if ((ap->a_active_task != NULL) &&
900 (ap->a_active_task->ts_state == SBP2_TASK_PEND)) {
901 mutex_exit(&ap->a_mutex);
902 sbp2_agent_release(ap);
903 return (SBP2_SUCCESS);
904 }
905
906 /*
907 * cannot submit tasks from interrupt context,
908 * upper layer driver is responsible to call nudge
909 */
910 if (servicing_interrupt()) {
911 mutex_exit(&ap->a_mutex);
912 sbp2_agent_release(ap);
913 return (SBP2_ECONTEXT);
914 }
915
916 /* no active task, grab the first one on the list in INIT state */
917 ap->a_active_task = sbp2_ses_find_task_state(sp, SBP2_TASK_INIT);
918 if (ap->a_active_task == NULL) {
919 mutex_exit(&ap->a_mutex);
920 sbp2_agent_release(ap);
921 return (SBP2_SUCCESS);
922 }
923 task = ap->a_active_task;
924 task->ts_ses = sp;
925 task->ts_state = SBP2_TASK_PEND;
926
927 /* can't work with a dead agent */
928 if (sbp2_agent_keepalive(ap, &task->ts_bus_error) != SBP2_SUCCESS) {
929 task->ts_error = SBP2_TASK_ERR_DEAD;
930 goto error;
931 }
932
933 /*
934 * In theory, we should schedule task timeout after it's been submitted.
935 * However, some fast tasks complete even before timeout is scheduled.
936 * To avoid additional complications in the code, schedule timeout now.
937 */
938 ASSERT(task->ts_timeout_id == 0);
939 task->ts_time_start = gethrtime();
940 if (task->ts_timeout > 0) {
941 task->ts_timeout_id = timeout(sbp2_task_timeout, task,
942 task->ts_timeout * drv_usectohz(1000000));
943 }
944
945 /* notify fetch agent */
946 ap->a_state = SBP2_AGENT_STATE_ACTIVE;
947 mutex_exit(&ap->a_mutex);
948 ret = sbp2_agent_write_orbp(ap, task->ts_buf->bb_baddr,
949 &task->ts_bus_error);
950 tp->t_stat.stat_submit_orbp++;
951 mutex_enter(&ap->a_mutex);
952
953 if (ret != SBP2_SUCCESS) {
954 ap->a_state = SBP2_AGENT_STATE_DEAD;
955 tp->t_stat.stat_status_dead++;
956
957 if (task->ts_timeout_id != 0) {
958 timeout_id = task->ts_timeout_id;
959 task->ts_timeout_id = 0;
960 (void) untimeout(timeout_id);
961 }
962 task->ts_error = SBP2_TASK_ERR_BUS;
963 goto error;
964 }
965
966 mutex_exit(&ap->a_mutex);
967
968 sbp2_agent_release(ap);
969 return (SBP2_SUCCESS);
970
971 error:
972 /*
973 * Return immediate error if failed task is the one being submitted,
974 * otherwise use callback.
975 */
976 callback = (ap->a_active_task != new_task);
977 ASSERT(task == ap->a_active_task);
978 ap->a_active_task = NULL;
979 mutex_exit(&ap->a_mutex);
980 sbp2_agent_release(ap);
981
982 /*
983 * Remove task from the list. It is important not to change task state
984 * to SBP2_TASK_COMP while it's still on the list, to avoid race with
985 * upper layer driver (e.g. scsa1394).
986 */
987 ret = sbp2_ses_remove_task(sp, task);
988 ASSERT(ret == SBP2_SUCCESS);
989 task->ts_state = SBP2_TASK_COMP;
990
991 if (callback) {
992 sp->s_status_cb(sp->s_status_cb_arg, task);
993 return (SBP2_SUCCESS);
994 } else {
995 /* upper layer driver is responsible to call nudge */
996 return (SBP2_FAILURE);
997 }
998 }
999
1000 void
1001 sbp2_ses_nudge(sbp2_ses_t *sp)
1002 {
1003 (void) sbp2_ses_submit_task(sp, NULL);
1004 }
1005
1006 /*
1007 * append task to the task list
1008 */
1009 static void
1010 sbp2_ses_append_task(sbp2_ses_t *sp, sbp2_task_t *task)
1011 {
1012 sbp2_tgt_t *tp = sp->s_tgt;
1013
1014 mutex_enter(&sp->s_task_mutex);
1015 if (sp->s_task_head == NULL) {
1016 ASSERT(sp->s_task_tail == NULL);
1017 ASSERT(sp->s_task_cnt == 0);
1018 task->ts_prev = task->ts_next = NULL;
1019 sp->s_task_head = sp->s_task_tail = task;
1020 } else {
1021 ASSERT(sp->s_task_cnt > 0);
1022 task->ts_next = NULL;
1023 task->ts_prev = sp->s_task_tail;
1024 sp->s_task_tail->ts_next = task;
1025 sp->s_task_tail = task;
1026 }
1027 ASSERT(task != task->ts_prev);
1028 ASSERT(task != task->ts_next);
1029
1030 sp->s_task_cnt++;
1031 if (sp->s_task_cnt > tp->t_stat.stat_task_max) {
1032 tp->t_stat.stat_task_max = sp->s_task_cnt;
1033 }
1034 mutex_exit(&sp->s_task_mutex);
1035 }
1036
1037 /*
1038 * remove task from the task list
1039 */
1040 static int
1041 sbp2_ses_remove_task_locked(sbp2_ses_t *sp, sbp2_task_t *task)
1042 {
1043 sp->s_task_cnt--;
1044 if (task == sp->s_task_head) { /* first */
1045 ASSERT(task->ts_prev == NULL);
1046 if (task->ts_next == NULL) { /* and last */
1047 ASSERT(sp->s_task_cnt == 0);
1048 sp->s_task_head = sp->s_task_tail = NULL;
1049 } else { /* but not last */
1050 sp->s_task_head = task->ts_next;
1051 sp->s_task_head->ts_prev = NULL;
1052 }
1053 } else if (task == sp->s_task_tail) { /* last but not first */
1054 ASSERT(task->ts_next == NULL);
1055 sp->s_task_tail = task->ts_prev;
1056 sp->s_task_tail->ts_next = NULL;
1057 } else { /* in the middle */
1058 task->ts_prev->ts_next = task->ts_next;
1059 task->ts_next->ts_prev = task->ts_prev;
1060 }
1061 task->ts_prev = task->ts_next = NULL;
1062 ASSERT(sp->s_task_cnt >= 0);
1063
1064 return (SBP2_SUCCESS);
1065 }
1066
1067 int
1068 sbp2_ses_remove_task(sbp2_ses_t *sp, sbp2_task_t *task)
1069 {
1070 int ret;
1071
1072 mutex_enter(&sp->s_task_mutex);
1073 ret = sbp2_ses_remove_task_locked(sp, task);
1074 mutex_exit(&sp->s_task_mutex);
1075
1076 return (ret);
1077 }
1078
1079 /*
1080 * Return first task on the list in specified state.
1081 */
1082 sbp2_task_t *
1083 sbp2_ses_find_task_state(sbp2_ses_t *sp, sbp2_task_state_t state)
1084 {
1085 sbp2_task_t *task = NULL;
1086
1087 mutex_enter(&sp->s_task_mutex);
1088 for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
1089 if (task->ts_state == state) {
1090 break;
1091 }
1092 }
1093 mutex_exit(&sp->s_task_mutex);
1094
1095 return (task);
1096 }
1097
1098 /*
1099 * Remove first task on the list. Returns pointer to the removed task or NULL.
1100 */
1101 sbp2_task_t *
1102 sbp2_ses_remove_first_task(sbp2_ses_t *sp)
1103 {
1104 sbp2_task_t *task = NULL;
1105
1106 mutex_enter(&sp->s_task_mutex);
1107 task = sp->s_task_head;
1108 if (task != NULL) {
1109 (void) sbp2_ses_remove_task_locked(sp, task);
1110 }
1111 mutex_exit(&sp->s_task_mutex);
1112
1113 return (task);
1114 }
1115
1116 /*
1117 * Remove first task on the list only if it's in specified state.
1118 * Returns pointer to the removed task or NULL.
1119 */
1120 sbp2_task_t *
1121 sbp2_ses_remove_first_task_state(sbp2_ses_t *sp, sbp2_task_state_t state)
1122 {
1123 sbp2_task_t *task = NULL;
1124
1125 mutex_enter(&sp->s_task_mutex);
1126 if ((sp->s_task_head != NULL) && (sp->s_task_head->ts_state == state)) {
1127 task = sp->s_task_head;
1128 (void) sbp2_ses_remove_task_locked(sp, task);
1129 }
1130 mutex_exit(&sp->s_task_mutex);
1131
1132 return (task);
1133 }
1134
1135 /*
1136 * Remove first task on the list. If there's timeout, untimeout it.
1137 * Returns pointer to the removed task or NULL.
1138 */
1139 sbp2_task_t *
1140 sbp2_ses_cancel_first_task(sbp2_ses_t *sp)
1141 {
1142 sbp2_task_t *task = NULL;
1143 timeout_id_t timeout_id;
1144
1145 mutex_enter(&sp->s_task_mutex);
1146 task = sp->s_task_head;
1147 if (task != NULL) {
1148 (void) sbp2_ses_remove_task_locked(sp, task);
1149 }
1150 mutex_exit(&sp->s_task_mutex);
1151
1152 if ((task != NULL) && ((timeout_id = task->ts_timeout_id) != 0)) {
1153 task->ts_timeout_id = 0;
1154 (void) untimeout(timeout_id);
1155 }
1156
1157 return (task);
1158 }
1159
1160 /*
1161 * Reset pending tasks on the list to their initial state.
1162 */
1163 static void
1164 sbp2_ses_reset_pending_tasks(sbp2_ses_t *sp, uint16_t nodeID)
1165 {
1166 sbp2_agent_t *ap = &sp->s_agent;
1167 sbp2_task_t *task = NULL;
1168 timeout_id_t timeout_id;
1169 sbp2_cmd_orb_t *orb;
1170
1171 mutex_enter(&sp->s_task_mutex);
1172 for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
1173 task->ts_state = SBP2_TASK_INIT;
1174
1175 /* cancel timeout */
1176 if ((timeout_id = task->ts_timeout_id) != 0) {
1177 task->ts_timeout_id = 0;
1178 (void) untimeout(timeout_id);
1179 }
1180
1181 /* update ORB nodeID */
1182 orb = (sbp2_cmd_orb_t *)sbp2_task_orb_kaddr(task);
1183 *(uint16_t *)orb->co_data_descr = SBP2_SWAP16(nodeID);
1184 sbp2_task_orb_sync(sp->s_lun, task, DDI_DMA_SYNC_FORDEV);
1185 }
1186 mutex_exit(&sp->s_task_mutex);
1187
1188 mutex_enter(&ap->a_mutex);
1189 ap->a_active_task = NULL;
1190 mutex_exit(&ap->a_mutex);
1191 }
1192
1193 int
1194 sbp2_ses_agent_reset(sbp2_ses_t *sp, int *berr)
1195 {
1196 return (sbp2_agent_reset(&sp->s_agent, berr));
1197 }
1198
1199 int
1200 sbp2_ses_abort_task(sbp2_ses_t *sp, sbp2_task_t *task, int *berr)
1201 {
1202 sbp2_tgt_t *tp = sp->s_tgt;
1203 sbp2_lun_t *lp = sp->s_lun;
1204 uint16_t params;
1205 sbp2_cmd_orb_t *orb = (sbp2_cmd_orb_t *)task->ts_buf->bb_kaddr;
1206 int ret = SBP2_SUCCESS;
1207
1208 /* mark ORB as dummy ORB */
1209 params = (orb->co_params & ~SBP2_ORB_RQ_FMT) | SBP2_ORB_RQ_FMT_DUMMY;
1210 orb->co_params = params;
1211 (void) SBP2_SYNC_BUF(tp, task->ts_buf, 0, 0, DDI_DMA_SYNC_FORDEV);
1212
1213 ret = sbp2_tgt_task_mgt_request(tp, lp->l_login_resp.lr_login_id,
1214 SBP2_ORB_MGT_FUNC_ABORT_TASK, task->ts_buf->bb_baddr, berr);
1215
1216 return (ret);
1217 }
1218
1219
1220 int
1221 sbp2_ses_abort_task_set(sbp2_ses_t *sp, int *berr)
1222 {
1223 sbp2_tgt_t *tp = sp->s_tgt;
1224 sbp2_lun_t *lp = sp->s_lun;
1225 int ret;
1226
1227 ret = sbp2_tgt_task_mgt_request(tp, lp->l_login_resp.lr_login_id,
1228 SBP2_ORB_MGT_FUNC_ABORT_TASK_SET, 0, berr);
1229
1230 return (ret);
1231 }
1232
1233
1234 /*
1235 *
1236 * ORB functions
1237 *
1238 * allocate ORB resources
1239 *
1240 * we maintain a freelist of ORB's for faster allocation
1241 */
1242 /*ARGSUSED*/
1243 static sbp2_bus_buf_t *
1244 sbp2_orb_freelist_get(sbp2_lun_t *lp, sbp2_task_t *task, int len)
1245 {
1246 sbp2_buf_list_t *bl = &lp->l_orb_freelist;
1247 sbp2_bus_buf_t *buf = NULL;
1248
1249 mutex_enter(&bl->bl_mutex);
1250 if ((bl->bl_head != NULL) && (bl->bl_head->bb_len == len)) {
1251 buf = bl->bl_head;
1252 bl->bl_head = buf->bb_next;
1253 if (bl->bl_tail == buf) { /* last one? */
1254 ASSERT(bl->bl_head == NULL);
1255 bl->bl_tail = NULL;
1256 }
1257 bl->bl_len--;
1258 buf->bb_next = NULL;
1259 }
1260 mutex_exit(&bl->bl_mutex);
1261
1262 return (buf);
1263 }
1264
1265 static int
1266 sbp2_orb_freelist_put(sbp2_lun_t *lp, sbp2_bus_buf_t *buf)
1267 {
1268 sbp2_buf_list_t *bl = &lp->l_orb_freelist;
1269 int ret;
1270
1271 mutex_enter(&bl->bl_mutex);
1272 if (bl->bl_len < SBP2_ORB_FREELIST_MAX) {
1273 if (bl->bl_head == NULL) {
1274 ASSERT(bl->bl_tail == NULL);
1275 bl->bl_head = bl->bl_tail = buf;
1276 } else {
1277 bl->bl_tail->bb_next = buf;
1278 bl->bl_tail = buf;
1279 }
1280 buf->bb_next = NULL;
1281 bl->bl_len++;
1282 ret = SBP2_SUCCESS;
1283 } else {
1284 ret = SBP2_FAILURE;
1285 }
1286 mutex_exit(&bl->bl_mutex);
1287
1288 return (ret);
1289 }
1290
1291 static void
1292 sbp2_orb_freelist_destroy(sbp2_lun_t *lp)
1293 {
1294 sbp2_tgt_t *tp = lp->l_tgt;
1295 sbp2_buf_list_t *bl = &lp->l_orb_freelist;
1296 sbp2_bus_buf_t *buf, *buf_next;
1297
1298 mutex_enter(&bl->bl_mutex);
1299 for (buf = bl->bl_head; buf != NULL; ) {
1300 SBP2_FREE_BUF(tp, buf);
1301 buf_next = buf->bb_next;
1302 kmem_free(buf, sizeof (sbp2_bus_buf_t));
1303 buf = buf_next;
1304 }
1305 bl->bl_head = bl->bl_tail = NULL;
1306 mutex_exit(&bl->bl_mutex);
1307 }
1308
1309 int
1310 sbp2_task_orb_alloc(sbp2_lun_t *lp, sbp2_task_t *task, int len)
1311 {
1312 sbp2_tgt_t *tp = lp->l_tgt;
1313 int buf_len;
1314 int ret;
1315
1316 buf_len = SBP2_ORB_SIZE_ROUNDUP(tp, len);
1317
1318 /* try freelist first */
1319 if ((task->ts_buf = sbp2_orb_freelist_get(lp, task, buf_len)) != NULL) {
1320 return (SBP2_SUCCESS);
1321 }
1322
1323 /* if no free buffers, allocate new */
1324 task->ts_buf = kmem_zalloc(sizeof (sbp2_bus_buf_t), KM_SLEEP);
1325 task->ts_buf->bb_len = buf_len;
1326 task->ts_buf->bb_flags = SBP2_BUS_BUF_DMA | SBP2_BUS_BUF_RD;
1327 if ((ret = SBP2_ALLOC_BUF(tp, task->ts_buf)) != SBP2_SUCCESS) {
1328 kmem_free(task->ts_buf, sizeof (sbp2_bus_buf_t));
1329 task->ts_buf = NULL;
1330 }
1331
1332 return (ret);
1333 }
1334
1335 void
1336 sbp2_task_orb_free(sbp2_lun_t *lp, sbp2_task_t *task)
1337 {
1338 sbp2_tgt_t *tp = lp->l_tgt;
1339
1340 if (task->ts_buf != NULL) {
1341 if (sbp2_orb_freelist_put(lp, task->ts_buf) != SBP2_SUCCESS) {
1342 SBP2_FREE_BUF(tp, task->ts_buf);
1343 kmem_free(task->ts_buf, sizeof (sbp2_bus_buf_t));
1344 }
1345 task->ts_buf = NULL;
1346 }
1347 }
1348
1349 void *
1350 sbp2_task_orb_kaddr(sbp2_task_t *task)
1351 {
1352 return (task->ts_buf->bb_kaddr);
1353 }
1354
1355 void
1356 sbp2_task_orb_sync(sbp2_lun_t *lp, sbp2_task_t *task, int flags)
1357 {
1358 (void) SBP2_SYNC_BUF(lp->l_tgt, task->ts_buf, 0, 0, flags);
1359 }
1360
1361 /*
1362 *
1363 * --- fetch agent routines
1364 *
1365 */
1366 static int
1367 sbp2_agent_init(sbp2_agent_t *ap, uint64_t offset, sbp2_tgt_t *tp)
1368 {
1369 int ret;
1370
1371 /* paranoia */
1372 if (offset == 0) {
1373 return (SBP2_FAILURE);
1374 }
1375
1376 ap->a_tgt = tp;
1377
1378 ap->a_reg_agent_state = offset + SBP2_AGENT_STATE_OFFSET;
1379 ap->a_reg_agent_reset = offset + SBP2_AGENT_RESET_OFFSET;
1380 ap->a_reg_orbp = offset + SBP2_ORB_POINTER_OFFSET;
1381 ap->a_reg_doorbell = offset + SBP2_DOORBELL_OFFSET;
1382 ap->a_reg_unsol_status_enable = offset +
1383 SBP2_UNSOLICITED_STATUS_ENABLE_OFFSET;
1384
1385 /*
1386 * allocate bus commands
1387 */
1388 if ((ret = SBP2_ALLOC_CMD(tp, &ap->a_cmd, 0)) != SBP2_SUCCESS) {
1389 return (ret);
1390 }
1391 ap->a_cmd_data = allocb(sizeof (sbp2_orbp_t), BPRI_HI);
1392 if (ap->a_cmd_data == NULL) {
1393 sbp2_agent_fini(ap);
1394 return (SBP2_ENOMEM);
1395 }
1396
1397 mutex_init(&ap->a_mutex, NULL, MUTEX_DRIVER,
1398 SBP2_GET_IBLOCK_COOKIE(tp));
1399 cv_init(&ap->a_cv, NULL, CV_DRIVER, NULL);
1400
1401 #ifndef __lock_lint
1402 ap->a_state = SBP2_AGENT_STATE_RESET;
1403 #endif
1404
1405 return (SBP2_SUCCESS);
1406 }
1407
1408
1409 static void
1410 sbp2_agent_fini(sbp2_agent_t *ap)
1411 {
1412 sbp2_tgt_t *tp = ap->a_tgt;
1413
1414 /* free bus commands */
1415 if (ap->a_cmd != NULL) {
1416 SBP2_FREE_CMD(tp, ap->a_cmd);
1417 }
1418 if (ap->a_cmd_data != NULL) {
1419 freeb(ap->a_cmd_data);
1420 }
1421 cv_destroy(&ap->a_cv);
1422 mutex_destroy(&ap->a_mutex);
1423 }
1424
1425
1426 static void
1427 sbp2_agent_acquire_locked(sbp2_agent_t *ap)
1428 {
1429 while (ap->a_acquired) {
1430 cv_wait(&ap->a_cv, &ap->a_mutex);
1431 }
1432 ap->a_acquired = B_TRUE;
1433 }
1434
1435
1436 static void
1437 sbp2_agent_release_locked(sbp2_agent_t *ap)
1438 {
1439 ap->a_acquired = B_FALSE;
1440 cv_signal(&ap->a_cv); /* wake next waiter */
1441 }
1442
1443
1444 static void
1445 sbp2_agent_acquire(sbp2_agent_t *ap)
1446 {
1447 mutex_enter(&ap->a_mutex);
1448 sbp2_agent_acquire_locked(ap);
1449 mutex_exit(&ap->a_mutex);
1450 }
1451
1452
1453 static void
1454 sbp2_agent_release(sbp2_agent_t *ap)
1455 {
1456 mutex_enter(&ap->a_mutex);
1457 sbp2_agent_release_locked(ap);
1458 mutex_exit(&ap->a_mutex);
1459 }
1460
1461
1462 static int
1463 sbp2_agent_keepalive(sbp2_agent_t *ap, int *berr)
1464 {
1465 boolean_t acquired;
1466 int ret = SBP2_SUCCESS;
1467
1468 ASSERT(mutex_owned(&ap->a_mutex));
1469
1470 if (ap->a_state == SBP2_AGENT_STATE_DEAD) {
1471 acquired = ap->a_acquired;
1472 if (!acquired) {
1473 sbp2_agent_acquire_locked(ap);
1474 }
1475
1476 mutex_exit(&ap->a_mutex);
1477 ret = sbp2_agent_reset(ap, berr);
1478 mutex_enter(&ap->a_mutex);
1479
1480 if (!acquired) {
1481 sbp2_agent_release_locked(ap);
1482 }
1483 }
1484
1485 return (ret);
1486 }
1487
1488 #ifndef __lock_lint
1489 static int
1490 sbp2_agent_doorbell(sbp2_agent_t *ap, int *berr)
1491 {
1492 return (SBP2_WQ(ap->a_tgt, ap->a_cmd, ap->a_reg_doorbell, 0, berr));
1493 }
1494 #endif
1495
1496 /*
1497 * write into ORB_POINTER register and make sure it reached target
1498 *
1499 * From E.2: "If no acknowledgement is received by the initiator after a write
1500 * to the ORB_POINTER register, the initiator should not retry the write.
1501 * The recommended method for error recovery is a write to the AGENT_RESET
1502 * register." So we can retry, but not in case of timeout.
1503 */
1504 static int
1505 sbp2_agent_write_orbp(sbp2_agent_t *ap, uint64_t baddr, int *berr)
1506 {
1507 int i = 0;
1508 int ret;
1509
1510 SBP2_ORBP_SET(ap->a_cmd_data->b_rptr, baddr);
1511 ap->a_cmd_data->b_wptr = ap->a_cmd_data->b_rptr + 8;
1512
1513 for (;;) {
1514 ap->a_tgt->t_stat.stat_agent_worbp++;
1515 if ((ret = SBP2_WB(ap->a_tgt, ap->a_cmd, ap->a_reg_orbp,
1516 ap->a_cmd_data, 8, berr)) == SBP2_SUCCESS) {
1517 return (ret);
1518 }
1519 ap->a_tgt->t_stat.stat_agent_worbp_fail++;
1520
1521 if ((ret == SBP2_ETIMEOUT) ||
1522 (++i > sbp2_write_orbp_nretries)) {
1523 break;
1524 }
1525 if (sbp2_write_orbp_delay > 0) {
1526 drv_usecwait(sbp2_write_orbp_delay);
1527 }
1528 }
1529
1530 return (ret);
1531 }
1532
1533
1534 /*
1535 * reset fetch agent by writing into AGENT_RESET register
1536 */
1537 static int
1538 sbp2_agent_reset(sbp2_agent_t *ap, int *berr)
1539 {
1540 int i = 0;
1541 int ret;
1542
1543 for (;;) {
1544 ap->a_tgt->t_stat.stat_agent_wreset++;
1545 if ((ret = SBP2_WQ(ap->a_tgt, ap->a_cmd, ap->a_reg_agent_reset,
1546 0, berr)) == SBP2_SUCCESS) {
1547 mutex_enter(&ap->a_mutex);
1548 ap->a_state = SBP2_AGENT_STATE_RESET;
1549 mutex_exit(&ap->a_mutex);
1550 break;
1551 }
1552
1553 ap->a_tgt->t_stat.stat_agent_wreset_fail++;
1554 if (++i > sbp2_submit_reset_nretries) {
1555 break;
1556 }
1557 if (sbp2_submit_reset_delay > 0) {
1558 drv_usecwait(sbp2_submit_reset_delay);
1559 }
1560 }
1561 return (ret);
1562 }
1563
1564 /*
1565 *
1566 * --- callbacks and timeouts
1567 *
1568 */
1569 /*
1570 * Status FIFO callback for mgt ORB's.
1571 */
1572 /*ARGSUSED*/
1573 static void
1574 sbp2_mgt_status_fifo_wb_cb(sbp2_bus_buf_t *buf, void *reqh, mblk_t **bpp)
1575 {
1576 sbp2_tgt_t *tp = buf->bb_sbp2_priv;
1577 int len;
1578 sbp2_status_t *st;
1579 uint64_t orbp;
1580
1581 len = MBLKL(*bpp);
1582
1583 /* 8 bytes minimum */
1584 if (len < 8) {
1585 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_ELENGTH);
1586 tp->t_stat.stat_status_short++;
1587 return;
1588 }
1589
1590 /* convert 2-quadlet header from BE to native endianness */
1591 st = (sbp2_status_t *)(*bpp)->b_rptr;
1592 SBP2_SWAP16_1(st->st_orb_offset_hi);
1593 SBP2_SWAP32_1(st->st_orb_offset_lo);
1594 orbp = ((uint64_t)st->st_orb_offset_hi << 32) | st->st_orb_offset_lo;
1595
1596 if (orbp != tp->t_mgt_orb_buf.bb_baddr) {
1597 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_FAILURE);
1598 tp->t_stat.stat_status_mgt_notask++;
1599 return;
1600 }
1601
1602 /* make a local copy of status block */
1603 bzero(&tp->t_mgt_status, sizeof (sbp2_status_t));
1604 bcopy((*bpp)->b_rptr, &tp->t_mgt_status, len);
1605
1606 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_SUCCESS);
1607
1608 /* wake up waiter */
1609 mutex_enter(&tp->t_mutex);
1610 tp->t_mgt_status_rcvd = B_TRUE;
1611 cv_signal(&tp->t_mgt_status_cv);
1612 mutex_exit(&tp->t_mutex);
1613 }
1614
1615 static void
1616 sbp2_task_timeout(void *arg)
1617 {
1618 sbp2_task_t *task = arg;
1619 sbp2_ses_t *sp = task->ts_ses;
1620 sbp2_agent_t *ap = &sp->s_agent;
1621
1622 mutex_enter(&ap->a_mutex);
1623
1624 /* cancelled? */
1625 if (task->ts_timeout_id == 0) {
1626 mutex_exit(&ap->a_mutex);
1627 return;
1628 }
1629 task->ts_timeout_id = 0;
1630 task->ts_time_comp = gethrtime();
1631
1632 /* avoid race with other callbacks */
1633 if (task->ts_state != SBP2_TASK_PEND) {
1634 mutex_exit(&ap->a_mutex);
1635 return;
1636 }
1637
1638 if (task == ap->a_active_task) {
1639 ap->a_active_task = NULL;
1640 }
1641 task->ts_error = SBP2_TASK_ERR_TIMEOUT;
1642 task->ts_state = SBP2_TASK_COMP;
1643
1644 /* we mark agent DEAD so it's reset before next task is submitted */
1645 ap->a_state = SBP2_AGENT_STATE_DEAD;
1646 sp->s_tgt->t_stat.stat_status_dead++;
1647 mutex_exit(&ap->a_mutex);
1648
1649 sp->s_status_cb(sp->s_status_cb_arg, task);
1650 }
1651
1652 /*
1653 * Status FIFO callback for command ORB's. Also used for login ORB.
1654 */
1655 /*ARGSUSED*/
1656 static void
1657 sbp2_status_fifo_wb_cb(sbp2_bus_buf_t *buf, void *reqh, mblk_t **bpp)
1658 {
1659 sbp2_ses_t *sp = buf->bb_sbp2_priv;
1660 sbp2_tgt_t *tp = sp->s_tgt;
1661 sbp2_agent_t *ap = &sp->s_agent;
1662 int len;
1663 sbp2_status_t *st;
1664 uint8_t src;
1665 uint64_t orbp;
1666 sbp2_task_t *task;
1667 timeout_id_t timeout_id;
1668
1669 len = MBLKL(*bpp);
1670
1671 /* 8 bytes minimum */
1672 if (len < 8) {
1673 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_ELENGTH);
1674 tp->t_stat.stat_status_short++;
1675 return;
1676 }
1677
1678 /* convert 2-quadlet header from BE32 to native endianness */
1679 st = (sbp2_status_t *)(*bpp)->b_rptr;
1680 SBP2_SWAP16_1(st->st_orb_offset_hi);
1681 SBP2_SWAP32_1(st->st_orb_offset_lo);
1682
1683 orbp = ((uint64_t)st->st_orb_offset_hi << 32) | st->st_orb_offset_lo;
1684
1685 /* login ORB status? */
1686 if (orbp == tp->t_mgt_orb_buf.bb_baddr) {
1687 bzero(&tp->t_mgt_status, sizeof (sbp2_status_t));
1688 bcopy((*bpp)->b_rptr, &tp->t_mgt_status, len);
1689
1690 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_SUCCESS);
1691
1692 /* wake up waiter */
1693 mutex_enter(&tp->t_mutex);
1694 tp->t_mgt_status_rcvd = B_TRUE;
1695 cv_signal(&tp->t_mgt_status_cv);
1696 mutex_exit(&tp->t_mutex);
1697 return;
1698 }
1699
1700 /* dismiss unsolicited status */
1701 src = st->st_param & SBP2_ST_SRC;
1702 if (src == SBP2_ST_SRC_UNSOLICITED) {
1703 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_FAILURE);
1704 tp->t_stat.stat_status_unsolicited++;
1705 return;
1706 }
1707
1708 /* find task corresponding to this ORB pointer */
1709 if ((task = sbp2_ses_orbp2task(sp, orbp)) == NULL) {
1710 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_FAILURE);
1711 tp->t_stat.stat_status_notask++;
1712 return;
1713 }
1714
1715 /*
1716 * Copy status block into a local buffer.
1717 *
1718 * Note: (ref: B.2) "SBP-2 permits the return of a status block between
1719 * two and eight quadlets in length. When a truncated status block
1720 * is stored, the omited quadlets shall be interpreted as if zero
1721 * values were stored."
1722 */
1723 bzero(&task->ts_status, sizeof (sbp2_status_t));
1724 bcopy((*bpp)->b_rptr, &task->ts_status, len);
1725
1726 SBP2_BUF_WR_DONE(tp, buf, reqh, SBP2_BUS_BUF_SUCCESS);
1727
1728 mutex_enter(&ap->a_mutex);
1729
1730 if ((timeout_id = task->ts_timeout_id) != 0) {
1731 task->ts_timeout_id = 0;
1732 (void) untimeout(timeout_id);
1733 }
1734
1735 /* determine agent state */
1736 if (st->st_param & SBP2_ST_DEAD) {
1737 ap->a_state = SBP2_AGENT_STATE_DEAD;
1738 tp->t_stat.stat_status_dead++;
1739 }
1740
1741 /* avoid race with other callbacks */
1742 if (task->ts_state != SBP2_TASK_PEND) {
1743 mutex_exit(&ap->a_mutex);
1744 return;
1745 }
1746
1747 if (task == ap->a_active_task) {
1748 ap->a_active_task = NULL;
1749 }
1750 task->ts_error = SBP2_TASK_ERR_NONE;
1751 task->ts_state = SBP2_TASK_COMP;
1752
1753 mutex_exit(&ap->a_mutex);
1754
1755 sp->s_status_cb(sp->s_status_cb_arg, task); /* notify the driver */
1756 }
1757
1758 /*
1759 *
1760 * --- other
1761 *
1762 * since mgt agent is shared between LUNs and login sessions,
1763 * it is safer to serialize mgt requests
1764 */
1765 static void
1766 sbp2_mgt_agent_acquire(sbp2_tgt_t *tp)
1767 {
1768 mutex_enter(&tp->t_mutex);
1769 while (tp->t_mgt_agent_acquired) {
1770 cv_wait(&tp->t_mgt_agent_cv, &tp->t_mutex);
1771 }
1772 tp->t_mgt_agent_acquired = B_TRUE;
1773 mutex_exit(&tp->t_mutex);
1774 }
1775
1776 static void
1777 sbp2_mgt_agent_release(sbp2_tgt_t *tp)
1778 {
1779 mutex_enter(&tp->t_mutex);
1780 tp->t_mgt_agent_acquired = B_FALSE;
1781 cv_signal(&tp->t_mgt_agent_cv); /* wake next waiter */
1782 mutex_exit(&tp->t_mutex);
1783 }