Home | History | Annotate | Line # | Download | only in ieee1394
sbp.c revision 1.20.8.1
      1  1.20.8.1       mjf /*	$NetBSD: sbp.c,v 1.20.8.1 2008/04/03 12:42:43 mjf Exp $	*/
      2       1.1  kiyohara /*-
      3       1.1  kiyohara  * Copyright (c) 2003 Hidetoshi Shimokawa
      4       1.1  kiyohara  * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa
      5       1.1  kiyohara  * All rights reserved.
      6       1.1  kiyohara  *
      7       1.1  kiyohara  * Redistribution and use in source and binary forms, with or without
      8       1.1  kiyohara  * modification, are permitted provided that the following conditions
      9       1.1  kiyohara  * are met:
     10       1.1  kiyohara  * 1. Redistributions of source code must retain the above copyright
     11       1.1  kiyohara  *    notice, this list of conditions and the following disclaimer.
     12       1.1  kiyohara  * 2. Redistributions in binary form must reproduce the above copyright
     13       1.1  kiyohara  *    notice, this list of conditions and the following disclaimer in the
     14       1.1  kiyohara  *    documentation and/or other materials provided with the distribution.
     15       1.1  kiyohara  * 3. All advertising materials mentioning features or use of this software
     16       1.1  kiyohara  *    must display the acknowledgement as bellow:
     17       1.1  kiyohara  *
     18       1.1  kiyohara  *    This product includes software developed by K. Kobayashi and H. Shimokawa
     19       1.1  kiyohara  *
     20       1.1  kiyohara  * 4. The name of the author may not be used to endorse or promote products
     21       1.1  kiyohara  *    derived from this software without specific prior written permission.
     22       1.1  kiyohara  *
     23       1.1  kiyohara  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     24       1.1  kiyohara  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     25       1.1  kiyohara  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     26       1.1  kiyohara  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
     27       1.1  kiyohara  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     28       1.1  kiyohara  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     29       1.1  kiyohara  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30       1.1  kiyohara  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     31       1.1  kiyohara  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     32       1.1  kiyohara  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     33       1.1  kiyohara  * POSSIBILITY OF SUCH DAMAGE.
     34       1.1  kiyohara  *
     35      1.19  kiyohara  * $FreeBSD: src/sys/dev/firewire/sbp.c,v 1.92 2007/06/06 14:31:36 simokawa Exp $
     36       1.1  kiyohara  *
     37       1.1  kiyohara  */
     38       1.1  kiyohara 
     39      1.20     lukem #include <sys/cdefs.h>
     40      1.20     lukem __KERNEL_RCSID(0, "$NetBSD: sbp.c,v 1.20.8.1 2008/04/03 12:42:43 mjf Exp $");
     41      1.20     lukem 
     42       1.1  kiyohara #if defined(__FreeBSD__)
     43       1.1  kiyohara #include <sys/param.h>
     44       1.1  kiyohara #include <sys/systm.h>
     45       1.1  kiyohara #include <sys/conf.h>
     46       1.1  kiyohara #include <sys/module.h>
     47       1.1  kiyohara #include <sys/bus.h>
     48       1.1  kiyohara #include <sys/kernel.h>
     49       1.1  kiyohara #include <sys/sysctl.h>
     50      1.18        ad #include <sys/bus.h>
     51       1.1  kiyohara #include <sys/malloc.h>
     52       1.1  kiyohara #if defined(__FreeBSD__) && __FreeBSD_version >= 501102
     53       1.1  kiyohara #include <sys/lock.h>
     54       1.1  kiyohara #include <sys/mutex.h>
     55       1.1  kiyohara #endif
     56       1.1  kiyohara 
     57       1.1  kiyohara #if defined(__DragonFly__) || __FreeBSD_version < 500106
     58       1.1  kiyohara #include <sys/devicestat.h>	/* for struct devstat */
     59       1.1  kiyohara #endif
     60       1.1  kiyohara 
     61       1.1  kiyohara #ifdef __DragonFly__
     62       1.1  kiyohara #include <bus/cam/cam.h>
     63       1.1  kiyohara #include <bus/cam/cam_ccb.h>
     64       1.1  kiyohara #include <bus/cam/cam_sim.h>
     65       1.1  kiyohara #include <bus/cam/cam_xpt_sim.h>
     66       1.1  kiyohara #include <bus/cam/cam_debug.h>
     67       1.1  kiyohara #include <bus/cam/cam_periph.h>
     68       1.1  kiyohara #include <bus/cam/scsi/scsi_all.h>
     69       1.1  kiyohara 
     70       1.1  kiyohara #include <bus/firewire/fw_port.h>
     71       1.1  kiyohara #include <bus/firewire/firewire.h>
     72       1.1  kiyohara #include <bus/firewire/firewirereg.h>
     73       1.1  kiyohara #include <bus/firewire/fwdma.h>
     74       1.1  kiyohara #include <bus/firewire/iec13213.h>
     75       1.1  kiyohara #include "sbp.h"
     76       1.1  kiyohara #else
     77       1.1  kiyohara #include <cam/cam.h>
     78       1.1  kiyohara #include <cam/cam_ccb.h>
     79       1.1  kiyohara #include <cam/cam_sim.h>
     80       1.1  kiyohara #include <cam/cam_xpt_sim.h>
     81       1.1  kiyohara #include <cam/cam_debug.h>
     82       1.1  kiyohara #include <cam/cam_periph.h>
     83       1.1  kiyohara #include <cam/scsi/scsi_all.h>
     84       1.1  kiyohara 
     85       1.1  kiyohara #include <dev/firewire/fw_port.h>
     86       1.1  kiyohara #include <dev/firewire/firewire.h>
     87       1.1  kiyohara #include <dev/firewire/firewirereg.h>
     88       1.1  kiyohara #include <dev/firewire/fwdma.h>
     89       1.1  kiyohara #include <dev/firewire/iec13213.h>
     90       1.1  kiyohara #include <dev/firewire/sbp.h>
     91       1.1  kiyohara #endif
     92       1.1  kiyohara #elif defined(__NetBSD__)
     93       1.1  kiyohara #include <sys/param.h>
     94       1.1  kiyohara #include <sys/device.h>
     95       1.1  kiyohara #include <sys/errno.h>
     96       1.1  kiyohara #include <sys/buf.h>
     97       1.1  kiyohara #include <sys/kernel.h>
     98       1.1  kiyohara #include <sys/kthread.h>
     99       1.1  kiyohara #include <sys/malloc.h>
    100       1.1  kiyohara #include <sys/proc.h>
    101       1.1  kiyohara #include <sys/sysctl.h>
    102       1.1  kiyohara 
    103      1.18        ad #include <sys/bus.h>
    104       1.1  kiyohara 
    105       1.1  kiyohara #include <dev/scsipi/scsi_spc.h>
    106       1.1  kiyohara #include <dev/scsipi/scsi_all.h>
    107       1.1  kiyohara #include <dev/scsipi/scsipi_all.h>
    108       1.1  kiyohara #include <dev/scsipi/scsiconf.h>
    109       1.1  kiyohara #include <dev/scsipi/scsipiconf.h>
    110       1.1  kiyohara 
    111       1.1  kiyohara #include <dev/ieee1394/fw_port.h>
    112       1.1  kiyohara #include <dev/ieee1394/firewire.h>
    113       1.1  kiyohara #include <dev/ieee1394/firewirereg.h>
    114       1.1  kiyohara #include <dev/ieee1394/fwdma.h>
    115       1.1  kiyohara #include <dev/ieee1394/iec13213.h>
    116       1.1  kiyohara #include <dev/ieee1394/sbp.h>
    117       1.1  kiyohara 
    118       1.1  kiyohara #include "locators.h"
    119       1.1  kiyohara #endif
    120       1.1  kiyohara 
    121       1.1  kiyohara #define ccb_sdev_ptr	spriv_ptr0
    122       1.1  kiyohara #define ccb_sbp_ptr	spriv_ptr1
    123       1.1  kiyohara 
    124       1.1  kiyohara #define SBP_NUM_TARGETS 8 /* MAX 64 */
    125       1.1  kiyohara /*
    126       1.1  kiyohara  * Scan_bus doesn't work for more than 8 LUNs
    127       1.1  kiyohara  * because of CAM_SCSI2_MAXLUN in cam_xpt.c
    128       1.1  kiyohara  */
    129       1.1  kiyohara #define SBP_NUM_LUNS 64
    130      1.16  kiyohara #define SBP_MAXPHYS  MIN(MAXPHYS, (512*1024) /* 512KB */)
    131       1.1  kiyohara #define SBP_DMA_SIZE PAGE_SIZE
    132       1.1  kiyohara #define SBP_LOGIN_SIZE sizeof(struct sbp_login_res)
    133       1.1  kiyohara #define SBP_QUEUE_LEN ((SBP_DMA_SIZE - SBP_LOGIN_SIZE) / sizeof(struct sbp_ocb))
    134       1.1  kiyohara #define SBP_NUM_OCB (SBP_QUEUE_LEN * SBP_NUM_TARGETS)
    135       1.1  kiyohara 
    136       1.1  kiyohara /*
    137       1.1  kiyohara  * STATUS FIFO addressing
    138       1.1  kiyohara  *   bit
    139       1.1  kiyohara  * -----------------------
    140       1.1  kiyohara  *  0- 1( 2): 0 (alignment)
    141       1.1  kiyohara  *  2- 9( 8): lun
    142       1.1  kiyohara  * 10-31(14): unit
    143       1.1  kiyohara  * 32-47(16): SBP_BIND_HI
    144       1.1  kiyohara  * 48-64(16): bus_id, node_id
    145       1.1  kiyohara  */
    146       1.1  kiyohara #define SBP_BIND_HI 0x1
    147       1.1  kiyohara #define SBP_DEV2ADDR(u, l) \
    148       1.1  kiyohara 	(((u_int64_t)SBP_BIND_HI << 32) \
    149       1.1  kiyohara 	| (((u) & 0x3fff) << 10) \
    150       1.1  kiyohara 	| (((l) & 0xff) << 2))
    151       1.1  kiyohara #define SBP_ADDR2UNIT(a)	(((a) >> 10) & 0x3fff)
    152       1.1  kiyohara #define SBP_ADDR2LUN(a)		(((a) >> 2) & 0xff)
    153       1.1  kiyohara #define SBP_INITIATOR 7
    154       1.1  kiyohara 
    155       1.1  kiyohara static const char *orb_fun_name[] = {
    156       1.1  kiyohara 	ORB_FUN_NAMES
    157       1.1  kiyohara };
    158       1.1  kiyohara 
    159       1.1  kiyohara static int debug = 0;
    160       1.1  kiyohara static int auto_login = 1;
    161       1.1  kiyohara static int max_speed = -1;
    162       1.1  kiyohara static int sbp_cold = 1;
    163       1.1  kiyohara static int ex_login = 1;
    164       1.1  kiyohara static int login_delay = 1000;	/* msec */
    165       1.1  kiyohara static int scan_delay = 500;	/* msec */
    166       1.1  kiyohara static int use_doorbell = 0;
    167       1.1  kiyohara static int sbp_tags = 0;
    168       1.1  kiyohara 
    169       1.1  kiyohara #if defined(__FreeBSD__)
    170       1.1  kiyohara SYSCTL_DECL(_hw_firewire);
    171       1.1  kiyohara SYSCTL_NODE(_hw_firewire, OID_AUTO, sbp, CTLFLAG_RD, 0, "SBP-II Subsystem");
    172       1.1  kiyohara SYSCTL_INT(_debug, OID_AUTO, sbp_debug, CTLFLAG_RW, &debug, 0,
    173       1.1  kiyohara 	"SBP debug flag");
    174       1.1  kiyohara SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, auto_login, CTLFLAG_RW, &auto_login, 0,
    175       1.1  kiyohara 	"SBP perform login automatically");
    176       1.1  kiyohara SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, max_speed, CTLFLAG_RW, &max_speed, 0,
    177       1.1  kiyohara 	"SBP transfer max speed");
    178       1.1  kiyohara SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, exclusive_login, CTLFLAG_RW,
    179       1.1  kiyohara 	&ex_login, 0, "SBP enable exclusive login");
    180       1.1  kiyohara SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, login_delay, CTLFLAG_RW,
    181       1.1  kiyohara 	&login_delay, 0, "SBP login delay in msec");
    182       1.1  kiyohara SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, scan_delay, CTLFLAG_RW,
    183       1.1  kiyohara 	&scan_delay, 0, "SBP scan delay in msec");
    184       1.1  kiyohara SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, use_doorbell, CTLFLAG_RW,
    185       1.1  kiyohara 	&use_doorbell, 0, "SBP use doorbell request");
    186       1.1  kiyohara SYSCTL_INT(_hw_firewire_sbp, OID_AUTO, tags, CTLFLAG_RW, &sbp_tags, 0,
    187       1.1  kiyohara 	"SBP tagged queuing support");
    188       1.1  kiyohara 
    189       1.1  kiyohara TUNABLE_INT("hw.firewire.sbp.auto_login", &auto_login);
    190       1.1  kiyohara TUNABLE_INT("hw.firewire.sbp.max_speed", &max_speed);
    191       1.1  kiyohara TUNABLE_INT("hw.firewire.sbp.exclusive_login", &ex_login);
    192       1.1  kiyohara TUNABLE_INT("hw.firewire.sbp.login_delay", &login_delay);
    193       1.1  kiyohara TUNABLE_INT("hw.firewire.sbp.scan_delay", &scan_delay);
    194       1.1  kiyohara TUNABLE_INT("hw.firewire.sbp.use_doorbell", &use_doorbell);
    195       1.1  kiyohara TUNABLE_INT("hw.firewire.sbp.tags", &sbp_tags);
    196       1.1  kiyohara #elif defined(__NetBSD__)
    197       1.1  kiyohara static int sysctl_sbp_verify(SYSCTLFN_PROTO, int lower, int upper);
    198       1.1  kiyohara static int sysctl_sbp_verify_max_speed(SYSCTLFN_PROTO);
    199       1.1  kiyohara static int sysctl_sbp_verify_tags(SYSCTLFN_PROTO);
    200       1.1  kiyohara 
    201       1.1  kiyohara /*
    202       1.1  kiyohara  * Setup sysctl(3) MIB, hw.sbp.*
    203       1.1  kiyohara  *
    204       1.1  kiyohara  * TBD condition CTLFLAG_PERMANENT on being an LKM or not
    205       1.1  kiyohara  */
    206       1.1  kiyohara SYSCTL_SETUP(sysctl_sbp, "sysctl sbp(4) subtree setup")
    207       1.1  kiyohara {
    208       1.1  kiyohara 	int rc, sbp_node_num;
    209       1.1  kiyohara 	const struct sysctlnode *node;
    210       1.1  kiyohara 
    211       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, NULL,
    212       1.1  kiyohara 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "hw", NULL,
    213       1.1  kiyohara 	    NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0) {
    214       1.1  kiyohara 		goto err;
    215       1.1  kiyohara 	}
    216       1.1  kiyohara 
    217       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    218       1.1  kiyohara 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "sbp",
    219       1.1  kiyohara 	    SYSCTL_DESCR("sbp controls"), NULL, 0, NULL,
    220       1.1  kiyohara 	    0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) {
    221       1.1  kiyohara 		goto err;
    222       1.1  kiyohara 	}
    223       1.1  kiyohara 	sbp_node_num = node->sysctl_num;
    224       1.1  kiyohara 
    225       1.1  kiyohara 	/* sbp auto login flag */
    226       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    227       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    228       1.1  kiyohara 	    "auto_login", SYSCTL_DESCR("SBP perform login automatically"),
    229       1.1  kiyohara 	    NULL, 0, &auto_login,
    230       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    231       1.1  kiyohara 		goto err;
    232       1.1  kiyohara 	}
    233       1.1  kiyohara 
    234       1.1  kiyohara 	/* sbp max speed */
    235       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    236       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    237       1.1  kiyohara 	    "max_speed", SYSCTL_DESCR("SBP transfer max speed"),
    238       1.1  kiyohara 	    sysctl_sbp_verify_max_speed, 0, &max_speed,
    239       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    240       1.1  kiyohara 		goto err;
    241       1.1  kiyohara 	}
    242       1.1  kiyohara 
    243       1.1  kiyohara 	/* sbp exclusive login flag */
    244       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    245       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    246       1.1  kiyohara 	    "exclusive_login", SYSCTL_DESCR("SBP enable exclusive login"),
    247       1.1  kiyohara 	    NULL, 0, &ex_login,
    248       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    249       1.1  kiyohara 		goto err;
    250       1.1  kiyohara 	}
    251       1.1  kiyohara 
    252       1.1  kiyohara 	/* sbp login delay */
    253       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    254       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    255       1.1  kiyohara 	    "login_delay", SYSCTL_DESCR("SBP login delay in msec"),
    256       1.1  kiyohara 	    NULL, 0, &login_delay,
    257       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    258       1.1  kiyohara 		goto err;
    259       1.1  kiyohara 	}
    260       1.1  kiyohara 
    261       1.1  kiyohara 	/* sbp scan delay */
    262       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    263       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    264       1.1  kiyohara 	    "scan_delay", SYSCTL_DESCR("SBP scan delay in msec"),
    265       1.1  kiyohara 	    NULL, 0, &scan_delay,
    266       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    267       1.1  kiyohara 		goto err;
    268       1.1  kiyohara 	}
    269       1.1  kiyohara 
    270       1.1  kiyohara 	/* sbp use doorbell flag */
    271       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    272       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    273       1.1  kiyohara 	    "use_doorbell", SYSCTL_DESCR("SBP use doorbell request"),
    274       1.1  kiyohara 	    NULL, 0, &use_doorbell,
    275       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    276       1.1  kiyohara 		goto err;
    277       1.1  kiyohara 	}
    278       1.1  kiyohara 
    279       1.1  kiyohara 	/* sbp force tagged queuing */
    280       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    281       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    282       1.1  kiyohara 	    "tags", SYSCTL_DESCR("SBP tagged queuing support"),
    283       1.1  kiyohara 	    sysctl_sbp_verify_tags, 0, &sbp_tags,
    284       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    285       1.1  kiyohara 		goto err;
    286       1.1  kiyohara 	}
    287       1.1  kiyohara 
    288       1.1  kiyohara 	/* sbp driver debug flag */
    289       1.1  kiyohara 	if ((rc = sysctl_createv(clog, 0, NULL, &node,
    290       1.1  kiyohara 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
    291       1.1  kiyohara 	    "sbp_debug", SYSCTL_DESCR("SBP debug flag"),
    292       1.1  kiyohara 	    NULL, 0, &debug,
    293       1.1  kiyohara 	    0, CTL_HW, sbp_node_num, CTL_CREATE, CTL_EOL)) != 0) {
    294       1.1  kiyohara 		goto err;
    295       1.1  kiyohara 	}
    296       1.1  kiyohara 
    297       1.1  kiyohara 	return;
    298       1.1  kiyohara 
    299       1.1  kiyohara err:
    300       1.1  kiyohara 	printf("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
    301       1.1  kiyohara }
    302       1.1  kiyohara 
    303       1.1  kiyohara static int
    304       1.1  kiyohara sysctl_sbp_verify(SYSCTLFN_ARGS, int lower, int upper)
    305       1.1  kiyohara {
    306       1.1  kiyohara 	int error, t;
    307       1.1  kiyohara 	struct sysctlnode node;
    308       1.1  kiyohara 
    309       1.1  kiyohara 	node = *rnode;
    310       1.1  kiyohara 	t = *(int*)rnode->sysctl_data;
    311       1.1  kiyohara 	node.sysctl_data = &t;
    312       1.1  kiyohara 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    313       1.1  kiyohara 	if (error || newp == NULL)
    314       1.1  kiyohara 		return (error);
    315       1.1  kiyohara 
    316       1.1  kiyohara 	if (t < lower || t > upper)
    317       1.1  kiyohara 		return (EINVAL);
    318       1.1  kiyohara 
    319       1.1  kiyohara 	*(int*)rnode->sysctl_data = t;
    320       1.1  kiyohara 
    321       1.1  kiyohara 	return (0);
    322       1.1  kiyohara }
    323       1.1  kiyohara 
    324       1.1  kiyohara static int
    325       1.1  kiyohara sysctl_sbp_verify_max_speed(SYSCTLFN_ARGS)
    326       1.1  kiyohara {
    327       1.1  kiyohara 	return (sysctl_sbp_verify(SYSCTLFN_CALL(rnode), 0, FWSPD_S400));
    328       1.1  kiyohara }
    329       1.1  kiyohara 
    330       1.1  kiyohara static int
    331       1.1  kiyohara sysctl_sbp_verify_tags(SYSCTLFN_ARGS)
    332       1.1  kiyohara {
    333       1.1  kiyohara 	return (sysctl_sbp_verify(SYSCTLFN_CALL(rnode), -1, 1));
    334       1.1  kiyohara }
    335       1.1  kiyohara #endif
    336       1.1  kiyohara 
    337       1.1  kiyohara #define NEED_RESPONSE 0
    338       1.1  kiyohara 
    339       1.1  kiyohara #define SBP_SEG_MAX rounddown(0xffff, PAGE_SIZE)
    340       1.1  kiyohara #ifdef __sparc64__ /* iommu */
    341      1.16  kiyohara #define SBP_IND_MAX howmany(SBP_MAXPHYS, SBP_SEG_MAX)
    342       1.1  kiyohara #else
    343      1.16  kiyohara #define SBP_IND_MAX howmany(SBP_MAXPHYS, PAGE_SIZE)
    344       1.1  kiyohara #endif
    345       1.1  kiyohara struct sbp_ocb {
    346       1.1  kiyohara 	STAILQ_ENTRY(sbp_ocb)	ocb;
    347       1.1  kiyohara 	sbp_scsi_xfer *sxfer;
    348       1.1  kiyohara 	bus_addr_t	bus_addr;
    349       1.1  kiyohara 	uint32_t	orb[8];
    350       1.1  kiyohara #define IND_PTR_OFFSET	(8*sizeof(uint32_t))
    351       1.1  kiyohara 	struct ind_ptr  ind_ptr[SBP_IND_MAX];
    352       1.1  kiyohara 	struct sbp_dev	*sdev;
    353       1.1  kiyohara 	int		flags; /* XXX should be removed */
    354       1.1  kiyohara 	bus_dmamap_t	dmamap;
    355       1.1  kiyohara };
    356       1.1  kiyohara 
    357       1.1  kiyohara #define OCB_ACT_MGM 0
    358       1.1  kiyohara #define OCB_ACT_CMD 1
    359       1.1  kiyohara #define OCB_MATCH(o,s)	((o)->bus_addr == ntohl((s)->orb_lo))
    360       1.1  kiyohara 
    361       1.1  kiyohara struct sbp_dev{
    362       1.1  kiyohara #define SBP_DEV_RESET		0	/* accept login */
    363       1.1  kiyohara #define SBP_DEV_LOGIN		1	/* to login */
    364       1.1  kiyohara #if 0
    365       1.1  kiyohara #define SBP_DEV_RECONN		2	/* to reconnect */
    366       1.1  kiyohara #endif
    367       1.1  kiyohara #define SBP_DEV_TOATTACH	3	/* to attach */
    368       1.1  kiyohara #define SBP_DEV_PROBE		4	/* scan lun */
    369       1.1  kiyohara #define SBP_DEV_ATTACHED	5	/* in operation */
    370       1.1  kiyohara #define SBP_DEV_DEAD		6	/* unavailable unit */
    371       1.1  kiyohara #define SBP_DEV_RETRY		7	/* unavailable unit */
    372       1.1  kiyohara 	uint8_t status:4,
    373       1.1  kiyohara 		 timeout:4;
    374       1.1  kiyohara 	uint8_t type;
    375       1.1  kiyohara 	uint16_t lun_id;
    376       1.1  kiyohara 	uint16_t freeze;
    377       1.1  kiyohara #define	ORB_LINK_DEAD		(1 << 0)
    378       1.1  kiyohara #define	VALID_LUN		(1 << 1)
    379       1.1  kiyohara #define	ORB_POINTER_ACTIVE	(1 << 2)
    380       1.1  kiyohara #define	ORB_POINTER_NEED	(1 << 3)
    381       1.1  kiyohara #define	ORB_DOORBELL_ACTIVE	(1 << 4)
    382       1.1  kiyohara #define	ORB_DOORBELL_NEED	(1 << 5)
    383       1.1  kiyohara #define	ORB_SHORTAGE		(1 << 6)
    384       1.1  kiyohara 	uint16_t flags;
    385       1.1  kiyohara #if defined(__FreeBSD__)
    386       1.1  kiyohara 	struct cam_path *path;
    387       1.1  kiyohara #elif defined(__NetBSD__)
    388       1.1  kiyohara 	struct scsipi_periph *periph;
    389       1.1  kiyohara #endif
    390       1.1  kiyohara 	struct sbp_target *target;
    391       1.1  kiyohara 	struct fwdma_alloc dma;
    392       1.1  kiyohara 	struct sbp_login_res *login;
    393       1.1  kiyohara 	struct callout login_callout;
    394       1.1  kiyohara 	struct sbp_ocb *ocb;
    395       1.1  kiyohara 	STAILQ_HEAD(, sbp_ocb) ocbs;
    396       1.1  kiyohara 	STAILQ_HEAD(, sbp_ocb) free_ocbs;
    397       1.1  kiyohara 	struct sbp_ocb *last_ocb;
    398       1.1  kiyohara 	char vendor[32];
    399       1.1  kiyohara 	char product[32];
    400       1.1  kiyohara 	char revision[10];
    401       1.1  kiyohara };
    402       1.1  kiyohara 
    403       1.1  kiyohara struct sbp_target {
    404       1.1  kiyohara 	int target_id;
    405       1.1  kiyohara 	int num_lun;
    406       1.1  kiyohara 	struct sbp_dev	**luns;
    407       1.1  kiyohara 	struct sbp_softc *sbp;
    408       1.1  kiyohara 	struct fw_device *fwdev;
    409       1.1  kiyohara 	uint32_t mgm_hi, mgm_lo;
    410       1.1  kiyohara 	struct sbp_ocb *mgm_ocb_cur;
    411       1.1  kiyohara 	STAILQ_HEAD(, sbp_ocb) mgm_ocb_queue;
    412       1.1  kiyohara 	struct callout mgm_ocb_timeout;
    413       1.1  kiyohara 	struct callout scan_callout;
    414       1.1  kiyohara 	STAILQ_HEAD(, fw_xfer) xferlist;
    415       1.1  kiyohara 	int n_xfer;
    416       1.1  kiyohara };
    417       1.1  kiyohara 
    418       1.1  kiyohara struct sbp_softc {
    419       1.1  kiyohara 	struct firewire_dev_comm fd;
    420       1.1  kiyohara #if defined(__FreeBSD__)
    421       1.1  kiyohara 	struct cam_sim  *sim;
    422       1.1  kiyohara 	struct cam_path  *path;
    423       1.1  kiyohara #elif defined(__NetBSD__)
    424       1.1  kiyohara 	struct scsipi_adapter sc_adapter;
    425       1.1  kiyohara 	struct scsipi_channel sc_channel;
    426  1.20.8.1       mjf 	device_t sc_bus;
    427      1.17        ad 	struct lwp *lwp;
    428       1.1  kiyohara #endif
    429       1.1  kiyohara 	struct sbp_target target;
    430       1.1  kiyohara 	struct fw_bind fwb;
    431       1.1  kiyohara 	fw_bus_dma_tag_t dmat;
    432       1.1  kiyohara 	struct timeval last_busreset;
    433       1.1  kiyohara #define SIMQ_FREEZED 1
    434       1.1  kiyohara 	int flags;
    435      1.19  kiyohara 	fw_mtx_t mtx;
    436       1.1  kiyohara };
    437      1.19  kiyohara #define SBP_LOCK(sbp)	fw_mtx_lock(&(sbp)->mtx)
    438      1.19  kiyohara #define SBP_UNLOCK(sbp)	fw_mtx_unlock(&(sbp)->mtx)
    439       1.1  kiyohara 
    440       1.1  kiyohara #if defined(__NetBSD__)
    441  1.20.8.1       mjf int sbpmatch (device_t, struct cfdata *, void *);
    442  1.20.8.1       mjf void sbpattach (device_t parent, device_t self, void *aux);
    443  1.20.8.1       mjf int sbpdetach (device_t self, int flags);
    444       1.1  kiyohara #endif
    445       1.1  kiyohara static void sbp_post_explore (void *);
    446       1.1  kiyohara static void sbp_recv (struct fw_xfer *);
    447       1.1  kiyohara static void sbp_mgm_callback (struct fw_xfer *);
    448       1.1  kiyohara #if 0
    449       1.1  kiyohara static void sbp_cmd_callback (struct fw_xfer *);
    450       1.1  kiyohara #endif
    451       1.1  kiyohara static void sbp_orb_pointer (struct sbp_dev *, struct sbp_ocb *);
    452       1.1  kiyohara static void sbp_doorbell(struct sbp_dev *);
    453       1.1  kiyohara static void sbp_execute_ocb (void *,  bus_dma_segment_t *, int, int);
    454       1.1  kiyohara static void sbp_free_ocb (struct sbp_dev *, struct sbp_ocb *);
    455       1.1  kiyohara static void sbp_abort_ocb (struct sbp_ocb *, int);
    456       1.1  kiyohara static void sbp_abort_all_ocbs (struct sbp_dev *, int);
    457       1.1  kiyohara static struct fw_xfer * sbp_write_cmd (struct sbp_dev *, int, int);
    458       1.1  kiyohara static struct sbp_ocb * sbp_get_ocb (struct sbp_dev *);
    459       1.1  kiyohara static struct sbp_ocb * sbp_enqueue_ocb (struct sbp_dev *, struct sbp_ocb *);
    460       1.1  kiyohara static struct sbp_ocb * sbp_dequeue_ocb (struct sbp_dev *, struct sbp_status *);
    461       1.1  kiyohara static void sbp_free_sdev(struct sbp_dev *);
    462       1.1  kiyohara static void sbp_free_target (struct sbp_target *);
    463       1.1  kiyohara static void sbp_mgm_timeout (void *arg);
    464       1.1  kiyohara static void sbp_timeout (void *arg);
    465       1.1  kiyohara static void sbp_mgm_orb (struct sbp_dev *, int, struct sbp_ocb *);
    466       1.1  kiyohara #if defined(__FreeBSD__)
    467       1.1  kiyohara 
    468       1.1  kiyohara MALLOC_DEFINE(M_SBP, "sbp", "SBP-II/FireWire");
    469       1.1  kiyohara #elif defined(__NetBSD__)
    470       1.1  kiyohara static void sbp_scsipi_request(
    471       1.1  kiyohara     struct scsipi_channel *, scsipi_adapter_req_t, void *);
    472       1.1  kiyohara static void sbp_minphys(struct buf *);
    473       1.1  kiyohara 
    474       1.1  kiyohara MALLOC_DEFINE(M_SBP, "sbp", "SBP-II/IEEE1394");
    475       1.1  kiyohara #endif
    476       1.1  kiyohara 
    477       1.1  kiyohara #if defined(__FreeBSD__)
    478       1.1  kiyohara /* cam related functions */
    479       1.1  kiyohara static void	sbp_action(struct cam_sim *, sbp_scsi_xfer *sxfer);
    480       1.1  kiyohara static void	sbp_poll(struct cam_sim *);
    481       1.1  kiyohara static void	sbp_cam_scan_lun(struct cam_periph *, sbp_scsi_xfer *);
    482       1.1  kiyohara static void	sbp_cam_scan_target(void *);
    483       1.1  kiyohara static void	sbp_cam_detach_sdev(struct sbp_dev *);
    484       1.1  kiyohara static void	sbp_cam_detach_target (struct sbp_target *);
    485       1.1  kiyohara #define SBP_DETACH_SDEV(sd)	sbp_cam_detach_sdev((sd))
    486       1.1  kiyohara #define SBP_DETACH_TARGET(st)	sbp_cam_detach_target((st))
    487       1.1  kiyohara #elif defined(__NetBSD__)
    488       1.1  kiyohara /* scsipi related functions */
    489       1.1  kiyohara static void	sbp_scsipi_scan_target(void *);
    490       1.1  kiyohara static void	sbp_scsipi_detach_sdev(struct sbp_dev *);
    491       1.1  kiyohara static void	sbp_scsipi_detach_target (struct sbp_target *);
    492       1.1  kiyohara #define SBP_DETACH_SDEV(sd)	sbp_scsipi_detach_sdev((sd))
    493       1.1  kiyohara #define SBP_DETACH_TARGET(st)	sbp_scsipi_detach_target((st))
    494       1.1  kiyohara #endif
    495       1.1  kiyohara 
    496       1.1  kiyohara static const char *orb_status0[] = {
    497       1.1  kiyohara 	/* 0 */ "No additional information to report",
    498       1.1  kiyohara 	/* 1 */ "Request type not supported",
    499       1.1  kiyohara 	/* 2 */ "Speed not supported",
    500       1.1  kiyohara 	/* 3 */ "Page size not supported",
    501       1.1  kiyohara 	/* 4 */ "Access denied",
    502       1.1  kiyohara 	/* 5 */ "Logical unit not supported",
    503       1.1  kiyohara 	/* 6 */ "Maximum payload too small",
    504       1.1  kiyohara 	/* 7 */ "Reserved for future standardization",
    505       1.1  kiyohara 	/* 8 */ "Resources unavailable",
    506       1.1  kiyohara 	/* 9 */ "Function rejected",
    507       1.1  kiyohara 	/* A */ "Login ID not recognized",
    508       1.1  kiyohara 	/* B */ "Dummy ORB completed",
    509       1.1  kiyohara 	/* C */ "Request aborted",
    510       1.1  kiyohara 	/* FF */ "Unspecified error"
    511       1.1  kiyohara #define MAX_ORB_STATUS0 0xd
    512       1.1  kiyohara };
    513       1.1  kiyohara 
    514       1.1  kiyohara static const char *orb_status1_object[] = {
    515       1.1  kiyohara 	/* 0 */ "Operation request block (ORB)",
    516       1.1  kiyohara 	/* 1 */ "Data buffer",
    517       1.1  kiyohara 	/* 2 */ "Page table",
    518       1.1  kiyohara 	/* 3 */ "Unable to specify"
    519       1.1  kiyohara };
    520       1.1  kiyohara 
    521       1.1  kiyohara static const char *orb_status1_serial_bus_error[] = {
    522       1.1  kiyohara 	/* 0 */ "Missing acknowledge",
    523       1.1  kiyohara 	/* 1 */ "Reserved; not to be used",
    524       1.1  kiyohara 	/* 2 */ "Time-out error",
    525       1.1  kiyohara 	/* 3 */ "Reserved; not to be used",
    526       1.1  kiyohara 	/* 4 */ "Busy retry limit exceeded(X)",
    527       1.1  kiyohara 	/* 5 */ "Busy retry limit exceeded(A)",
    528       1.1  kiyohara 	/* 6 */ "Busy retry limit exceeded(B)",
    529       1.1  kiyohara 	/* 7 */ "Reserved for future standardization",
    530       1.1  kiyohara 	/* 8 */ "Reserved for future standardization",
    531       1.1  kiyohara 	/* 9 */ "Reserved for future standardization",
    532       1.1  kiyohara 	/* A */ "Reserved for future standardization",
    533       1.1  kiyohara 	/* B */ "Tardy retry limit exceeded",
    534       1.1  kiyohara 	/* C */ "Conflict error",
    535       1.1  kiyohara 	/* D */ "Data error",
    536       1.1  kiyohara 	/* E */ "Type error",
    537       1.1  kiyohara 	/* F */ "Address error"
    538       1.1  kiyohara };
    539       1.1  kiyohara 
    540       1.1  kiyohara #if defined(__FreeBSD__)
    541       1.1  kiyohara #if 0
    542       1.1  kiyohara static void
    543       1.1  kiyohara sbp_identify(driver_t *driver, device_t parent)
    544       1.1  kiyohara {
    545       1.1  kiyohara 	device_t child;
    546       1.1  kiyohara SBP_DEBUG(0)
    547       1.1  kiyohara 	printf("sbp_identify\n");
    548       1.1  kiyohara END_DEBUG
    549       1.1  kiyohara 
    550      1.19  kiyohara 	child = BUS_ADD_CHILD(parent, 0, "sbp", fw_get_unit(parent));
    551       1.1  kiyohara }
    552       1.1  kiyohara #endif
    553       1.1  kiyohara 
    554       1.1  kiyohara /*
    555       1.1  kiyohara  * sbp_probe()
    556       1.1  kiyohara  */
    557       1.1  kiyohara static int
    558       1.1  kiyohara sbp_probe(device_t dev)
    559       1.1  kiyohara {
    560       1.1  kiyohara 	device_t pa;
    561       1.1  kiyohara 
    562       1.1  kiyohara SBP_DEBUG(0)
    563       1.1  kiyohara 	printf("sbp_probe\n");
    564       1.1  kiyohara END_DEBUG
    565       1.1  kiyohara 
    566       1.1  kiyohara 	pa = device_get_parent(dev);
    567      1.19  kiyohara 	if(fw_get_unit(dev) != fw_get_unit(pa)){
    568       1.1  kiyohara 		return(ENXIO);
    569       1.1  kiyohara 	}
    570       1.1  kiyohara 
    571       1.1  kiyohara 	device_set_desc(dev, "SBP-2/SCSI over FireWire");
    572       1.1  kiyohara 
    573       1.1  kiyohara #if 0
    574       1.1  kiyohara 	if (bootverbose)
    575       1.1  kiyohara 		debug = bootverbose;
    576       1.1  kiyohara #endif
    577       1.1  kiyohara 
    578       1.1  kiyohara 	return (0);
    579       1.1  kiyohara }
    580       1.1  kiyohara #elif defined(__NetBSD__)
    581       1.1  kiyohara int
    582  1.20.8.1       mjf sbpmatch(device_t parent, struct cfdata *cf, void *aux)
    583       1.1  kiyohara {
    584       1.1  kiyohara 	struct fw_attach_args *fwa = aux;
    585       1.1  kiyohara 
    586       1.1  kiyohara 	if (strcmp(fwa->name, "sbp") == 0)
    587      1.19  kiyohara 		return 1;
    588      1.19  kiyohara 	return 0;
    589       1.1  kiyohara }
    590       1.1  kiyohara #endif
    591       1.1  kiyohara 
    592       1.1  kiyohara static void
    593       1.1  kiyohara sbp_show_sdev_info(struct sbp_dev *sdev, int new)
    594       1.1  kiyohara {
    595       1.1  kiyohara 	struct fw_device *fwdev;
    596       1.1  kiyohara 
    597       1.1  kiyohara 	printf("%s:%d:%d ",
    598      1.19  kiyohara 		fw_get_nameunit(sdev->target->sbp->fd.dev),
    599       1.1  kiyohara 		sdev->target->target_id,
    600       1.1  kiyohara 		sdev->lun_id
    601       1.1  kiyohara 	);
    602       1.1  kiyohara 	if (new == 2) {
    603       1.1  kiyohara 		return;
    604       1.1  kiyohara 	}
    605       1.1  kiyohara 	fwdev = sdev->target->fwdev;
    606       1.1  kiyohara 	printf("ordered:%d type:%d EUI:%08x%08x node:%d "
    607       1.1  kiyohara 		"speed:%d maxrec:%d",
    608       1.1  kiyohara 		(sdev->type & 0x40) >> 6,
    609       1.1  kiyohara 		(sdev->type & 0x1f),
    610       1.1  kiyohara 		fwdev->eui.hi,
    611       1.1  kiyohara 		fwdev->eui.lo,
    612       1.1  kiyohara 		fwdev->dst,
    613       1.1  kiyohara 		fwdev->speed,
    614       1.1  kiyohara 		fwdev->maxrec
    615       1.1  kiyohara 	);
    616       1.1  kiyohara 	if (new)
    617       1.1  kiyohara 		printf(" new!\n");
    618       1.1  kiyohara 	else
    619       1.1  kiyohara 		printf("\n");
    620       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
    621       1.1  kiyohara 	printf("'%s' '%s' '%s'\n", sdev->vendor, sdev->product, sdev->revision);
    622       1.1  kiyohara }
    623       1.1  kiyohara 
    624       1.1  kiyohara static void
    625       1.1  kiyohara sbp_alloc_lun(struct sbp_target *target)
    626       1.1  kiyohara {
    627       1.1  kiyohara 	struct crom_context cc;
    628       1.1  kiyohara 	struct csrreg *reg;
    629       1.1  kiyohara 	struct sbp_dev *sdev, **newluns;
    630       1.1  kiyohara 	struct sbp_softc *sbp;
    631       1.1  kiyohara 	int maxlun, lun, i;
    632       1.1  kiyohara 
    633       1.1  kiyohara 	sbp = target->sbp;
    634       1.1  kiyohara 	crom_init_context(&cc, target->fwdev->csrrom);
    635       1.1  kiyohara 	/* XXX shoud parse appropriate unit directories only */
    636       1.1  kiyohara 	maxlun = -1;
    637       1.1  kiyohara 	while (cc.depth >= 0) {
    638       1.1  kiyohara 		reg = crom_search_key(&cc, CROM_LUN);
    639       1.1  kiyohara 		if (reg == NULL)
    640       1.1  kiyohara 			break;
    641       1.1  kiyohara 		lun = reg->val & 0xffff;
    642       1.1  kiyohara SBP_DEBUG(0)
    643       1.1  kiyohara 		printf("target %d lun %d found\n", target->target_id, lun);
    644       1.1  kiyohara END_DEBUG
    645       1.1  kiyohara 		if (maxlun < lun)
    646       1.1  kiyohara 			maxlun = lun;
    647       1.1  kiyohara 		crom_next(&cc);
    648       1.1  kiyohara 	}
    649       1.1  kiyohara 	if (maxlun < 0)
    650       1.1  kiyohara 		printf("%s:%d no LUN found\n",
    651      1.19  kiyohara 		    fw_get_nameunit(target->sbp->fd.dev),
    652       1.1  kiyohara 		    target->target_id);
    653       1.1  kiyohara 
    654       1.1  kiyohara 	maxlun ++;
    655       1.1  kiyohara 	if (maxlun >= SBP_NUM_LUNS)
    656       1.1  kiyohara 		maxlun = SBP_NUM_LUNS;
    657       1.1  kiyohara 
    658       1.1  kiyohara 	/* Invalidiate stale devices */
    659       1.1  kiyohara 	for (lun = 0; lun < target->num_lun; lun ++) {
    660       1.1  kiyohara 		sdev = target->luns[lun];
    661       1.1  kiyohara 		if (sdev == NULL)
    662       1.1  kiyohara 			continue;
    663       1.1  kiyohara 		sdev->flags &= ~VALID_LUN;
    664       1.1  kiyohara 		if (lun >= maxlun) {
    665       1.1  kiyohara 			/* lost device */
    666       1.1  kiyohara 			SBP_DETACH_SDEV(sdev);
    667       1.1  kiyohara 			sbp_free_sdev(sdev);
    668       1.1  kiyohara 		}
    669       1.1  kiyohara 	}
    670       1.1  kiyohara 
    671       1.1  kiyohara 	/* Reallocate */
    672       1.1  kiyohara 	if (maxlun != target->num_lun) {
    673       1.1  kiyohara 		newluns = (struct sbp_dev **) realloc(target->luns,
    674       1.1  kiyohara 		    sizeof(struct sbp_dev *) * maxlun,
    675       1.1  kiyohara 		    M_SBP, M_NOWAIT | M_ZERO);
    676       1.1  kiyohara 
    677       1.1  kiyohara 		if (newluns == NULL) {
    678       1.1  kiyohara 			printf("%s: realloc failed\n", __func__);
    679       1.1  kiyohara 			newluns = target->luns;
    680       1.1  kiyohara 			maxlun = target->num_lun;
    681       1.1  kiyohara 		}
    682       1.1  kiyohara 
    683       1.1  kiyohara 		/*
    684       1.1  kiyohara 		 * We must zero the extended region for the case
    685       1.1  kiyohara 		 * realloc() doesn't allocate new buffer.
    686       1.1  kiyohara 		 */
    687       1.1  kiyohara 		if (maxlun > target->num_lun)
    688       1.1  kiyohara 			bzero(&newluns[target->num_lun],
    689       1.1  kiyohara 			    sizeof(struct sbp_dev *) *
    690       1.1  kiyohara 			    (maxlun - target->num_lun));
    691       1.1  kiyohara 
    692       1.1  kiyohara 		target->luns = newluns;
    693       1.1  kiyohara 		target->num_lun = maxlun;
    694       1.1  kiyohara 	}
    695       1.1  kiyohara 
    696       1.1  kiyohara 	crom_init_context(&cc, target->fwdev->csrrom);
    697       1.1  kiyohara 	while (cc.depth >= 0) {
    698       1.1  kiyohara 		int new = 0;
    699       1.1  kiyohara 
    700       1.1  kiyohara 		reg = crom_search_key(&cc, CROM_LUN);
    701       1.1  kiyohara 		if (reg == NULL)
    702       1.1  kiyohara 			break;
    703       1.1  kiyohara 		lun = reg->val & 0xffff;
    704       1.1  kiyohara 		if (lun >= SBP_NUM_LUNS) {
    705       1.1  kiyohara 			printf("too large lun %d\n", lun);
    706       1.1  kiyohara 			goto next;
    707       1.1  kiyohara 		}
    708       1.1  kiyohara 
    709       1.1  kiyohara 		sdev = target->luns[lun];
    710       1.1  kiyohara 		if (sdev == NULL) {
    711       1.1  kiyohara 			sdev = malloc(sizeof(struct sbp_dev),
    712       1.1  kiyohara 			    M_SBP, M_NOWAIT | M_ZERO);
    713       1.1  kiyohara 			if (sdev == NULL) {
    714       1.1  kiyohara 				printf("%s: malloc failed\n", __func__);
    715       1.1  kiyohara 				goto next;
    716       1.1  kiyohara 			}
    717       1.1  kiyohara 			target->luns[lun] = sdev;
    718       1.1  kiyohara 			sdev->lun_id = lun;
    719       1.1  kiyohara 			sdev->target = target;
    720       1.1  kiyohara 			STAILQ_INIT(&sdev->ocbs);
    721      1.19  kiyohara 			fw_callout_init(&sdev->login_callout);
    722       1.1  kiyohara 			sdev->status = SBP_DEV_RESET;
    723       1.1  kiyohara 			new = 1;
    724       1.1  kiyohara 			SBP_DEVICE_PREATTACH();
    725       1.1  kiyohara 		}
    726       1.1  kiyohara 		sdev->flags |= VALID_LUN;
    727       1.1  kiyohara 		sdev->type = (reg->val & 0xff0000) >> 16;
    728       1.1  kiyohara 
    729       1.1  kiyohara 		if (new == 0)
    730       1.1  kiyohara 			goto next;
    731       1.1  kiyohara 
    732       1.1  kiyohara 		fwdma_malloc(sbp->fd.fc,
    733       1.1  kiyohara 			/* alignment */ sizeof(uint32_t),
    734       1.1  kiyohara 			SBP_DMA_SIZE, &sdev->dma, BUS_DMA_NOWAIT);
    735       1.1  kiyohara 		if (sdev->dma.v_addr == NULL) {
    736       1.1  kiyohara 			printf("%s: dma space allocation failed\n",
    737       1.1  kiyohara 							__func__);
    738       1.1  kiyohara 			free(sdev, M_SBP);
    739       1.1  kiyohara 			target->luns[lun] = NULL;
    740       1.1  kiyohara 			goto next;
    741       1.1  kiyohara 		}
    742       1.1  kiyohara 		sdev->login = (struct sbp_login_res *) sdev->dma.v_addr;
    743       1.1  kiyohara 		sdev->ocb = (struct sbp_ocb *)
    744       1.1  kiyohara 				((char *)sdev->dma.v_addr + SBP_LOGIN_SIZE);
    745       1.1  kiyohara 		bzero((char *)sdev->ocb,
    746       1.1  kiyohara 			sizeof (struct sbp_ocb) * SBP_QUEUE_LEN);
    747       1.1  kiyohara 
    748       1.1  kiyohara 		STAILQ_INIT(&sdev->free_ocbs);
    749       1.1  kiyohara 		for (i = 0; i < SBP_QUEUE_LEN; i++) {
    750       1.1  kiyohara 			struct sbp_ocb *ocb;
    751       1.1  kiyohara 			ocb = &sdev->ocb[i];
    752       1.1  kiyohara 			ocb->bus_addr = sdev->dma.bus_addr
    753       1.1  kiyohara 				+ SBP_LOGIN_SIZE
    754       1.1  kiyohara 				+ sizeof(struct sbp_ocb) * i
    755       1.1  kiyohara 				+ offsetof(struct sbp_ocb, orb[0]);
    756       1.1  kiyohara 			if (fw_bus_dmamap_create(sbp->dmat, 0, &ocb->dmamap)) {
    757       1.1  kiyohara 				printf("sbp_attach: cannot create dmamap\n");
    758       1.1  kiyohara 				/* XXX */
    759       1.1  kiyohara 				goto next;
    760       1.1  kiyohara 			}
    761       1.1  kiyohara 			sbp_free_ocb(sdev, ocb);
    762       1.1  kiyohara 		}
    763       1.1  kiyohara next:
    764       1.1  kiyohara 		crom_next(&cc);
    765       1.1  kiyohara 	}
    766       1.1  kiyohara 
    767       1.1  kiyohara 	for (lun = 0; lun < target->num_lun; lun ++) {
    768       1.1  kiyohara 		sdev = target->luns[lun];
    769       1.1  kiyohara 		if (sdev != NULL && (sdev->flags & VALID_LUN) == 0) {
    770       1.1  kiyohara 			SBP_DETACH_SDEV(sdev);
    771       1.1  kiyohara 			sbp_free_sdev(sdev);
    772       1.1  kiyohara 			target->luns[lun] = NULL;
    773       1.1  kiyohara 		}
    774       1.1  kiyohara 	}
    775       1.1  kiyohara }
    776       1.1  kiyohara 
    777       1.1  kiyohara static struct sbp_target *
    778       1.1  kiyohara sbp_alloc_target(struct sbp_softc *sbp, struct fw_device *fwdev)
    779       1.1  kiyohara {
    780       1.1  kiyohara 	struct sbp_target *target;
    781       1.1  kiyohara 	struct crom_context cc;
    782       1.1  kiyohara 	struct csrreg *reg;
    783       1.1  kiyohara 
    784       1.1  kiyohara SBP_DEBUG(1)
    785       1.1  kiyohara 	printf("sbp_alloc_target\n");
    786       1.1  kiyohara END_DEBUG
    787       1.1  kiyohara 	/* new target */
    788       1.1  kiyohara 	target = &sbp->target;
    789       1.1  kiyohara 	target->sbp = sbp;
    790       1.1  kiyohara 	target->fwdev = fwdev;
    791       1.1  kiyohara 	target->target_id = 0;
    792       1.1  kiyohara 	/* XXX we may want to reload mgm port after each bus reset */
    793       1.1  kiyohara 	/* XXX there might be multiple management agents */
    794       1.1  kiyohara 	crom_init_context(&cc, target->fwdev->csrrom);
    795       1.1  kiyohara 	reg = crom_search_key(&cc, CROM_MGM);
    796       1.1  kiyohara 	if (reg == NULL || reg->val == 0) {
    797       1.1  kiyohara 		printf("NULL management address\n");
    798       1.1  kiyohara 		target->fwdev = NULL;
    799       1.1  kiyohara 		return NULL;
    800       1.1  kiyohara 	}
    801       1.1  kiyohara 	target->mgm_hi = 0xffff;
    802       1.1  kiyohara 	target->mgm_lo = 0xf0000000 | (reg->val << 2);
    803       1.1  kiyohara 	target->mgm_ocb_cur = NULL;
    804       1.1  kiyohara SBP_DEBUG(1)
    805       1.1  kiyohara 	printf("target: mgm_port: %x\n", target->mgm_lo);
    806       1.1  kiyohara END_DEBUG
    807       1.1  kiyohara 	STAILQ_INIT(&target->xferlist);
    808       1.1  kiyohara 	target->n_xfer = 0;
    809       1.1  kiyohara 	STAILQ_INIT(&target->mgm_ocb_queue);
    810      1.19  kiyohara 	fw_callout_init(&target->mgm_ocb_timeout);
    811      1.19  kiyohara 	fw_callout_init(&target->scan_callout);
    812       1.1  kiyohara 
    813       1.1  kiyohara 	target->luns = NULL;
    814       1.1  kiyohara 	target->num_lun = 0;
    815       1.1  kiyohara 	return target;
    816       1.1  kiyohara }
    817       1.1  kiyohara 
    818       1.1  kiyohara static void
    819       1.1  kiyohara sbp_probe_lun(struct sbp_dev *sdev)
    820       1.1  kiyohara {
    821       1.1  kiyohara 	struct fw_device *fwdev;
    822       1.1  kiyohara 	struct crom_context c, *cc = &c;
    823       1.1  kiyohara 	struct csrreg *reg;
    824       1.1  kiyohara 
    825       1.1  kiyohara 	bzero(sdev->vendor, sizeof(sdev->vendor));
    826       1.1  kiyohara 	bzero(sdev->product, sizeof(sdev->product));
    827       1.1  kiyohara 
    828       1.1  kiyohara 	fwdev = sdev->target->fwdev;
    829       1.1  kiyohara 	crom_init_context(cc, fwdev->csrrom);
    830       1.1  kiyohara 	/* get vendor string */
    831       1.1  kiyohara 	crom_search_key(cc, CSRKEY_VENDOR);
    832       1.1  kiyohara 	crom_next(cc);
    833       1.1  kiyohara 	crom_parse_text(cc, sdev->vendor, sizeof(sdev->vendor));
    834       1.1  kiyohara 	/* skip to the unit directory for SBP-2 */
    835       1.1  kiyohara 	while ((reg = crom_search_key(cc, CSRKEY_VER)) != NULL) {
    836       1.1  kiyohara 		if (reg->val == CSRVAL_T10SBP2)
    837       1.1  kiyohara 			break;
    838       1.1  kiyohara 		crom_next(cc);
    839       1.1  kiyohara 	}
    840       1.1  kiyohara 	/* get firmware revision */
    841       1.1  kiyohara 	reg = crom_search_key(cc, CSRKEY_FIRM_VER);
    842       1.1  kiyohara 	if (reg != NULL)
    843       1.1  kiyohara 		snprintf(sdev->revision, sizeof(sdev->revision),
    844       1.1  kiyohara 						"%06x", reg->val);
    845       1.1  kiyohara 	/* get product string */
    846       1.1  kiyohara 	crom_search_key(cc, CSRKEY_MODEL);
    847       1.1  kiyohara 	crom_next(cc);
    848       1.1  kiyohara 	crom_parse_text(cc, sdev->product, sizeof(sdev->product));
    849       1.1  kiyohara }
    850       1.1  kiyohara 
    851       1.1  kiyohara static void
    852       1.1  kiyohara sbp_login_callout(void *arg)
    853       1.1  kiyohara {
    854       1.1  kiyohara 	struct sbp_dev *sdev = (struct sbp_dev *)arg;
    855       1.1  kiyohara 	sbp_mgm_orb(sdev, ORB_FUN_LGI, NULL);
    856       1.1  kiyohara }
    857       1.1  kiyohara 
    858       1.1  kiyohara static void
    859       1.1  kiyohara sbp_login(struct sbp_dev *sdev)
    860       1.1  kiyohara {
    861       1.1  kiyohara 	struct timeval delta;
    862       1.1  kiyohara 	struct timeval t;
    863       1.1  kiyohara 	int ticks = 0;
    864       1.1  kiyohara 
    865       1.1  kiyohara 	microtime(&delta);
    866      1.19  kiyohara 	fw_timevalsub(&delta, &sdev->target->sbp->last_busreset);
    867       1.1  kiyohara 	t.tv_sec = login_delay / 1000;
    868       1.1  kiyohara 	t.tv_usec = (login_delay % 1000) * 1000;
    869      1.19  kiyohara 	fw_timevalsub(&t, &delta);
    870       1.1  kiyohara 	if (t.tv_sec >= 0 && t.tv_usec > 0)
    871       1.1  kiyohara 		ticks = (t.tv_sec * 1000 + t.tv_usec / 1000) * hz / 1000;
    872       1.1  kiyohara SBP_DEBUG(0)
    873      1.16  kiyohara 	printf("%s: sec = %jd usec = %ld ticks = %d\n", __func__,
    874      1.16  kiyohara 	    (intmax_t)t.tv_sec, t.tv_usec, ticks);
    875       1.1  kiyohara END_DEBUG
    876      1.19  kiyohara 	fw_callout_reset(&sdev->login_callout, ticks,
    877       1.1  kiyohara 			sbp_login_callout, (void *)(sdev));
    878       1.1  kiyohara }
    879       1.1  kiyohara 
    880       1.1  kiyohara static void
    881       1.1  kiyohara sbp_probe_target(void *arg)
    882       1.1  kiyohara {
    883       1.1  kiyohara 	struct sbp_target *target = (struct sbp_target *)arg;
    884       1.1  kiyohara 	struct sbp_softc *sbp;
    885       1.1  kiyohara 	struct sbp_dev *sdev;
    886       1.1  kiyohara 	struct firewire_comm *fc;
    887       1.1  kiyohara 	int i;
    888       1.1  kiyohara 
    889       1.1  kiyohara SBP_DEBUG(1)
    890       1.1  kiyohara 	printf("sbp_probe_target %d\n", target->target_id);
    891       1.1  kiyohara END_DEBUG
    892       1.1  kiyohara 
    893       1.1  kiyohara 	sbp = target->sbp;
    894       1.1  kiyohara 	fc = target->sbp->fd.fc;
    895       1.1  kiyohara 	sbp_alloc_lun(target);
    896       1.1  kiyohara 
    897       1.1  kiyohara 	/* XXX untimeout mgm_ocb and dequeue */
    898       1.1  kiyohara 	for (i=0; i < target->num_lun; i++) {
    899       1.1  kiyohara 		sdev = target->luns[i];
    900       1.1  kiyohara 		if (sdev == NULL)
    901       1.1  kiyohara 			continue;
    902       1.1  kiyohara 		if (sdev->status != SBP_DEV_DEAD) {
    903       1.1  kiyohara 			if (SBP_DEVICE(sdev) != NULL) {
    904      1.19  kiyohara 				SBP_LOCK(sbp);
    905       1.1  kiyohara 				SBP_DEVICE_FREEZE(sdev, 1);
    906       1.1  kiyohara 				sdev->freeze ++;
    907      1.19  kiyohara 				SBP_UNLOCK(sbp);
    908       1.1  kiyohara 			}
    909       1.1  kiyohara 			sbp_probe_lun(sdev);
    910       1.1  kiyohara SBP_DEBUG(0)
    911       1.1  kiyohara 			sbp_show_sdev_info(sdev,
    912       1.1  kiyohara 					(sdev->status == SBP_DEV_RESET));
    913       1.1  kiyohara END_DEBUG
    914       1.1  kiyohara 
    915       1.1  kiyohara 			sbp_abort_all_ocbs(sdev, XS_SCSI_BUS_RESET);
    916       1.1  kiyohara 			switch (sdev->status) {
    917       1.1  kiyohara 			case SBP_DEV_RESET:
    918       1.1  kiyohara 				/* new or revived target */
    919       1.1  kiyohara 				if (auto_login)
    920       1.1  kiyohara 					sbp_login(sdev);
    921       1.1  kiyohara 				break;
    922       1.1  kiyohara 			case SBP_DEV_TOATTACH:
    923       1.1  kiyohara 			case SBP_DEV_PROBE:
    924       1.1  kiyohara 			case SBP_DEV_ATTACHED:
    925       1.1  kiyohara 			case SBP_DEV_RETRY:
    926       1.1  kiyohara 			default:
    927       1.1  kiyohara 				sbp_mgm_orb(sdev, ORB_FUN_RCN, NULL);
    928       1.1  kiyohara 				break;
    929       1.1  kiyohara 			}
    930       1.1  kiyohara 		} else {
    931       1.1  kiyohara 			switch (sdev->status) {
    932       1.1  kiyohara 			case SBP_DEV_ATTACHED:
    933       1.1  kiyohara SBP_DEBUG(0)
    934       1.1  kiyohara 				/* the device has gone */
    935       1.1  kiyohara 				sbp_show_sdev_info(sdev, 2);
    936       1.1  kiyohara 				printf("lost target\n");
    937       1.1  kiyohara END_DEBUG
    938       1.1  kiyohara 				if (SBP_DEVICE(sdev) != NULL) {
    939      1.19  kiyohara 					SBP_LOCK(sbp);
    940       1.1  kiyohara 					SBP_DEVICE_FREEZE(sdev, 1);
    941       1.1  kiyohara 					sdev->freeze ++;
    942      1.19  kiyohara 					SBP_UNLOCK(sbp);
    943       1.1  kiyohara 				}
    944       1.1  kiyohara 				sdev->status = SBP_DEV_RETRY;
    945       1.1  kiyohara 				sbp_abort_all_ocbs(sdev, XS_SCSI_BUS_RESET);
    946       1.1  kiyohara 				break;
    947       1.1  kiyohara 			case SBP_DEV_PROBE:
    948       1.1  kiyohara 			case SBP_DEV_TOATTACH:
    949       1.1  kiyohara 				sdev->status = SBP_DEV_RESET;
    950       1.1  kiyohara 				break;
    951       1.1  kiyohara 			case SBP_DEV_RETRY:
    952       1.1  kiyohara 			case SBP_DEV_RESET:
    953       1.1  kiyohara 			case SBP_DEV_DEAD:
    954       1.1  kiyohara 				break;
    955       1.1  kiyohara 			}
    956       1.1  kiyohara 		}
    957       1.1  kiyohara 	}
    958       1.1  kiyohara }
    959       1.1  kiyohara 
    960       1.1  kiyohara #define SBP_FWDEV_ALIVE(fwdev) (((fwdev)->status == FWDEVATTACHED) \
    961       1.1  kiyohara 	&& crom_has_specver((fwdev)->csrrom, CSRVAL_ANSIT10, CSRVAL_T10SBP2))
    962       1.1  kiyohara 
    963       1.1  kiyohara static void
    964       1.1  kiyohara sbp_post_busreset(void *arg)
    965       1.1  kiyohara {
    966       1.1  kiyohara 	struct sbp_softc *sbp = (struct sbp_softc *)arg;
    967       1.1  kiyohara 	struct sbp_target *target = &sbp->target;
    968       1.1  kiyohara 	struct fw_device *fwdev = target->fwdev;
    969       1.1  kiyohara 	int alive;
    970       1.1  kiyohara 
    971       1.1  kiyohara 	alive = SBP_FWDEV_ALIVE(fwdev);
    972       1.1  kiyohara SBP_DEBUG(0)
    973       1.1  kiyohara 	printf("sbp_post_busreset\n");
    974       1.1  kiyohara 	if (!alive)
    975       1.1  kiyohara 		printf("not alive\n");
    976       1.1  kiyohara END_DEBUG
    977      1.10  kiyohara 	microtime(&sbp->last_busreset);
    978      1.10  kiyohara 
    979       1.1  kiyohara 	if (!alive)
    980       1.1  kiyohara 		return;
    981       1.1  kiyohara 
    982      1.19  kiyohara 	SBP_LOCK(sbp);
    983       1.1  kiyohara 	SBP_BUS_FREEZE(sbp);
    984      1.19  kiyohara 	SBP_UNLOCK(sbp);
    985       1.1  kiyohara }
    986       1.1  kiyohara 
    987       1.1  kiyohara static void
    988       1.1  kiyohara sbp_post_explore(void *arg)
    989       1.1  kiyohara {
    990       1.1  kiyohara 	struct sbp_softc *sbp = (struct sbp_softc *)arg;
    991       1.1  kiyohara 	struct sbp_target *target = &sbp->target;
    992       1.1  kiyohara 	struct fw_device *fwdev = target->fwdev;
    993       1.1  kiyohara 	int alive;
    994       1.1  kiyohara 
    995       1.1  kiyohara 	alive = SBP_FWDEV_ALIVE(fwdev);
    996       1.1  kiyohara SBP_DEBUG(0)
    997       1.1  kiyohara 	printf("sbp_post_explore (sbp_cold=%d)\n", sbp_cold);
    998       1.1  kiyohara 	if (!alive)
    999       1.1  kiyohara 		printf("not alive\n");
   1000       1.1  kiyohara END_DEBUG
   1001       1.1  kiyohara 	if (!alive)
   1002       1.1  kiyohara 		return;
   1003       1.1  kiyohara 
   1004       1.1  kiyohara 	if (sbp_cold > 0)
   1005       1.1  kiyohara 		sbp_cold --;
   1006       1.1  kiyohara 
   1007       1.1  kiyohara #if 0
   1008       1.1  kiyohara 	/*
   1009       1.1  kiyohara 	 * XXX don't let CAM the bus rest.
   1010       1.1  kiyohara 	 * CAM tries to do something with freezed (DEV_RETRY) devices.
   1011       1.1  kiyohara 	 */
   1012       1.1  kiyohara 	xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL);
   1013       1.1  kiyohara #endif
   1014       1.1  kiyohara 
   1015       1.1  kiyohara SBP_DEBUG(0)
   1016       1.1  kiyohara 	printf("sbp_post_explore: EUI:%08x%08x ", fwdev->eui.hi, fwdev->eui.lo);
   1017       1.1  kiyohara END_DEBUG
   1018       1.1  kiyohara 	sbp_probe_target((void *)target);
   1019       1.1  kiyohara 	if (target->num_lun == 0)
   1020       1.1  kiyohara 		sbp_free_target(target);
   1021       1.1  kiyohara 
   1022      1.19  kiyohara 	SBP_LOCK(sbp);
   1023       1.1  kiyohara 	SBP_BUS_THAW(sbp);
   1024      1.19  kiyohara 	SBP_UNLOCK(sbp);
   1025       1.1  kiyohara }
   1026       1.1  kiyohara 
   1027       1.1  kiyohara #if NEED_RESPONSE
   1028       1.1  kiyohara static void
   1029       1.1  kiyohara sbp_loginres_callback(struct fw_xfer *xfer){
   1030       1.1  kiyohara 	int s;
   1031       1.1  kiyohara 	struct sbp_dev *sdev;
   1032       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1033       1.1  kiyohara SBP_DEBUG(1)
   1034       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1035       1.1  kiyohara 	printf("sbp_loginres_callback\n");
   1036       1.1  kiyohara END_DEBUG
   1037       1.1  kiyohara 	/* recycle */
   1038       1.1  kiyohara 	s = splfw();
   1039       1.1  kiyohara 	STAILQ_INSERT_TAIL(&sdev->target->sbp->fwb.xferlist, xfer, link);
   1040       1.1  kiyohara 	splx(s);
   1041       1.1  kiyohara 	return;
   1042       1.1  kiyohara }
   1043       1.1  kiyohara #endif
   1044       1.1  kiyohara 
   1045       1.4     perry static inline void
   1046       1.1  kiyohara sbp_xfer_free(struct fw_xfer *xfer)
   1047       1.1  kiyohara {
   1048       1.1  kiyohara 	struct sbp_dev *sdev;
   1049       1.1  kiyohara 	int s;
   1050       1.1  kiyohara 
   1051       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1052       1.1  kiyohara 	fw_xfer_unload(xfer);
   1053       1.1  kiyohara 	s = splfw();
   1054      1.19  kiyohara 	SBP_LOCK(sdev->target->sbp);
   1055       1.1  kiyohara 	STAILQ_INSERT_TAIL(&sdev->target->xferlist, xfer, link);
   1056      1.19  kiyohara 	SBP_UNLOCK(sdev->target->sbp);
   1057       1.1  kiyohara 	splx(s);
   1058       1.1  kiyohara }
   1059       1.1  kiyohara 
   1060       1.1  kiyohara static void
   1061       1.1  kiyohara sbp_reset_start_callback(struct fw_xfer *xfer)
   1062       1.1  kiyohara {
   1063       1.1  kiyohara 	struct sbp_dev *tsdev, *sdev = (struct sbp_dev *)xfer->sc;
   1064       1.1  kiyohara 	struct sbp_target *target = sdev->target;
   1065       1.1  kiyohara 	int i;
   1066       1.1  kiyohara 
   1067       1.1  kiyohara 	if (xfer->resp != 0) {
   1068       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1069       1.1  kiyohara 		printf("sbp_reset_start failed: resp=%d\n", xfer->resp);
   1070       1.1  kiyohara 	}
   1071       1.1  kiyohara 
   1072       1.1  kiyohara 	for (i = 0; i < target->num_lun; i++) {
   1073       1.1  kiyohara 		tsdev = target->luns[i];
   1074       1.1  kiyohara 		if (tsdev != NULL && tsdev->status == SBP_DEV_LOGIN)
   1075       1.1  kiyohara 			sbp_login(tsdev);
   1076       1.1  kiyohara 	}
   1077       1.1  kiyohara }
   1078       1.1  kiyohara 
   1079       1.1  kiyohara static void
   1080       1.1  kiyohara sbp_reset_start(struct sbp_dev *sdev)
   1081       1.1  kiyohara {
   1082       1.1  kiyohara 	struct fw_xfer *xfer;
   1083       1.1  kiyohara 	struct fw_pkt *fp;
   1084       1.1  kiyohara 
   1085       1.1  kiyohara SBP_DEBUG(0)
   1086       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1087       1.1  kiyohara 	printf("sbp_reset_start\n");
   1088       1.1  kiyohara END_DEBUG
   1089       1.1  kiyohara 
   1090       1.1  kiyohara 	xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0);
   1091       1.1  kiyohara 	xfer->hand = sbp_reset_start_callback;
   1092       1.1  kiyohara 	fp = &xfer->send.hdr;
   1093       1.1  kiyohara 	fp->mode.wreqq.dest_hi = 0xffff;
   1094       1.1  kiyohara 	fp->mode.wreqq.dest_lo = 0xf0000000 | RESET_START;
   1095       1.1  kiyohara 	fp->mode.wreqq.data = htonl(0xf);
   1096       1.1  kiyohara 	fw_asyreq(xfer->fc, -1, xfer);
   1097       1.1  kiyohara }
   1098       1.1  kiyohara 
   1099       1.1  kiyohara static void
   1100       1.1  kiyohara sbp_mgm_callback(struct fw_xfer *xfer)
   1101       1.1  kiyohara {
   1102       1.1  kiyohara 	struct sbp_dev *sdev;
   1103       1.1  kiyohara 	int resp;
   1104       1.1  kiyohara 
   1105       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1106       1.1  kiyohara 
   1107       1.1  kiyohara SBP_DEBUG(1)
   1108       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1109       1.1  kiyohara 	printf("sbp_mgm_callback\n");
   1110       1.1  kiyohara END_DEBUG
   1111       1.1  kiyohara 	resp = xfer->resp;
   1112       1.1  kiyohara 	sbp_xfer_free(xfer);
   1113       1.1  kiyohara #if 0
   1114       1.1  kiyohara 	if (resp != 0) {
   1115       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1116       1.1  kiyohara 		printf("management ORB failed(%d) ... RESET_START\n", resp);
   1117       1.1  kiyohara 		sbp_reset_start(sdev);
   1118       1.1  kiyohara 	}
   1119       1.1  kiyohara #endif
   1120       1.1  kiyohara 	return;
   1121       1.1  kiyohara }
   1122       1.1  kiyohara 
   1123       1.1  kiyohara #if defined(__FreeBSD__)
   1124       1.1  kiyohara static struct sbp_dev *
   1125       1.1  kiyohara sbp_next_dev(struct sbp_target *target, int lun)
   1126       1.1  kiyohara {
   1127       1.1  kiyohara 	struct sbp_dev **sdevp;
   1128       1.1  kiyohara 	int i;
   1129       1.1  kiyohara 
   1130       1.1  kiyohara 	for (i = lun, sdevp = &target->luns[lun]; i < target->num_lun;
   1131       1.1  kiyohara 	    i++, sdevp++)
   1132       1.1  kiyohara 		if (*sdevp != NULL && (*sdevp)->status == SBP_DEV_PROBE)
   1133       1.1  kiyohara 			return(*sdevp);
   1134       1.1  kiyohara 	return(NULL);
   1135       1.1  kiyohara }
   1136       1.1  kiyohara 
   1137       1.1  kiyohara #define SCAN_PRI 1
   1138       1.1  kiyohara static void
   1139       1.1  kiyohara sbp_cam_scan_lun(struct cam_periph *periph, sbp_scsi_xfer *sxfer)
   1140       1.1  kiyohara {
   1141       1.1  kiyohara 	struct sbp_target *target;
   1142       1.1  kiyohara 	struct sbp_dev *sdev;
   1143       1.1  kiyohara 
   1144       1.1  kiyohara 	sdev = (struct sbp_dev *) sxfer->ccb_h.ccb_sdev_ptr;
   1145       1.1  kiyohara 	target = sdev->target;
   1146       1.1  kiyohara SBP_DEBUG(0)
   1147       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1148       1.1  kiyohara 	printf("sbp_cam_scan_lun\n");
   1149       1.1  kiyohara END_DEBUG
   1150       1.1  kiyohara 	if ((SCSI_XFER_ERROR(sxfer) & CAM_STATUS_MASK) == XS_REQ_CMP) {
   1151       1.1  kiyohara 		sdev->status = SBP_DEV_ATTACHED;
   1152       1.1  kiyohara 	} else {
   1153       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1154       1.1  kiyohara 		printf("scan failed\n");
   1155       1.1  kiyohara 	}
   1156       1.1  kiyohara 	sdev = sbp_next_dev(target, sdev->lun_id + 1);
   1157       1.1  kiyohara 	if (sdev == NULL) {
   1158       1.1  kiyohara 		free(sxfer, M_SBP);
   1159       1.1  kiyohara 		return;
   1160       1.1  kiyohara 	}
   1161       1.1  kiyohara 	/* reuse sxfer */
   1162       1.1  kiyohara 	xpt_setup_ccb(&sxfer->ccb_h, sdev->path, SCAN_PRI);
   1163       1.1  kiyohara 	sxfer->ccb_h.ccb_sdev_ptr = sdev;
   1164       1.1  kiyohara 	xpt_action(sxfer);
   1165       1.1  kiyohara 	xpt_release_devq(sdev->path, sdev->freeze, TRUE);
   1166       1.1  kiyohara 	sdev->freeze = 1;
   1167       1.1  kiyohara }
   1168       1.1  kiyohara 
   1169       1.1  kiyohara static void
   1170       1.1  kiyohara sbp_cam_scan_target(void *arg)
   1171       1.1  kiyohara {
   1172       1.1  kiyohara 	struct sbp_target *target = (struct sbp_target *)arg;
   1173       1.1  kiyohara 	struct sbp_dev *sdev;
   1174       1.1  kiyohara 	sbp_scsi_xfer *sxfer;
   1175       1.1  kiyohara 
   1176       1.1  kiyohara 	sdev = sbp_next_dev(target, 0);
   1177       1.1  kiyohara 	if (sdev == NULL) {
   1178       1.1  kiyohara 		printf("sbp_cam_scan_target: nothing to do for target%d\n",
   1179       1.1  kiyohara 							target->target_id);
   1180       1.1  kiyohara 		return;
   1181       1.1  kiyohara 	}
   1182       1.1  kiyohara SBP_DEBUG(0)
   1183       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1184       1.1  kiyohara 	printf("sbp_cam_scan_target\n");
   1185       1.1  kiyohara END_DEBUG
   1186       1.1  kiyohara 	sxfer = malloc(sizeof(sbp_scsi_xfer), M_SBP, M_NOWAIT | M_ZERO);
   1187       1.1  kiyohara 	if (sxfer == NULL) {
   1188       1.1  kiyohara 		printf("sbp_cam_scan_target: malloc failed\n");
   1189       1.1  kiyohara 		return;
   1190       1.1  kiyohara 	}
   1191       1.1  kiyohara 	xpt_setup_ccb(&sxfer->ccb_h, sdev->path, SCAN_PRI);
   1192       1.1  kiyohara 	sxfer->ccb_h.func_code = XPT_SCAN_LUN;
   1193       1.1  kiyohara 	sxfer->ccb_h.cbfcnp = sbp_cam_scan_lun;
   1194       1.1  kiyohara 	sxfer->ccb_h.flags |= CAM_DEV_QFREEZE;
   1195       1.1  kiyohara 	sxfer->crcn.flags = CAM_FLAG_NONE;
   1196       1.1  kiyohara 	sxfer->ccb_h.ccb_sdev_ptr = sdev;
   1197       1.1  kiyohara 
   1198       1.1  kiyohara 	/* The scan is in progress now. */
   1199      1.19  kiyohara 	SBP_LOCK(target->sbp);
   1200       1.1  kiyohara 	xpt_action(sxfer);
   1201       1.1  kiyohara 	xpt_release_devq(sdev->path, sdev->freeze, TRUE);
   1202       1.1  kiyohara 	sdev->freeze = 1;
   1203      1.19  kiyohara 	SBP_UNLOCK(target->sbp);
   1204       1.1  kiyohara }
   1205       1.1  kiyohara 
   1206       1.4     perry static inline void
   1207       1.1  kiyohara sbp_scan_dev(struct sbp_dev *sdev)
   1208       1.1  kiyohara {
   1209       1.1  kiyohara 	sdev->status = SBP_DEV_PROBE;
   1210      1.19  kiyohara 	fw_callout_reset(&sdev->target->scan_callout, scan_delay * hz / 1000,
   1211       1.1  kiyohara 			sbp_cam_scan_target, (void *)sdev->target);
   1212       1.1  kiyohara }
   1213  1.20.8.1       mjf #elif defined(__NetBSD__)
   1214       1.1  kiyohara static void
   1215       1.1  kiyohara sbp_scsipi_scan_target(void *arg)
   1216       1.1  kiyohara {
   1217       1.1  kiyohara 	struct sbp_target *target = (struct sbp_target *)arg;
   1218       1.1  kiyohara 	struct sbp_softc *sbp = target->sbp;
   1219       1.1  kiyohara 	struct sbp_dev *sdev;
   1220       1.1  kiyohara 	struct scsipi_channel *chan = &sbp->sc_channel;
   1221  1.20.8.1       mjf 	struct scsibus_softc *sc_bus = device_private(sbp->sc_bus);
   1222       1.1  kiyohara 	int lun, yet;
   1223       1.1  kiyohara 
   1224       1.1  kiyohara 	do {
   1225       1.1  kiyohara 		tsleep(target, PWAIT|PCATCH, "-", 0);
   1226       1.1  kiyohara 		yet = 0;
   1227       1.1  kiyohara 
   1228       1.1  kiyohara 		for (lun = 0; lun < target->num_lun; lun ++) {
   1229       1.1  kiyohara 			sdev = target->luns[lun];
   1230       1.1  kiyohara 			if (sdev == NULL)
   1231       1.1  kiyohara 				continue;
   1232       1.1  kiyohara 			if (sdev->status != SBP_DEV_PROBE) {
   1233       1.1  kiyohara 				yet ++;
   1234       1.1  kiyohara 				continue;
   1235       1.1  kiyohara 			}
   1236       1.1  kiyohara 
   1237       1.1  kiyohara 			if (sdev->periph == NULL) {
   1238       1.1  kiyohara 				if (chan->chan_nluns < target->num_lun)
   1239       1.1  kiyohara 					chan->chan_nluns = target->num_lun;
   1240       1.1  kiyohara 
   1241       1.1  kiyohara 				scsi_probe_bus(sc_bus,
   1242       1.1  kiyohara 				    target->target_id, sdev->lun_id);
   1243       1.1  kiyohara 				sdev->periph = scsipi_lookup_periph(
   1244       1.1  kiyohara 				    chan, target->target_id, lun);
   1245       1.1  kiyohara 			}
   1246       1.1  kiyohara 			sdev->status = SBP_DEV_ATTACHED;
   1247       1.1  kiyohara 		}
   1248       1.1  kiyohara 	} while (yet > 0);
   1249       1.1  kiyohara 
   1250      1.17        ad 	sbp->lwp = NULL;
   1251       1.1  kiyohara 	kthread_exit(0);
   1252       1.1  kiyohara }
   1253       1.1  kiyohara 
   1254       1.4     perry static inline void
   1255       1.1  kiyohara sbp_scan_dev(struct sbp_dev *sdev)
   1256       1.1  kiyohara {
   1257       1.1  kiyohara 	sdev->status = SBP_DEV_PROBE;
   1258       1.1  kiyohara 	wakeup(sdev->target);
   1259       1.1  kiyohara }
   1260       1.1  kiyohara #endif
   1261       1.1  kiyohara 
   1262       1.1  kiyohara 
   1263       1.1  kiyohara static void
   1264       1.1  kiyohara sbp_do_attach(struct fw_xfer *xfer)
   1265       1.1  kiyohara {
   1266       1.1  kiyohara 	struct sbp_dev *sdev;
   1267       1.1  kiyohara 	struct sbp_target *target;
   1268       1.1  kiyohara 	struct sbp_softc *sbp;
   1269       1.1  kiyohara 
   1270       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1271       1.1  kiyohara 	target = sdev->target;
   1272       1.1  kiyohara 	sbp = target->sbp;
   1273       1.1  kiyohara 
   1274       1.1  kiyohara SBP_DEBUG(0)
   1275       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1276       1.1  kiyohara 	printf("sbp_do_attach\n");
   1277       1.1  kiyohara END_DEBUG
   1278       1.1  kiyohara 	sbp_xfer_free(xfer);
   1279       1.1  kiyohara 
   1280       1.1  kiyohara #if defined(__FreeBSD__)
   1281       1.1  kiyohara 	if (sdev->path == NULL)
   1282       1.1  kiyohara 		xpt_create_path(&sdev->path, xpt_periph,
   1283       1.1  kiyohara 			cam_sim_path(target->sbp->sim),
   1284       1.1  kiyohara 			target->target_id, sdev->lun_id);
   1285       1.1  kiyohara 
   1286       1.1  kiyohara 	/*
   1287       1.1  kiyohara 	 * Let CAM scan the bus if we are in the boot process.
   1288       1.1  kiyohara 	 * XXX xpt_scan_bus cannot detect LUN larger than 0
   1289       1.1  kiyohara 	 * if LUN 0 doesn't exists.
   1290       1.1  kiyohara 	 */
   1291       1.1  kiyohara 	if (sbp_cold > 0) {
   1292       1.1  kiyohara 		sdev->status = SBP_DEV_ATTACHED;
   1293       1.1  kiyohara 		return;
   1294       1.1  kiyohara 	}
   1295       1.1  kiyohara #endif
   1296       1.1  kiyohara 
   1297       1.1  kiyohara 	sbp_scan_dev(sdev);
   1298       1.1  kiyohara 	return;
   1299       1.1  kiyohara }
   1300       1.1  kiyohara 
   1301       1.1  kiyohara static void
   1302       1.1  kiyohara sbp_agent_reset_callback(struct fw_xfer *xfer)
   1303       1.1  kiyohara {
   1304       1.1  kiyohara 	struct sbp_dev *sdev;
   1305       1.1  kiyohara 
   1306       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1307       1.1  kiyohara SBP_DEBUG(1)
   1308       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1309       1.1  kiyohara 	printf("%s\n", __func__);
   1310       1.1  kiyohara END_DEBUG
   1311       1.1  kiyohara 	if (xfer->resp != 0) {
   1312       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1313       1.1  kiyohara 		printf("%s: resp=%d\n", __func__, xfer->resp);
   1314       1.1  kiyohara 	}
   1315       1.1  kiyohara 
   1316       1.1  kiyohara 	sbp_xfer_free(xfer);
   1317       1.1  kiyohara 	if (SBP_DEVICE(sdev)) {
   1318      1.19  kiyohara 		SBP_LOCK(sdev->target->sbp);
   1319       1.1  kiyohara 		SBP_DEVICE_THAW(sdev, sdev->freeze);
   1320       1.1  kiyohara 		sdev->freeze = 0;
   1321      1.19  kiyohara 		SBP_UNLOCK(sdev->target->sbp);
   1322       1.1  kiyohara 	}
   1323       1.1  kiyohara }
   1324       1.1  kiyohara 
   1325       1.1  kiyohara static void
   1326       1.1  kiyohara sbp_agent_reset(struct sbp_dev *sdev)
   1327       1.1  kiyohara {
   1328       1.1  kiyohara 	struct fw_xfer *xfer;
   1329       1.1  kiyohara 	struct fw_pkt *fp;
   1330       1.1  kiyohara 
   1331       1.1  kiyohara SBP_DEBUG(0)
   1332       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1333       1.1  kiyohara 	printf("sbp_agent_reset\n");
   1334       1.1  kiyohara END_DEBUG
   1335       1.1  kiyohara 	xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x04);
   1336       1.1  kiyohara 	if (xfer == NULL)
   1337       1.1  kiyohara 		return;
   1338       1.1  kiyohara 	if (sdev->status == SBP_DEV_ATTACHED || sdev->status == SBP_DEV_PROBE)
   1339       1.1  kiyohara 		xfer->hand = sbp_agent_reset_callback;
   1340       1.1  kiyohara 	else
   1341       1.1  kiyohara 		xfer->hand = sbp_do_attach;
   1342       1.1  kiyohara 	fp = &xfer->send.hdr;
   1343       1.1  kiyohara 	fp->mode.wreqq.data = htonl(0xf);
   1344       1.1  kiyohara 	fw_asyreq(xfer->fc, -1, xfer);
   1345       1.1  kiyohara 	sbp_abort_all_ocbs(sdev, XS_BDR_SENT);
   1346       1.1  kiyohara }
   1347       1.1  kiyohara 
   1348       1.1  kiyohara static void
   1349       1.1  kiyohara sbp_busy_timeout_callback(struct fw_xfer *xfer)
   1350       1.1  kiyohara {
   1351       1.1  kiyohara 	struct sbp_dev *sdev;
   1352       1.1  kiyohara 
   1353       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1354       1.1  kiyohara SBP_DEBUG(1)
   1355       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1356       1.1  kiyohara 	printf("sbp_busy_timeout_callback\n");
   1357       1.1  kiyohara END_DEBUG
   1358       1.1  kiyohara 	sbp_xfer_free(xfer);
   1359       1.1  kiyohara 	sbp_agent_reset(sdev);
   1360       1.1  kiyohara }
   1361       1.1  kiyohara 
   1362       1.1  kiyohara static void
   1363       1.1  kiyohara sbp_busy_timeout(struct sbp_dev *sdev)
   1364       1.1  kiyohara {
   1365       1.1  kiyohara 	struct fw_pkt *fp;
   1366       1.1  kiyohara 	struct fw_xfer *xfer;
   1367       1.1  kiyohara SBP_DEBUG(0)
   1368       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1369       1.1  kiyohara 	printf("sbp_busy_timeout\n");
   1370       1.1  kiyohara END_DEBUG
   1371       1.1  kiyohara 	xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0);
   1372       1.1  kiyohara 
   1373       1.1  kiyohara 	xfer->hand = sbp_busy_timeout_callback;
   1374       1.1  kiyohara 	fp = &xfer->send.hdr;
   1375       1.1  kiyohara 	fp->mode.wreqq.dest_hi = 0xffff;
   1376       1.1  kiyohara 	fp->mode.wreqq.dest_lo = 0xf0000000 | BUSY_TIMEOUT;
   1377       1.1  kiyohara 	fp->mode.wreqq.data = htonl((1 << (13+12)) | 0xf);
   1378       1.1  kiyohara 	fw_asyreq(xfer->fc, -1, xfer);
   1379       1.1  kiyohara }
   1380       1.1  kiyohara 
   1381       1.1  kiyohara static void
   1382       1.1  kiyohara sbp_orb_pointer_callback(struct fw_xfer *xfer)
   1383       1.1  kiyohara {
   1384       1.1  kiyohara 	struct sbp_dev *sdev;
   1385       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1386       1.1  kiyohara 
   1387       1.1  kiyohara SBP_DEBUG(1)
   1388       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1389       1.1  kiyohara 	printf("%s\n", __func__);
   1390       1.1  kiyohara END_DEBUG
   1391       1.1  kiyohara 	if (xfer->resp != 0) {
   1392       1.1  kiyohara 		/* XXX */
   1393       1.1  kiyohara 		printf("%s: xfer->resp = %d\n", __func__, xfer->resp);
   1394       1.1  kiyohara 	}
   1395       1.1  kiyohara 	sbp_xfer_free(xfer);
   1396       1.1  kiyohara 	sdev->flags &= ~ORB_POINTER_ACTIVE;
   1397       1.1  kiyohara 
   1398       1.1  kiyohara 	if ((sdev->flags & ORB_POINTER_NEED) != 0) {
   1399       1.1  kiyohara 		struct sbp_ocb *ocb;
   1400       1.1  kiyohara 
   1401       1.1  kiyohara 		sdev->flags &= ~ORB_POINTER_NEED;
   1402       1.1  kiyohara 		ocb = STAILQ_FIRST(&sdev->ocbs);
   1403       1.1  kiyohara 		if (ocb != NULL)
   1404       1.1  kiyohara 			sbp_orb_pointer(sdev, ocb);
   1405       1.1  kiyohara 	}
   1406       1.1  kiyohara 	return;
   1407       1.1  kiyohara }
   1408       1.1  kiyohara 
   1409       1.1  kiyohara static void
   1410       1.1  kiyohara sbp_orb_pointer(struct sbp_dev *sdev, struct sbp_ocb *ocb)
   1411       1.1  kiyohara {
   1412       1.1  kiyohara 	struct fw_xfer *xfer;
   1413       1.1  kiyohara 	struct fw_pkt *fp;
   1414       1.1  kiyohara SBP_DEBUG(1)
   1415       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1416       1.1  kiyohara 	printf("%s: 0x%08x\n", __func__, (uint32_t)ocb->bus_addr);
   1417       1.1  kiyohara END_DEBUG
   1418       1.1  kiyohara 
   1419       1.1  kiyohara 	if ((sdev->flags & ORB_POINTER_ACTIVE) != 0) {
   1420       1.1  kiyohara SBP_DEBUG(0)
   1421       1.1  kiyohara 		printf("%s: orb pointer active\n", __func__);
   1422       1.1  kiyohara END_DEBUG
   1423       1.1  kiyohara 		sdev->flags |= ORB_POINTER_NEED;
   1424       1.1  kiyohara 		return;
   1425       1.1  kiyohara 	}
   1426       1.1  kiyohara 
   1427       1.1  kiyohara 	sdev->flags |= ORB_POINTER_ACTIVE;
   1428       1.1  kiyohara 	xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0x08);
   1429       1.1  kiyohara 	if (xfer == NULL)
   1430       1.1  kiyohara 		return;
   1431       1.1  kiyohara 	xfer->hand = sbp_orb_pointer_callback;
   1432       1.1  kiyohara 
   1433       1.1  kiyohara 	fp = &xfer->send.hdr;
   1434       1.1  kiyohara 	fp->mode.wreqb.len = 8;
   1435       1.1  kiyohara 	fp->mode.wreqb.extcode = 0;
   1436       1.1  kiyohara 	xfer->send.payload[0] =
   1437       1.1  kiyohara 		htonl(((sdev->target->sbp->fd.fc->nodeid | FWLOCALBUS )<< 16));
   1438       1.1  kiyohara 	xfer->send.payload[1] = htonl((uint32_t)ocb->bus_addr);
   1439       1.1  kiyohara 
   1440       1.1  kiyohara 	if(fw_asyreq(xfer->fc, -1, xfer) != 0){
   1441       1.1  kiyohara 			sbp_xfer_free(xfer);
   1442       1.1  kiyohara 			SCSI_XFER_ERROR(ocb->sxfer) = XS_REQ_INVALID;
   1443       1.1  kiyohara 			SCSI_TRANSFER_DONE(ocb->sxfer);
   1444       1.1  kiyohara 	}
   1445       1.1  kiyohara }
   1446       1.1  kiyohara 
   1447       1.1  kiyohara static void
   1448       1.1  kiyohara sbp_doorbell_callback(struct fw_xfer *xfer)
   1449       1.1  kiyohara {
   1450       1.1  kiyohara 	struct sbp_dev *sdev;
   1451       1.1  kiyohara 	sdev = (struct sbp_dev *)xfer->sc;
   1452       1.1  kiyohara 
   1453       1.1  kiyohara SBP_DEBUG(1)
   1454       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1455       1.1  kiyohara 	printf("sbp_doorbell_callback\n");
   1456       1.1  kiyohara END_DEBUG
   1457       1.1  kiyohara 	if (xfer->resp != 0) {
   1458       1.1  kiyohara 		/* XXX */
   1459       1.1  kiyohara 		printf("%s: xfer->resp = %d\n", __func__, xfer->resp);
   1460       1.1  kiyohara 	}
   1461       1.1  kiyohara 	sbp_xfer_free(xfer);
   1462       1.1  kiyohara 	sdev->flags &= ~ORB_DOORBELL_ACTIVE;
   1463       1.1  kiyohara 	if ((sdev->flags & ORB_DOORBELL_NEED) != 0) {
   1464       1.1  kiyohara 		sdev->flags &= ~ORB_DOORBELL_NEED;
   1465       1.1  kiyohara 		sbp_doorbell(sdev);
   1466       1.1  kiyohara 	}
   1467       1.1  kiyohara 	return;
   1468       1.1  kiyohara }
   1469       1.1  kiyohara 
   1470       1.1  kiyohara static void
   1471       1.1  kiyohara sbp_doorbell(struct sbp_dev *sdev)
   1472       1.1  kiyohara {
   1473       1.1  kiyohara 	struct fw_xfer *xfer;
   1474       1.1  kiyohara 	struct fw_pkt *fp;
   1475       1.1  kiyohara SBP_DEBUG(1)
   1476       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1477       1.1  kiyohara 	printf("sbp_doorbell\n");
   1478       1.1  kiyohara END_DEBUG
   1479       1.1  kiyohara 
   1480       1.1  kiyohara 	if ((sdev->flags & ORB_DOORBELL_ACTIVE) != 0) {
   1481       1.1  kiyohara 		sdev->flags |= ORB_DOORBELL_NEED;
   1482       1.1  kiyohara 		return;
   1483       1.1  kiyohara 	}
   1484       1.1  kiyohara 	sdev->flags |= ORB_DOORBELL_ACTIVE;
   1485       1.1  kiyohara 	xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x10);
   1486       1.1  kiyohara 	if (xfer == NULL)
   1487       1.1  kiyohara 		return;
   1488       1.1  kiyohara 	xfer->hand = sbp_doorbell_callback;
   1489       1.1  kiyohara 	fp = &xfer->send.hdr;
   1490       1.1  kiyohara 	fp->mode.wreqq.data = htonl(0xf);
   1491       1.1  kiyohara 	fw_asyreq(xfer->fc, -1, xfer);
   1492       1.1  kiyohara }
   1493       1.1  kiyohara 
   1494       1.1  kiyohara static struct fw_xfer *
   1495       1.1  kiyohara sbp_write_cmd(struct sbp_dev *sdev, int tcode, int offset)
   1496       1.1  kiyohara {
   1497       1.1  kiyohara 	struct fw_xfer *xfer;
   1498       1.1  kiyohara 	struct fw_pkt *fp;
   1499       1.1  kiyohara 	struct sbp_target *target;
   1500       1.1  kiyohara 	int s, new = 0;
   1501       1.1  kiyohara 
   1502       1.1  kiyohara 	target = sdev->target;
   1503       1.1  kiyohara 	s = splfw();
   1504       1.1  kiyohara 	xfer = STAILQ_FIRST(&target->xferlist);
   1505       1.1  kiyohara 	if (xfer == NULL) {
   1506       1.1  kiyohara 		if (target->n_xfer > 5 /* XXX */) {
   1507       1.1  kiyohara 			printf("sbp: no more xfer for this target\n");
   1508       1.1  kiyohara 			splx(s);
   1509       1.1  kiyohara 			return(NULL);
   1510       1.1  kiyohara 		}
   1511       1.1  kiyohara 		xfer = fw_xfer_alloc_buf(M_SBP, 8, 0);
   1512       1.1  kiyohara 		if(xfer == NULL){
   1513       1.1  kiyohara 			printf("sbp: fw_xfer_alloc_buf failed\n");
   1514       1.1  kiyohara 			splx(s);
   1515       1.1  kiyohara 			return NULL;
   1516       1.1  kiyohara 		}
   1517       1.1  kiyohara 		target->n_xfer ++;
   1518       1.1  kiyohara 		if (debug)
   1519       1.1  kiyohara 			printf("sbp: alloc %d xfer\n", target->n_xfer);
   1520       1.1  kiyohara 		new = 1;
   1521       1.1  kiyohara 	} else {
   1522       1.1  kiyohara 		STAILQ_REMOVE_HEAD(&target->xferlist, link);
   1523       1.1  kiyohara 	}
   1524       1.1  kiyohara 	splx(s);
   1525       1.1  kiyohara 
   1526       1.1  kiyohara 	microtime(&xfer->tv);
   1527       1.1  kiyohara 
   1528       1.1  kiyohara 	if (new) {
   1529       1.1  kiyohara 		xfer->recv.pay_len = 0;
   1530       1.1  kiyohara 		xfer->send.spd = min(sdev->target->fwdev->speed, max_speed);
   1531       1.1  kiyohara 		xfer->fc = sdev->target->sbp->fd.fc;
   1532       1.1  kiyohara 	}
   1533       1.1  kiyohara 
   1534       1.1  kiyohara 	if (tcode == FWTCODE_WREQB)
   1535       1.1  kiyohara 		xfer->send.pay_len = 8;
   1536       1.1  kiyohara 	else
   1537       1.1  kiyohara 		xfer->send.pay_len = 0;
   1538       1.1  kiyohara 
   1539      1.15  christos 	xfer->sc = (void *)sdev;
   1540       1.1  kiyohara 	fp = &xfer->send.hdr;
   1541       1.1  kiyohara 	fp->mode.wreqq.dest_hi = sdev->login->cmd_hi;
   1542       1.1  kiyohara 	fp->mode.wreqq.dest_lo = sdev->login->cmd_lo + offset;
   1543       1.1  kiyohara 	fp->mode.wreqq.tlrt = 0;
   1544       1.1  kiyohara 	fp->mode.wreqq.tcode = tcode;
   1545       1.1  kiyohara 	fp->mode.wreqq.pri = 0;
   1546       1.1  kiyohara 	fp->mode.wreqq.dst = FWLOCALBUS | sdev->target->fwdev->dst;
   1547       1.1  kiyohara 
   1548       1.1  kiyohara 	return xfer;
   1549       1.1  kiyohara }
   1550       1.1  kiyohara 
   1551       1.1  kiyohara static void
   1552       1.1  kiyohara sbp_mgm_orb(struct sbp_dev *sdev, int func, struct sbp_ocb *aocb)
   1553       1.1  kiyohara {
   1554       1.1  kiyohara 	struct fw_xfer *xfer;
   1555       1.1  kiyohara 	struct fw_pkt *fp;
   1556       1.1  kiyohara 	struct sbp_ocb *ocb;
   1557       1.1  kiyohara 	struct sbp_target *target;
   1558       1.1  kiyohara 	int s, nid, dv_unit;
   1559       1.1  kiyohara 
   1560       1.1  kiyohara 	target = sdev->target;
   1561       1.1  kiyohara 	nid = target->sbp->fd.fc->nodeid | FWLOCALBUS;
   1562      1.19  kiyohara 	dv_unit = fw_get_unit(target->sbp->fd.dev);
   1563       1.1  kiyohara 
   1564       1.1  kiyohara 	s = splfw();
   1565      1.19  kiyohara 	SBP_LOCK(target->sbp);
   1566       1.1  kiyohara 	if (func == ORB_FUN_RUNQUEUE) {
   1567       1.1  kiyohara 		ocb = STAILQ_FIRST(&target->mgm_ocb_queue);
   1568       1.1  kiyohara 		if (target->mgm_ocb_cur != NULL || ocb == NULL) {
   1569      1.19  kiyohara 			SBP_UNLOCK(target->sbp);
   1570       1.1  kiyohara 			splx(s);
   1571       1.1  kiyohara 			return;
   1572       1.1  kiyohara 		}
   1573       1.1  kiyohara 		STAILQ_REMOVE_HEAD(&target->mgm_ocb_queue, ocb);
   1574      1.19  kiyohara 		SBP_UNLOCK(target->sbp);
   1575       1.1  kiyohara 		goto start;
   1576       1.1  kiyohara 	}
   1577       1.1  kiyohara 	if ((ocb = sbp_get_ocb(sdev)) == NULL) {
   1578      1.19  kiyohara 		SBP_UNLOCK(target->sbp);
   1579       1.1  kiyohara 		splx(s);
   1580       1.1  kiyohara 		/* XXX */
   1581       1.1  kiyohara 		return;
   1582       1.1  kiyohara 	}
   1583      1.19  kiyohara 	SBP_UNLOCK(target->sbp);
   1584       1.1  kiyohara 	ocb->flags = OCB_ACT_MGM;
   1585       1.1  kiyohara 	ocb->sdev = sdev;
   1586       1.1  kiyohara 
   1587       1.1  kiyohara 	bzero((void *)ocb->orb, sizeof(ocb->orb));
   1588       1.1  kiyohara 	ocb->orb[6] = htonl((nid << 16) | SBP_BIND_HI);
   1589       1.1  kiyohara 	ocb->orb[7] = htonl(SBP_DEV2ADDR(dv_unit, sdev->lun_id));
   1590       1.1  kiyohara 
   1591       1.1  kiyohara SBP_DEBUG(0)
   1592       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1593       1.1  kiyohara 	printf("%s\n", orb_fun_name[(func>>16)&0xf]);
   1594       1.1  kiyohara END_DEBUG
   1595       1.1  kiyohara 	switch (func) {
   1596       1.1  kiyohara 	case ORB_FUN_LGI:
   1597       1.1  kiyohara 		ocb->orb[0] = ocb->orb[1] = 0; /* password */
   1598       1.1  kiyohara 		ocb->orb[2] = htonl(nid << 16);
   1599       1.1  kiyohara 		ocb->orb[3] = htonl(sdev->dma.bus_addr);
   1600       1.1  kiyohara 		ocb->orb[4] = htonl(ORB_NOTIFY | sdev->lun_id);
   1601       1.1  kiyohara 		if (ex_login)
   1602       1.1  kiyohara 			ocb->orb[4] |= htonl(ORB_EXV);
   1603       1.1  kiyohara 		ocb->orb[5] = htonl(SBP_LOGIN_SIZE);
   1604       1.1  kiyohara 		break;
   1605       1.1  kiyohara 	case ORB_FUN_ATA:
   1606       1.1  kiyohara 		ocb->orb[0] = htonl((0 << 16) | 0);
   1607       1.1  kiyohara 		ocb->orb[1] = htonl(aocb->bus_addr & 0xffffffff);
   1608       1.1  kiyohara 		/* fall through */
   1609       1.1  kiyohara 	case ORB_FUN_RCN:
   1610       1.1  kiyohara 	case ORB_FUN_LGO:
   1611       1.1  kiyohara 	case ORB_FUN_LUR:
   1612       1.1  kiyohara 	case ORB_FUN_RST:
   1613       1.1  kiyohara 	case ORB_FUN_ATS:
   1614       1.1  kiyohara 		ocb->orb[4] = htonl(ORB_NOTIFY | func | sdev->login->id);
   1615       1.1  kiyohara 		break;
   1616       1.1  kiyohara 	}
   1617       1.1  kiyohara 
   1618       1.1  kiyohara 	if (target->mgm_ocb_cur != NULL) {
   1619       1.1  kiyohara 		/* there is a standing ORB */
   1620      1.19  kiyohara 		SBP_LOCK(target->sbp);
   1621       1.1  kiyohara 		STAILQ_INSERT_TAIL(&sdev->target->mgm_ocb_queue, ocb, ocb);
   1622      1.19  kiyohara 		SBP_UNLOCK(target->sbp);
   1623       1.1  kiyohara 		splx(s);
   1624       1.1  kiyohara 		return;
   1625       1.1  kiyohara 	}
   1626       1.1  kiyohara start:
   1627       1.1  kiyohara 	target->mgm_ocb_cur = ocb;
   1628       1.1  kiyohara 	splx(s);
   1629       1.1  kiyohara 
   1630      1.19  kiyohara 	fw_callout_reset(&target->mgm_ocb_timeout, 5*hz,
   1631      1.15  christos 				sbp_mgm_timeout, (void *)ocb);
   1632       1.1  kiyohara 	xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0);
   1633       1.1  kiyohara 	if(xfer == NULL){
   1634       1.1  kiyohara 		return;
   1635       1.1  kiyohara 	}
   1636       1.1  kiyohara 	xfer->hand = sbp_mgm_callback;
   1637       1.1  kiyohara 
   1638       1.1  kiyohara 	fp = &xfer->send.hdr;
   1639       1.1  kiyohara 	fp->mode.wreqb.dest_hi = sdev->target->mgm_hi;
   1640       1.1  kiyohara 	fp->mode.wreqb.dest_lo = sdev->target->mgm_lo;
   1641       1.1  kiyohara 	fp->mode.wreqb.len = 8;
   1642       1.1  kiyohara 	fp->mode.wreqb.extcode = 0;
   1643       1.1  kiyohara 	xfer->send.payload[0] = htonl(nid << 16);
   1644       1.1  kiyohara 	xfer->send.payload[1] = htonl(ocb->bus_addr & 0xffffffff);
   1645       1.1  kiyohara SBP_DEBUG(0)
   1646       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1647       1.1  kiyohara 	printf("mgm orb: %08x\n", (uint32_t)ocb->bus_addr);
   1648       1.1  kiyohara END_DEBUG
   1649       1.1  kiyohara 
   1650       1.1  kiyohara 	/* cache writeback & invalidate(required ORB_FUN_LGI func) */
   1651       1.1  kiyohara 	/* when abort_ocb, should sync POST ope ? */
   1652       1.1  kiyohara 	fwdma_sync(&sdev->dma, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
   1653       1.1  kiyohara 	fw_asyreq(xfer->fc, -1, xfer);
   1654       1.1  kiyohara }
   1655       1.1  kiyohara 
   1656       1.1  kiyohara static void
   1657       1.1  kiyohara sbp_print_scsi_cmd(struct sbp_ocb *ocb)
   1658       1.1  kiyohara {
   1659       1.1  kiyohara #if defined(__FreeBSD__)
   1660       1.1  kiyohara 	struct ccb_scsiio *csio;
   1661       1.1  kiyohara 
   1662       1.1  kiyohara 	csio = &ocb->sxfer->csio;
   1663       1.1  kiyohara #endif
   1664       1.1  kiyohara 	printf("%s:%d:%d XPT_SCSI_IO: "
   1665       1.1  kiyohara 		"cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x"
   1666       1.1  kiyohara 		", flags: 0x%02x, "
   1667       1.1  kiyohara 		"%db cmd/%db data/%db sense\n",
   1668      1.19  kiyohara 		fw_get_nameunit(ocb->sdev->target->sbp->fd.dev),
   1669       1.1  kiyohara 		SCSI_XFER_TARGET(ocb->sxfer), SCSI_XFER_LUN(ocb->sxfer),
   1670       1.1  kiyohara 		SCSI_XFER_10BCMD_DUMP(ocb->sxfer),
   1671       1.1  kiyohara 		SCSI_XFER_DIR(ocb->sxfer),
   1672       1.1  kiyohara 		SCSI_XFER_CMDLEN(ocb->sxfer), SCSI_XFER_DATALEN(ocb->sxfer),
   1673       1.1  kiyohara 		SCSI_XFER_SENSELEN(ocb->sxfer));
   1674       1.1  kiyohara }
   1675       1.1  kiyohara 
   1676       1.1  kiyohara static void
   1677       1.1  kiyohara sbp_scsi_status(struct sbp_status *sbp_status, struct sbp_ocb *ocb)
   1678       1.1  kiyohara {
   1679       1.1  kiyohara 	struct sbp_cmd_status *sbp_cmd_status;
   1680       1.1  kiyohara 	scsi3_sense_data_t sense =
   1681       1.1  kiyohara 	    (scsi3_sense_data_t)SCSI_SENSE_DATA(ocb->sxfer);
   1682       1.1  kiyohara 
   1683       1.1  kiyohara 	sbp_cmd_status = (struct sbp_cmd_status *)sbp_status->data;
   1684       1.1  kiyohara 
   1685       1.1  kiyohara SBP_DEBUG(0)
   1686       1.1  kiyohara 	sbp_print_scsi_cmd(ocb);
   1687       1.1  kiyohara 	/* XXX need decode status */
   1688       1.1  kiyohara 	sbp_show_sdev_info(ocb->sdev, 2);
   1689       1.1  kiyohara 	printf("SCSI status %x sfmt %x valid %x key %x code %x qlfr %x len %d\n",
   1690       1.1  kiyohara 		sbp_cmd_status->status,
   1691       1.1  kiyohara 		sbp_cmd_status->sfmt,
   1692       1.1  kiyohara 		sbp_cmd_status->valid,
   1693       1.1  kiyohara 		sbp_cmd_status->s_key,
   1694       1.1  kiyohara 		sbp_cmd_status->s_code,
   1695       1.1  kiyohara 		sbp_cmd_status->s_qlfr,
   1696       1.1  kiyohara 		sbp_status->len
   1697       1.1  kiyohara 	);
   1698       1.1  kiyohara END_DEBUG
   1699       1.1  kiyohara 
   1700       1.1  kiyohara 	switch (sbp_cmd_status->status) {
   1701       1.1  kiyohara 	case SCSI_STATUS_CHECK_COND:
   1702       1.1  kiyohara 	case SCSI_STATUS_BUSY:
   1703       1.1  kiyohara 	case SCSI_STATUS_CMD_TERMINATED:
   1704       1.1  kiyohara 		if(sbp_cmd_status->sfmt == SBP_SFMT_CURR){
   1705       1.1  kiyohara 			sense->response_code = SSD_CURRENT_ERROR;
   1706       1.1  kiyohara 		}else{
   1707       1.1  kiyohara 			sense->response_code = SSD_DEFERRED_ERROR;
   1708       1.1  kiyohara 		}
   1709       1.1  kiyohara 		if(sbp_cmd_status->valid)
   1710       1.1  kiyohara 			sense->response_code |= SSD_RESPONSE_CODE_VALID;
   1711       1.1  kiyohara 		sense->flags = sbp_cmd_status->s_key;
   1712       1.1  kiyohara 		if(sbp_cmd_status->mark)
   1713       1.1  kiyohara 			sense->flags |= SSD_FILEMARK;
   1714       1.1  kiyohara 		if(sbp_cmd_status->eom)
   1715       1.1  kiyohara 			sense->flags |= SSD_EOM;
   1716       1.1  kiyohara 		if(sbp_cmd_status->ill_len)
   1717       1.1  kiyohara 			sense->flags |= SSD_ILI;
   1718       1.1  kiyohara 
   1719       1.5       wiz 		bcopy(&sbp_cmd_status->info, &sense->information[0], 4);
   1720       1.1  kiyohara 
   1721       1.1  kiyohara 		if (sbp_status->len <= 1)
   1722       1.1  kiyohara 			/* XXX not scsi status. shouldn't be happened */
   1723       1.1  kiyohara 			sense->asl = 0;
   1724       1.1  kiyohara 		else if (sbp_status->len <= 4)
   1725       1.1  kiyohara 			/* add_sense_code(_qual), info, cmd_spec_info */
   1726       1.1  kiyohara 			sense->asl = 6;
   1727       1.1  kiyohara 		else
   1728       1.1  kiyohara 			/* fru, sense_key_spec */
   1729       1.1  kiyohara 			sense->asl = 10;
   1730       1.1  kiyohara 
   1731       1.1  kiyohara 		bcopy(&sbp_cmd_status->cdb, &sense->csi[0], 4);
   1732       1.1  kiyohara 
   1733       1.1  kiyohara 		sense->asc = sbp_cmd_status->s_code;
   1734       1.1  kiyohara 		sense->ascq = sbp_cmd_status->s_qlfr;
   1735       1.1  kiyohara 		sense->fruc = sbp_cmd_status->fru;
   1736       1.1  kiyohara 
   1737       1.1  kiyohara 		bcopy(&sbp_cmd_status->s_keydep[0], &sense->sks[0], 3);
   1738       1.1  kiyohara 		SCSI_XFER_ERROR(ocb->sxfer) = XS_SENSE;
   1739       1.1  kiyohara 		SCSI_XFER_STATUS(ocb->sxfer) = sbp_cmd_status->status;
   1740       1.1  kiyohara /*
   1741       1.1  kiyohara {
   1742       1.1  kiyohara 		uint8_t j, *tmp;
   1743       1.1  kiyohara 		tmp = sense;
   1744       1.1  kiyohara 		for( j = 0 ; j < 32 ; j+=8){
   1745       1.1  kiyohara 			printf("sense %02x%02x %02x%02x %02x%02x %02x%02x\n",
   1746       1.1  kiyohara 				tmp[j], tmp[j+1], tmp[j+2], tmp[j+3],
   1747       1.1  kiyohara 				tmp[j+4], tmp[j+5], tmp[j+6], tmp[j+7]);
   1748       1.1  kiyohara 		}
   1749       1.1  kiyohara 
   1750       1.1  kiyohara }
   1751       1.1  kiyohara */
   1752       1.1  kiyohara 		break;
   1753       1.1  kiyohara 	default:
   1754       1.1  kiyohara 		sbp_show_sdev_info(ocb->sdev, 2);
   1755       1.1  kiyohara 		printf("sbp_scsi_status: unknown scsi status 0x%x\n",
   1756       1.1  kiyohara 						sbp_cmd_status->status);
   1757       1.1  kiyohara 	}
   1758       1.1  kiyohara }
   1759       1.1  kiyohara 
   1760       1.1  kiyohara static void
   1761       1.1  kiyohara sbp_fix_inq_data(struct sbp_ocb *ocb)
   1762       1.1  kiyohara {
   1763       1.1  kiyohara 	sbp_scsi_xfer *sxfer = ocb->sxfer;
   1764       1.1  kiyohara 	struct sbp_dev *sdev;
   1765       1.1  kiyohara 	scsi3_inquiry_data_t inq =
   1766       1.1  kiyohara 	    (scsi3_inquiry_data_t)SCSI_INQUIRY_DATA(sxfer);
   1767       1.1  kiyohara 	sdev = ocb->sdev;
   1768       1.1  kiyohara 
   1769       1.1  kiyohara 	if (SCSI_XFER_EVPD(sxfer))
   1770       1.1  kiyohara 		return;
   1771       1.1  kiyohara SBP_DEBUG(1)
   1772       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   1773       1.1  kiyohara 	printf("sbp_fix_inq_data\n");
   1774       1.1  kiyohara END_DEBUG
   1775       1.1  kiyohara 	switch (inq->device & SID_TYPE) {
   1776       1.1  kiyohara 	case T_DIRECT:
   1777       1.1  kiyohara #if 0
   1778       1.1  kiyohara 		/*
   1779       1.1  kiyohara 		 * XXX Convert Direct Access device to RBC.
   1780       1.1  kiyohara 		 * I've never seen FireWire DA devices which support READ_6.
   1781       1.1  kiyohara 		 */
   1782       1.1  kiyohara 		if ((inq->device & SID_TYPE) == T_DIRECT)
   1783       1.1  kiyohara 			inq->device |= T_RBC; /*  T_DIRECT == 0 */
   1784       1.1  kiyohara #endif
   1785       1.1  kiyohara 		/* fall through */
   1786       1.1  kiyohara 	case T_RBC:
   1787       1.1  kiyohara 		/*
   1788       1.1  kiyohara 		 * Override vendor/product/revision information.
   1789       1.1  kiyohara 		 * Some devices sometimes return strange strings.
   1790       1.1  kiyohara 		 */
   1791       1.1  kiyohara #if 1
   1792       1.1  kiyohara 		bcopy(sdev->vendor, inq->vendor, sizeof(inq->vendor));
   1793       1.1  kiyohara 		bcopy(sdev->product, inq->product, sizeof(inq->product));
   1794       1.1  kiyohara 		bcopy(sdev->revision+2, inq->revision, sizeof(inq->revision));
   1795       1.1  kiyohara #endif
   1796       1.1  kiyohara 		break;
   1797       1.1  kiyohara 	}
   1798       1.1  kiyohara 	/*
   1799       1.1  kiyohara 	 * Force to enable/disable tagged queuing.
   1800       1.1  kiyohara 	 * XXX CAM also checks SCP_QUEUE_DQUE flag in the control mode page.
   1801       1.1  kiyohara 	 */
   1802       1.1  kiyohara 	if (sbp_tags > 0)
   1803       1.1  kiyohara 		inq->flags[1] |= SID_CmdQue;
   1804       1.1  kiyohara 	else if (sbp_tags < 0)
   1805       1.1  kiyohara 		inq->flags[1] &= ~SID_CmdQue;
   1806       1.1  kiyohara 
   1807       1.1  kiyohara }
   1808       1.1  kiyohara 
   1809       1.1  kiyohara static void
   1810       1.1  kiyohara sbp_recv1(struct fw_xfer *xfer)
   1811       1.1  kiyohara {
   1812       1.1  kiyohara 	struct fw_pkt *rfp;
   1813       1.1  kiyohara #if NEED_RESPONSE
   1814       1.1  kiyohara 	struct fw_pkt *sfp;
   1815       1.1  kiyohara #endif
   1816       1.1  kiyohara 	struct sbp_softc *sbp;
   1817       1.1  kiyohara 	struct sbp_dev *sdev;
   1818       1.1  kiyohara 	struct sbp_ocb *ocb;
   1819       1.1  kiyohara 	struct sbp_login_res *login_res = NULL;
   1820       1.1  kiyohara 	struct sbp_status *sbp_status;
   1821       1.1  kiyohara 	struct sbp_target *target;
   1822       1.1  kiyohara 	int	orb_fun, status_valid0, status_valid, l, reset_agent = 0;
   1823       1.1  kiyohara 	uint32_t addr;
   1824       1.1  kiyohara /*
   1825       1.1  kiyohara 	uint32_t *ld;
   1826       1.1  kiyohara 	ld = xfer->recv.buf;
   1827       1.1  kiyohara printf("sbp %x %d %d %08x %08x %08x %08x\n",
   1828       1.1  kiyohara 			xfer->resp, xfer->recv.len, xfer->recv.off, ntohl(ld[0]), ntohl(ld[1]), ntohl(ld[2]), ntohl(ld[3]));
   1829       1.1  kiyohara printf("sbp %08x %08x %08x %08x\n", ntohl(ld[4]), ntohl(ld[5]), ntohl(ld[6]), ntohl(ld[7]));
   1830       1.1  kiyohara printf("sbp %08x %08x %08x %08x\n", ntohl(ld[8]), ntohl(ld[9]), ntohl(ld[10]), ntohl(ld[11]));
   1831       1.1  kiyohara */
   1832       1.1  kiyohara 	sbp = (struct sbp_softc *)xfer->sc;
   1833       1.1  kiyohara 	if (xfer->resp != 0){
   1834       1.1  kiyohara 		printf("sbp_recv: xfer->resp = %d\n", xfer->resp);
   1835       1.1  kiyohara 		goto done0;
   1836       1.1  kiyohara 	}
   1837       1.1  kiyohara 	if (xfer->recv.payload == NULL){
   1838       1.1  kiyohara 		printf("sbp_recv: xfer->recv.payload == NULL\n");
   1839       1.1  kiyohara 		goto done0;
   1840       1.1  kiyohara 	}
   1841       1.1  kiyohara 	rfp = &xfer->recv.hdr;
   1842       1.1  kiyohara 	if(rfp->mode.wreqb.tcode != FWTCODE_WREQB){
   1843       1.1  kiyohara 		printf("sbp_recv: tcode = %d\n", rfp->mode.wreqb.tcode);
   1844       1.1  kiyohara 		goto done0;
   1845       1.1  kiyohara 	}
   1846       1.1  kiyohara 	sbp_status = (struct sbp_status *)xfer->recv.payload;
   1847       1.1  kiyohara 	addr = rfp->mode.wreqb.dest_lo;
   1848       1.1  kiyohara SBP_DEBUG(2)
   1849       1.1  kiyohara 	printf("received address 0x%x\n", addr);
   1850       1.1  kiyohara END_DEBUG
   1851       1.1  kiyohara 	target = &sbp->target;
   1852       1.1  kiyohara 	l = SBP_ADDR2LUN(addr);
   1853       1.1  kiyohara 	if (l >= target->num_lun || target->luns[l] == NULL) {
   1854      1.19  kiyohara 		fw_printf(sbp->fd.dev,
   1855       1.1  kiyohara 			"sbp_recv1: invalid lun %d (target=%d)\n",
   1856       1.1  kiyohara 			l, target->target_id);
   1857       1.1  kiyohara 		goto done0;
   1858       1.1  kiyohara 	}
   1859       1.1  kiyohara 	sdev = target->luns[l];
   1860       1.1  kiyohara 
   1861       1.1  kiyohara 	fwdma_sync(&sdev->dma, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
   1862       1.1  kiyohara 
   1863       1.1  kiyohara 	ocb = NULL;
   1864       1.1  kiyohara 	switch (sbp_status->src) {
   1865       1.1  kiyohara 	case SRC_NEXT_EXISTS:
   1866       1.1  kiyohara 	case SRC_NO_NEXT:
   1867       1.1  kiyohara 		/* check mgm_ocb_cur first */
   1868       1.1  kiyohara 		ocb  = target->mgm_ocb_cur;
   1869       1.1  kiyohara 		if (ocb != NULL) {
   1870       1.1  kiyohara 			if (OCB_MATCH(ocb, sbp_status)) {
   1871      1.19  kiyohara 				fw_callout_stop(&target->mgm_ocb_timeout);
   1872       1.1  kiyohara 				target->mgm_ocb_cur = NULL;
   1873       1.1  kiyohara 				break;
   1874       1.1  kiyohara 			}
   1875       1.1  kiyohara 		}
   1876       1.1  kiyohara 		ocb = sbp_dequeue_ocb(sdev, sbp_status);
   1877       1.1  kiyohara 		if (ocb == NULL) {
   1878       1.1  kiyohara 			sbp_show_sdev_info(sdev, 2);
   1879       1.1  kiyohara #if defined(__DragonFly__) || \
   1880       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   1881       1.1  kiyohara 			printf("No ocb(%lx) on the queue\n",
   1882       1.1  kiyohara #else
   1883       1.1  kiyohara 			printf("No ocb(%x) on the queue\n",
   1884       1.1  kiyohara #endif
   1885       1.1  kiyohara 					ntohl(sbp_status->orb_lo));
   1886       1.1  kiyohara 		}
   1887       1.1  kiyohara 		break;
   1888       1.1  kiyohara 	case SRC_UNSOL:
   1889       1.1  kiyohara 		/* unsolicit */
   1890       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1891       1.1  kiyohara 		printf("unsolicit status received\n");
   1892       1.1  kiyohara 		break;
   1893       1.1  kiyohara 	default:
   1894       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1895       1.1  kiyohara 		printf("unknown sbp_status->src\n");
   1896       1.1  kiyohara 	}
   1897       1.1  kiyohara 
   1898       1.1  kiyohara 	status_valid0 = (sbp_status->src < 2
   1899       1.1  kiyohara 			&& sbp_status->resp == SBP_REQ_CMP
   1900       1.1  kiyohara 			&& sbp_status->dead == 0);
   1901       1.1  kiyohara 	status_valid = (status_valid0 && sbp_status->status == 0);
   1902       1.1  kiyohara 
   1903       1.1  kiyohara 	if (!status_valid0 || debug > 2){
   1904       1.1  kiyohara 		int status;
   1905       1.1  kiyohara SBP_DEBUG(0)
   1906       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1907       1.1  kiyohara 		printf("ORB status src:%x resp:%x dead:%x"
   1908       1.1  kiyohara #if defined(__DragonFly__) || \
   1909       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   1910       1.1  kiyohara 				" len:%x stat:%x orb:%x%08lx\n",
   1911       1.1  kiyohara #else
   1912       1.1  kiyohara 				" len:%x stat:%x orb:%x%08x\n",
   1913       1.1  kiyohara #endif
   1914       1.1  kiyohara 			sbp_status->src, sbp_status->resp, sbp_status->dead,
   1915       1.1  kiyohara 			sbp_status->len, sbp_status->status,
   1916       1.1  kiyohara 			ntohs(sbp_status->orb_hi), ntohl(sbp_status->orb_lo));
   1917       1.1  kiyohara END_DEBUG
   1918       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   1919       1.1  kiyohara 		status = sbp_status->status;
   1920       1.1  kiyohara 		switch(sbp_status->resp) {
   1921       1.1  kiyohara 		case SBP_REQ_CMP:
   1922       1.1  kiyohara 			if (status > MAX_ORB_STATUS0)
   1923       1.1  kiyohara 				printf("%s\n", orb_status0[MAX_ORB_STATUS0]);
   1924       1.1  kiyohara 			else
   1925       1.1  kiyohara 				printf("%s\n", orb_status0[status]);
   1926       1.1  kiyohara 			break;
   1927       1.1  kiyohara 		case SBP_TRANS_FAIL:
   1928       1.1  kiyohara 			printf("Obj: %s, Error: %s\n",
   1929       1.1  kiyohara 				orb_status1_object[(status>>6) & 3],
   1930       1.1  kiyohara 				orb_status1_serial_bus_error[status & 0xf]);
   1931       1.1  kiyohara 			break;
   1932       1.1  kiyohara 		case SBP_ILLE_REQ:
   1933       1.1  kiyohara 			printf("Illegal request\n");
   1934       1.1  kiyohara 			break;
   1935       1.1  kiyohara 		case SBP_VEND_DEP:
   1936       1.1  kiyohara 			printf("Vendor dependent\n");
   1937       1.1  kiyohara 			break;
   1938       1.1  kiyohara 		default:
   1939       1.1  kiyohara 			printf("unknown respose code %d\n", sbp_status->resp);
   1940       1.1  kiyohara 		}
   1941       1.1  kiyohara 	}
   1942       1.1  kiyohara 
   1943       1.1  kiyohara 	/* we have to reset the fetch agent if it's dead */
   1944       1.1  kiyohara 	if (sbp_status->dead) {
   1945       1.1  kiyohara 		if (SBP_DEVICE(sdev) != NULL) {
   1946      1.19  kiyohara 			SBP_LOCK(sbp);
   1947       1.1  kiyohara 			SBP_DEVICE_FREEZE(sdev, 1);
   1948       1.1  kiyohara 			sdev->freeze ++;
   1949      1.19  kiyohara 			SBP_UNLOCK(sbp);
   1950       1.1  kiyohara 		}
   1951       1.1  kiyohara 		reset_agent = 1;
   1952       1.1  kiyohara 	}
   1953       1.1  kiyohara 
   1954       1.1  kiyohara 	if (ocb == NULL)
   1955       1.1  kiyohara 		goto done;
   1956       1.1  kiyohara 
   1957       1.1  kiyohara 	switch(ntohl(ocb->orb[4]) & ORB_FMT_MSK){
   1958       1.1  kiyohara 	case ORB_FMT_NOP:
   1959       1.1  kiyohara 		break;
   1960       1.1  kiyohara 	case ORB_FMT_VED:
   1961       1.1  kiyohara 		break;
   1962       1.1  kiyohara 	case ORB_FMT_STD:
   1963       1.1  kiyohara 		switch(ocb->flags) {
   1964       1.1  kiyohara 		case OCB_ACT_MGM:
   1965       1.1  kiyohara 			orb_fun = ntohl(ocb->orb[4]) & ORB_FUN_MSK;
   1966       1.1  kiyohara 			reset_agent = 0;
   1967       1.1  kiyohara 			switch(orb_fun) {
   1968       1.1  kiyohara 			case ORB_FUN_LGI:
   1969       1.1  kiyohara 				login_res = sdev->login;
   1970       1.1  kiyohara 				login_res->len = ntohs(login_res->len);
   1971       1.1  kiyohara 				login_res->id = ntohs(login_res->id);
   1972       1.1  kiyohara 				login_res->cmd_hi = ntohs(login_res->cmd_hi);
   1973       1.1  kiyohara 				login_res->cmd_lo = ntohl(login_res->cmd_lo);
   1974       1.1  kiyohara 				if (status_valid) {
   1975       1.1  kiyohara SBP_DEBUG(0)
   1976       1.1  kiyohara sbp_show_sdev_info(sdev, 2);
   1977       1.1  kiyohara printf("login: len %d, ID %d, cmd %08x%08x, recon_hold %d\n", login_res->len, login_res->id, login_res->cmd_hi, login_res->cmd_lo, ntohs(login_res->recon_hold));
   1978       1.1  kiyohara END_DEBUG
   1979       1.1  kiyohara 					sbp_busy_timeout(sdev);
   1980       1.1  kiyohara 				} else {
   1981       1.1  kiyohara 					/* forgot logout? */
   1982       1.1  kiyohara 					sbp_show_sdev_info(sdev, 2);
   1983       1.1  kiyohara 					printf("login failed\n");
   1984       1.1  kiyohara 					sdev->status = SBP_DEV_RESET;
   1985       1.1  kiyohara 				}
   1986       1.1  kiyohara 				break;
   1987       1.1  kiyohara 			case ORB_FUN_RCN:
   1988       1.1  kiyohara 				login_res = sdev->login;
   1989       1.1  kiyohara 				if (status_valid) {
   1990       1.1  kiyohara SBP_DEBUG(0)
   1991       1.1  kiyohara sbp_show_sdev_info(sdev, 2);
   1992       1.1  kiyohara printf("reconnect: len %d, ID %d, cmd %08x%08x\n", login_res->len, login_res->id, login_res->cmd_hi, login_res->cmd_lo);
   1993       1.1  kiyohara END_DEBUG
   1994       1.1  kiyohara #if 1
   1995       1.1  kiyohara #if defined(__FreeBSD__)
   1996       1.1  kiyohara 					if (sdev->status == SBP_DEV_ATTACHED)
   1997       1.1  kiyohara 						sbp_scan_dev(sdev);
   1998       1.1  kiyohara 					else
   1999       1.1  kiyohara #endif
   2000       1.1  kiyohara 						sbp_agent_reset(sdev);
   2001       1.1  kiyohara #else
   2002       1.1  kiyohara 					sdev->status = SBP_DEV_ATTACHED;
   2003       1.1  kiyohara 					sbp_mgm_orb(sdev, ORB_FUN_ATS, NULL);
   2004       1.1  kiyohara #endif
   2005       1.1  kiyohara 				} else {
   2006       1.1  kiyohara 					/* reconnection hold time exceed? */
   2007       1.1  kiyohara SBP_DEBUG(0)
   2008       1.1  kiyohara 					sbp_show_sdev_info(sdev, 2);
   2009       1.1  kiyohara 					printf("reconnect failed\n");
   2010       1.1  kiyohara END_DEBUG
   2011       1.1  kiyohara 					sbp_login(sdev);
   2012       1.1  kiyohara 				}
   2013       1.1  kiyohara 				break;
   2014       1.1  kiyohara 			case ORB_FUN_LGO:
   2015       1.1  kiyohara 				sdev->status = SBP_DEV_RESET;
   2016       1.1  kiyohara 				break;
   2017       1.1  kiyohara 			case ORB_FUN_RST:
   2018       1.1  kiyohara 				sbp_busy_timeout(sdev);
   2019       1.1  kiyohara 				break;
   2020       1.1  kiyohara 			case ORB_FUN_LUR:
   2021       1.1  kiyohara 			case ORB_FUN_ATA:
   2022       1.1  kiyohara 			case ORB_FUN_ATS:
   2023       1.1  kiyohara 				sbp_agent_reset(sdev);
   2024       1.1  kiyohara 				break;
   2025       1.1  kiyohara 			default:
   2026       1.1  kiyohara 				sbp_show_sdev_info(sdev, 2);
   2027       1.1  kiyohara 				printf("unknown function %d\n", orb_fun);
   2028       1.1  kiyohara 				break;
   2029       1.1  kiyohara 			}
   2030       1.1  kiyohara 			sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL);
   2031       1.1  kiyohara 			break;
   2032       1.1  kiyohara 		case OCB_ACT_CMD:
   2033       1.1  kiyohara 			sdev->timeout = 0;
   2034       1.1  kiyohara 			if(ocb->sxfer != NULL){
   2035       1.1  kiyohara 				sbp_scsi_xfer *sxfer = ocb->sxfer;
   2036       1.1  kiyohara /*
   2037       1.1  kiyohara 				uint32_t *ld = SCSI_XFER_DATA(ocb->sxfer);
   2038       1.1  kiyohara 				if(ld != NULL &&
   2039       1.1  kiyohara 				    SCSI_XFER_DATALEN(ocb->sxfer) != 0)
   2040       1.1  kiyohara 					printf("ptr %08x %08x %08x %08x\n", ld[0], ld[1], ld[2], ld[3]);
   2041       1.1  kiyohara 				else
   2042       1.1  kiyohara 					printf("ptr NULL\n");
   2043       1.1  kiyohara printf("len %d\n", sbp_status->len);
   2044       1.1  kiyohara */
   2045       1.1  kiyohara 				if(sbp_status->len > 1){
   2046       1.1  kiyohara 					sbp_scsi_status(sbp_status, ocb);
   2047       1.1  kiyohara 				}else{
   2048       1.1  kiyohara 					if(sbp_status->resp != SBP_REQ_CMP){
   2049       1.1  kiyohara 						SCSI_XFER_ERROR(sxfer) =
   2050       1.1  kiyohara 						    XS_REQ_CMP_ERR;
   2051       1.1  kiyohara 					}else{
   2052       1.1  kiyohara 						SCSI_XFER_ERROR(sxfer) =
   2053       1.1  kiyohara 						    XS_REQ_CMP;
   2054       1.1  kiyohara 						SCSI_XFER_REQUEST_COMPLETE(
   2055       1.1  kiyohara 						    sxfer);
   2056       1.1  kiyohara 					}
   2057       1.1  kiyohara 				}
   2058       1.1  kiyohara 				/* fix up inq data */
   2059       1.1  kiyohara 				if (SCSI_XFER_OPECODE(sxfer) == INQUIRY)
   2060       1.1  kiyohara 					sbp_fix_inq_data(ocb);
   2061      1.19  kiyohara 				SBP_LOCK(sbp);
   2062       1.1  kiyohara 				SCSI_TRANSFER_DONE(sxfer);
   2063      1.19  kiyohara 				SBP_UNLOCK(sbp);
   2064       1.1  kiyohara 			}
   2065       1.1  kiyohara 			break;
   2066       1.1  kiyohara 		default:
   2067       1.1  kiyohara 			break;
   2068       1.1  kiyohara 		}
   2069       1.1  kiyohara 	}
   2070       1.1  kiyohara 
   2071       1.1  kiyohara 	if (!use_doorbell)
   2072       1.1  kiyohara 		sbp_free_ocb(sdev, ocb);
   2073       1.1  kiyohara done:
   2074       1.1  kiyohara 	if (reset_agent)
   2075       1.1  kiyohara 		sbp_agent_reset(sdev);
   2076       1.1  kiyohara 
   2077       1.1  kiyohara done0:
   2078       1.1  kiyohara 	xfer->recv.pay_len = SBP_RECV_LEN;
   2079       1.1  kiyohara /* The received packet is usually small enough to be stored within
   2080       1.1  kiyohara  * the buffer. In that case, the controller return ack_complete and
   2081       1.1  kiyohara  * no respose is necessary.
   2082       1.1  kiyohara  *
   2083       1.1  kiyohara  * XXX fwohci.c and firewire.c should inform event_code such as
   2084       1.1  kiyohara  * ack_complete or ack_pending to upper driver.
   2085       1.1  kiyohara  */
   2086       1.1  kiyohara #if NEED_RESPONSE
   2087       1.1  kiyohara 	xfer->send.off = 0;
   2088       1.1  kiyohara 	sfp = (struct fw_pkt *)xfer->send.buf;
   2089       1.1  kiyohara 	sfp->mode.wres.dst = rfp->mode.wreqb.src;
   2090       1.1  kiyohara 	xfer->dst = sfp->mode.wres.dst;
   2091       1.1  kiyohara 	xfer->spd = min(sdev->target->fwdev->speed, max_speed);
   2092       1.1  kiyohara 	xfer->hand = sbp_loginres_callback;
   2093       1.1  kiyohara 
   2094       1.1  kiyohara 	sfp->mode.wres.tlrt = rfp->mode.wreqb.tlrt;
   2095       1.1  kiyohara 	sfp->mode.wres.tcode = FWTCODE_WRES;
   2096       1.1  kiyohara 	sfp->mode.wres.rtcode = 0;
   2097       1.1  kiyohara 	sfp->mode.wres.pri = 0;
   2098       1.1  kiyohara 
   2099       1.1  kiyohara 	fw_asyreq(xfer->fc, -1, xfer);
   2100       1.1  kiyohara #else
   2101       1.1  kiyohara 	/* recycle */
   2102       1.1  kiyohara 	STAILQ_INSERT_TAIL(&sbp->fwb.xferlist, xfer, link);
   2103       1.1  kiyohara #endif
   2104       1.1  kiyohara 
   2105       1.1  kiyohara 	return;
   2106       1.1  kiyohara 
   2107       1.1  kiyohara }
   2108       1.1  kiyohara 
   2109       1.1  kiyohara static void
   2110       1.1  kiyohara sbp_recv(struct fw_xfer *xfer)
   2111       1.1  kiyohara {
   2112       1.1  kiyohara 	int s;
   2113       1.1  kiyohara 
   2114       1.1  kiyohara 	s = splfwsbp();
   2115       1.1  kiyohara 	sbp_recv1(xfer);
   2116       1.1  kiyohara 	splx(s);
   2117       1.1  kiyohara }
   2118       1.1  kiyohara /*
   2119       1.1  kiyohara  * sbp_attach()
   2120       1.1  kiyohara  */
   2121       1.1  kiyohara FW_ATTACH(sbp)
   2122       1.1  kiyohara {
   2123       1.1  kiyohara 	FW_ATTACH_START(sbp, sbp, fwa);
   2124       1.1  kiyohara 	int dv_unit, error, s;
   2125      1.19  kiyohara 	struct firewire_comm *fc;
   2126       1.1  kiyohara 	SBP_ATTACH_START;
   2127       1.1  kiyohara 
   2128      1.16  kiyohara 	if (DFLTPHYS > SBP_MAXPHYS)
   2129      1.19  kiyohara 		fw_printf(sbp->fd.dev,
   2130      1.16  kiyohara 		    "Warning, DFLTPHYS(%dKB) is larger than "
   2131      1.16  kiyohara 		    "SBP_MAXPHYS(%dKB).\n", DFLTPHYS / 1024,
   2132      1.16  kiyohara 		    SBP_MAXPHYS / 1024);
   2133       1.1  kiyohara SBP_DEBUG(0)
   2134       1.1  kiyohara 	printf("sbp_attach (cold=%d)\n", cold);
   2135       1.1  kiyohara END_DEBUG
   2136       1.1  kiyohara 
   2137       1.1  kiyohara 	if (cold)
   2138       1.1  kiyohara 		sbp_cold ++;
   2139      1.19  kiyohara 	sbp->fd.fc = fc = fwa->fc;
   2140      1.19  kiyohara 	fw_mtx_init(&sbp->mtx, "sbp", NULL, MTX_DEF);
   2141       1.1  kiyohara 
   2142       1.1  kiyohara 	if (max_speed < 0)
   2143      1.19  kiyohara 		max_speed = fc->speed;
   2144       1.1  kiyohara 
   2145      1.19  kiyohara 	error = fw_bus_dma_tag_create(/*parent*/fc->dmat,
   2146       1.1  kiyohara 				/* XXX shoud be 4 for sane backend? */
   2147       1.1  kiyohara 				/*alignment*/1,
   2148       1.1  kiyohara 				/*boundary*/0,
   2149       1.1  kiyohara 				/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
   2150       1.1  kiyohara 				/*highaddr*/BUS_SPACE_MAXADDR,
   2151       1.1  kiyohara 				/*filter*/NULL, /*filterarg*/NULL,
   2152       1.1  kiyohara 				/*maxsize*/0x100000, /*nsegments*/SBP_IND_MAX,
   2153       1.1  kiyohara 				/*maxsegsz*/SBP_SEG_MAX,
   2154       1.1  kiyohara 				/*flags*/BUS_DMA_ALLOCNOW,
   2155       1.1  kiyohara 				/*lockfunc*/busdma_lock_mutex,
   2156      1.19  kiyohara 				/*lockarg*/&sbp->mtx,
   2157       1.1  kiyohara 				&sbp->dmat);
   2158       1.1  kiyohara 	if (error != 0) {
   2159       1.1  kiyohara 		printf("sbp_attach: Could not allocate DMA tag "
   2160       1.1  kiyohara 			"- error %d\n", error);
   2161       1.1  kiyohara 			FW_ATTACH_RETURN(ENOMEM);
   2162       1.1  kiyohara 	}
   2163       1.1  kiyohara 
   2164       1.1  kiyohara #if defined(__FreeBSD__)
   2165       1.1  kiyohara 	devq = cam_simq_alloc(/*maxopenings*/SBP_NUM_OCB);
   2166       1.1  kiyohara 	if (devq == NULL)
   2167       1.1  kiyohara 		return (ENXIO);
   2168       1.1  kiyohara #endif
   2169       1.1  kiyohara 
   2170       1.1  kiyohara 	sbp->target.fwdev = NULL;
   2171       1.1  kiyohara 	sbp->target.luns = NULL;
   2172       1.1  kiyohara 
   2173       1.1  kiyohara 	if (sbp_alloc_target(sbp, fwa->fwdev) == NULL)
   2174       1.1  kiyohara 		FW_ATTACH_RETURN(ENXIO);
   2175       1.1  kiyohara 
   2176       1.1  kiyohara 	SBP_SCSIBUS_ATTACH;
   2177       1.1  kiyohara 
   2178       1.1  kiyohara 	/* We reserve 16 bit space (4 bytes X 64 unit X 256 luns) */
   2179      1.19  kiyohara 	dv_unit = fw_get_unit(sbp->fd.dev);
   2180       1.1  kiyohara 	sbp->fwb.start = SBP_DEV2ADDR(dv_unit, 0);
   2181       1.1  kiyohara 	sbp->fwb.end = SBP_DEV2ADDR(dv_unit, -1);
   2182       1.1  kiyohara 	/* pre-allocate xfer */
   2183       1.1  kiyohara 	STAILQ_INIT(&sbp->fwb.xferlist);
   2184       1.1  kiyohara 	fw_xferlist_add(&sbp->fwb.xferlist, M_SBP,
   2185       1.1  kiyohara 	    /*send*/ 0, /*recv*/ SBP_RECV_LEN, SBP_NUM_OCB/2,
   2186      1.19  kiyohara 	    fc, (void *)sbp, sbp_recv);
   2187      1.19  kiyohara 	fw_bindadd(fc, &sbp->fwb);
   2188       1.1  kiyohara 
   2189       1.1  kiyohara 	sbp->fd.post_busreset = sbp_post_busreset;
   2190       1.1  kiyohara 	sbp->fd.post_explore = sbp_post_explore;
   2191       1.1  kiyohara 
   2192      1.19  kiyohara 	if (fc->status != FWBUSNOTREADY) {
   2193       1.1  kiyohara 		s = splfw();
   2194       1.1  kiyohara 		sbp_post_busreset((void *)sbp);
   2195       1.1  kiyohara 		sbp_post_explore((void *)sbp);
   2196       1.1  kiyohara 		splx(s);
   2197       1.1  kiyohara 	}
   2198       1.1  kiyohara 
   2199       1.1  kiyohara 	FW_ATTACH_RETURN(0);
   2200       1.1  kiyohara #if defined(__FreeBSD__)
   2201       1.1  kiyohara fail:
   2202      1.19  kiyohara 	SBP_UNLOCK(sbp);
   2203       1.1  kiyohara 	cam_sim_free(sbp->sim, /*free_devq*/TRUE);
   2204       1.1  kiyohara 	return (ENXIO);
   2205       1.1  kiyohara #endif
   2206       1.1  kiyohara }
   2207       1.1  kiyohara 
   2208       1.1  kiyohara static int
   2209       1.1  kiyohara sbp_logout_all(struct sbp_softc *sbp)
   2210       1.1  kiyohara {
   2211       1.1  kiyohara 	struct sbp_target *target;
   2212       1.1  kiyohara 	struct sbp_dev *sdev;
   2213       1.1  kiyohara 	int i;
   2214       1.1  kiyohara 
   2215       1.1  kiyohara SBP_DEBUG(0)
   2216       1.1  kiyohara 	printf("sbp_logout_all\n");
   2217       1.1  kiyohara END_DEBUG
   2218       1.1  kiyohara 	target = &sbp->target;
   2219       1.1  kiyohara 	if (target->luns != NULL)
   2220       1.1  kiyohara 		for (i = 0; i < target->num_lun; i++) {
   2221       1.1  kiyohara 			sdev = target->luns[i];
   2222       1.1  kiyohara 			if (sdev == NULL)
   2223       1.1  kiyohara 				continue;
   2224      1.19  kiyohara 			fw_callout_stop(&sdev->login_callout);
   2225       1.1  kiyohara 			if (sdev->status >= SBP_DEV_TOATTACH &&
   2226       1.1  kiyohara 					sdev->status <= SBP_DEV_ATTACHED)
   2227       1.1  kiyohara 				sbp_mgm_orb(sdev, ORB_FUN_LGO, NULL);
   2228       1.1  kiyohara 		}
   2229       1.1  kiyohara 
   2230       1.1  kiyohara 	return 0;
   2231       1.1  kiyohara }
   2232       1.1  kiyohara 
   2233       1.1  kiyohara #if defined(__FreeBSD__)
   2234       1.1  kiyohara static int
   2235       1.1  kiyohara sbp_shutdown(device_t dev)
   2236       1.1  kiyohara {
   2237       1.1  kiyohara 	struct sbp_softc *sbp = ((struct sbp_softc *)device_get_softc(dev));
   2238       1.1  kiyohara 
   2239       1.1  kiyohara 	sbp_logout_all(sbp);
   2240       1.1  kiyohara 	return (0);
   2241       1.1  kiyohara }
   2242       1.1  kiyohara #endif
   2243       1.1  kiyohara 
   2244       1.1  kiyohara static void
   2245       1.1  kiyohara sbp_free_sdev(struct sbp_dev *sdev)
   2246       1.1  kiyohara {
   2247       1.1  kiyohara 	int i;
   2248       1.1  kiyohara 
   2249       1.1  kiyohara 	if (sdev == NULL)
   2250       1.1  kiyohara 		return;
   2251       1.1  kiyohara 	for (i = 0; i < SBP_QUEUE_LEN; i++)
   2252       1.1  kiyohara 		fw_bus_dmamap_destroy(sdev->target->sbp->dmat,
   2253       1.1  kiyohara 		    sdev->ocb[i].dmamap);
   2254       1.1  kiyohara 	fwdma_free(sdev->target->sbp->fd.fc, &sdev->dma);
   2255       1.1  kiyohara 	free(sdev, M_SBP);
   2256       1.1  kiyohara }
   2257       1.1  kiyohara 
   2258       1.1  kiyohara static void
   2259       1.1  kiyohara sbp_free_target(struct sbp_target *target)
   2260       1.1  kiyohara {
   2261       1.1  kiyohara 	struct sbp_softc *sbp;
   2262       1.1  kiyohara 	struct fw_xfer *xfer, *next;
   2263       1.1  kiyohara 	int i;
   2264       1.1  kiyohara 
   2265       1.1  kiyohara 	if (target->luns == NULL)
   2266       1.1  kiyohara 		return;
   2267      1.19  kiyohara 	fw_callout_stop(&target->mgm_ocb_timeout);
   2268       1.1  kiyohara 	sbp = target->sbp;
   2269       1.1  kiyohara 	for (i = 0; i < target->num_lun; i++)
   2270       1.1  kiyohara 		sbp_free_sdev(target->luns[i]);
   2271       1.1  kiyohara 
   2272       1.1  kiyohara 	for (xfer = STAILQ_FIRST(&target->xferlist);
   2273       1.1  kiyohara 			xfer != NULL; xfer = next) {
   2274       1.1  kiyohara 		next = STAILQ_NEXT(xfer, link);
   2275       1.1  kiyohara 		fw_xfer_free_buf(xfer);
   2276       1.1  kiyohara 	}
   2277       1.1  kiyohara 	STAILQ_INIT(&target->xferlist);
   2278       1.1  kiyohara 	free(target->luns, M_SBP);
   2279       1.1  kiyohara 	target->num_lun = 0;;
   2280       1.1  kiyohara 	target->luns = NULL;
   2281       1.1  kiyohara 	target->fwdev = NULL;
   2282       1.1  kiyohara }
   2283       1.1  kiyohara 
   2284       1.1  kiyohara FW_DETACH(sbp)
   2285       1.1  kiyohara {
   2286       1.1  kiyohara 	FW_DETACH_START(sbp, sbp);
   2287       1.1  kiyohara 	struct firewire_comm *fc = sbp->fd.fc;
   2288       1.1  kiyohara 	int i;
   2289       1.1  kiyohara 
   2290       1.1  kiyohara SBP_DEBUG(0)
   2291       1.1  kiyohara 	printf("sbp_detach\n");
   2292       1.1  kiyohara END_DEBUG
   2293       1.1  kiyohara 
   2294       1.1  kiyohara 	SBP_DETACH_TARGET(&sbp->target);
   2295       1.1  kiyohara #if defined(__FreeBSD__)
   2296      1.19  kiyohara 	SBP_LOCK(sbp);
   2297       1.1  kiyohara 	xpt_async(AC_LOST_DEVICE, sbp->path, NULL);
   2298       1.1  kiyohara 	xpt_free_path(sbp->path);
   2299       1.1  kiyohara 	xpt_bus_deregister(cam_sim_path(sbp->sim));
   2300       1.1  kiyohara 	cam_sim_free(sbp->sim, /*free_devq*/ TRUE),
   2301      1.19  kiyohara 	SBP_UNLOCK(sbp);
   2302       1.1  kiyohara #endif
   2303       1.1  kiyohara 
   2304       1.1  kiyohara 	sbp_logout_all(sbp);
   2305       1.1  kiyohara 
   2306       1.1  kiyohara 	/* XXX wait for logout completion */
   2307       1.1  kiyohara 	tsleep(&i, FWPRI, "sbpdtc", hz/2);
   2308       1.1  kiyohara 
   2309       1.1  kiyohara 	sbp_free_target(&sbp->target);
   2310       1.1  kiyohara 
   2311       1.1  kiyohara 	fw_bindremove(fc, &sbp->fwb);
   2312       1.1  kiyohara 	fw_xferlist_remove(&sbp->fwb.xferlist);
   2313       1.1  kiyohara 
   2314       1.1  kiyohara 	fw_bus_dma_tag_destroy(sbp->dmat);
   2315      1.19  kiyohara 	fw_mtx_destroy(&sbp->mtx);
   2316       1.1  kiyohara 
   2317       1.1  kiyohara 	return (0);
   2318       1.1  kiyohara }
   2319       1.1  kiyohara 
   2320       1.1  kiyohara #if defined(__FreeBSD__)
   2321       1.1  kiyohara static void
   2322       1.1  kiyohara sbp_cam_detach_sdev(struct sbp_dev *sdev)
   2323       1.1  kiyohara {
   2324       1.1  kiyohara 	if (sdev == NULL)
   2325       1.1  kiyohara 		return;
   2326       1.1  kiyohara 	if (sdev->status == SBP_DEV_DEAD)
   2327       1.1  kiyohara 		return;
   2328       1.1  kiyohara 	if (sdev->status == SBP_DEV_RESET)
   2329       1.1  kiyohara 		return;
   2330      1.19  kiyohara 	sbp_abort_all_ocbs(sdev, CAM_DEV_NOT_THERE);
   2331       1.1  kiyohara 	if (sdev->path) {
   2332      1.19  kiyohara 		SBP_LOCK(sdev->target->sbp);
   2333       1.1  kiyohara 		xpt_release_devq(sdev->path,
   2334       1.1  kiyohara 				 sdev->freeze, TRUE);
   2335       1.1  kiyohara 		sdev->freeze = 0;
   2336       1.1  kiyohara 		xpt_async(AC_LOST_DEVICE, sdev->path, NULL);
   2337       1.1  kiyohara 		xpt_free_path(sdev->path);
   2338       1.1  kiyohara 		sdev->path = NULL;
   2339      1.19  kiyohara 		SBP_UNLOCK(sdev->target->sbp);
   2340       1.1  kiyohara 	}
   2341       1.1  kiyohara }
   2342       1.1  kiyohara 
   2343       1.1  kiyohara static void
   2344       1.1  kiyohara sbp_cam_detach_target(struct sbp_target *target)
   2345       1.1  kiyohara {
   2346       1.1  kiyohara 	int i;
   2347       1.1  kiyohara 
   2348       1.1  kiyohara 	if (target->luns != NULL) {
   2349       1.1  kiyohara SBP_DEBUG(0)
   2350       1.1  kiyohara 		printf("sbp_detach_target %d\n", target->target_id);
   2351       1.1  kiyohara END_DEBUG
   2352      1.19  kiyohara 		fw_callout_stop(&target->scan_callout);
   2353       1.1  kiyohara 		for (i = 0; i < target->num_lun; i++)
   2354       1.1  kiyohara 			sbp_cam_detach_sdev(target->luns[i]);
   2355       1.1  kiyohara 	}
   2356       1.1  kiyohara }
   2357       1.1  kiyohara #elif defined(__NetBSD__)
   2358       1.1  kiyohara static void
   2359       1.1  kiyohara sbp_scsipi_detach_sdev(struct sbp_dev *sdev)
   2360       1.1  kiyohara {
   2361       1.7    rpaulo 	struct sbp_target *target;
   2362       1.7    rpaulo 	struct sbp_softc *sbp;
   2363       1.7    rpaulo 
   2364       1.1  kiyohara 	if (sdev == NULL)
   2365       1.1  kiyohara 		return;
   2366       1.7    rpaulo 
   2367       1.7    rpaulo 	target = sdev->target;
   2368       1.7    rpaulo 	if (target == NULL)
   2369       1.7    rpaulo 		return;
   2370       1.7    rpaulo 
   2371       1.7    rpaulo 	sbp = target->sbp;
   2372       1.7    rpaulo 
   2373       1.1  kiyohara 	if (sdev->status == SBP_DEV_DEAD)
   2374       1.1  kiyohara 		return;
   2375       1.1  kiyohara 	if (sdev->status == SBP_DEV_RESET)
   2376       1.1  kiyohara 		return;
   2377       1.1  kiyohara 	if (sdev->periph) {
   2378       1.1  kiyohara 		scsipi_periph_thaw(sdev->periph, sdev->freeze);
   2379       1.1  kiyohara 		scsipi_channel_thaw(&sbp->sc_channel, 0);	/* XXXX */
   2380       1.1  kiyohara 		sdev->freeze = 0;
   2381       1.1  kiyohara 		if (scsipi_target_detach(&sbp->sc_channel,
   2382       1.1  kiyohara 		    target->target_id, sdev->lun_id, DETACH_FORCE) != 0) {
   2383       1.1  kiyohara 			sbp_show_sdev_info(sdev, 2);
   2384       1.1  kiyohara 			printf("detach failed\n");
   2385       1.1  kiyohara 		}
   2386       1.1  kiyohara 		sdev->periph = NULL;
   2387       1.1  kiyohara 	}
   2388       1.1  kiyohara 	sbp_abort_all_ocbs(sdev, XS_DEV_NOT_THERE);
   2389       1.1  kiyohara }
   2390       1.1  kiyohara 
   2391       1.1  kiyohara static void
   2392       1.1  kiyohara sbp_scsipi_detach_target(struct sbp_target *target)
   2393       1.1  kiyohara {
   2394       1.1  kiyohara 	struct sbp_softc *sbp = target->sbp;
   2395       1.1  kiyohara 	int i;
   2396       1.1  kiyohara 
   2397       1.1  kiyohara 	if (target->luns != NULL) {
   2398       1.1  kiyohara SBP_DEBUG(0)
   2399       1.1  kiyohara 		printf("sbp_detach_target %d\n", target->target_id);
   2400       1.1  kiyohara END_DEBUG
   2401      1.19  kiyohara 		fw_callout_stop(&target->scan_callout);
   2402       1.1  kiyohara 		for (i = 0; i < target->num_lun; i++)
   2403       1.1  kiyohara 			sbp_scsipi_detach_sdev(target->luns[i]);
   2404       1.1  kiyohara 		if (config_detach(sbp->sc_bus, DETACH_FORCE) != 0)
   2405      1.19  kiyohara 			fw_printf(sbp->fd.dev, "%d detach failed\n",
   2406       1.1  kiyohara 				target->target_id);
   2407       1.1  kiyohara 		sbp->sc_bus = NULL;
   2408       1.1  kiyohara 	}
   2409       1.1  kiyohara }
   2410       1.1  kiyohara #endif
   2411       1.1  kiyohara 
   2412       1.1  kiyohara static void
   2413       1.1  kiyohara sbp_target_reset(struct sbp_dev *sdev, int method)
   2414       1.1  kiyohara {
   2415       1.1  kiyohara 	int i;
   2416       1.1  kiyohara 	struct sbp_target *target = sdev->target;
   2417       1.1  kiyohara 	struct sbp_dev *tsdev;
   2418       1.1  kiyohara 
   2419       1.1  kiyohara 	for (i = 0; i < target->num_lun; i++) {
   2420       1.1  kiyohara 		tsdev = target->luns[i];
   2421       1.1  kiyohara 		if (tsdev == NULL)
   2422       1.1  kiyohara 			continue;
   2423       1.1  kiyohara 		if (tsdev->status == SBP_DEV_DEAD)
   2424       1.1  kiyohara 			continue;
   2425       1.1  kiyohara 		if (tsdev->status == SBP_DEV_RESET)
   2426       1.1  kiyohara 			continue;
   2427      1.19  kiyohara 		SBP_LOCK(target->sbp);
   2428       1.1  kiyohara 		SBP_DEVICE_FREEZE(tsdev, 1);
   2429       1.1  kiyohara 		tsdev->freeze ++;
   2430      1.19  kiyohara 		SBP_UNLOCK(target->sbp);
   2431       1.1  kiyohara 		sbp_abort_all_ocbs(tsdev, XS_CMD_TIMEOUT);
   2432       1.1  kiyohara 		if (method == 2)
   2433       1.1  kiyohara 			tsdev->status = SBP_DEV_LOGIN;
   2434       1.1  kiyohara 	}
   2435       1.1  kiyohara 	switch(method) {
   2436       1.1  kiyohara 	case 1:
   2437       1.1  kiyohara 		printf("target reset\n");
   2438       1.1  kiyohara 		sbp_mgm_orb(sdev, ORB_FUN_RST, NULL);
   2439       1.1  kiyohara 		break;
   2440       1.1  kiyohara 	case 2:
   2441       1.1  kiyohara 		printf("reset start\n");
   2442       1.1  kiyohara 		sbp_reset_start(sdev);
   2443       1.1  kiyohara 		break;
   2444       1.1  kiyohara 	}
   2445       1.1  kiyohara 
   2446       1.1  kiyohara }
   2447       1.1  kiyohara 
   2448       1.1  kiyohara static void
   2449       1.1  kiyohara sbp_mgm_timeout(void *arg)
   2450       1.1  kiyohara {
   2451       1.1  kiyohara 	struct sbp_ocb *ocb = (struct sbp_ocb *)arg;
   2452       1.1  kiyohara 	struct sbp_dev *sdev = ocb->sdev;
   2453       1.1  kiyohara 	struct sbp_target *target = sdev->target;
   2454       1.1  kiyohara 
   2455       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   2456       1.1  kiyohara 	printf("request timeout(mgm orb:0x%08x) ... ",
   2457       1.1  kiyohara 	    (uint32_t)ocb->bus_addr);
   2458       1.1  kiyohara 	target->mgm_ocb_cur = NULL;
   2459       1.1  kiyohara 	sbp_free_ocb(sdev, ocb);
   2460       1.1  kiyohara #if 0
   2461       1.1  kiyohara 	/* XXX */
   2462       1.1  kiyohara 	printf("run next request\n");
   2463       1.1  kiyohara 	sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL);
   2464       1.1  kiyohara #endif
   2465       1.1  kiyohara #if 1
   2466       1.1  kiyohara 	printf("reset start\n");
   2467       1.1  kiyohara 	sbp_reset_start(sdev);
   2468       1.1  kiyohara #endif
   2469       1.1  kiyohara }
   2470       1.1  kiyohara 
   2471       1.1  kiyohara static void
   2472       1.1  kiyohara sbp_timeout(void *arg)
   2473       1.1  kiyohara {
   2474       1.1  kiyohara 	struct sbp_ocb *ocb = (struct sbp_ocb *)arg;
   2475       1.1  kiyohara 	struct sbp_dev *sdev = ocb->sdev;
   2476       1.1  kiyohara 
   2477       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   2478       1.1  kiyohara 	printf("request timeout(cmd orb:0x%08x) ... ",
   2479       1.1  kiyohara 	    (uint32_t)ocb->bus_addr);
   2480       1.1  kiyohara 
   2481       1.1  kiyohara 	sdev->timeout ++;
   2482       1.1  kiyohara 	switch(sdev->timeout) {
   2483       1.1  kiyohara 	case 1:
   2484       1.1  kiyohara 		printf("agent reset\n");
   2485      1.19  kiyohara 		SBP_LOCK(sdev->target->sbp);
   2486       1.1  kiyohara 		SBP_DEVICE_FREEZE(sdev, 1);
   2487       1.1  kiyohara 		sdev->freeze ++;
   2488      1.19  kiyohara 		SBP_UNLOCK(sdev->target->sbp);
   2489       1.1  kiyohara 		sbp_abort_all_ocbs(sdev, XS_CMD_TIMEOUT);
   2490       1.1  kiyohara 		sbp_agent_reset(sdev);
   2491       1.1  kiyohara 		break;
   2492       1.1  kiyohara 	case 2:
   2493       1.1  kiyohara 	case 3:
   2494       1.1  kiyohara 		sbp_target_reset(sdev, sdev->timeout - 1);
   2495       1.1  kiyohara 		break;
   2496       1.1  kiyohara #if 0
   2497       1.1  kiyohara 	default:
   2498       1.1  kiyohara 		/* XXX give up */
   2499       1.1  kiyohara 		SBP_DETACH_TARGET(target);
   2500       1.1  kiyohara 		if (target->luns != NULL)
   2501       1.1  kiyohara 			free(target->luns, M_SBP);
   2502       1.1  kiyohara 		target->num_lun = 0;;
   2503       1.1  kiyohara 		target->luns = NULL;
   2504       1.1  kiyohara 		target->fwdev = NULL;
   2505       1.1  kiyohara #endif
   2506       1.1  kiyohara 	}
   2507       1.1  kiyohara }
   2508       1.1  kiyohara 
   2509       1.1  kiyohara static void
   2510       1.1  kiyohara sbp_action1(struct sbp_softc *sbp, sbp_scsi_xfer *sxfer)
   2511       1.1  kiyohara {
   2512       1.1  kiyohara 
   2513       1.1  kiyohara 	struct sbp_target *target = NULL;
   2514       1.1  kiyohara 	struct sbp_dev *sdev = NULL;
   2515       1.1  kiyohara 
   2516       1.1  kiyohara 	/* target:lun -> sdev mapping */
   2517       1.1  kiyohara 	if (sbp != NULL) {
   2518       1.1  kiyohara 		target = &sbp->target;
   2519       1.1  kiyohara 		if (target->fwdev != NULL
   2520       1.1  kiyohara 				&& NOT_LUN_WILDCARD(SCSI_XFER_LUN(sxfer))
   2521       1.1  kiyohara 				&& SCSI_XFER_LUN(sxfer) < target->num_lun) {
   2522       1.1  kiyohara 			sdev = target->luns[SCSI_XFER_LUN(sxfer)];
   2523       1.1  kiyohara 			if (sdev != NULL && sdev->status != SBP_DEV_ATTACHED &&
   2524       1.1  kiyohara 				sdev->status != SBP_DEV_PROBE)
   2525       1.1  kiyohara 				sdev = NULL;
   2526       1.1  kiyohara 		}
   2527       1.1  kiyohara 	}
   2528       1.1  kiyohara 
   2529       1.1  kiyohara SBP_DEBUG(1)
   2530       1.1  kiyohara 	if (sdev == NULL)
   2531       1.1  kiyohara 		printf("invalid target %d lun %d\n",
   2532       1.1  kiyohara 			SCSI_XFER_TARGET(sxfer), SCSI_XFER_LUN(sxfer));
   2533       1.1  kiyohara END_DEBUG
   2534       1.1  kiyohara 
   2535       1.1  kiyohara 	switch (SCSI_XFER_FUNCCODE(sxfer)) {
   2536       1.1  kiyohara 	case XPT_SCSI_IO:
   2537       1.1  kiyohara #if defined(__FreeBSD__)
   2538       1.1  kiyohara 	case XPT_RESET_DEV:
   2539       1.1  kiyohara 	case XPT_GET_TRAN_SETTINGS:
   2540       1.1  kiyohara 	case XPT_SET_TRAN_SETTINGS:
   2541       1.1  kiyohara 	case XPT_CALC_GEOMETRY:
   2542       1.1  kiyohara #endif
   2543       1.1  kiyohara 		if (sdev == NULL) {
   2544       1.1  kiyohara SBP_DEBUG(1)
   2545       1.1  kiyohara 			printf("%s:%d:%d:func_code 0x%04x: "
   2546       1.1  kiyohara 				"Invalid target (target needed)\n",
   2547      1.19  kiyohara 				sbp ? fw_get_nameunit(sbp->fd.dev) : "???",
   2548       1.1  kiyohara 				SCSI_XFER_TARGET(sxfer), SCSI_XFER_LUN(sxfer),
   2549       1.1  kiyohara 				SCSI_XFER_FUNCCODE(sxfer));
   2550       1.1  kiyohara END_DEBUG
   2551       1.1  kiyohara 
   2552       1.1  kiyohara 			SCSI_XFER_ERROR(sxfer) = XS_DEV_NOT_THERE;
   2553       1.1  kiyohara 			SCSI_TRANSFER_DONE(sxfer);
   2554       1.1  kiyohara 			return;
   2555       1.1  kiyohara 		}
   2556       1.1  kiyohara 		break;
   2557       1.1  kiyohara #if defined(__FreeBSD__)
   2558       1.1  kiyohara 	case XPT_PATH_INQ:
   2559       1.1  kiyohara 	case XPT_NOOP:
   2560       1.1  kiyohara 		/* The opcodes sometimes aimed at a target (sc is valid),
   2561       1.1  kiyohara 		 * sometimes aimed at the SIM (sc is invalid and target is
   2562       1.1  kiyohara 		 * CAM_TARGET_WILDCARD)
   2563       1.1  kiyohara 		 */
   2564       1.1  kiyohara 		if (sbp == NULL &&
   2565       1.1  kiyohara 			sxfer->ccb_h.target_id != CAM_TARGET_WILDCARD) {
   2566       1.1  kiyohara SBP_DEBUG(0)
   2567       1.1  kiyohara 			printf("%s:%d:%d func_code 0x%04x: "
   2568       1.1  kiyohara 				"Invalid target (no wildcard)\n",
   2569      1.19  kiyohara 				fw_get_nameunit(sbp->fd.dev),
   2570       1.1  kiyohara 				sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun,
   2571       1.1  kiyohara 				sxfer->ccb_h.func_code);
   2572       1.1  kiyohara END_DEBUG
   2573       1.1  kiyohara 			SCSI_XFER_ERROR(sxfer) = XS_DEV_NOT_THERE;
   2574       1.1  kiyohara 			SCSI_TRANSFER_DONE(sxfer);
   2575       1.1  kiyohara 			return;
   2576       1.1  kiyohara 		}
   2577       1.1  kiyohara 		break;
   2578       1.1  kiyohara #endif
   2579       1.1  kiyohara 	default:
   2580       1.1  kiyohara 		/* XXX Hm, we should check the input parameters */
   2581       1.1  kiyohara 		break;
   2582       1.1  kiyohara 	}
   2583       1.1  kiyohara 
   2584       1.1  kiyohara 	switch (SCSI_XFER_FUNCCODE(sxfer)) {
   2585       1.1  kiyohara 	case XPT_SCSI_IO:
   2586       1.1  kiyohara 	{
   2587       1.1  kiyohara 		struct sbp_ocb *ocb;
   2588       1.1  kiyohara 		int speed;
   2589       1.1  kiyohara 		void *cdb;
   2590      1.19  kiyohara 		fw_mtx_assert(sim->mtx, MA_OWNED);
   2591       1.1  kiyohara 
   2592       1.1  kiyohara SBP_DEBUG(2)
   2593       1.1  kiyohara 		printf("%s:%d:%d XPT_SCSI_IO: "
   2594       1.1  kiyohara 			"cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x"
   2595       1.1  kiyohara 			", flags: 0x%02x, "
   2596       1.1  kiyohara 			"%db cmd/%db data/%db sense\n",
   2597      1.19  kiyohara 			fw_get_nameunit(sbp->fd.dev),
   2598       1.1  kiyohara 			SCSI_XFER_TARGET(sxfer), SCSI_XFER_LUN(sxfer),
   2599       1.1  kiyohara 			SCSI_XFER_10BCMD_DUMP(sxfer),
   2600       1.1  kiyohara 			SCSI_XFER_DIR(sxfer),
   2601       1.1  kiyohara 			SCSI_XFER_CMDLEN(sxfer), SCSI_XFER_DATALEN(sxfer),
   2602       1.1  kiyohara 			SCSI_XFER_SENSELEN(sxfer));
   2603       1.1  kiyohara END_DEBUG
   2604       1.1  kiyohara 		if(sdev == NULL){
   2605       1.1  kiyohara 			SCSI_XFER_ERROR(sxfer) = XS_DEV_NOT_THERE;
   2606       1.1  kiyohara 			SCSI_TRANSFER_DONE(sxfer);
   2607       1.1  kiyohara 			return;
   2608       1.1  kiyohara 		}
   2609       1.1  kiyohara #if 0
   2610       1.1  kiyohara 		/* if we are in probe stage, pass only probe commands */
   2611       1.1  kiyohara 		if (sdev->status == SBP_DEV_PROBE) {
   2612       1.1  kiyohara 			char *name;
   2613       1.1  kiyohara 			name = xpt_path_periph(sxfer->ccb_h.path)->periph_name;
   2614       1.1  kiyohara 			printf("probe stage, periph name: %s\n", name);
   2615       1.1  kiyohara 			if (strcmp(name, "probe") != 0) {
   2616       1.1  kiyohara 				SCSI_XFER_ERROR(sxfer) = XS_REQUEUE_REQ;
   2617       1.1  kiyohara 				SCSI_TRANSFER_DONE(sxfer);
   2618       1.1  kiyohara 				return;
   2619       1.1  kiyohara 			}
   2620       1.1  kiyohara 		}
   2621       1.1  kiyohara #endif
   2622       1.1  kiyohara 		if ((ocb = sbp_get_ocb(sdev)) == NULL) {
   2623       1.1  kiyohara 			SCSI_XFER_ERROR(sxfer) = XS_REQUEUE_REQ;
   2624       1.1  kiyohara 			if (sdev->freeze == 0) {
   2625      1.19  kiyohara 				SBP_LOCK(sdev->target->sbp);
   2626       1.1  kiyohara 				SBP_DEVICE_FREEZE(sdev, 1);
   2627       1.1  kiyohara 				sdev->freeze ++;
   2628      1.19  kiyohara 				SBP_UNLOCK(sdev->target->sbp);
   2629       1.1  kiyohara 			}
   2630       1.1  kiyohara 			SCSI_TRANSFER_DONE(sxfer);
   2631       1.1  kiyohara 			return;
   2632       1.1  kiyohara 		}
   2633       1.1  kiyohara 
   2634       1.1  kiyohara 		ocb->flags = OCB_ACT_CMD;
   2635       1.1  kiyohara 		ocb->sdev = sdev;
   2636       1.1  kiyohara 		ocb->sxfer = sxfer;
   2637       1.1  kiyohara #if defined(__FreeBSD__)
   2638       1.1  kiyohara 		sxfer->ccb_h.ccb_sdev_ptr = sdev;
   2639       1.1  kiyohara #endif
   2640       1.1  kiyohara 		ocb->orb[0] = htonl(1 << 31);
   2641       1.1  kiyohara 		ocb->orb[1] = 0;
   2642       1.1  kiyohara 		ocb->orb[2] = htonl(((sbp->fd.fc->nodeid | FWLOCALBUS )<< 16) );
   2643       1.1  kiyohara 		ocb->orb[3] = htonl(ocb->bus_addr + IND_PTR_OFFSET);
   2644       1.1  kiyohara 		speed = min(target->fwdev->speed, max_speed);
   2645       1.1  kiyohara 		ocb->orb[4] = htonl(ORB_NOTIFY | ORB_CMD_SPD(speed)
   2646       1.1  kiyohara 						| ORB_CMD_MAXP(speed + 7));
   2647       1.1  kiyohara 		if(SCSI_XFER_DIR(sxfer) == SCSI_XFER_DATA_IN){
   2648       1.1  kiyohara 			ocb->orb[4] |= htonl(ORB_CMD_IN);
   2649       1.1  kiyohara 		}
   2650       1.1  kiyohara 
   2651       1.1  kiyohara 		if (CAM_XFER_FLAGS(sxfer) & CAM_SCATTER_VALID)
   2652       1.1  kiyohara 			printf("sbp: CAM_SCATTER_VALID\n");
   2653       1.1  kiyohara 		if (CAM_XFER_FLAGS(sxfer) & CAM_DATA_PHYS)
   2654       1.1  kiyohara 			printf("sbp: CAM_DATA_PHYS\n");
   2655       1.1  kiyohara 
   2656       1.1  kiyohara 		cdb = SCSI_XFER_CMD(sxfer);
   2657       1.1  kiyohara 		bcopy(cdb, (void *)&ocb->orb[5], SCSI_XFER_CMDLEN(sxfer));
   2658       1.1  kiyohara /*
   2659       1.1  kiyohara printf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[0]), ntohl(ocb->orb[1]), ntohl(ocb->orb[2]), ntohl(ocb->orb[3]));
   2660       1.1  kiyohara printf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[4]), ntohl(ocb->orb[5]), ntohl(ocb->orb[6]), ntohl(ocb->orb[7]));
   2661       1.1  kiyohara */
   2662       1.1  kiyohara 		if (SCSI_XFER_DATALEN(sxfer) > 0) {
   2663       1.1  kiyohara 			int s, error;
   2664       1.1  kiyohara 
   2665       1.1  kiyohara 			s = splsoftvm();
   2666       1.1  kiyohara 			error = fw_bus_dmamap_load(/*dma tag*/sbp->dmat,
   2667       1.1  kiyohara 					/*dma map*/ocb->dmamap,
   2668       1.1  kiyohara 					SCSI_XFER_DATA(sxfer),
   2669       1.1  kiyohara 					SCSI_XFER_DATALEN(sxfer),
   2670       1.1  kiyohara 					sbp_execute_ocb,
   2671       1.1  kiyohara 					ocb,
   2672       1.1  kiyohara 					/*flags*/0);
   2673       1.1  kiyohara 			splx(s);
   2674       1.1  kiyohara 			if (error)
   2675       1.1  kiyohara 				printf("sbp: bus_dmamap_load error %d\n", error);
   2676       1.1  kiyohara 		} else
   2677       1.1  kiyohara 			sbp_execute_ocb(ocb, NULL, 0, 0);
   2678       1.1  kiyohara 		break;
   2679       1.1  kiyohara 	}
   2680       1.1  kiyohara #if defined(__FreeBSD__)
   2681       1.1  kiyohara 	case XPT_CALC_GEOMETRY:
   2682       1.1  kiyohara 	{
   2683       1.1  kiyohara 		struct ccb_calc_geometry *ccg;
   2684       1.1  kiyohara #if defined(__DragonFly__) || __FreeBSD_version < 501100
   2685       1.1  kiyohara 		uint32_t size_mb;
   2686       1.1  kiyohara 		uint32_t secs_per_cylinder;
   2687       1.1  kiyohara 		int extended = 1;
   2688       1.1  kiyohara #endif
   2689       1.1  kiyohara 
   2690       1.1  kiyohara 		ccg = &sxfer->ccg;
   2691       1.1  kiyohara 		if (ccg->block_size == 0) {
   2692       1.1  kiyohara 			printf("sbp_action1: block_size is 0.\n");
   2693       1.1  kiyohara 			SCSI_XFER_ERROR(sxfer) = XS_REQ_INVALID;
   2694       1.1  kiyohara 			SCSI_TRANSFER_DONE(sxfer);
   2695       1.1  kiyohara 			break;
   2696       1.1  kiyohara 		}
   2697       1.1  kiyohara SBP_DEBUG(1)
   2698       1.1  kiyohara 		printf("%s:%d:%d:%d:XPT_CALC_GEOMETRY: "
   2699       1.1  kiyohara #if defined(__DragonFly__) || __FreeBSD_version < 500000
   2700       1.1  kiyohara 			"Volume size = %d\n",
   2701       1.1  kiyohara #else
   2702       1.1  kiyohara 			"Volume size = %jd\n",
   2703       1.1  kiyohara #endif
   2704      1.19  kiyohara 			fw_get_nameunit(sbp->fd.dev),
   2705       1.1  kiyohara 			cam_sim_path(sbp->sim),
   2706       1.1  kiyohara 			sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun,
   2707       1.1  kiyohara #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
   2708       1.1  kiyohara 			(uintmax_t)
   2709       1.1  kiyohara #endif
   2710       1.1  kiyohara 				ccg->volume_size);
   2711       1.1  kiyohara END_DEBUG
   2712       1.1  kiyohara 
   2713       1.1  kiyohara #if defined(__DragonFly__) || __FreeBSD_version < 501100
   2714       1.1  kiyohara 		size_mb = ccg->volume_size
   2715       1.1  kiyohara 			/ ((1024L * 1024L) / ccg->block_size);
   2716       1.1  kiyohara 
   2717       1.1  kiyohara 		if (size_mb > 1024 && extended) {
   2718       1.1  kiyohara 			ccg->heads = 255;
   2719       1.1  kiyohara 			ccg->secs_per_track = 63;
   2720       1.1  kiyohara 		} else {
   2721       1.1  kiyohara 			ccg->heads = 64;
   2722       1.1  kiyohara 			ccg->secs_per_track = 32;
   2723       1.1  kiyohara 		}
   2724       1.1  kiyohara 		secs_per_cylinder = ccg->heads * ccg->secs_per_track;
   2725       1.1  kiyohara 		ccg->cylinders = ccg->volume_size / secs_per_cylinder;
   2726       1.1  kiyohara 		SCSI_XFER_ERROR(sxfer) = XS_REQ_CMP;
   2727       1.1  kiyohara #else
   2728       1.1  kiyohara 		cam_calc_geometry(ccg, /*extended*/1);
   2729       1.1  kiyohara #endif
   2730       1.1  kiyohara 		SCSI_TRANSFER_DONE(sxfer);
   2731       1.1  kiyohara 		break;
   2732       1.1  kiyohara 	}
   2733       1.1  kiyohara 	case XPT_RESET_BUS:		/* Reset the specified SCSI bus */
   2734       1.1  kiyohara 	{
   2735       1.1  kiyohara 
   2736       1.1  kiyohara SBP_DEBUG(1)
   2737       1.1  kiyohara 		printf("%s:%d:XPT_RESET_BUS: \n",
   2738      1.19  kiyohara 			fw_get_nameunit(sbp->fd.dev), cam_sim_path(sbp->sim));
   2739       1.1  kiyohara END_DEBUG
   2740       1.1  kiyohara 
   2741       1.1  kiyohara 		SCSI_XFER_ERROR(sxfer) = XS_REQ_INVALID;
   2742       1.1  kiyohara 		SCSI_TRANSFER_DONE(sxfer);
   2743       1.1  kiyohara 		break;
   2744       1.1  kiyohara 	}
   2745       1.1  kiyohara 	case XPT_PATH_INQ:		/* Path routing inquiry */
   2746       1.1  kiyohara 	{
   2747       1.1  kiyohara 		struct ccb_pathinq *cpi = &sxfer->cpi;
   2748       1.1  kiyohara 		struct cam_sim *sim = sbp->sim;
   2749       1.1  kiyohara 
   2750       1.1  kiyohara SBP_DEBUG(1)
   2751       1.1  kiyohara 		printf("%s:%d:%d XPT_PATH_INQ:.\n",
   2752      1.19  kiyohara 			fw_get_nameunit(sbp->fd.dev),
   2753       1.1  kiyohara 			sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun);
   2754       1.1  kiyohara END_DEBUG
   2755       1.1  kiyohara 		cpi->version_num = 1; /* XXX??? */
   2756       1.1  kiyohara 		cpi->hba_inquiry = PI_TAG_ABLE;
   2757       1.1  kiyohara 		cpi->target_sprt = 0;
   2758       1.1  kiyohara 		cpi->hba_misc = PIM_NOBUSRESET | PIM_NO_6_BYTE;
   2759       1.1  kiyohara 		cpi->hba_eng_cnt = 0;
   2760       1.1  kiyohara 		cpi->max_target = SBP_NUM_TARGETS - 1;
   2761       1.1  kiyohara 		cpi->max_lun = SBP_NUM_LUNS - 1;
   2762       1.1  kiyohara 		cpi->initiator_id = SBP_INITIATOR;
   2763       1.1  kiyohara 		cpi->bus_id = sim->bus_id;
   2764       1.1  kiyohara 		cpi->base_transfer_speed = 400 * 1000 / 8;
   2765       1.1  kiyohara 		strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
   2766       1.1  kiyohara 		strncpy(cpi->hba_vid, "SBP", HBA_IDLEN);
   2767       1.1  kiyohara 		strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN);
   2768       1.1  kiyohara 		cpi->unit_number = sim->unit_number;
   2769      1.16  kiyohara 		cpi->transport = XPORT_SPI;	/* XX should havea FireWire */
   2770      1.16  kiyohara 		cpi->transport_version = 2;
   2771      1.16  kiyohara 		cpi->protocol = PROTO_SCSI;
   2772      1.16  kiyohara 		cpi->protocol_version = SCSI_REV_2;
   2773       1.1  kiyohara 
   2774       1.1  kiyohara 		SCSI_XFER_ERROR(cpi) = XS_REQ_CMP;
   2775       1.1  kiyohara 		SCSI_TRANSFER_DONE(sxfer);
   2776       1.1  kiyohara 		break;
   2777       1.1  kiyohara 	}
   2778       1.1  kiyohara 	case XPT_GET_TRAN_SETTINGS:
   2779       1.1  kiyohara 	{
   2780       1.1  kiyohara 		struct ccb_trans_settings *cts = &sxfer->cts;
   2781      1.16  kiyohara 		struct ccb_trans_settings_scsi *scsi =
   2782      1.16  kiyohara 		    &cts->proto_specific.scsi;
   2783      1.16  kiyohara 		struct ccb_trans_settings_spi *spi =
   2784      1.16  kiyohara 		    &cts->xport_specific.spi;
   2785      1.16  kiyohara 
   2786      1.16  kiyohara 		cts->protocol = PROTO_SCSI;
   2787      1.16  kiyohara 		cts->protocol_version = SCSI_REV_2;
   2788      1.16  kiyohara 		cts->transport = XPORT_SPI;     /* should have a FireWire */
   2789      1.16  kiyohara 		cts->transport_version = 2;
   2790      1.16  kiyohara 		spi->valid = CTS_SPI_VALID_DISC;
   2791      1.16  kiyohara 		spi->flags = CTS_SPI_FLAGS_DISC_ENB;
   2792      1.16  kiyohara 		scsi->valid = CTS_SCSI_VALID_TQ;
   2793      1.16  kiyohara 		scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
   2794       1.1  kiyohara SBP_DEBUG(1)
   2795       1.1  kiyohara 		printf("%s:%d:%d XPT_GET_TRAN_SETTINGS:.\n",
   2796      1.19  kiyohara 			fw_get_nameunit(sbp->fd.dev),
   2797       1.1  kiyohara 			sxfer->ccb_h.target_id, sxfer->ccb_h.target_lun);
   2798       1.1  kiyohara END_DEBUG
   2799       1.1  kiyohara 		SCSI_XFER_ERROR(cts) = XS_REQ_CMP;
   2800       1.1  kiyohara 		SCSI_TRANSFER_DONE(sxfer);
   2801       1.1  kiyohara 		break;
   2802       1.1  kiyohara 	}
   2803       1.1  kiyohara 	case XPT_ABORT:
   2804       1.1  kiyohara 		SCSI_XFER_ERROR(sxfer) = XS_UA_ABORT;
   2805       1.1  kiyohara 		SCSI_TRANSFER_DONE(sxfer);
   2806       1.1  kiyohara 		break;
   2807       1.1  kiyohara 	case XPT_SET_TRAN_SETTINGS:
   2808       1.1  kiyohara 		/* XXX */
   2809       1.1  kiyohara 	default:
   2810       1.1  kiyohara 		SCSI_XFER_ERROR(sxfer) = XS_REQ_INVALID;
   2811       1.1  kiyohara 		SCSI_TRANSFER_DONE(sxfer);
   2812       1.1  kiyohara 		break;
   2813       1.1  kiyohara #endif
   2814       1.1  kiyohara 	}
   2815       1.1  kiyohara 	return;
   2816       1.1  kiyohara }
   2817       1.1  kiyohara 
   2818       1.1  kiyohara #if defined(__FreeBSD__)
   2819       1.1  kiyohara static void
   2820       1.1  kiyohara sbp_action(struct cam_sim *sim, sbp_scsi_xfer *sxfer)
   2821       1.1  kiyohara {
   2822       1.1  kiyohara 	int s;
   2823       1.1  kiyohara 
   2824       1.1  kiyohara 	s = splfw();
   2825       1.1  kiyohara 	sbp_action1(sim->softc, sxfer);
   2826       1.1  kiyohara 	splx(s);
   2827       1.1  kiyohara }
   2828       1.1  kiyohara #endif
   2829       1.1  kiyohara 
   2830       1.1  kiyohara static void
   2831       1.1  kiyohara sbp_execute_ocb(void *arg,  bus_dma_segment_t *segments, int seg, int error)
   2832       1.1  kiyohara {
   2833       1.1  kiyohara 	int i;
   2834       1.1  kiyohara 	struct sbp_ocb *ocb;
   2835       1.1  kiyohara 	struct sbp_ocb *prev;
   2836       1.1  kiyohara 	bus_dma_segment_t *s;
   2837       1.1  kiyohara 
   2838       1.1  kiyohara 	if (error)
   2839       1.1  kiyohara 		printf("sbp_execute_ocb: error=%d\n", error);
   2840       1.1  kiyohara 
   2841       1.1  kiyohara 	ocb = (struct sbp_ocb *)arg;
   2842       1.1  kiyohara 
   2843       1.1  kiyohara SBP_DEBUG(2)
   2844       1.1  kiyohara 	printf("sbp_execute_ocb: seg %d", seg);
   2845       1.1  kiyohara 	for (i = 0; i < seg; i++)
   2846       1.1  kiyohara #if defined(__DragonFly__) || \
   2847       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   2848       1.1  kiyohara 		printf(", %x:%d", segments[i].ds_addr, segments[i].ds_len);
   2849       1.1  kiyohara #else
   2850       1.1  kiyohara 		printf(", %jx:%jd", (uintmax_t)segments[i].ds_addr,
   2851       1.1  kiyohara 					(uintmax_t)segments[i].ds_len);
   2852       1.1  kiyohara #endif
   2853       1.1  kiyohara 	printf("\n");
   2854       1.1  kiyohara END_DEBUG
   2855       1.1  kiyohara 
   2856       1.1  kiyohara 	if (seg == 1) {
   2857       1.1  kiyohara 		/* direct pointer */
   2858       1.1  kiyohara 		s = &segments[0];
   2859       1.1  kiyohara 		if (s->ds_len > SBP_SEG_MAX)
   2860       1.1  kiyohara 			panic("ds_len > SBP_SEG_MAX, fix busdma code");
   2861       1.1  kiyohara 		ocb->orb[3] = htonl(s->ds_addr);
   2862       1.1  kiyohara 		ocb->orb[4] |= htonl(s->ds_len);
   2863       1.1  kiyohara 	} else if(seg > 1) {
   2864       1.1  kiyohara 		/* page table */
   2865       1.1  kiyohara 		for (i = 0; i < seg; i++) {
   2866       1.1  kiyohara 			s = &segments[i];
   2867       1.1  kiyohara SBP_DEBUG(0)
   2868       1.1  kiyohara 			/* XXX LSI Logic "< 16 byte" bug might be hit */
   2869       1.1  kiyohara 			if (s->ds_len < 16)
   2870       1.1  kiyohara 				printf("sbp_execute_ocb: warning, "
   2871       1.1  kiyohara #if defined(__DragonFly__) || \
   2872       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   2873       1.1  kiyohara 					"segment length(%d) is less than 16."
   2874       1.1  kiyohara #else
   2875       1.1  kiyohara 					"segment length(%jd) is less than 16."
   2876       1.1  kiyohara #endif
   2877       1.1  kiyohara 					"(seg=%d/%d)\n", (uintmax_t)s->ds_len, i+1, seg);
   2878       1.1  kiyohara END_DEBUG
   2879       1.1  kiyohara 			if (s->ds_len > SBP_SEG_MAX)
   2880       1.1  kiyohara 				panic("ds_len > SBP_SEG_MAX, fix busdma code");
   2881       1.1  kiyohara 			ocb->ind_ptr[i].hi = htonl(s->ds_len << 16);
   2882       1.1  kiyohara 			ocb->ind_ptr[i].lo = htonl(s->ds_addr);
   2883       1.1  kiyohara 		}
   2884       1.1  kiyohara 		ocb->orb[4] |= htonl(ORB_CMD_PTBL | seg);
   2885       1.1  kiyohara 	}
   2886       1.1  kiyohara 
   2887       1.1  kiyohara 	if (seg > 0)
   2888       1.1  kiyohara 		fw_bus_dmamap_sync(ocb->sdev->target->sbp->dmat, ocb->dmamap,
   2889       1.1  kiyohara 			(ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
   2890       1.1  kiyohara 			BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
   2891       1.1  kiyohara 	prev = sbp_enqueue_ocb(ocb->sdev, ocb);
   2892       1.1  kiyohara 	fwdma_sync(&ocb->sdev->dma, BUS_DMASYNC_PREWRITE);
   2893       1.1  kiyohara 	if (use_doorbell) {
   2894       1.1  kiyohara 		if (prev == NULL) {
   2895       1.1  kiyohara 			if (ocb->sdev->last_ocb != NULL)
   2896       1.1  kiyohara 				sbp_doorbell(ocb->sdev);
   2897       1.1  kiyohara 			else
   2898       1.1  kiyohara 				sbp_orb_pointer(ocb->sdev, ocb);
   2899       1.1  kiyohara 		}
   2900       1.1  kiyohara 	} else {
   2901       1.1  kiyohara 		if (prev == NULL || (ocb->sdev->flags & ORB_LINK_DEAD) != 0) {
   2902       1.1  kiyohara 			ocb->sdev->flags &= ~ORB_LINK_DEAD;
   2903       1.1  kiyohara 			sbp_orb_pointer(ocb->sdev, ocb);
   2904       1.1  kiyohara 		}
   2905       1.1  kiyohara 	}
   2906       1.1  kiyohara }
   2907       1.1  kiyohara 
   2908       1.1  kiyohara #if defined(__FreeBSD__)
   2909       1.1  kiyohara static void
   2910       1.1  kiyohara sbp_poll(struct cam_sim *sim)
   2911       1.1  kiyohara {
   2912       1.1  kiyohara 	struct sbp_softc *sbp;
   2913       1.1  kiyohara 	struct firewire_comm *fc;
   2914       1.1  kiyohara 
   2915       1.1  kiyohara 	sbp = (struct sbp_softc *)sim->softc;
   2916       1.1  kiyohara 	fc = sbp->fd.fc;
   2917       1.1  kiyohara 
   2918       1.1  kiyohara 	fc->poll(fc, 0, -1);
   2919       1.1  kiyohara 
   2920       1.1  kiyohara 	return;
   2921       1.1  kiyohara }
   2922       1.1  kiyohara 
   2923       1.1  kiyohara #endif
   2924       1.1  kiyohara static struct sbp_ocb *
   2925       1.1  kiyohara sbp_dequeue_ocb(struct sbp_dev *sdev, struct sbp_status *sbp_status)
   2926       1.1  kiyohara {
   2927       1.1  kiyohara 	struct sbp_ocb *ocb;
   2928       1.1  kiyohara 	struct sbp_ocb *next;
   2929       1.1  kiyohara 	int s = splfw(), order = 0;
   2930       1.1  kiyohara 	int flags;
   2931       1.1  kiyohara 
   2932       1.1  kiyohara SBP_DEBUG(1)
   2933       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   2934       1.1  kiyohara #if defined(__DragonFly__) || \
   2935       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   2936       1.1  kiyohara 	printf("%s: 0x%08lx src %d\n",
   2937       1.1  kiyohara #else
   2938       1.1  kiyohara 	printf("%s: 0x%08x src %d\n",
   2939       1.1  kiyohara #endif
   2940       1.1  kiyohara 	    __func__, ntohl(sbp_status->orb_lo), sbp_status->src);
   2941       1.1  kiyohara END_DEBUG
   2942      1.19  kiyohara 	SBP_LOCK(sdev->target->sbp);
   2943       1.1  kiyohara 	for (ocb = STAILQ_FIRST(&sdev->ocbs); ocb != NULL; ocb = next) {
   2944       1.1  kiyohara 		next = STAILQ_NEXT(ocb, ocb);
   2945       1.1  kiyohara 		flags = ocb->flags;
   2946       1.1  kiyohara 		if (OCB_MATCH(ocb, sbp_status)) {
   2947       1.1  kiyohara 			/* found */
   2948       1.1  kiyohara 			STAILQ_REMOVE(&sdev->ocbs, ocb, sbp_ocb, ocb);
   2949       1.1  kiyohara 			if (ocb->sxfer != NULL)
   2950       1.1  kiyohara #if defined(__DragonFly__) || defined(__NetBSD__)
   2951      1.19  kiyohara 				fw_callout_stop(&SCSI_XFER_CALLOUT(ocb->sxfer));
   2952       1.1  kiyohara #else
   2953      1.15  christos 				untimeout(sbp_timeout, (void *)ocb,
   2954       1.1  kiyohara 						SCSI_XFER_CALLOUT(ocb->sxfer));
   2955       1.1  kiyohara #endif
   2956       1.1  kiyohara 			if (ntohl(ocb->orb[4]) & 0xffff) {
   2957       1.1  kiyohara 				fw_bus_dmamap_sync(sdev->target->sbp->dmat,
   2958       1.1  kiyohara 					ocb->dmamap,
   2959       1.1  kiyohara 					(ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
   2960       1.1  kiyohara 					BUS_DMASYNC_POSTREAD :
   2961       1.1  kiyohara 					BUS_DMASYNC_POSTWRITE);
   2962       1.1  kiyohara 				fw_bus_dmamap_unload(sdev->target->sbp->dmat,
   2963       1.1  kiyohara 					ocb->dmamap);
   2964       1.1  kiyohara 			}
   2965       1.1  kiyohara 			if (!use_doorbell) {
   2966       1.1  kiyohara 				if (sbp_status->src == SRC_NO_NEXT) {
   2967       1.1  kiyohara 					if (next != NULL)
   2968       1.1  kiyohara 						sbp_orb_pointer(sdev, next);
   2969       1.1  kiyohara 					else if (order > 0) {
   2970       1.1  kiyohara 						/*
   2971       1.1  kiyohara 						 * Unordered execution
   2972       1.1  kiyohara 						 * We need to send pointer for
   2973       1.1  kiyohara 						 * next ORB
   2974       1.1  kiyohara 						 */
   2975       1.1  kiyohara 						sdev->flags |= ORB_LINK_DEAD;
   2976       1.1  kiyohara 					}
   2977       1.1  kiyohara 				}
   2978       1.1  kiyohara 			} else {
   2979       1.1  kiyohara 				/*
   2980       1.1  kiyohara 				 * XXX this is not correct for unordered
   2981       1.1  kiyohara 				 * execution.
   2982       1.1  kiyohara 				 */
   2983       1.1  kiyohara 				if (sdev->last_ocb != NULL)
   2984       1.1  kiyohara 					sbp_free_ocb(sdev, sdev->last_ocb);
   2985       1.1  kiyohara 				sdev->last_ocb = ocb;
   2986       1.1  kiyohara 				if (next != NULL &&
   2987       1.1  kiyohara 				    sbp_status->src == SRC_NO_NEXT)
   2988       1.1  kiyohara 					sbp_doorbell(sdev);
   2989       1.1  kiyohara 			}
   2990       1.1  kiyohara 			break;
   2991       1.1  kiyohara 		} else
   2992       1.1  kiyohara 			order ++;
   2993       1.1  kiyohara 	}
   2994      1.19  kiyohara 	SBP_UNLOCK(sdev->target->sbp);
   2995       1.1  kiyohara 	splx(s);
   2996       1.1  kiyohara SBP_DEBUG(0)
   2997       1.1  kiyohara 	if (ocb && order > 0) {
   2998       1.1  kiyohara 		sbp_show_sdev_info(sdev, 2);
   2999       1.1  kiyohara 		printf("unordered execution order:%d\n", order);
   3000       1.1  kiyohara 	}
   3001       1.1  kiyohara END_DEBUG
   3002       1.1  kiyohara 	return (ocb);
   3003       1.1  kiyohara }
   3004       1.1  kiyohara 
   3005       1.1  kiyohara static struct sbp_ocb *
   3006       1.1  kiyohara sbp_enqueue_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb)
   3007       1.1  kiyohara {
   3008       1.1  kiyohara 	int s = splfw();
   3009       1.1  kiyohara 	struct sbp_ocb *prev, *prev2;
   3010       1.1  kiyohara 
   3011       1.1  kiyohara SBP_DEBUG(1)
   3012       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   3013       1.1  kiyohara #if defined(__DragonFly__) || \
   3014       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   3015       1.1  kiyohara 	printf("%s: 0x%08x\n", __func__, ocb->bus_addr);
   3016       1.1  kiyohara #else
   3017       1.1  kiyohara 	printf("%s: 0x%08jx\n", __func__, (uintmax_t)ocb->bus_addr);
   3018       1.1  kiyohara #endif
   3019       1.1  kiyohara END_DEBUG
   3020       1.1  kiyohara 	prev2 = prev = STAILQ_LAST(&sdev->ocbs, sbp_ocb, ocb);
   3021       1.1  kiyohara 	STAILQ_INSERT_TAIL(&sdev->ocbs, ocb, ocb);
   3022       1.1  kiyohara 
   3023       1.1  kiyohara 	if (ocb->sxfer != NULL)
   3024       1.1  kiyohara #if defined(__DragonFly__) || defined(__NetBSD__)
   3025      1.19  kiyohara 		fw_callout_reset(&SCSI_XFER_CALLOUT(ocb->sxfer),
   3026       1.1  kiyohara 		    mstohz(SCSI_XFER_TIMEOUT(ocb->sxfer)), sbp_timeout, ocb);
   3027       1.1  kiyohara #else
   3028       1.1  kiyohara 		SCSI_XFER_CALLOUT(ocb->sxfer) = timeout(sbp_timeout,
   3029      1.15  christos 		    (void *)ocb, mstohz(SCSI_XFER_TIMEOUT(ocb->sxfer)));
   3030       1.1  kiyohara #endif
   3031       1.1  kiyohara 
   3032       1.1  kiyohara 	if (use_doorbell && prev == NULL)
   3033       1.1  kiyohara 		prev2 = sdev->last_ocb;
   3034       1.1  kiyohara 
   3035       1.1  kiyohara 	if (prev2 != NULL) {
   3036       1.1  kiyohara SBP_DEBUG(2)
   3037       1.1  kiyohara #if defined(__DragonFly__) || \
   3038       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   3039       1.1  kiyohara 		printf("linking chain 0x%x -> 0x%x\n",
   3040       1.1  kiyohara 		    prev2->bus_addr, ocb->bus_addr);
   3041       1.1  kiyohara #else
   3042       1.1  kiyohara 		printf("linking chain 0x%jx -> 0x%jx\n",
   3043       1.1  kiyohara 		    (uintmax_t)prev2->bus_addr, (uintmax_t)ocb->bus_addr);
   3044       1.1  kiyohara #endif
   3045       1.1  kiyohara END_DEBUG
   3046       1.1  kiyohara 		prev2->orb[1] = htonl(ocb->bus_addr);
   3047       1.1  kiyohara 		prev2->orb[0] = 0;
   3048       1.1  kiyohara 	}
   3049       1.1  kiyohara 	splx(s);
   3050       1.1  kiyohara 
   3051       1.1  kiyohara 	return prev;
   3052       1.1  kiyohara }
   3053       1.1  kiyohara 
   3054       1.1  kiyohara static struct sbp_ocb *
   3055       1.1  kiyohara sbp_get_ocb(struct sbp_dev *sdev)
   3056       1.1  kiyohara {
   3057       1.1  kiyohara 	struct sbp_ocb *ocb;
   3058       1.1  kiyohara 	int s = splfw();
   3059      1.19  kiyohara 
   3060      1.19  kiyohara 	fw_mtx_assert(&sdev->target->sbp->mtx, MA_OWNED);
   3061       1.1  kiyohara 	ocb = STAILQ_FIRST(&sdev->free_ocbs);
   3062       1.1  kiyohara 	if (ocb == NULL) {
   3063       1.1  kiyohara 		sdev->flags |= ORB_SHORTAGE;
   3064       1.1  kiyohara 		printf("ocb shortage!!!\n");
   3065       1.1  kiyohara 		splx(s);
   3066       1.1  kiyohara 		return NULL;
   3067       1.1  kiyohara 	}
   3068       1.1  kiyohara 	STAILQ_REMOVE_HEAD(&sdev->free_ocbs, ocb);
   3069       1.1  kiyohara 	splx(s);
   3070       1.1  kiyohara 	ocb->sxfer = NULL;
   3071       1.1  kiyohara 	return (ocb);
   3072       1.1  kiyohara }
   3073       1.1  kiyohara 
   3074       1.1  kiyohara static void
   3075       1.1  kiyohara sbp_free_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb)
   3076       1.1  kiyohara {
   3077       1.1  kiyohara 	ocb->flags = 0;
   3078       1.1  kiyohara 	ocb->sxfer = NULL;
   3079      1.19  kiyohara 
   3080      1.19  kiyohara 	SBP_LOCK(sdev->target->sbp);
   3081       1.1  kiyohara 	STAILQ_INSERT_TAIL(&sdev->free_ocbs, ocb, ocb);
   3082       1.1  kiyohara 	if ((sdev->flags & ORB_SHORTAGE) != 0) {
   3083       1.1  kiyohara 		int count;
   3084       1.1  kiyohara 
   3085       1.1  kiyohara 		sdev->flags &= ~ORB_SHORTAGE;
   3086       1.1  kiyohara 		count = sdev->freeze;
   3087       1.1  kiyohara 		sdev->freeze = 0;
   3088       1.1  kiyohara 		SBP_DEVICE_THAW(sdev, count);
   3089       1.1  kiyohara 	}
   3090      1.19  kiyohara 	SBP_UNLOCK(sdev->target->sbp);
   3091       1.1  kiyohara }
   3092       1.1  kiyohara 
   3093       1.1  kiyohara static void
   3094       1.1  kiyohara sbp_abort_ocb(struct sbp_ocb *ocb, int status)
   3095       1.1  kiyohara {
   3096       1.1  kiyohara 	struct sbp_dev *sdev;
   3097       1.1  kiyohara 
   3098       1.1  kiyohara 	sdev = ocb->sdev;
   3099       1.1  kiyohara SBP_DEBUG(0)
   3100       1.1  kiyohara 	sbp_show_sdev_info(sdev, 2);
   3101       1.1  kiyohara #if defined(__DragonFly__) || \
   3102       1.1  kiyohara     (defined(__FreeBSD__) && __FreeBSD_version < 500000)
   3103       1.1  kiyohara 	printf("sbp_abort_ocb 0x%x\n", ocb->bus_addr);
   3104       1.1  kiyohara #else
   3105       1.1  kiyohara 	printf("sbp_abort_ocb 0x%jx\n", (uintmax_t)ocb->bus_addr);
   3106       1.1  kiyohara #endif
   3107       1.1  kiyohara END_DEBUG
   3108       1.1  kiyohara SBP_DEBUG(1)
   3109       1.1  kiyohara 	if (ocb->sxfer != NULL)
   3110       1.1  kiyohara 		sbp_print_scsi_cmd(ocb);
   3111       1.1  kiyohara END_DEBUG
   3112       1.1  kiyohara 	if (ntohl(ocb->orb[4]) & 0xffff) {
   3113       1.1  kiyohara 		fw_bus_dmamap_sync(sdev->target->sbp->dmat, ocb->dmamap,
   3114       1.1  kiyohara 			(ntohl(ocb->orb[4]) & ORB_CMD_IN) ?
   3115       1.1  kiyohara 			BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
   3116       1.1  kiyohara 		fw_bus_dmamap_unload(sdev->target->sbp->dmat, ocb->dmamap);
   3117       1.1  kiyohara 	}
   3118       1.1  kiyohara 	if (ocb->sxfer != NULL) {
   3119       1.1  kiyohara #if defined(__DragonFly__ ) || defined(__NetBSD__)
   3120      1.19  kiyohara 		fw_callout_stop(&SCSI_XFER_CALLOUT(ocb->sxfer));
   3121       1.1  kiyohara #else
   3122      1.15  christos 		untimeout(sbp_timeout, (void *)ocb,
   3123       1.1  kiyohara 					SCSI_XFER_CALLOUT(ocb->sxfer));
   3124       1.1  kiyohara #endif
   3125       1.1  kiyohara 		SCSI_XFER_ERROR(ocb->sxfer) = status;
   3126      1.19  kiyohara 		SBP_LOCK(sdev->target->sbp);
   3127       1.1  kiyohara 		SCSI_TRANSFER_DONE(ocb->sxfer);
   3128      1.19  kiyohara 		SBP_UNLOCK(sdev->target->sbp);
   3129       1.1  kiyohara 	}
   3130       1.1  kiyohara 	sbp_free_ocb(sdev, ocb);
   3131       1.1  kiyohara }
   3132       1.1  kiyohara 
   3133       1.1  kiyohara static void
   3134       1.1  kiyohara sbp_abort_all_ocbs(struct sbp_dev *sdev, int status)
   3135       1.1  kiyohara {
   3136       1.1  kiyohara 	int s;
   3137       1.1  kiyohara 	struct sbp_ocb *ocb, *next;
   3138       1.1  kiyohara 	STAILQ_HEAD(, sbp_ocb) temp;
   3139       1.1  kiyohara 
   3140       1.1  kiyohara 	s = splfw();
   3141       1.1  kiyohara 
   3142       1.1  kiyohara 	bcopy(&sdev->ocbs, &temp, sizeof(temp));
   3143       1.1  kiyohara 	STAILQ_INIT(&sdev->ocbs);
   3144       1.1  kiyohara 	for (ocb = STAILQ_FIRST(&temp); ocb != NULL; ocb = next) {
   3145       1.1  kiyohara 		next = STAILQ_NEXT(ocb, ocb);
   3146       1.1  kiyohara 		sbp_abort_ocb(ocb, status);
   3147       1.1  kiyohara 	}
   3148       1.1  kiyohara 	if (sdev->last_ocb != NULL) {
   3149       1.1  kiyohara 		sbp_free_ocb(sdev, sdev->last_ocb);
   3150       1.1  kiyohara 		sdev->last_ocb = NULL;
   3151       1.1  kiyohara 	}
   3152       1.1  kiyohara 
   3153       1.1  kiyohara 	splx(s);
   3154       1.1  kiyohara }
   3155       1.1  kiyohara 
   3156       1.1  kiyohara #if defined(__FreeBSD__)
   3157       1.1  kiyohara static devclass_t sbp_devclass;
   3158       1.1  kiyohara 
   3159       1.1  kiyohara static device_method_t sbp_methods[] = {
   3160       1.1  kiyohara 	/* device interface */
   3161       1.1  kiyohara 	DEVMETHOD(device_probe,		sbp_probe),
   3162       1.1  kiyohara 	DEVMETHOD(device_attach,	sbp_attach),
   3163       1.1  kiyohara 	DEVMETHOD(device_detach,	sbp_detach),
   3164       1.1  kiyohara 	DEVMETHOD(device_shutdown,	sbp_shutdown),
   3165       1.1  kiyohara 
   3166       1.1  kiyohara 	{ 0, 0 }
   3167       1.1  kiyohara };
   3168       1.1  kiyohara 
   3169       1.1  kiyohara static driver_t sbp_driver = {
   3170       1.1  kiyohara 	"sbp",
   3171       1.1  kiyohara 	sbp_methods,
   3172       1.1  kiyohara 	sizeof(struct sbp_softc),
   3173       1.1  kiyohara };
   3174       1.1  kiyohara #ifdef __DragonFly__
   3175       1.1  kiyohara DECLARE_DUMMY_MODULE(sbp);
   3176       1.1  kiyohara #endif
   3177       1.1  kiyohara DRIVER_MODULE(sbp, firewire, sbp_driver, sbp_devclass, 0, 0);
   3178       1.1  kiyohara MODULE_VERSION(sbp, 1);
   3179       1.1  kiyohara MODULE_DEPEND(sbp, firewire, 1, 1, 1);
   3180       1.1  kiyohara MODULE_DEPEND(sbp, cam, 1, 1, 1);
   3181       1.1  kiyohara #elif defined(__NetBSD__)
   3182       1.1  kiyohara static void
   3183       1.1  kiyohara sbp_scsipi_request(
   3184       1.1  kiyohara     struct scsipi_channel *channel, scsipi_adapter_req_t req, void *arg)
   3185       1.1  kiyohara {
   3186       1.1  kiyohara 	int i, s;
   3187       1.1  kiyohara 	struct sbp_softc *sbp =
   3188  1.20.8.1       mjf 	    device_private(channel->chan_adapter->adapt_dev);
   3189       1.1  kiyohara 	struct scsipi_xfer *xs = arg;
   3190       1.1  kiyohara 
   3191       1.1  kiyohara 	if (debug > 1)
   3192       1.1  kiyohara 		printf("Called sbpscsi_scsipi_request\n");
   3193       1.1  kiyohara 
   3194       1.1  kiyohara 	switch (req) {
   3195       1.1  kiyohara 	case ADAPTER_REQ_RUN_XFER:
   3196       1.1  kiyohara 		if (debug > 1) {
   3197       1.1  kiyohara 			printf("Got req_run_xfer\n");
   3198       1.1  kiyohara 			printf("xs control: 0x%08x, timeout: %d\n",
   3199       1.1  kiyohara 			    xs->xs_control, xs->timeout);
   3200       1.1  kiyohara 			printf("opcode: 0x%02x\n", (int)xs->cmd->opcode);
   3201       1.1  kiyohara 			for (i = 0; i < 15; i++)
   3202       1.1  kiyohara 				printf("0x%02x ",(int)xs->cmd->bytes[i]);
   3203       1.1  kiyohara 			printf("\n");
   3204       1.1  kiyohara 		}
   3205       1.1  kiyohara 		if (xs->xs_control & XS_CTL_RESET) {
   3206       1.1  kiyohara 			if (debug > 1)
   3207       1.1  kiyohara 				printf("XS_CTL_RESET not support\n");
   3208       1.1  kiyohara 			break;
   3209       1.1  kiyohara 		}
   3210       1.1  kiyohara #define SBPSCSI_SBP2_MAX_CDB 12
   3211       1.1  kiyohara 		if (xs->cmdlen > SBPSCSI_SBP2_MAX_CDB) {
   3212       1.1  kiyohara 			if (debug > 0)
   3213       1.1  kiyohara 				printf(
   3214       1.1  kiyohara 				    "sbp doesn't support cdb's larger than %d "
   3215       1.1  kiyohara 				    "bytes\n", SBPSCSI_SBP2_MAX_CDB);
   3216       1.1  kiyohara 			SCSI_XFER_ERROR(xs) = XS_REQ_INVALID;
   3217       1.1  kiyohara 			SCSI_TRANSFER_DONE(xs);
   3218       1.1  kiyohara 			return;
   3219       1.1  kiyohara 		}
   3220       1.1  kiyohara 		s = splfw();
   3221       1.1  kiyohara 		sbp_action1(sbp, xs);
   3222       1.1  kiyohara 		splx(s);
   3223       1.1  kiyohara 
   3224       1.1  kiyohara 		break;
   3225       1.1  kiyohara 	case ADAPTER_REQ_GROW_RESOURCES:
   3226       1.1  kiyohara 		if (debug > 1)
   3227       1.1  kiyohara 			printf("Got req_grow_resources\n");
   3228       1.1  kiyohara 		break;
   3229       1.1  kiyohara 	case ADAPTER_REQ_SET_XFER_MODE:
   3230       1.1  kiyohara 		if (debug > 1)
   3231       1.1  kiyohara 			printf("Got set xfer mode\n");
   3232       1.1  kiyohara 		break;
   3233       1.1  kiyohara 	default:
   3234       1.1  kiyohara 		panic("Unknown request: %d\n", (int)req);
   3235       1.1  kiyohara 	}
   3236       1.1  kiyohara }
   3237       1.1  kiyohara 
   3238       1.1  kiyohara static void
   3239       1.1  kiyohara sbp_minphys(struct buf *bp)
   3240       1.1  kiyohara {
   3241       1.1  kiyohara 	minphys(bp);
   3242       1.1  kiyohara }
   3243       1.1  kiyohara 
   3244  1.20.8.1       mjf CFATTACH_DECL_NEW(sbp, sizeof(struct sbp_softc),
   3245       1.1  kiyohara     sbpmatch, sbpattach, sbpdetach, NULL);
   3246       1.1  kiyohara #endif
   3247