1139749Simp/*- 2122526Ssimokawa * Copyright (c) 2003 Hidetoshi Shimokawa 3122526Ssimokawa * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa 4103285Sikob * All rights reserved. 5103285Sikob * 6103285Sikob * Redistribution and use in source and binary forms, with or without 7103285Sikob * modification, are permitted provided that the following conditions 8103285Sikob * are met: 9103285Sikob * 1. Redistributions of source code must retain the above copyright 10103285Sikob * notice, this list of conditions and the following disclaimer. 11103285Sikob * 2. Redistributions in binary form must reproduce the above copyright 12103285Sikob * notice, this list of conditions and the following disclaimer in the 13103285Sikob * documentation and/or other materials provided with the distribution. 14103285Sikob * 3. All advertising materials mentioning features or use of this software 15103285Sikob * must display the acknowledgement as bellow: 16103285Sikob * 17103285Sikob * This product includes software developed by K. Kobayashi and H. Shimokawa 18103285Sikob * 19103285Sikob * 4. The name of the author may not be used to endorse or promote products 20103285Sikob * derived from this software without specific prior written permission. 21103285Sikob * 22103285Sikob * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23103285Sikob * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 24103285Sikob * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 25103285Sikob * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 26103285Sikob * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 27103285Sikob * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 28103285Sikob * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29103285Sikob * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 30103285Sikob * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 31103285Sikob * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32103285Sikob * POSSIBILITY OF SUCH DAMAGE. 33103285Sikob * 34103285Sikob * $FreeBSD: releng/10.2/sys/dev/firewire/sbp.c 275982 2014-12-21 03:06:11Z smh $ 35103285Sikob * 36103285Sikob */ 37103285Sikob 38103285Sikob#include <sys/param.h> 39103285Sikob#include <sys/systm.h> 40103285Sikob#include <sys/module.h> 41103285Sikob#include <sys/bus.h> 42127468Ssimokawa#include <sys/kernel.h> 43103285Sikob#include <sys/sysctl.h> 44103285Sikob#include <machine/bus.h> 45103285Sikob#include <sys/malloc.h> 46127468Ssimokawa#if defined(__FreeBSD__) && __FreeBSD_version >= 501102 47117126Sscottl#include <sys/lock.h> 48117126Sscottl#include <sys/mutex.h> 49117732Ssimokawa#endif 50103285Sikob 51127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500106 52112136Ssimokawa#include <sys/devicestat.h> /* for struct devstat */ 53112136Ssimokawa#endif 54103285Sikob 55127468Ssimokawa#ifdef __DragonFly__ 56127468Ssimokawa#include <bus/cam/cam.h> 57127468Ssimokawa#include <bus/cam/cam_ccb.h> 58127468Ssimokawa#include <bus/cam/cam_sim.h> 59127468Ssimokawa#include <bus/cam/cam_xpt_sim.h> 60127468Ssimokawa#include <bus/cam/cam_debug.h> 61127468Ssimokawa#include <bus/cam/cam_periph.h> 62127468Ssimokawa#include <bus/cam/scsi/scsi_all.h> 63127468Ssimokawa 64127468Ssimokawa#include <bus/firewire/firewire.h> 65127468Ssimokawa#include <bus/firewire/firewirereg.h> 66127468Ssimokawa#include <bus/firewire/fwdma.h> 67127468Ssimokawa#include <bus/firewire/iec13213.h> 68127468Ssimokawa#include "sbp.h" 69127468Ssimokawa#else 70103285Sikob#include <cam/cam.h> 71103285Sikob#include <cam/cam_ccb.h> 72103285Sikob#include <cam/cam_sim.h> 73103285Sikob#include <cam/cam_xpt_sim.h> 74103285Sikob#include <cam/cam_debug.h> 75103285Sikob#include <cam/cam_periph.h> 76103285Sikob#include <cam/scsi/scsi_all.h> 77103285Sikob 78103285Sikob#include <dev/firewire/firewire.h> 79103285Sikob#include <dev/firewire/firewirereg.h> 80113584Ssimokawa#include <dev/firewire/fwdma.h> 81103285Sikob#include <dev/firewire/iec13213.h> 82120660Ssimokawa#include <dev/firewire/sbp.h> 83127468Ssimokawa#endif 84103285Sikob 85103285Sikob#define ccb_sdev_ptr spriv_ptr0 86103285Sikob#define ccb_sbp_ptr spriv_ptr1 87103285Sikob 88111615Ssimokawa#define SBP_NUM_TARGETS 8 /* MAX 64 */ 89121185Ssimokawa/* 90121185Ssimokawa * Scan_bus doesn't work for more than 8 LUNs 91121185Ssimokawa * because of CAM_SCSI2_MAXLUN in cam_xpt.c 92121185Ssimokawa */ 93121185Ssimokawa#define SBP_NUM_LUNS 64 94167622Ssimokawa#define SBP_MAXPHYS MIN(MAXPHYS, (512*1024) /* 512KB */) 95113584Ssimokawa#define SBP_DMA_SIZE PAGE_SIZE 96113584Ssimokawa#define SBP_LOGIN_SIZE sizeof(struct sbp_login_res) 97113584Ssimokawa#define SBP_QUEUE_LEN ((SBP_DMA_SIZE - SBP_LOGIN_SIZE) / sizeof(struct sbp_ocb)) 98103285Sikob#define SBP_NUM_OCB (SBP_QUEUE_LEN * SBP_NUM_TARGETS) 99113584Ssimokawa 100111615Ssimokawa/* 101111615Ssimokawa * STATUS FIFO addressing 102111615Ssimokawa * bit 103111615Ssimokawa * ----------------------- 104130532Sdfr * 0- 1( 2): 0 (alignment) 105111615Ssimokawa * 2- 7( 6): target 106111615Ssimokawa * 8-15( 8): lun 107120660Ssimokawa * 16-31( 8): reserved 108111615Ssimokawa * 32-47(16): SBP_BIND_HI 109111615Ssimokawa * 48-64(16): bus_id, node_id 110111615Ssimokawa */ 111103285Sikob#define SBP_BIND_HI 0x1 112120660Ssimokawa#define SBP_DEV2ADDR(t, l) \ 113120660Ssimokawa (((u_int64_t)SBP_BIND_HI << 32) \ 114120660Ssimokawa | (((l) & 0xff) << 8) \ 115120660Ssimokawa | (((t) & 0x3f) << 2)) 116103285Sikob#define SBP_ADDR2TRG(a) (((a) >> 2) & 0x3f) 117103285Sikob#define SBP_ADDR2LUN(a) (((a) >> 8) & 0xff) 118120660Ssimokawa#define SBP_INITIATOR 7 119103285Sikob 120103285Sikobstatic char *orb_fun_name[] = { 121120660Ssimokawa ORB_FUN_NAMES 122103285Sikob}; 123103285Sikob 124111203Ssimokawastatic int debug = 0; 125103285Sikobstatic int auto_login = 1; 126124251Ssimokawastatic int max_speed = -1; 127111199Ssimokawastatic int sbp_cold = 1; 128122387Ssimokawastatic int ex_login = 1; 129122387Ssimokawastatic int login_delay = 1000; /* msec */ 130122387Ssimokawastatic int scan_delay = 500; /* msec */ 131127468Ssimokawastatic int use_doorbell = 0; 132127468Ssimokawastatic int sbp_tags = 0; 133103285Sikob 134103285SikobSYSCTL_DECL(_hw_firewire); 135227309Sedstatic SYSCTL_NODE(_hw_firewire, OID_AUTO, sbp, CTLFLAG_RD, 0, 136227309Sed "SBP-II Subsystem"); 137103285SikobSYSCTL_INT(_debug, OID_AUTO, sbp_debug, CTLFLAG_RW, &debug, 0, 138103285Sikob "SBP debug flag"); 139103285SikobSYSCTL_INT(_hw_firewire_sbp, OID_AUTO, auto_login, CTLFLAG_RW, &auto_login, 0, 140103285Sikob "SBP perform login automatically"); 141103285SikobSYSCTL_INT(_hw_firewire_sbp, OID_AUTO, max_speed, CTLFLAG_RW, &max_speed, 0, 142103285Sikob "SBP transfer max speed"); 143121792SsimokawaSYSCTL_INT(_hw_firewire_sbp, OID_AUTO, exclusive_login, CTLFLAG_RW, 144130677Ssimokawa &ex_login, 0, "SBP enable exclusive login"); 145122387SsimokawaSYSCTL_INT(_hw_firewire_sbp, OID_AUTO, login_delay, CTLFLAG_RW, 146122387Ssimokawa &login_delay, 0, "SBP login delay in msec"); 147122387SsimokawaSYSCTL_INT(_hw_firewire_sbp, OID_AUTO, scan_delay, CTLFLAG_RW, 148122387Ssimokawa &scan_delay, 0, "SBP scan delay in msec"); 149127468SsimokawaSYSCTL_INT(_hw_firewire_sbp, OID_AUTO, use_doorbell, CTLFLAG_RW, 150127468Ssimokawa &use_doorbell, 0, "SBP use doorbell request"); 151127468SsimokawaSYSCTL_INT(_hw_firewire_sbp, OID_AUTO, tags, CTLFLAG_RW, &sbp_tags, 0, 152127468Ssimokawa "SBP tagged queuing support"); 153103285Sikob 154122387SsimokawaTUNABLE_INT("hw.firewire.sbp.auto_login", &auto_login); 155122387SsimokawaTUNABLE_INT("hw.firewire.sbp.max_speed", &max_speed); 156122387SsimokawaTUNABLE_INT("hw.firewire.sbp.exclusive_login", &ex_login); 157122387SsimokawaTUNABLE_INT("hw.firewire.sbp.login_delay", &login_delay); 158122387SsimokawaTUNABLE_INT("hw.firewire.sbp.scan_delay", &scan_delay); 159127468SsimokawaTUNABLE_INT("hw.firewire.sbp.use_doorbell", &use_doorbell); 160127468SsimokawaTUNABLE_INT("hw.firewire.sbp.tags", &sbp_tags); 161122387Ssimokawa 162103285Sikob#define NEED_RESPONSE 0 163103285Sikob 164113584Ssimokawa#define SBP_SEG_MAX rounddown(0xffff, PAGE_SIZE) 165113584Ssimokawa#ifdef __sparc64__ /* iommu */ 166167622Ssimokawa#define SBP_IND_MAX howmany(SBP_MAXPHYS, SBP_SEG_MAX) 167113584Ssimokawa#else 168167622Ssimokawa#define SBP_IND_MAX howmany(SBP_MAXPHYS, PAGE_SIZE) 169113584Ssimokawa#endif 170103285Sikobstruct sbp_ocb { 171103285Sikob STAILQ_ENTRY(sbp_ocb) ocb; 172103285Sikob union ccb *ccb; 173113584Ssimokawa bus_addr_t bus_addr; 174129585Sdfr uint32_t orb[8]; 175129585Sdfr#define IND_PTR_OFFSET (8*sizeof(uint32_t)) 176120660Ssimokawa struct ind_ptr ind_ptr[SBP_IND_MAX]; 177103285Sikob struct sbp_dev *sdev; 178113584Ssimokawa int flags; /* XXX should be removed */ 179103285Sikob bus_dmamap_t dmamap; 180275978Ssmh struct callout timer; 181103285Sikob}; 182113584Ssimokawa 183103285Sikob#define OCB_ACT_MGM 0 184103285Sikob#define OCB_ACT_CMD 1 185113584Ssimokawa#define OCB_MATCH(o,s) ((o)->bus_addr == ntohl((s)->orb_lo)) 186103285Sikob 187103285Sikobstruct sbp_dev{ 188103285Sikob#define SBP_DEV_RESET 0 /* accept login */ 189114732Ssimokawa#define SBP_DEV_LOGIN 1 /* to login */ 190110336Ssimokawa#if 0 191103285Sikob#define SBP_DEV_RECONN 2 /* to reconnect */ 192110336Ssimokawa#endif 193103285Sikob#define SBP_DEV_TOATTACH 3 /* to attach */ 194103285Sikob#define SBP_DEV_PROBE 4 /* scan lun */ 195103285Sikob#define SBP_DEV_ATTACHED 5 /* in operation */ 196103285Sikob#define SBP_DEV_DEAD 6 /* unavailable unit */ 197103285Sikob#define SBP_DEV_RETRY 7 /* unavailable unit */ 198129585Sdfr uint8_t status:4, 199114732Ssimokawa timeout:4; 200129585Sdfr uint8_t type; 201129585Sdfr uint16_t lun_id; 202129585Sdfr uint16_t freeze; 203121185Ssimokawa#define ORB_LINK_DEAD (1 << 0) 204121185Ssimokawa#define VALID_LUN (1 << 1) 205121185Ssimokawa#define ORB_POINTER_ACTIVE (1 << 2) 206121185Ssimokawa#define ORB_POINTER_NEED (1 << 3) 207127468Ssimokawa#define ORB_DOORBELL_ACTIVE (1 << 4) 208127468Ssimokawa#define ORB_DOORBELL_NEED (1 << 5) 209127468Ssimokawa#define ORB_SHORTAGE (1 << 6) 210129585Sdfr uint16_t flags; 211103285Sikob struct cam_path *path; 212103285Sikob struct sbp_target *target; 213113584Ssimokawa struct fwdma_alloc dma; 214113584Ssimokawa struct sbp_login_res *login; 215111615Ssimokawa struct callout login_callout; 216113584Ssimokawa struct sbp_ocb *ocb; 217103285Sikob STAILQ_HEAD(, sbp_ocb) ocbs; 218113584Ssimokawa STAILQ_HEAD(, sbp_ocb) free_ocbs; 219127468Ssimokawa struct sbp_ocb *last_ocb; 220103285Sikob char vendor[32]; 221103285Sikob char product[32]; 222103285Sikob char revision[10]; 223188756Ssbruno char bustgtlun[32]; 224103285Sikob}; 225103285Sikob 226103285Sikobstruct sbp_target { 227103285Sikob int target_id; 228103285Sikob int num_lun; 229121185Ssimokawa struct sbp_dev **luns; 230103285Sikob struct sbp_softc *sbp; 231103285Sikob struct fw_device *fwdev; 232129585Sdfr uint32_t mgm_hi, mgm_lo; 233111615Ssimokawa struct sbp_ocb *mgm_ocb_cur; 234111615Ssimokawa STAILQ_HEAD(, sbp_ocb) mgm_ocb_queue; 235111615Ssimokawa struct callout mgm_ocb_timeout; 236111615Ssimokawa struct callout scan_callout; 237113584Ssimokawa STAILQ_HEAD(, fw_xfer) xferlist; 238113584Ssimokawa int n_xfer; 239103285Sikob}; 240103285Sikob 241103285Sikobstruct sbp_softc { 242103285Sikob struct firewire_dev_comm fd; 243103285Sikob struct cam_sim *sim; 244111615Ssimokawa struct cam_path *path; 245103285Sikob struct sbp_target targets[SBP_NUM_TARGETS]; 246103285Sikob struct fw_bind fwb; 247103285Sikob bus_dma_tag_t dmat; 248122387Ssimokawa struct timeval last_busreset; 249124145Ssimokawa#define SIMQ_FREEZED 1 250124145Ssimokawa int flags; 251170374Ssimokawa struct mtx mtx; 252103285Sikob}; 253275978Ssmh#define SBP_LOCK(sbp) mtx_lock(&(sbp)->mtx) 254275978Ssmh#define SBP_UNLOCK(sbp) mtx_unlock(&(sbp)->mtx) 255275978Ssmh#define SBP_LOCK_ASSERT(sbp) mtx_assert(&(sbp)->mtx, MA_OWNED) 256122387Ssimokawa 257124169Ssimokawastatic void sbp_post_explore (void *); 258124169Ssimokawastatic void sbp_recv (struct fw_xfer *); 259124169Ssimokawastatic void sbp_mgm_callback (struct fw_xfer *); 260121185Ssimokawa#if 0 261124169Ssimokawastatic void sbp_cmd_callback (struct fw_xfer *); 262121185Ssimokawa#endif 263124169Ssimokawastatic void sbp_orb_pointer (struct sbp_dev *, struct sbp_ocb *); 264127468Ssimokawastatic void sbp_doorbell(struct sbp_dev *); 265124169Ssimokawastatic void sbp_execute_ocb (void *, bus_dma_segment_t *, int, int); 266124169Ssimokawastatic void sbp_free_ocb (struct sbp_dev *, struct sbp_ocb *); 267124169Ssimokawastatic void sbp_abort_ocb (struct sbp_ocb *, int); 268124169Ssimokawastatic void sbp_abort_all_ocbs (struct sbp_dev *, int); 269124169Ssimokawastatic struct fw_xfer * sbp_write_cmd (struct sbp_dev *, int, int); 270124169Ssimokawastatic struct sbp_ocb * sbp_get_ocb (struct sbp_dev *); 271124169Ssimokawastatic struct sbp_ocb * sbp_enqueue_ocb (struct sbp_dev *, struct sbp_ocb *); 272124169Ssimokawastatic struct sbp_ocb * sbp_dequeue_ocb (struct sbp_dev *, struct sbp_status *); 273121185Ssimokawastatic void sbp_cam_detach_sdev(struct sbp_dev *); 274121185Ssimokawastatic void sbp_free_sdev(struct sbp_dev *); 275124169Ssimokawastatic void sbp_cam_detach_target (struct sbp_target *); 276124169Ssimokawastatic void sbp_free_target (struct sbp_target *); 277124169Ssimokawastatic void sbp_mgm_timeout (void *arg); 278124169Ssimokawastatic void sbp_timeout (void *arg); 279124169Ssimokawastatic void sbp_mgm_orb (struct sbp_dev *, int, struct sbp_ocb *); 280103285Sikob 281227293Sedstatic MALLOC_DEFINE(M_SBP, "sbp", "SBP-II/FireWire"); 282103285Sikob 283103285Sikob/* cam related functions */ 284103285Sikobstatic void sbp_action(struct cam_sim *sim, union ccb *ccb); 285103285Sikobstatic void sbp_poll(struct cam_sim *sim); 286111615Ssimokawastatic void sbp_cam_scan_lun(struct cam_periph *, union ccb *); 287111615Ssimokawastatic void sbp_cam_scan_target(void *arg); 288103285Sikob 289103285Sikobstatic char *orb_status0[] = { 290103285Sikob /* 0 */ "No additional information to report", 291103285Sikob /* 1 */ "Request type not supported", 292103285Sikob /* 2 */ "Speed not supported", 293103285Sikob /* 3 */ "Page size not supported", 294103285Sikob /* 4 */ "Access denied", 295103285Sikob /* 5 */ "Logical unit not supported", 296103285Sikob /* 6 */ "Maximum payload too small", 297103285Sikob /* 7 */ "Reserved for future standardization", 298103285Sikob /* 8 */ "Resources unavailable", 299103285Sikob /* 9 */ "Function rejected", 300103285Sikob /* A */ "Login ID not recognized", 301103285Sikob /* B */ "Dummy ORB completed", 302103285Sikob /* C */ "Request aborted", 303103285Sikob /* FF */ "Unspecified error" 304103285Sikob#define MAX_ORB_STATUS0 0xd 305103285Sikob}; 306103285Sikob 307103285Sikobstatic char *orb_status1_object[] = { 308103285Sikob /* 0 */ "Operation request block (ORB)", 309103285Sikob /* 1 */ "Data buffer", 310103285Sikob /* 2 */ "Page table", 311103285Sikob /* 3 */ "Unable to specify" 312103285Sikob}; 313103285Sikob 314103285Sikobstatic char *orb_status1_serial_bus_error[] = { 315103285Sikob /* 0 */ "Missing acknowledge", 316103285Sikob /* 1 */ "Reserved; not to be used", 317103285Sikob /* 2 */ "Time-out error", 318103285Sikob /* 3 */ "Reserved; not to be used", 319103285Sikob /* 4 */ "Busy retry limit exceeded(X)", 320103285Sikob /* 5 */ "Busy retry limit exceeded(A)", 321103285Sikob /* 6 */ "Busy retry limit exceeded(B)", 322103285Sikob /* 7 */ "Reserved for future standardization", 323103285Sikob /* 8 */ "Reserved for future standardization", 324103285Sikob /* 9 */ "Reserved for future standardization", 325103285Sikob /* A */ "Reserved for future standardization", 326103285Sikob /* B */ "Tardy retry limit exceeded", 327103285Sikob /* C */ "Conflict error", 328103285Sikob /* D */ "Data error", 329103285Sikob /* E */ "Type error", 330103285Sikob /* F */ "Address error" 331103285Sikob}; 332103285Sikob 333103285Sikobstatic void 334103285Sikobsbp_identify(driver_t *driver, device_t parent) 335103285Sikob{ 336103285SikobSBP_DEBUG(0) 337103285Sikob printf("sbp_identify\n"); 338103285SikobEND_DEBUG 339103285Sikob 340275978Ssmh if (device_find_child(parent, "sbp", -1) == NULL) 341275978Ssmh BUS_ADD_CHILD(parent, 0, "sbp", -1); 342103285Sikob} 343103285Sikob 344103285Sikob/* 345103285Sikob * sbp_probe() 346103285Sikob */ 347103285Sikobstatic int 348103285Sikobsbp_probe(device_t dev) 349103285Sikob{ 350103285Sikob 351103285SikobSBP_DEBUG(0) 352103285Sikob printf("sbp_probe\n"); 353103285SikobEND_DEBUG 354103285Sikob 355120660Ssimokawa device_set_desc(dev, "SBP-2/SCSI over FireWire"); 356111615Ssimokawa 357132432Ssimokawa#if 0 358111615Ssimokawa if (bootverbose) 359111615Ssimokawa debug = bootverbose; 360132432Ssimokawa#endif 361132432Ssimokawa 362103285Sikob return (0); 363103285Sikob} 364103285Sikob 365188756Ssbruno/* 366188756Ssbruno * Display device characteristics on the console 367188756Ssbruno */ 368103285Sikobstatic void 369188756Ssbrunosbp_show_sdev_info(struct sbp_dev *sdev) 370103285Sikob{ 371103285Sikob struct fw_device *fwdev; 372103285Sikob 373103285Sikob fwdev = sdev->target->fwdev; 374188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 375188756Ssbruno "%s: %s: ordered:%d type:%d EUI:%08x%08x node:%d " 376188756Ssbruno "speed:%d maxrec:%d\n", 377188756Ssbruno __func__, 378188756Ssbruno sdev->bustgtlun, 379108503Ssimokawa (sdev->type & 0x40) >> 6, 380108503Ssimokawa (sdev->type & 0x1f), 381103285Sikob fwdev->eui.hi, 382103285Sikob fwdev->eui.lo, 383103285Sikob fwdev->dst, 384103285Sikob fwdev->speed, 385188756Ssbruno fwdev->maxrec); 386188756Ssbruno 387188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 388188756Ssbruno "%s: %s '%s' '%s' '%s'\n", 389188756Ssbruno __func__, 390188756Ssbruno sdev->bustgtlun, 391188756Ssbruno sdev->vendor, 392188756Ssbruno sdev->product, 393188756Ssbruno sdev->revision); 394103285Sikob} 395103285Sikob 396110184Ssimokawastatic struct { 397110184Ssimokawa int bus; 398110184Ssimokawa int target; 399110184Ssimokawa struct fw_eui64 eui; 400110184Ssimokawa} wired[] = { 401110184Ssimokawa /* Bus Target EUI64 */ 402110184Ssimokawa#if 0 403110184Ssimokawa {0, 2, {0x00018ea0, 0x01fd0154}}, /* Logitec HDD */ 404110184Ssimokawa {0, 0, {0x00018ea6, 0x00100682}}, /* Logitec DVD */ 405110184Ssimokawa {0, 1, {0x00d03200, 0xa412006a}}, /* Yano HDD */ 406110184Ssimokawa#endif 407110184Ssimokawa {-1, -1, {0,0}} 408110184Ssimokawa}; 409110184Ssimokawa 410110184Ssimokawastatic int 411110184Ssimokawasbp_new_target(struct sbp_softc *sbp, struct fw_device *fwdev) 412110184Ssimokawa{ 413110184Ssimokawa int bus, i, target=-1; 414110184Ssimokawa char w[SBP_NUM_TARGETS]; 415110184Ssimokawa 416110184Ssimokawa bzero(w, sizeof(w)); 417110184Ssimokawa bus = device_get_unit(sbp->fd.dev); 418110184Ssimokawa 419110184Ssimokawa /* XXX wired-down configuration should be gotten from 420110184Ssimokawa tunable or device hint */ 421110184Ssimokawa for (i = 0; wired[i].bus >= 0; i ++) { 422110184Ssimokawa if (wired[i].bus == bus) { 423110184Ssimokawa w[wired[i].target] = 1; 424110184Ssimokawa if (wired[i].eui.hi == fwdev->eui.hi && 425110184Ssimokawa wired[i].eui.lo == fwdev->eui.lo) 426110184Ssimokawa target = wired[i].target; 427110184Ssimokawa } 428110184Ssimokawa } 429110184Ssimokawa if (target >= 0) { 430110184Ssimokawa if(target < SBP_NUM_TARGETS && 431110184Ssimokawa sbp->targets[target].fwdev == NULL) 432110184Ssimokawa return(target); 433110184Ssimokawa device_printf(sbp->fd.dev, 434110184Ssimokawa "target %d is not free for %08x:%08x\n", 435110184Ssimokawa target, fwdev->eui.hi, fwdev->eui.lo); 436110184Ssimokawa target = -1; 437110184Ssimokawa } 438110184Ssimokawa /* non-wired target */ 439110184Ssimokawa for (i = 0; i < SBP_NUM_TARGETS; i ++) 440110184Ssimokawa if (sbp->targets[i].fwdev == NULL && w[i] == 0) { 441110184Ssimokawa target = i; 442110184Ssimokawa break; 443110184Ssimokawa } 444110184Ssimokawa 445110184Ssimokawa return target; 446110184Ssimokawa} 447110184Ssimokawa 448121185Ssimokawastatic void 449121185Ssimokawasbp_alloc_lun(struct sbp_target *target) 450103285Sikob{ 451108503Ssimokawa struct crom_context cc; 452108503Ssimokawa struct csrreg *reg; 453121185Ssimokawa struct sbp_dev *sdev, **newluns; 454121185Ssimokawa struct sbp_softc *sbp; 455121185Ssimokawa int maxlun, lun, i; 456103285Sikob 457121185Ssimokawa sbp = target->sbp; 458275978Ssmh SBP_LOCK_ASSERT(sbp); 459114069Ssimokawa crom_init_context(&cc, target->fwdev->csrrom); 460108503Ssimokawa /* XXX shoud parse appropriate unit directories only */ 461108503Ssimokawa maxlun = -1; 462108503Ssimokawa while (cc.depth >= 0) { 463108503Ssimokawa reg = crom_search_key(&cc, CROM_LUN); 464108503Ssimokawa if (reg == NULL) 465108503Ssimokawa break; 466110839Ssimokawa lun = reg->val & 0xffff; 467108642SsimokawaSBP_DEBUG(0) 468108642Ssimokawa printf("target %d lun %d found\n", target->target_id, lun); 469108642SsimokawaEND_DEBUG 470108503Ssimokawa if (maxlun < lun) 471108503Ssimokawa maxlun = lun; 472108503Ssimokawa crom_next(&cc); 473108503Ssimokawa } 474110839Ssimokawa if (maxlun < 0) 475275978Ssmh device_printf(target->sbp->fd.dev, "%d no LUN found\n", 476121185Ssimokawa target->target_id); 477121185Ssimokawa 478121185Ssimokawa maxlun ++; 479110839Ssimokawa if (maxlun >= SBP_NUM_LUNS) 480110839Ssimokawa maxlun = SBP_NUM_LUNS; 481121185Ssimokawa 482121185Ssimokawa /* Invalidiate stale devices */ 483121185Ssimokawa for (lun = 0; lun < target->num_lun; lun ++) { 484121185Ssimokawa sdev = target->luns[lun]; 485121185Ssimokawa if (sdev == NULL) 486121185Ssimokawa continue; 487121185Ssimokawa sdev->flags &= ~VALID_LUN; 488121185Ssimokawa if (lun >= maxlun) { 489121185Ssimokawa /* lost device */ 490121185Ssimokawa sbp_cam_detach_sdev(sdev); 491121185Ssimokawa sbp_free_sdev(sdev); 492187993Ssbruno target->luns[lun] = NULL; 493121185Ssimokawa } 494103285Sikob } 495121185Ssimokawa 496121185Ssimokawa /* Reallocate */ 497121185Ssimokawa if (maxlun != target->num_lun) { 498121185Ssimokawa newluns = (struct sbp_dev **) realloc(target->luns, 499121185Ssimokawa sizeof(struct sbp_dev *) * maxlun, 500121185Ssimokawa M_SBP, M_NOWAIT | M_ZERO); 501121185Ssimokawa 502121185Ssimokawa if (newluns == NULL) { 503127468Ssimokawa printf("%s: realloc failed\n", __func__); 504121185Ssimokawa newluns = target->luns; 505121185Ssimokawa maxlun = target->num_lun; 506121185Ssimokawa } 507121185Ssimokawa 508121185Ssimokawa /* 509121185Ssimokawa * We must zero the extended region for the case 510121185Ssimokawa * realloc() doesn't allocate new buffer. 511121185Ssimokawa */ 512121185Ssimokawa if (maxlun > target->num_lun) 513121185Ssimokawa bzero(&newluns[target->num_lun], 514121185Ssimokawa sizeof(struct sbp_dev *) * 515121185Ssimokawa (maxlun - target->num_lun)); 516121185Ssimokawa 517121185Ssimokawa target->luns = newluns; 518121185Ssimokawa target->num_lun = maxlun; 519121185Ssimokawa } 520121185Ssimokawa 521108503Ssimokawa crom_init_context(&cc, target->fwdev->csrrom); 522108503Ssimokawa while (cc.depth >= 0) { 523121185Ssimokawa int new = 0; 524121185Ssimokawa 525108503Ssimokawa reg = crom_search_key(&cc, CROM_LUN); 526108503Ssimokawa if (reg == NULL) 527108503Ssimokawa break; 528110839Ssimokawa lun = reg->val & 0xffff; 529110839Ssimokawa if (lun >= SBP_NUM_LUNS) { 530110839Ssimokawa printf("too large lun %d\n", lun); 531121185Ssimokawa goto next; 532110839Ssimokawa } 533121185Ssimokawa 534121185Ssimokawa sdev = target->luns[lun]; 535121185Ssimokawa if (sdev == NULL) { 536121185Ssimokawa sdev = malloc(sizeof(struct sbp_dev), 537121185Ssimokawa M_SBP, M_NOWAIT | M_ZERO); 538121185Ssimokawa if (sdev == NULL) { 539127468Ssimokawa printf("%s: malloc failed\n", __func__); 540121185Ssimokawa goto next; 541121185Ssimokawa } 542121185Ssimokawa target->luns[lun] = sdev; 543121185Ssimokawa sdev->lun_id = lun; 544121185Ssimokawa sdev->target = target; 545121185Ssimokawa STAILQ_INIT(&sdev->ocbs); 546275978Ssmh callout_init_mtx(&sdev->login_callout, &sbp->mtx, 0); 547121185Ssimokawa sdev->status = SBP_DEV_RESET; 548121185Ssimokawa new = 1; 549188756Ssbruno snprintf(sdev->bustgtlun, 32, "%s:%d:%d", 550188756Ssbruno device_get_nameunit(sdev->target->sbp->fd.dev), 551188756Ssbruno sdev->target->target_id, 552188756Ssbruno sdev->lun_id); 553121185Ssimokawa } 554121185Ssimokawa sdev->flags |= VALID_LUN; 555119196Ssimokawa sdev->type = (reg->val & 0xff0000) >> 16; 556113584Ssimokawa 557121185Ssimokawa if (new == 0) 558121185Ssimokawa goto next; 559121185Ssimokawa 560113584Ssimokawa fwdma_malloc(sbp->fd.fc, 561129585Sdfr /* alignment */ sizeof(uint32_t), 562219543Smarius SBP_DMA_SIZE, &sdev->dma, BUS_DMA_NOWAIT | 563219543Smarius BUS_DMA_COHERENT); 564113584Ssimokawa if (sdev->dma.v_addr == NULL) { 565113584Ssimokawa printf("%s: dma space allocation failed\n", 566127468Ssimokawa __func__); 567121185Ssimokawa free(sdev, M_SBP); 568121185Ssimokawa target->luns[lun] = NULL; 569121185Ssimokawa goto next; 570113584Ssimokawa } 571113584Ssimokawa sdev->login = (struct sbp_login_res *) sdev->dma.v_addr; 572113584Ssimokawa sdev->ocb = (struct sbp_ocb *) 573113584Ssimokawa ((char *)sdev->dma.v_addr + SBP_LOGIN_SIZE); 574113584Ssimokawa bzero((char *)sdev->ocb, 575113584Ssimokawa sizeof (struct sbp_ocb) * SBP_QUEUE_LEN); 576113584Ssimokawa 577113584Ssimokawa STAILQ_INIT(&sdev->free_ocbs); 578113584Ssimokawa for (i = 0; i < SBP_QUEUE_LEN; i++) { 579113584Ssimokawa struct sbp_ocb *ocb; 580113584Ssimokawa ocb = &sdev->ocb[i]; 581113584Ssimokawa ocb->bus_addr = sdev->dma.bus_addr 582113584Ssimokawa + SBP_LOGIN_SIZE 583113584Ssimokawa + sizeof(struct sbp_ocb) * i 584113584Ssimokawa + offsetof(struct sbp_ocb, orb[0]); 585113584Ssimokawa if (bus_dmamap_create(sbp->dmat, 0, &ocb->dmamap)) { 586113584Ssimokawa printf("sbp_attach: cannot create dmamap\n"); 587121185Ssimokawa /* XXX */ 588121185Ssimokawa goto next; 589113584Ssimokawa } 590275978Ssmh callout_init_mtx(&ocb->timer, &sbp->mtx, 0); 591113584Ssimokawa sbp_free_ocb(sdev, ocb); 592113584Ssimokawa } 593121185Ssimokawanext: 594108503Ssimokawa crom_next(&cc); 595103285Sikob } 596121185Ssimokawa 597121185Ssimokawa for (lun = 0; lun < target->num_lun; lun ++) { 598121185Ssimokawa sdev = target->luns[lun]; 599121185Ssimokawa if (sdev != NULL && (sdev->flags & VALID_LUN) == 0) { 600121185Ssimokawa sbp_cam_detach_sdev(sdev); 601121185Ssimokawa sbp_free_sdev(sdev); 602121185Ssimokawa target->luns[lun] = NULL; 603121185Ssimokawa } 604121185Ssimokawa } 605121185Ssimokawa} 606121185Ssimokawa 607121185Ssimokawastatic struct sbp_target * 608121185Ssimokawasbp_alloc_target(struct sbp_softc *sbp, struct fw_device *fwdev) 609121185Ssimokawa{ 610121185Ssimokawa int i; 611121185Ssimokawa struct sbp_target *target; 612121185Ssimokawa struct crom_context cc; 613121185Ssimokawa struct csrreg *reg; 614121185Ssimokawa 615121185SsimokawaSBP_DEBUG(1) 616121185Ssimokawa printf("sbp_alloc_target\n"); 617121185SsimokawaEND_DEBUG 618121185Ssimokawa i = sbp_new_target(sbp, fwdev); 619121185Ssimokawa if (i < 0) { 620121185Ssimokawa device_printf(sbp->fd.dev, "increase SBP_NUM_TARGETS!\n"); 621121185Ssimokawa return NULL; 622121185Ssimokawa } 623121185Ssimokawa /* new target */ 624121185Ssimokawa target = &sbp->targets[i]; 625121185Ssimokawa target->sbp = sbp; 626121185Ssimokawa target->fwdev = fwdev; 627121185Ssimokawa target->target_id = i; 628121185Ssimokawa /* XXX we may want to reload mgm port after each bus reset */ 629121185Ssimokawa /* XXX there might be multiple management agents */ 630121185Ssimokawa crom_init_context(&cc, target->fwdev->csrrom); 631121185Ssimokawa reg = crom_search_key(&cc, CROM_MGM); 632121185Ssimokawa if (reg == NULL || reg->val == 0) { 633121185Ssimokawa printf("NULL management address\n"); 634121185Ssimokawa target->fwdev = NULL; 635121185Ssimokawa return NULL; 636121185Ssimokawa } 637121185Ssimokawa target->mgm_hi = 0xffff; 638121185Ssimokawa target->mgm_lo = 0xf0000000 | (reg->val << 2); 639121185Ssimokawa target->mgm_ocb_cur = NULL; 640121185SsimokawaSBP_DEBUG(1) 641121185Ssimokawa printf("target:%d mgm_port: %x\n", i, target->mgm_lo); 642121185SsimokawaEND_DEBUG 643121185Ssimokawa STAILQ_INIT(&target->xferlist); 644121185Ssimokawa target->n_xfer = 0; 645121185Ssimokawa STAILQ_INIT(&target->mgm_ocb_queue); 646275978Ssmh callout_init_mtx(&target->mgm_ocb_timeout, &sbp->mtx, 0); 647275978Ssmh callout_init_mtx(&target->scan_callout, &sbp->mtx, 0); 648121185Ssimokawa 649121185Ssimokawa target->luns = NULL; 650121185Ssimokawa target->num_lun = 0; 651114069Ssimokawa return target; 652103285Sikob} 653103285Sikob 654103285Sikobstatic void 655103285Sikobsbp_probe_lun(struct sbp_dev *sdev) 656103285Sikob{ 657103285Sikob struct fw_device *fwdev; 658114069Ssimokawa struct crom_context c, *cc = &c; 659114069Ssimokawa struct csrreg *reg; 660103285Sikob 661103285Sikob bzero(sdev->vendor, sizeof(sdev->vendor)); 662103285Sikob bzero(sdev->product, sizeof(sdev->product)); 663114069Ssimokawa 664114069Ssimokawa fwdev = sdev->target->fwdev; 665114069Ssimokawa crom_init_context(cc, fwdev->csrrom); 666114069Ssimokawa /* get vendor string */ 667114069Ssimokawa crom_search_key(cc, CSRKEY_VENDOR); 668114069Ssimokawa crom_next(cc); 669114069Ssimokawa crom_parse_text(cc, sdev->vendor, sizeof(sdev->vendor)); 670114223Ssimokawa /* skip to the unit directory for SBP-2 */ 671114260Ssimokawa while ((reg = crom_search_key(cc, CSRKEY_VER)) != NULL) { 672114223Ssimokawa if (reg->val == CSRVAL_T10SBP2) 673114223Ssimokawa break; 674114260Ssimokawa crom_next(cc); 675114260Ssimokawa } 676114069Ssimokawa /* get firmware revision */ 677114069Ssimokawa reg = crom_search_key(cc, CSRKEY_FIRM_VER); 678114069Ssimokawa if (reg != NULL) 679114069Ssimokawa snprintf(sdev->revision, sizeof(sdev->revision), 680114069Ssimokawa "%06x", reg->val); 681114069Ssimokawa /* get product string */ 682114069Ssimokawa crom_search_key(cc, CSRKEY_MODEL); 683114069Ssimokawa crom_next(cc); 684114069Ssimokawa crom_parse_text(cc, sdev->product, sizeof(sdev->product)); 685103285Sikob} 686111615Ssimokawa 687103285Sikobstatic void 688111615Ssimokawasbp_login_callout(void *arg) 689103285Sikob{ 690111615Ssimokawa struct sbp_dev *sdev = (struct sbp_dev *)arg; 691275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 692111615Ssimokawa sbp_mgm_orb(sdev, ORB_FUN_LGI, NULL); 693111615Ssimokawa} 694111615Ssimokawa 695122387Ssimokawastatic void 696122387Ssimokawasbp_login(struct sbp_dev *sdev) 697122387Ssimokawa{ 698122387Ssimokawa struct timeval delta; 699122387Ssimokawa struct timeval t; 700122387Ssimokawa int ticks = 0; 701122387Ssimokawa 702122387Ssimokawa microtime(&delta); 703122387Ssimokawa timevalsub(&delta, &sdev->target->sbp->last_busreset); 704122387Ssimokawa t.tv_sec = login_delay / 1000; 705122387Ssimokawa t.tv_usec = (login_delay % 1000) * 1000; 706122387Ssimokawa timevalsub(&t, &delta); 707122387Ssimokawa if (t.tv_sec >= 0 && t.tv_usec > 0) 708122387Ssimokawa ticks = (t.tv_sec * 1000 + t.tv_usec / 1000) * hz / 1000; 709122387SsimokawaSBP_DEBUG(0) 710153706Strhodes printf("%s: sec = %jd usec = %ld ticks = %d\n", __func__, 711153706Strhodes (intmax_t)t.tv_sec, t.tv_usec, ticks); 712122387SsimokawaEND_DEBUG 713122387Ssimokawa callout_reset(&sdev->login_callout, ticks, 714122387Ssimokawa sbp_login_callout, (void *)(sdev)); 715122387Ssimokawa} 716122387Ssimokawa 717114069Ssimokawa#define SBP_FWDEV_ALIVE(fwdev) (((fwdev)->status == FWDEVATTACHED) \ 718114069Ssimokawa && crom_has_specver((fwdev)->csrrom, CSRVAL_ANSIT10, CSRVAL_T10SBP2)) 719111615Ssimokawa 720111615Ssimokawastatic void 721111615Ssimokawasbp_probe_target(void *arg) 722111615Ssimokawa{ 723111615Ssimokawa struct sbp_target *target = (struct sbp_target *)arg; 724188756Ssbruno struct sbp_softc *sbp = target->sbp; 725103285Sikob struct sbp_dev *sdev; 726111615Ssimokawa int i, alive; 727103285Sikob 728111615Ssimokawa alive = SBP_FWDEV_ALIVE(target->fwdev); 729103285SikobSBP_DEBUG(1) 730188756Ssbruno device_printf(sbp->fd.dev, "%s %d%salive\n", 731188756Ssbruno __func__, target->target_id, 732188756Ssbruno (!alive) ? " not " : ""); 733103285SikobEND_DEBUG 734103285Sikob 735103285Sikob sbp = target->sbp; 736275978Ssmh SBP_LOCK_ASSERT(sbp); 737121185Ssimokawa sbp_alloc_lun(target); 738121185Ssimokawa 739111615Ssimokawa /* XXX untimeout mgm_ocb and dequeue */ 740103285Sikob for (i=0; i < target->num_lun; i++) { 741121185Ssimokawa sdev = target->luns[i]; 742121185Ssimokawa if (sdev == NULL) 743121185Ssimokawa continue; 744103285Sikob if (alive && (sdev->status != SBP_DEV_DEAD)) { 745103285Sikob if (sdev->path != NULL) { 746103285Sikob xpt_freeze_devq(sdev->path, 1); 747111615Ssimokawa sdev->freeze ++; 748103285Sikob } 749111615Ssimokawa sbp_probe_lun(sdev); 750188756Ssbruno sbp_show_sdev_info(sdev); 751111615Ssimokawa 752111615Ssimokawa sbp_abort_all_ocbs(sdev, CAM_SCSI_BUS_RESET); 753103285Sikob switch (sdev->status) { 754110336Ssimokawa case SBP_DEV_RESET: 755103285Sikob /* new or revived target */ 756113584Ssimokawa if (auto_login) 757111615Ssimokawa sbp_login(sdev); 758103285Sikob break; 759111615Ssimokawa case SBP_DEV_TOATTACH: 760111615Ssimokawa case SBP_DEV_PROBE: 761111615Ssimokawa case SBP_DEV_ATTACHED: 762110336Ssimokawa case SBP_DEV_RETRY: 763110336Ssimokawa default: 764111615Ssimokawa sbp_mgm_orb(sdev, ORB_FUN_RCN, NULL); 765110336Ssimokawa break; 766103285Sikob } 767103285Sikob } else { 768103285Sikob switch (sdev->status) { 769103285Sikob case SBP_DEV_ATTACHED: 770103285SikobSBP_DEBUG(0) 771103285Sikob /* the device has gone */ 772188756Ssbruno device_printf(sbp->fd.dev, "%s: lost target\n", 773188756Ssbruno __func__); 774103285SikobEND_DEBUG 775111615Ssimokawa if (sdev->path) { 776103285Sikob xpt_freeze_devq(sdev->path, 1); 777111615Ssimokawa sdev->freeze ++; 778111615Ssimokawa } 779103285Sikob sdev->status = SBP_DEV_RETRY; 780187993Ssbruno sbp_cam_detach_sdev(sdev); 781187993Ssbruno sbp_free_sdev(sdev); 782187993Ssbruno target->luns[i] = NULL; 783103285Sikob break; 784103285Sikob case SBP_DEV_PROBE: 785103285Sikob case SBP_DEV_TOATTACH: 786103285Sikob sdev->status = SBP_DEV_RESET; 787103285Sikob break; 788103285Sikob case SBP_DEV_RETRY: 789103285Sikob case SBP_DEV_RESET: 790103285Sikob case SBP_DEV_DEAD: 791103285Sikob break; 792103285Sikob } 793103285Sikob } 794103285Sikob } 795103285Sikob} 796103285Sikob 797103285Sikobstatic void 798113584Ssimokawasbp_post_busreset(void *arg) 799113584Ssimokawa{ 800113584Ssimokawa struct sbp_softc *sbp; 801113584Ssimokawa 802113584Ssimokawa sbp = (struct sbp_softc *)arg; 803113584SsimokawaSBP_DEBUG(0) 804113584Ssimokawa printf("sbp_post_busreset\n"); 805113584SsimokawaEND_DEBUG 806275978Ssmh SBP_LOCK(sbp); 807124145Ssimokawa if ((sbp->sim->flags & SIMQ_FREEZED) == 0) { 808124145Ssimokawa xpt_freeze_simq(sbp->sim, /*count*/1); 809124145Ssimokawa sbp->sim->flags |= SIMQ_FREEZED; 810124145Ssimokawa } 811122387Ssimokawa microtime(&sbp->last_busreset); 812275978Ssmh SBP_UNLOCK(sbp); 813113584Ssimokawa} 814113584Ssimokawa 815113584Ssimokawastatic void 816103285Sikobsbp_post_explore(void *arg) 817103285Sikob{ 818103285Sikob struct sbp_softc *sbp = (struct sbp_softc *)arg; 819103285Sikob struct sbp_target *target; 820103285Sikob struct fw_device *fwdev; 821103285Sikob int i, alive; 822103285Sikob 823111199SsimokawaSBP_DEBUG(0) 824111199Ssimokawa printf("sbp_post_explore (sbp_cold=%d)\n", sbp_cold); 825103285SikobEND_DEBUG 826170400Ssimokawa /* We need physical access */ 827170400Ssimokawa if (!firewire_phydma_enable) 828170400Ssimokawa return; 829170400Ssimokawa 830122387Ssimokawa if (sbp_cold > 0) 831122387Ssimokawa sbp_cold --; 832122387Ssimokawa 833275978Ssmh SBP_LOCK(sbp); 834122387Ssimokawa#if 0 835122387Ssimokawa /* 836122387Ssimokawa * XXX don't let CAM the bus rest. 837122387Ssimokawa * CAM tries to do something with freezed (DEV_RETRY) devices. 838111615Ssimokawa */ 839111615Ssimokawa xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL); 840103285Sikob#endif 841111615Ssimokawa 842130532Sdfr /* Garbage Collection */ 843103285Sikob for(i = 0 ; i < SBP_NUM_TARGETS ; i ++){ 844103285Sikob target = &sbp->targets[i]; 845110193Ssimokawa STAILQ_FOREACH(fwdev, &sbp->fd.fc->devices, link) 846110193Ssimokawa if (target->fwdev == NULL || target->fwdev == fwdev) 847110193Ssimokawa break; 848121185Ssimokawa if (fwdev == NULL) { 849103285Sikob /* device has removed in lower driver */ 850110145Ssimokawa sbp_cam_detach_target(target); 851121185Ssimokawa sbp_free_target(target); 852103285Sikob } 853103285Sikob } 854103285Sikob /* traverse device list */ 855110193Ssimokawa STAILQ_FOREACH(fwdev, &sbp->fd.fc->devices, link) { 856103285SikobSBP_DEBUG(0) 857188756Ssbruno device_printf(sbp->fd.dev,"%s:: EUI:%08x%08x %s attached, state=%d\n", 858188756Ssbruno __func__, fwdev->eui.hi, fwdev->eui.lo, 859188756Ssbruno (fwdev->status != FWDEVATTACHED) ? "not" : "", 860188756Ssbruno fwdev->status); 861103285SikobEND_DEBUG 862111615Ssimokawa alive = SBP_FWDEV_ALIVE(fwdev); 863103285Sikob for(i = 0 ; i < SBP_NUM_TARGETS ; i ++){ 864103285Sikob target = &sbp->targets[i]; 865103285Sikob if(target->fwdev == fwdev ) { 866103285Sikob /* known target */ 867103285Sikob break; 868103285Sikob } 869103285Sikob } 870103285Sikob if(i == SBP_NUM_TARGETS){ 871103285Sikob if (alive) { 872103285Sikob /* new target */ 873103285Sikob target = sbp_alloc_target(sbp, fwdev); 874103285Sikob if (target == NULL) 875103285Sikob continue; 876103285Sikob } else { 877103285Sikob continue; 878103285Sikob } 879103285Sikob } 880111615Ssimokawa sbp_probe_target((void *)target); 881121185Ssimokawa if (target->num_lun == 0) 882121185Ssimokawa sbp_free_target(target); 883103285Sikob } 884124145Ssimokawa xpt_release_simq(sbp->sim, /*run queue*/TRUE); 885124145Ssimokawa sbp->sim->flags &= ~SIMQ_FREEZED; 886170374Ssimokawa SBP_UNLOCK(sbp); 887103285Sikob} 888103285Sikob 889103285Sikob#if NEED_RESPONSE 890103285Sikobstatic void 891103285Sikobsbp_loginres_callback(struct fw_xfer *xfer){ 892103285Sikob struct sbp_dev *sdev; 893103285Sikob sdev = (struct sbp_dev *)xfer->sc; 894113584SsimokawaSBP_DEBUG(1) 895188756Ssbruno device_printf(sdev->target->sbp->fd.dev,"%s\n", __func__); 896103285SikobEND_DEBUG 897113584Ssimokawa /* recycle */ 898275978Ssmh SBP_LOCK(sdev->target->sbp); 899113584Ssimokawa STAILQ_INSERT_TAIL(&sdev->target->sbp->fwb.xferlist, xfer, link); 900275978Ssmh SBP_UNLOCK(sdev->target->sbp); 901103285Sikob return; 902103285Sikob} 903103285Sikob#endif 904103285Sikob 905113584Ssimokawastatic __inline void 906113584Ssimokawasbp_xfer_free(struct fw_xfer *xfer) 907113584Ssimokawa{ 908113584Ssimokawa struct sbp_dev *sdev; 909113584Ssimokawa 910113584Ssimokawa sdev = (struct sbp_dev *)xfer->sc; 911113584Ssimokawa fw_xfer_unload(xfer); 912275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 913113584Ssimokawa STAILQ_INSERT_TAIL(&sdev->target->xferlist, xfer, link); 914113584Ssimokawa} 915113584Ssimokawa 916103285Sikobstatic void 917114732Ssimokawasbp_reset_start_callback(struct fw_xfer *xfer) 918103285Sikob{ 919114732Ssimokawa struct sbp_dev *tsdev, *sdev = (struct sbp_dev *)xfer->sc; 920114732Ssimokawa struct sbp_target *target = sdev->target; 921114732Ssimokawa int i; 922114732Ssimokawa 923114732Ssimokawa if (xfer->resp != 0) { 924188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 925188756Ssbruno "%s: %s failed: resp=%d\n", __func__, sdev->bustgtlun, xfer->resp); 926114732Ssimokawa } 927114732Ssimokawa 928275978Ssmh SBP_LOCK(target->sbp); 929114732Ssimokawa for (i = 0; i < target->num_lun; i++) { 930121185Ssimokawa tsdev = target->luns[i]; 931121185Ssimokawa if (tsdev != NULL && tsdev->status == SBP_DEV_LOGIN) 932121185Ssimokawa sbp_login(tsdev); 933114732Ssimokawa } 934275978Ssmh SBP_UNLOCK(target->sbp); 935114732Ssimokawa} 936114732Ssimokawa 937114732Ssimokawastatic void 938114732Ssimokawasbp_reset_start(struct sbp_dev *sdev) 939114732Ssimokawa{ 940114732Ssimokawa struct fw_xfer *xfer; 941114732Ssimokawa struct fw_pkt *fp; 942114732Ssimokawa 943114732SsimokawaSBP_DEBUG(0) 944188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 945188756Ssbruno "%s:%s\n", __func__,sdev->bustgtlun); 946114732SsimokawaEND_DEBUG 947114732Ssimokawa 948114732Ssimokawa xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0); 949167632Ssimokawa xfer->hand = sbp_reset_start_callback; 950120660Ssimokawa fp = &xfer->send.hdr; 951114732Ssimokawa fp->mode.wreqq.dest_hi = 0xffff; 952114732Ssimokawa fp->mode.wreqq.dest_lo = 0xf0000000 | RESET_START; 953114732Ssimokawa fp->mode.wreqq.data = htonl(0xf); 954114732Ssimokawa fw_asyreq(xfer->fc, -1, xfer); 955114732Ssimokawa} 956114732Ssimokawa 957114732Ssimokawastatic void 958114732Ssimokawasbp_mgm_callback(struct fw_xfer *xfer) 959114732Ssimokawa{ 960103285Sikob struct sbp_dev *sdev; 961114732Ssimokawa int resp; 962114732Ssimokawa 963103285Sikob sdev = (struct sbp_dev *)xfer->sc; 964114732Ssimokawa 965114732SsimokawaSBP_DEBUG(1) 966188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 967188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 968103285SikobEND_DEBUG 969114732Ssimokawa resp = xfer->resp; 970275978Ssmh SBP_LOCK(sdev->target->sbp); 971113584Ssimokawa sbp_xfer_free(xfer); 972275978Ssmh SBP_UNLOCK(sdev->target->sbp); 973103285Sikob} 974103285Sikob 975111615Ssimokawastatic struct sbp_dev * 976111615Ssimokawasbp_next_dev(struct sbp_target *target, int lun) 977111615Ssimokawa{ 978121185Ssimokawa struct sbp_dev **sdevp; 979111615Ssimokawa int i; 980111615Ssimokawa 981121185Ssimokawa for (i = lun, sdevp = &target->luns[lun]; i < target->num_lun; 982121185Ssimokawa i++, sdevp++) 983121185Ssimokawa if (*sdevp != NULL && (*sdevp)->status == SBP_DEV_PROBE) 984121185Ssimokawa return(*sdevp); 985121185Ssimokawa return(NULL); 986111615Ssimokawa} 987111615Ssimokawa 988111615Ssimokawa#define SCAN_PRI 1 989103285Sikobstatic void 990111615Ssimokawasbp_cam_scan_lun(struct cam_periph *periph, union ccb *ccb) 991103285Sikob{ 992111615Ssimokawa struct sbp_target *target; 993103285Sikob struct sbp_dev *sdev; 994111615Ssimokawa 995103285Sikob sdev = (struct sbp_dev *) ccb->ccb_h.ccb_sdev_ptr; 996111615Ssimokawa target = sdev->target; 997275978Ssmh SBP_LOCK_ASSERT(target->sbp); 998110269SsimokawaSBP_DEBUG(0) 999188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1000188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1001103285SikobEND_DEBUG 1002111615Ssimokawa if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) { 1003111615Ssimokawa sdev->status = SBP_DEV_ATTACHED; 1004111615Ssimokawa } else { 1005188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1006188756Ssbruno "%s:%s failed\n", __func__, sdev->bustgtlun); 1007111615Ssimokawa } 1008111615Ssimokawa sdev = sbp_next_dev(target, sdev->lun_id + 1); 1009111615Ssimokawa if (sdev == NULL) { 1010111615Ssimokawa free(ccb, M_SBP); 1011111615Ssimokawa return; 1012111615Ssimokawa } 1013111615Ssimokawa /* reuse ccb */ 1014111615Ssimokawa xpt_setup_ccb(&ccb->ccb_h, sdev->path, SCAN_PRI); 1015111615Ssimokawa ccb->ccb_h.ccb_sdev_ptr = sdev; 1016111615Ssimokawa xpt_action(ccb); 1017111615Ssimokawa xpt_release_devq(sdev->path, sdev->freeze, TRUE); 1018111615Ssimokawa sdev->freeze = 1; 1019103285Sikob} 1020103285Sikob 1021103285Sikobstatic void 1022111615Ssimokawasbp_cam_scan_target(void *arg) 1023103285Sikob{ 1024111615Ssimokawa struct sbp_target *target = (struct sbp_target *)arg; 1025111615Ssimokawa struct sbp_dev *sdev; 1026110798Ssimokawa union ccb *ccb; 1027103285Sikob 1028275978Ssmh SBP_LOCK_ASSERT(target->sbp); 1029111615Ssimokawa sdev = sbp_next_dev(target, 0); 1030111615Ssimokawa if (sdev == NULL) { 1031111615Ssimokawa printf("sbp_cam_scan_target: nothing to do for target%d\n", 1032111615Ssimokawa target->target_id); 1033110798Ssimokawa return; 1034110798Ssimokawa } 1035103285SikobSBP_DEBUG(0) 1036188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1037188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1038103285SikobEND_DEBUG 1039111615Ssimokawa ccb = malloc(sizeof(union ccb), M_SBP, M_NOWAIT | M_ZERO); 1040111615Ssimokawa if (ccb == NULL) { 1041111615Ssimokawa printf("sbp_cam_scan_target: malloc failed\n"); 1042111615Ssimokawa return; 1043111615Ssimokawa } 1044111615Ssimokawa xpt_setup_ccb(&ccb->ccb_h, sdev->path, SCAN_PRI); 1045103285Sikob ccb->ccb_h.func_code = XPT_SCAN_LUN; 1046111615Ssimokawa ccb->ccb_h.cbfcnp = sbp_cam_scan_lun; 1047111615Ssimokawa ccb->ccb_h.flags |= CAM_DEV_QFREEZE; 1048103285Sikob ccb->crcn.flags = CAM_FLAG_NONE; 1049103285Sikob ccb->ccb_h.ccb_sdev_ptr = sdev; 1050103285Sikob 1051103285Sikob /* The scan is in progress now. */ 1052111040Ssimokawa xpt_action(ccb); 1053111615Ssimokawa xpt_release_devq(sdev->path, sdev->freeze, TRUE); 1054111615Ssimokawa sdev->freeze = 1; 1055103285Sikob} 1056103285Sikob 1057111615Ssimokawastatic __inline void 1058111615Ssimokawasbp_scan_dev(struct sbp_dev *sdev) 1059111615Ssimokawa{ 1060111040Ssimokawa sdev->status = SBP_DEV_PROBE; 1061275982Ssmh callout_reset_sbt(&sdev->target->scan_callout, SBT_1MS * scan_delay, 0, 1062275982Ssmh sbp_cam_scan_target, (void *)sdev->target, 0); 1063103285Sikob} 1064103285Sikob 1065103285Sikobstatic void 1066103285Sikobsbp_do_attach(struct fw_xfer *xfer) 1067103285Sikob{ 1068103285Sikob struct sbp_dev *sdev; 1069111615Ssimokawa struct sbp_target *target; 1070111615Ssimokawa struct sbp_softc *sbp; 1071103285Sikob 1072103285Sikob sdev = (struct sbp_dev *)xfer->sc; 1073111615Ssimokawa target = sdev->target; 1074111615Ssimokawa sbp = target->sbp; 1075275978Ssmh SBP_LOCK(sbp); 1076103285SikobSBP_DEBUG(0) 1077188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1078188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1079103285SikobEND_DEBUG 1080113584Ssimokawa sbp_xfer_free(xfer); 1081111199Ssimokawa 1082103285Sikob if (sdev->path == NULL) 1083249468Smav xpt_create_path(&sdev->path, NULL, 1084111615Ssimokawa cam_sim_path(target->sbp->sim), 1085111615Ssimokawa target->target_id, sdev->lun_id); 1086103285Sikob 1087111199Ssimokawa /* 1088111199Ssimokawa * Let CAM scan the bus if we are in the boot process. 1089111199Ssimokawa * XXX xpt_scan_bus cannot detect LUN larger than 0 1090275978Ssmh * if LUN 0 doesn't exist. 1091111199Ssimokawa */ 1092111199Ssimokawa if (sbp_cold > 0) { 1093111615Ssimokawa sdev->status = SBP_DEV_ATTACHED; 1094275978Ssmh SBP_UNLOCK(sbp); 1095111199Ssimokawa return; 1096111199Ssimokawa } 1097111199Ssimokawa 1098111615Ssimokawa sbp_scan_dev(sdev); 1099275978Ssmh SBP_UNLOCK(sbp); 1100103285Sikob} 1101103285Sikob 1102103285Sikobstatic void 1103103285Sikobsbp_agent_reset_callback(struct fw_xfer *xfer) 1104103285Sikob{ 1105103285Sikob struct sbp_dev *sdev; 1106103285Sikob 1107103285Sikob sdev = (struct sbp_dev *)xfer->sc; 1108103285SikobSBP_DEBUG(1) 1109188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1110188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1111103285SikobEND_DEBUG 1112114732Ssimokawa if (xfer->resp != 0) { 1113188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1114188756Ssbruno "%s:%s resp=%d\n", __func__, sdev->bustgtlun, xfer->resp); 1115114732Ssimokawa } 1116114732Ssimokawa 1117275978Ssmh SBP_LOCK(sdev->target->sbp); 1118113584Ssimokawa sbp_xfer_free(xfer); 1119111615Ssimokawa if (sdev->path) { 1120111615Ssimokawa xpt_release_devq(sdev->path, sdev->freeze, TRUE); 1121111615Ssimokawa sdev->freeze = 0; 1122111615Ssimokawa } 1123275978Ssmh SBP_UNLOCK(sdev->target->sbp); 1124103285Sikob} 1125103285Sikob 1126103285Sikobstatic void 1127110336Ssimokawasbp_agent_reset(struct sbp_dev *sdev) 1128103285Sikob{ 1129103285Sikob struct fw_xfer *xfer; 1130103285Sikob struct fw_pkt *fp; 1131103285Sikob 1132275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 1133103285SikobSBP_DEBUG(0) 1134188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1135188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1136103285SikobEND_DEBUG 1137103285Sikob xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x04); 1138103285Sikob if (xfer == NULL) 1139103285Sikob return; 1140115788Ssimokawa if (sdev->status == SBP_DEV_ATTACHED || sdev->status == SBP_DEV_PROBE) 1141167632Ssimokawa xfer->hand = sbp_agent_reset_callback; 1142110336Ssimokawa else 1143167632Ssimokawa xfer->hand = sbp_do_attach; 1144120660Ssimokawa fp = &xfer->send.hdr; 1145103285Sikob fp->mode.wreqq.data = htonl(0xf); 1146103285Sikob fw_asyreq(xfer->fc, -1, xfer); 1147111615Ssimokawa sbp_abort_all_ocbs(sdev, CAM_BDR_SENT); 1148103285Sikob} 1149103285Sikob 1150103285Sikobstatic void 1151103285Sikobsbp_busy_timeout_callback(struct fw_xfer *xfer) 1152103285Sikob{ 1153103285Sikob struct sbp_dev *sdev; 1154103285Sikob 1155103285Sikob sdev = (struct sbp_dev *)xfer->sc; 1156103285SikobSBP_DEBUG(1) 1157188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1158188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1159103285SikobEND_DEBUG 1160275978Ssmh SBP_LOCK(sdev->target->sbp); 1161113584Ssimokawa sbp_xfer_free(xfer); 1162110336Ssimokawa sbp_agent_reset(sdev); 1163275978Ssmh SBP_UNLOCK(sdev->target->sbp); 1164103285Sikob} 1165103285Sikob 1166103285Sikobstatic void 1167103285Sikobsbp_busy_timeout(struct sbp_dev *sdev) 1168103285Sikob{ 1169103285Sikob struct fw_pkt *fp; 1170103285Sikob struct fw_xfer *xfer; 1171103285SikobSBP_DEBUG(0) 1172188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1173188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1174103285SikobEND_DEBUG 1175103285Sikob xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0); 1176103285Sikob 1177167632Ssimokawa xfer->hand = sbp_busy_timeout_callback; 1178120660Ssimokawa fp = &xfer->send.hdr; 1179113584Ssimokawa fp->mode.wreqq.dest_hi = 0xffff; 1180113584Ssimokawa fp->mode.wreqq.dest_lo = 0xf0000000 | BUSY_TIMEOUT; 1181110129Ssimokawa fp->mode.wreqq.data = htonl((1 << (13+12)) | 0xf); 1182103285Sikob fw_asyreq(xfer->fc, -1, xfer); 1183103285Sikob} 1184103285Sikob 1185103285Sikobstatic void 1186121185Ssimokawasbp_orb_pointer_callback(struct fw_xfer *xfer) 1187121185Ssimokawa{ 1188121185Ssimokawa struct sbp_dev *sdev; 1189121185Ssimokawa sdev = (struct sbp_dev *)xfer->sc; 1190121185Ssimokawa 1191170807SsimokawaSBP_DEBUG(2) 1192188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1193188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1194121185SsimokawaEND_DEBUG 1195121185Ssimokawa if (xfer->resp != 0) { 1196121185Ssimokawa /* XXX */ 1197127468Ssimokawa printf("%s: xfer->resp = %d\n", __func__, xfer->resp); 1198121185Ssimokawa } 1199275978Ssmh SBP_LOCK(sdev->target->sbp); 1200121185Ssimokawa sbp_xfer_free(xfer); 1201170807Ssimokawa 1202121185Ssimokawa sdev->flags &= ~ORB_POINTER_ACTIVE; 1203121185Ssimokawa 1204121185Ssimokawa if ((sdev->flags & ORB_POINTER_NEED) != 0) { 1205121185Ssimokawa struct sbp_ocb *ocb; 1206121185Ssimokawa 1207121185Ssimokawa sdev->flags &= ~ORB_POINTER_NEED; 1208121185Ssimokawa ocb = STAILQ_FIRST(&sdev->ocbs); 1209121185Ssimokawa if (ocb != NULL) 1210121185Ssimokawa sbp_orb_pointer(sdev, ocb); 1211121185Ssimokawa } 1212170807Ssimokawa SBP_UNLOCK(sdev->target->sbp); 1213121185Ssimokawa return; 1214121185Ssimokawa} 1215121185Ssimokawa 1216121185Ssimokawastatic void 1217103285Sikobsbp_orb_pointer(struct sbp_dev *sdev, struct sbp_ocb *ocb) 1218103285Sikob{ 1219103285Sikob struct fw_xfer *xfer; 1220103285Sikob struct fw_pkt *fp; 1221121185SsimokawaSBP_DEBUG(1) 1222188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1223188756Ssbruno "%s:%s 0x%08x\n", 1224188756Ssbruno __func__, sdev->bustgtlun, 1225188756Ssbruno (uint32_t)ocb->bus_addr); 1226103285SikobEND_DEBUG 1227103285Sikob 1228275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 1229170807Ssimokawa 1230121185Ssimokawa if ((sdev->flags & ORB_POINTER_ACTIVE) != 0) { 1231122421SsimokawaSBP_DEBUG(0) 1232127468Ssimokawa printf("%s: orb pointer active\n", __func__); 1233122421SsimokawaEND_DEBUG 1234121185Ssimokawa sdev->flags |= ORB_POINTER_NEED; 1235121185Ssimokawa return; 1236121185Ssimokawa } 1237121185Ssimokawa 1238121185Ssimokawa sdev->flags |= ORB_POINTER_ACTIVE; 1239275978Ssmh xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0x08); 1240103285Sikob if (xfer == NULL) 1241103285Sikob return; 1242167632Ssimokawa xfer->hand = sbp_orb_pointer_callback; 1243103285Sikob 1244120660Ssimokawa fp = &xfer->send.hdr; 1245113584Ssimokawa fp->mode.wreqb.len = 8; 1246103285Sikob fp->mode.wreqb.extcode = 0; 1247120660Ssimokawa xfer->send.payload[0] = 1248103285Sikob htonl(((sdev->target->sbp->fd.fc->nodeid | FWLOCALBUS )<< 16)); 1249129585Sdfr xfer->send.payload[1] = htonl((uint32_t)ocb->bus_addr); 1250103285Sikob 1251275978Ssmh if (fw_asyreq(xfer->fc, -1, xfer) != 0) { 1252275978Ssmh sbp_xfer_free(xfer); 1253275978Ssmh ocb->ccb->ccb_h.status = CAM_REQ_INVALID; 1254275978Ssmh xpt_done(ocb->ccb); 1255103285Sikob } 1256103285Sikob} 1257103285Sikob 1258103285Sikobstatic void 1259127468Ssimokawasbp_doorbell_callback(struct fw_xfer *xfer) 1260121185Ssimokawa{ 1261121185Ssimokawa struct sbp_dev *sdev; 1262121185Ssimokawa sdev = (struct sbp_dev *)xfer->sc; 1263127468Ssimokawa 1264127468SsimokawaSBP_DEBUG(1) 1265188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1266188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1267121185SsimokawaEND_DEBUG 1268121185Ssimokawa if (xfer->resp != 0) { 1269121185Ssimokawa /* XXX */ 1270188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1271188756Ssbruno "%s: xfer->resp = %d\n", __func__, xfer->resp); 1272121185Ssimokawa } 1273275978Ssmh SBP_LOCK(sdev->target->sbp); 1274121185Ssimokawa sbp_xfer_free(xfer); 1275127468Ssimokawa sdev->flags &= ~ORB_DOORBELL_ACTIVE; 1276127468Ssimokawa if ((sdev->flags & ORB_DOORBELL_NEED) != 0) { 1277127468Ssimokawa sdev->flags &= ~ORB_DOORBELL_NEED; 1278127468Ssimokawa sbp_doorbell(sdev); 1279127468Ssimokawa } 1280275978Ssmh SBP_UNLOCK(sdev->target->sbp); 1281121185Ssimokawa} 1282121185Ssimokawa 1283121185Ssimokawastatic void 1284103285Sikobsbp_doorbell(struct sbp_dev *sdev) 1285103285Sikob{ 1286103285Sikob struct fw_xfer *xfer; 1287103285Sikob struct fw_pkt *fp; 1288103285SikobSBP_DEBUG(1) 1289188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1290188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1291103285SikobEND_DEBUG 1292103285Sikob 1293127468Ssimokawa if ((sdev->flags & ORB_DOORBELL_ACTIVE) != 0) { 1294127468Ssimokawa sdev->flags |= ORB_DOORBELL_NEED; 1295127468Ssimokawa return; 1296127468Ssimokawa } 1297127468Ssimokawa sdev->flags |= ORB_DOORBELL_ACTIVE; 1298275978Ssmh xfer = sbp_write_cmd(sdev, FWTCODE_WREQQ, 0x10); 1299103285Sikob if (xfer == NULL) 1300103285Sikob return; 1301167632Ssimokawa xfer->hand = sbp_doorbell_callback; 1302127468Ssimokawa fp = &xfer->send.hdr; 1303103285Sikob fp->mode.wreqq.data = htonl(0xf); 1304103285Sikob fw_asyreq(xfer->fc, -1, xfer); 1305103285Sikob} 1306103285Sikob 1307103285Sikobstatic struct fw_xfer * 1308275978Ssmhsbp_write_cmd(struct sbp_dev *sdev, int tcode, int offset) 1309103285Sikob{ 1310103285Sikob struct fw_xfer *xfer; 1311103285Sikob struct fw_pkt *fp; 1312113584Ssimokawa struct sbp_target *target; 1313275978Ssmh int new = 0; 1314103285Sikob 1315275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 1316170807Ssimokawa 1317113584Ssimokawa target = sdev->target; 1318113584Ssimokawa xfer = STAILQ_FIRST(&target->xferlist); 1319113584Ssimokawa if (xfer == NULL) { 1320113584Ssimokawa if (target->n_xfer > 5 /* XXX */) { 1321113584Ssimokawa printf("sbp: no more xfer for this target\n"); 1322113584Ssimokawa return(NULL); 1323113584Ssimokawa } 1324120660Ssimokawa xfer = fw_xfer_alloc_buf(M_SBP, 8, 0); 1325113584Ssimokawa if(xfer == NULL){ 1326113584Ssimokawa printf("sbp: fw_xfer_alloc_buf failed\n"); 1327113584Ssimokawa return NULL; 1328113584Ssimokawa } 1329113584Ssimokawa target->n_xfer ++; 1330113584Ssimokawa if (debug) 1331113584Ssimokawa printf("sbp: alloc %d xfer\n", target->n_xfer); 1332113584Ssimokawa new = 1; 1333113584Ssimokawa } else { 1334113584Ssimokawa STAILQ_REMOVE_HEAD(&target->xferlist, link); 1335103285Sikob } 1336113584Ssimokawa 1337113584Ssimokawa if (new) { 1338120660Ssimokawa xfer->recv.pay_len = 0; 1339120660Ssimokawa xfer->send.spd = min(sdev->target->fwdev->speed, max_speed); 1340113584Ssimokawa xfer->fc = sdev->target->sbp->fd.fc; 1341103285Sikob } 1342120660Ssimokawa 1343120660Ssimokawa if (tcode == FWTCODE_WREQB) 1344120660Ssimokawa xfer->send.pay_len = 8; 1345120660Ssimokawa else 1346120660Ssimokawa xfer->send.pay_len = 0; 1347120660Ssimokawa 1348103285Sikob xfer->sc = (caddr_t)sdev; 1349120660Ssimokawa fp = &xfer->send.hdr; 1350113584Ssimokawa fp->mode.wreqq.dest_hi = sdev->login->cmd_hi; 1351113584Ssimokawa fp->mode.wreqq.dest_lo = sdev->login->cmd_lo + offset; 1352103285Sikob fp->mode.wreqq.tlrt = 0; 1353103285Sikob fp->mode.wreqq.tcode = tcode; 1354103285Sikob fp->mode.wreqq.pri = 0; 1355120660Ssimokawa fp->mode.wreqq.dst = FWLOCALBUS | sdev->target->fwdev->dst; 1356103285Sikob 1357103285Sikob return xfer; 1358103285Sikob} 1359103285Sikob 1360103285Sikobstatic void 1361111615Ssimokawasbp_mgm_orb(struct sbp_dev *sdev, int func, struct sbp_ocb *aocb) 1362103285Sikob{ 1363103285Sikob struct fw_xfer *xfer; 1364103285Sikob struct fw_pkt *fp; 1365103285Sikob struct sbp_ocb *ocb; 1366111615Ssimokawa struct sbp_target *target; 1367275978Ssmh int nid; 1368103285Sikob 1369111615Ssimokawa target = sdev->target; 1370111615Ssimokawa nid = target->sbp->fd.fc->nodeid | FWLOCALBUS; 1371111615Ssimokawa 1372275978Ssmh SBP_LOCK_ASSERT(target->sbp); 1373111615Ssimokawa if (func == ORB_FUN_RUNQUEUE) { 1374111615Ssimokawa ocb = STAILQ_FIRST(&target->mgm_ocb_queue); 1375111615Ssimokawa if (target->mgm_ocb_cur != NULL || ocb == NULL) { 1376111615Ssimokawa return; 1377111615Ssimokawa } 1378111615Ssimokawa STAILQ_REMOVE_HEAD(&target->mgm_ocb_queue, ocb); 1379111615Ssimokawa goto start; 1380111615Ssimokawa } 1381113584Ssimokawa if ((ocb = sbp_get_ocb(sdev)) == NULL) { 1382122528Ssimokawa /* XXX */ 1383103285Sikob return; 1384103285Sikob } 1385103285Sikob ocb->flags = OCB_ACT_MGM; 1386103285Sikob ocb->sdev = sdev; 1387103285Sikob 1388120660Ssimokawa bzero((void *)ocb->orb, sizeof(ocb->orb)); 1389103285Sikob ocb->orb[6] = htonl((nid << 16) | SBP_BIND_HI); 1390120660Ssimokawa ocb->orb[7] = htonl(SBP_DEV2ADDR(target->target_id, sdev->lun_id)); 1391103285Sikob 1392107653SsimokawaSBP_DEBUG(0) 1393188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1394188756Ssbruno "%s:%s %s\n", 1395188756Ssbruno __func__,sdev->bustgtlun, 1396188756Ssbruno orb_fun_name[(func>>16)&0xf]); 1397107653SsimokawaEND_DEBUG 1398103285Sikob switch (func) { 1399103285Sikob case ORB_FUN_LGI: 1400120660Ssimokawa ocb->orb[0] = ocb->orb[1] = 0; /* password */ 1401103285Sikob ocb->orb[2] = htonl(nid << 16); 1402113584Ssimokawa ocb->orb[3] = htonl(sdev->dma.bus_addr); 1403121792Ssimokawa ocb->orb[4] = htonl(ORB_NOTIFY | sdev->lun_id); 1404122387Ssimokawa if (ex_login) 1405121792Ssimokawa ocb->orb[4] |= htonl(ORB_EXV); 1406113584Ssimokawa ocb->orb[5] = htonl(SBP_LOGIN_SIZE); 1407113584Ssimokawa fwdma_sync(&sdev->dma, BUS_DMASYNC_PREREAD); 1408103285Sikob break; 1409110336Ssimokawa case ORB_FUN_ATA: 1410111615Ssimokawa ocb->orb[0] = htonl((0 << 16) | 0); 1411113584Ssimokawa ocb->orb[1] = htonl(aocb->bus_addr & 0xffffffff); 1412110336Ssimokawa /* fall through */ 1413103285Sikob case ORB_FUN_RCN: 1414103285Sikob case ORB_FUN_LGO: 1415103285Sikob case ORB_FUN_LUR: 1416103285Sikob case ORB_FUN_RST: 1417103285Sikob case ORB_FUN_ATS: 1418113584Ssimokawa ocb->orb[4] = htonl(ORB_NOTIFY | func | sdev->login->id); 1419103285Sikob break; 1420103285Sikob } 1421103285Sikob 1422111615Ssimokawa if (target->mgm_ocb_cur != NULL) { 1423111615Ssimokawa /* there is a standing ORB */ 1424111615Ssimokawa STAILQ_INSERT_TAIL(&sdev->target->mgm_ocb_queue, ocb, ocb); 1425111615Ssimokawa return; 1426111615Ssimokawa } 1427111615Ssimokawastart: 1428111615Ssimokawa target->mgm_ocb_cur = ocb; 1429111615Ssimokawa 1430275982Ssmh callout_reset(&target->mgm_ocb_timeout, 5 * hz, 1431114732Ssimokawa sbp_mgm_timeout, (caddr_t)ocb); 1432103285Sikob xfer = sbp_write_cmd(sdev, FWTCODE_WREQB, 0); 1433103285Sikob if(xfer == NULL){ 1434103285Sikob return; 1435103285Sikob } 1436167632Ssimokawa xfer->hand = sbp_mgm_callback; 1437103285Sikob 1438120660Ssimokawa fp = &xfer->send.hdr; 1439113584Ssimokawa fp->mode.wreqb.dest_hi = sdev->target->mgm_hi; 1440113584Ssimokawa fp->mode.wreqb.dest_lo = sdev->target->mgm_lo; 1441113584Ssimokawa fp->mode.wreqb.len = 8; 1442103285Sikob fp->mode.wreqb.extcode = 0; 1443120660Ssimokawa xfer->send.payload[0] = htonl(nid << 16); 1444120660Ssimokawa xfer->send.payload[1] = htonl(ocb->bus_addr & 0xffffffff); 1445103285Sikob 1446103285Sikob fw_asyreq(xfer->fc, -1, xfer); 1447103285Sikob} 1448103285Sikob 1449103285Sikobstatic void 1450105792Ssimokawasbp_print_scsi_cmd(struct sbp_ocb *ocb) 1451103285Sikob{ 1452103285Sikob struct ccb_scsiio *csio; 1453103285Sikob 1454103285Sikob csio = &ocb->ccb->csio; 1455103285Sikob printf("%s:%d:%d XPT_SCSI_IO: " 1456103285Sikob "cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x" 1457103285Sikob ", flags: 0x%02x, " 1458103285Sikob "%db cmd/%db data/%db sense\n", 1459103285Sikob device_get_nameunit(ocb->sdev->target->sbp->fd.dev), 1460103285Sikob ocb->ccb->ccb_h.target_id, ocb->ccb->ccb_h.target_lun, 1461103285Sikob csio->cdb_io.cdb_bytes[0], 1462103285Sikob csio->cdb_io.cdb_bytes[1], 1463103285Sikob csio->cdb_io.cdb_bytes[2], 1464103285Sikob csio->cdb_io.cdb_bytes[3], 1465103285Sikob csio->cdb_io.cdb_bytes[4], 1466103285Sikob csio->cdb_io.cdb_bytes[5], 1467103285Sikob csio->cdb_io.cdb_bytes[6], 1468103285Sikob csio->cdb_io.cdb_bytes[7], 1469103285Sikob csio->cdb_io.cdb_bytes[8], 1470103285Sikob csio->cdb_io.cdb_bytes[9], 1471103285Sikob ocb->ccb->ccb_h.flags & CAM_DIR_MASK, 1472103285Sikob csio->cdb_len, csio->dxfer_len, 1473103285Sikob csio->sense_len); 1474105792Ssimokawa} 1475105792Ssimokawa 1476105792Ssimokawastatic void 1477105792Ssimokawasbp_scsi_status(struct sbp_status *sbp_status, struct sbp_ocb *ocb) 1478105792Ssimokawa{ 1479105792Ssimokawa struct sbp_cmd_status *sbp_cmd_status; 1480225950Sken struct scsi_sense_data_fixed *sense; 1481105792Ssimokawa 1482105792Ssimokawa sbp_cmd_status = (struct sbp_cmd_status *)sbp_status->data; 1483225950Sken sense = (struct scsi_sense_data_fixed *)&ocb->ccb->csio.sense_data; 1484105792Ssimokawa 1485105792SsimokawaSBP_DEBUG(0) 1486105792Ssimokawa sbp_print_scsi_cmd(ocb); 1487103285Sikob /* XXX need decode status */ 1488188756Ssbruno printf("%s: SCSI status %x sfmt %x valid %x key %x code %x qlfr %x len %d\n", 1489188756Ssbruno ocb->sdev->bustgtlun, 1490103285Sikob sbp_cmd_status->status, 1491103285Sikob sbp_cmd_status->sfmt, 1492103285Sikob sbp_cmd_status->valid, 1493103285Sikob sbp_cmd_status->s_key, 1494103285Sikob sbp_cmd_status->s_code, 1495103285Sikob sbp_cmd_status->s_qlfr, 1496188756Ssbruno sbp_status->len); 1497103285SikobEND_DEBUG 1498103285Sikob 1499110071Ssimokawa switch (sbp_cmd_status->status) { 1500110071Ssimokawa case SCSI_STATUS_CHECK_COND: 1501110071Ssimokawa case SCSI_STATUS_BUSY: 1502110071Ssimokawa case SCSI_STATUS_CMD_TERMINATED: 1503103285Sikob if(sbp_cmd_status->sfmt == SBP_SFMT_CURR){ 1504103285Sikob sense->error_code = SSD_CURRENT_ERROR; 1505103285Sikob }else{ 1506103285Sikob sense->error_code = SSD_DEFERRED_ERROR; 1507103285Sikob } 1508103285Sikob if(sbp_cmd_status->valid) 1509103285Sikob sense->error_code |= SSD_ERRCODE_VALID; 1510103285Sikob sense->flags = sbp_cmd_status->s_key; 1511103285Sikob if(sbp_cmd_status->mark) 1512103285Sikob sense->flags |= SSD_FILEMARK; 1513103285Sikob if(sbp_cmd_status->eom) 1514103285Sikob sense->flags |= SSD_EOM; 1515103285Sikob if(sbp_cmd_status->ill_len) 1516103285Sikob sense->flags |= SSD_ILI; 1517119556Ssimokawa 1518119556Ssimokawa bcopy(&sbp_cmd_status->info, &sense->info[0], 4); 1519119556Ssimokawa 1520103285Sikob if (sbp_status->len <= 1) 1521103285Sikob /* XXX not scsi status. shouldn't be happened */ 1522103285Sikob sense->extra_len = 0; 1523103285Sikob else if (sbp_status->len <= 4) 1524103285Sikob /* add_sense_code(_qual), info, cmd_spec_info */ 1525103285Sikob sense->extra_len = 6; 1526103285Sikob else 1527103285Sikob /* fru, sense_key_spec */ 1528103285Sikob sense->extra_len = 10; 1529119556Ssimokawa 1530119556Ssimokawa bcopy(&sbp_cmd_status->cdb, &sense->cmd_spec_info[0], 4); 1531119556Ssimokawa 1532103285Sikob sense->add_sense_code = sbp_cmd_status->s_code; 1533103285Sikob sense->add_sense_code_qual = sbp_cmd_status->s_qlfr; 1534103285Sikob sense->fru = sbp_cmd_status->fru; 1535103285Sikob 1536119556Ssimokawa bcopy(&sbp_cmd_status->s_keydep[0], 1537119556Ssimokawa &sense->sense_key_spec[0], 3); 1538119556Ssimokawa 1539201758Smbr ocb->ccb->csio.scsi_status = sbp_cmd_status->status; 1540103285Sikob ocb->ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR 1541103285Sikob | CAM_AUTOSNS_VALID; 1542103285Sikob/* 1543103285Sikob{ 1544129585Sdfr uint8_t j, *tmp; 1545103285Sikob tmp = sense; 1546103285Sikob for( j = 0 ; j < 32 ; j+=8){ 1547103285Sikob printf("sense %02x%02x %02x%02x %02x%02x %02x%02x\n", 1548103285Sikob tmp[j], tmp[j+1], tmp[j+2], tmp[j+3], 1549103285Sikob tmp[j+4], tmp[j+5], tmp[j+6], tmp[j+7]); 1550103285Sikob } 1551103285Sikob 1552103285Sikob} 1553103285Sikob*/ 1554110071Ssimokawa break; 1555110071Ssimokawa default: 1556188756Ssbruno device_printf(ocb->sdev->target->sbp->fd.dev, 1557188756Ssbruno "%s:%s unknown scsi status 0x%x\n", 1558188756Ssbruno __func__, ocb->sdev->bustgtlun, 1559188756Ssbruno sbp_cmd_status->status); 1560103285Sikob } 1561103285Sikob} 1562103285Sikob 1563103285Sikobstatic void 1564103285Sikobsbp_fix_inq_data(struct sbp_ocb *ocb) 1565103285Sikob{ 1566103285Sikob union ccb *ccb; 1567103285Sikob struct sbp_dev *sdev; 1568103285Sikob struct scsi_inquiry_data *inq; 1569103285Sikob 1570103285Sikob ccb = ocb->ccb; 1571103285Sikob sdev = ocb->sdev; 1572103285Sikob 1573103285Sikob if (ccb->csio.cdb_io.cdb_bytes[1] & SI_EVPD) 1574103285Sikob return; 1575103285SikobSBP_DEBUG(1) 1576188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1577188756Ssbruno "%s:%s\n", __func__, sdev->bustgtlun); 1578103285SikobEND_DEBUG 1579103285Sikob inq = (struct scsi_inquiry_data *) ccb->csio.data_ptr; 1580103285Sikob switch (SID_TYPE(inq)) { 1581103285Sikob case T_DIRECT: 1582118291Ssimokawa#if 0 1583103285Sikob /* 1584103285Sikob * XXX Convert Direct Access device to RBC. 1585108281Ssimokawa * I've never seen FireWire DA devices which support READ_6. 1586103285Sikob */ 1587103285Sikob if (SID_TYPE(inq) == T_DIRECT) 1588103285Sikob inq->device |= T_RBC; /* T_DIRECT == 0 */ 1589103285Sikob#endif 1590103285Sikob /* fall through */ 1591103285Sikob case T_RBC: 1592103285Sikob /* 1593103285Sikob * Override vendor/product/revision information. 1594103285Sikob * Some devices sometimes return strange strings. 1595103285Sikob */ 1596111615Ssimokawa#if 1 1597103285Sikob bcopy(sdev->vendor, inq->vendor, sizeof(inq->vendor)); 1598103285Sikob bcopy(sdev->product, inq->product, sizeof(inq->product)); 1599103285Sikob bcopy(sdev->revision+2, inq->revision, sizeof(inq->revision)); 1600111615Ssimokawa#endif 1601103285Sikob break; 1602103285Sikob } 1603127468Ssimokawa /* 1604127468Ssimokawa * Force to enable/disable tagged queuing. 1605127468Ssimokawa * XXX CAM also checks SCP_QUEUE_DQUE flag in the control mode page. 1606127468Ssimokawa */ 1607127468Ssimokawa if (sbp_tags > 0) 1608127468Ssimokawa inq->flags |= SID_CmdQue; 1609127468Ssimokawa else if (sbp_tags < 0) 1610127468Ssimokawa inq->flags &= ~SID_CmdQue; 1611127468Ssimokawa 1612103285Sikob} 1613103285Sikob 1614103285Sikobstatic void 1615113584Ssimokawasbp_recv1(struct fw_xfer *xfer) 1616113584Ssimokawa{ 1617103285Sikob struct fw_pkt *rfp; 1618103285Sikob#if NEED_RESPONSE 1619103285Sikob struct fw_pkt *sfp; 1620103285Sikob#endif 1621103285Sikob struct sbp_softc *sbp; 1622103285Sikob struct sbp_dev *sdev; 1623103285Sikob struct sbp_ocb *ocb; 1624103285Sikob struct sbp_login_res *login_res = NULL; 1625103285Sikob struct sbp_status *sbp_status; 1626103285Sikob struct sbp_target *target; 1627111704Ssimokawa int orb_fun, status_valid0, status_valid, t, l, reset_agent = 0; 1628129585Sdfr uint32_t addr; 1629103285Sikob/* 1630129585Sdfr uint32_t *ld; 1631103285Sikob ld = xfer->recv.buf; 1632103285Sikobprintf("sbp %x %d %d %08x %08x %08x %08x\n", 1633103285Sikob xfer->resp, xfer->recv.len, xfer->recv.off, ntohl(ld[0]), ntohl(ld[1]), ntohl(ld[2]), ntohl(ld[3])); 1634103285Sikobprintf("sbp %08x %08x %08x %08x\n", ntohl(ld[4]), ntohl(ld[5]), ntohl(ld[6]), ntohl(ld[7])); 1635103285Sikobprintf("sbp %08x %08x %08x %08x\n", ntohl(ld[8]), ntohl(ld[9]), ntohl(ld[10]), ntohl(ld[11])); 1636103285Sikob*/ 1637113584Ssimokawa sbp = (struct sbp_softc *)xfer->sc; 1638275978Ssmh SBP_LOCK_ASSERT(sbp); 1639120660Ssimokawa if (xfer->resp != 0){ 1640122529Ssimokawa printf("sbp_recv: xfer->resp = %d\n", xfer->resp); 1641113584Ssimokawa goto done0; 1642103285Sikob } 1643120660Ssimokawa if (xfer->recv.payload == NULL){ 1644120660Ssimokawa printf("sbp_recv: xfer->recv.payload == NULL\n"); 1645113584Ssimokawa goto done0; 1646103285Sikob } 1647120660Ssimokawa rfp = &xfer->recv.hdr; 1648103285Sikob if(rfp->mode.wreqb.tcode != FWTCODE_WREQB){ 1649103285Sikob printf("sbp_recv: tcode = %d\n", rfp->mode.wreqb.tcode); 1650113584Ssimokawa goto done0; 1651103285Sikob } 1652120660Ssimokawa sbp_status = (struct sbp_status *)xfer->recv.payload; 1653113584Ssimokawa addr = rfp->mode.wreqb.dest_lo; 1654103285SikobSBP_DEBUG(2) 1655103285Sikob printf("received address 0x%x\n", addr); 1656103285SikobEND_DEBUG 1657110189Ssimokawa t = SBP_ADDR2TRG(addr); 1658110189Ssimokawa if (t >= SBP_NUM_TARGETS) { 1659110189Ssimokawa device_printf(sbp->fd.dev, 1660110189Ssimokawa "sbp_recv1: invalid target %d\n", t); 1661113584Ssimokawa goto done0; 1662110189Ssimokawa } 1663110189Ssimokawa target = &sbp->targets[t]; 1664110189Ssimokawa l = SBP_ADDR2LUN(addr); 1665121185Ssimokawa if (l >= target->num_lun || target->luns[l] == NULL) { 1666110189Ssimokawa device_printf(sbp->fd.dev, 1667110189Ssimokawa "sbp_recv1: invalid lun %d (target=%d)\n", l, t); 1668113584Ssimokawa goto done0; 1669110189Ssimokawa } 1670121185Ssimokawa sdev = target->luns[l]; 1671103285Sikob 1672110189Ssimokawa ocb = NULL; 1673110189Ssimokawa switch (sbp_status->src) { 1674110189Ssimokawa case 0: 1675110189Ssimokawa case 1: 1676111615Ssimokawa /* check mgm_ocb_cur first */ 1677111615Ssimokawa ocb = target->mgm_ocb_cur; 1678111615Ssimokawa if (ocb != NULL) { 1679111615Ssimokawa if (OCB_MATCH(ocb, sbp_status)) { 1680111615Ssimokawa callout_stop(&target->mgm_ocb_timeout); 1681111615Ssimokawa target->mgm_ocb_cur = NULL; 1682111615Ssimokawa break; 1683111615Ssimokawa } 1684111615Ssimokawa } 1685111615Ssimokawa ocb = sbp_dequeue_ocb(sdev, sbp_status); 1686110189Ssimokawa if (ocb == NULL) { 1687188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1688127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 1689188756Ssbruno "%s:%s No ocb(%lx) on the queue\n", 1690127468Ssimokawa#else 1691188756Ssbruno "%s:%s No ocb(%x) on the queue\n", 1692111858Ssimokawa#endif 1693188756Ssbruno __func__,sdev->bustgtlun, 1694188756Ssbruno ntohl(sbp_status->orb_lo)); 1695110189Ssimokawa } 1696110189Ssimokawa break; 1697110189Ssimokawa case 2: 1698110189Ssimokawa /* unsolicit */ 1699188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1700188756Ssbruno "%s:%s unsolicit status received\n", 1701188756Ssbruno __func__, sdev->bustgtlun); 1702110189Ssimokawa break; 1703110189Ssimokawa default: 1704188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1705188756Ssbruno "%s:%s unknown sbp_status->src\n", 1706188756Ssbruno __func__, sdev->bustgtlun); 1707110189Ssimokawa } 1708110189Ssimokawa 1709111615Ssimokawa status_valid0 = (sbp_status->src < 2 1710110189Ssimokawa && sbp_status->resp == ORB_RES_CMPL 1711111615Ssimokawa && sbp_status->dead == 0); 1712111615Ssimokawa status_valid = (status_valid0 && sbp_status->status == 0); 1713103285Sikob 1714121185Ssimokawa if (!status_valid0 || debug > 2){ 1715103285Sikob int status; 1716110129SsimokawaSBP_DEBUG(0) 1717188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1718188756Ssbruno "%s:%s ORB status src:%x resp:%x dead:%x" 1719127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 1720127468Ssimokawa " len:%x stat:%x orb:%x%08lx\n", 1721127468Ssimokawa#else 1722103285Sikob " len:%x stat:%x orb:%x%08x\n", 1723108712Ssimokawa#endif 1724188756Ssbruno __func__, sdev->bustgtlun, 1725103285Sikob sbp_status->src, sbp_status->resp, sbp_status->dead, 1726103285Sikob sbp_status->len, sbp_status->status, 1727108280Ssimokawa ntohs(sbp_status->orb_hi), ntohl(sbp_status->orb_lo)); 1728110129SsimokawaEND_DEBUG 1729188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1730188756Ssbruno "%s\n", sdev->bustgtlun); 1731103285Sikob status = sbp_status->status; 1732103285Sikob switch(sbp_status->resp) { 1733103285Sikob case 0: 1734103285Sikob if (status > MAX_ORB_STATUS0) 1735103285Sikob printf("%s\n", orb_status0[MAX_ORB_STATUS0]); 1736110189Ssimokawa else 1737110129Ssimokawa printf("%s\n", orb_status0[status]); 1738103285Sikob break; 1739103285Sikob case 1: 1740110336Ssimokawa printf("Obj: %s, Error: %s\n", 1741103285Sikob orb_status1_object[(status>>6) & 3], 1742103285Sikob orb_status1_serial_bus_error[status & 0xf]); 1743103285Sikob break; 1744110129Ssimokawa case 2: 1745110129Ssimokawa printf("Illegal request\n"); 1746110129Ssimokawa break; 1747110129Ssimokawa case 3: 1748110129Ssimokawa printf("Vendor dependent\n"); 1749110129Ssimokawa break; 1750103285Sikob default: 1751110129Ssimokawa printf("unknown respose code %d\n", sbp_status->resp); 1752103285Sikob } 1753103285Sikob } 1754103285Sikob 1755103285Sikob /* we have to reset the fetch agent if it's dead */ 1756103285Sikob if (sbp_status->dead) { 1757111615Ssimokawa if (sdev->path) { 1758103285Sikob xpt_freeze_devq(sdev->path, 1); 1759111615Ssimokawa sdev->freeze ++; 1760111615Ssimokawa } 1761111704Ssimokawa reset_agent = 1; 1762103285Sikob } 1763103285Sikob 1764111704Ssimokawa if (ocb == NULL) 1765111704Ssimokawa goto done; 1766103285Sikob 1767103285Sikob switch(ntohl(ocb->orb[4]) & ORB_FMT_MSK){ 1768103285Sikob case ORB_FMT_NOP: 1769103285Sikob break; 1770103285Sikob case ORB_FMT_VED: 1771103285Sikob break; 1772103285Sikob case ORB_FMT_STD: 1773111819Ssimokawa switch(ocb->flags) { 1774103285Sikob case OCB_ACT_MGM: 1775103285Sikob orb_fun = ntohl(ocb->orb[4]) & ORB_FUN_MSK; 1776120842Ssimokawa reset_agent = 0; 1777103285Sikob switch(orb_fun) { 1778103285Sikob case ORB_FUN_LGI: 1779113584Ssimokawa fwdma_sync(&sdev->dma, BUS_DMASYNC_POSTREAD); 1780113584Ssimokawa login_res = sdev->login; 1781103285Sikob login_res->len = ntohs(login_res->len); 1782103285Sikob login_res->id = ntohs(login_res->id); 1783103285Sikob login_res->cmd_hi = ntohs(login_res->cmd_hi); 1784103285Sikob login_res->cmd_lo = ntohl(login_res->cmd_lo); 1785103285Sikob if (status_valid) { 1786103285SikobSBP_DEBUG(0) 1787188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1788188756Ssbruno "%s:%s login: len %d, ID %d, cmd %08x%08x, recon_hold %d\n", 1789188756Ssbruno __func__, sdev->bustgtlun, 1790188756Ssbruno login_res->len, login_res->id, 1791188756Ssbruno login_res->cmd_hi, login_res->cmd_lo, 1792188756Ssbruno ntohs(login_res->recon_hold)); 1793103285SikobEND_DEBUG 1794103285Sikob sbp_busy_timeout(sdev); 1795103285Sikob } else { 1796110336Ssimokawa /* forgot logout? */ 1797188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1798188756Ssbruno "%s:%s login failed\n", 1799188756Ssbruno __func__, sdev->bustgtlun); 1800103285Sikob sdev->status = SBP_DEV_RESET; 1801103285Sikob } 1802103285Sikob break; 1803103285Sikob case ORB_FUN_RCN: 1804113584Ssimokawa login_res = sdev->login; 1805103285Sikob if (status_valid) { 1806103285SikobSBP_DEBUG(0) 1807188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1808188756Ssbruno "%s:%s reconnect: len %d, ID %d, cmd %08x%08x\n", 1809188756Ssbruno __func__, sdev->bustgtlun, 1810188756Ssbruno login_res->len, login_res->id, 1811188756Ssbruno login_res->cmd_hi, login_res->cmd_lo); 1812103285SikobEND_DEBUG 1813111615Ssimokawa if (sdev->status == SBP_DEV_ATTACHED) 1814111615Ssimokawa sbp_scan_dev(sdev); 1815111615Ssimokawa else 1816111615Ssimokawa sbp_agent_reset(sdev); 1817103285Sikob } else { 1818103285Sikob /* reconnection hold time exceed? */ 1819110336SsimokawaSBP_DEBUG(0) 1820188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1821188756Ssbruno "%s:%s reconnect failed\n", 1822188756Ssbruno __func__, sdev->bustgtlun); 1823110336SsimokawaEND_DEBUG 1824111615Ssimokawa sbp_login(sdev); 1825103285Sikob } 1826103285Sikob break; 1827103285Sikob case ORB_FUN_LGO: 1828103285Sikob sdev->status = SBP_DEV_RESET; 1829103285Sikob break; 1830110336Ssimokawa case ORB_FUN_RST: 1831110336Ssimokawa sbp_busy_timeout(sdev); 1832110336Ssimokawa break; 1833103285Sikob case ORB_FUN_LUR: 1834103285Sikob case ORB_FUN_ATA: 1835103285Sikob case ORB_FUN_ATS: 1836110336Ssimokawa sbp_agent_reset(sdev); 1837103285Sikob break; 1838103285Sikob default: 1839188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 1840188756Ssbruno "%s:%s unknown function %d\n", 1841188756Ssbruno __func__, sdev->bustgtlun, orb_fun); 1842103285Sikob break; 1843103285Sikob } 1844111615Ssimokawa sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL); 1845103285Sikob break; 1846103285Sikob case OCB_ACT_CMD: 1847114732Ssimokawa sdev->timeout = 0; 1848103285Sikob if(ocb->ccb != NULL){ 1849103285Sikob union ccb *ccb; 1850188756Ssbruno 1851103285Sikob ccb = ocb->ccb; 1852103285Sikob if(sbp_status->len > 1){ 1853103285Sikob sbp_scsi_status(sbp_status, ocb); 1854103285Sikob }else{ 1855103285Sikob if(sbp_status->resp != ORB_RES_CMPL){ 1856103285Sikob ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1857103285Sikob }else{ 1858103285Sikob ccb->ccb_h.status = CAM_REQ_CMP; 1859103285Sikob } 1860103285Sikob } 1861103285Sikob /* fix up inq data */ 1862103285Sikob if (ccb->csio.cdb_io.cdb_bytes[0] == INQUIRY) 1863103285Sikob sbp_fix_inq_data(ocb); 1864103285Sikob xpt_done(ccb); 1865103285Sikob } 1866103285Sikob break; 1867103285Sikob default: 1868103285Sikob break; 1869103285Sikob } 1870103285Sikob } 1871103285Sikob 1872127468Ssimokawa if (!use_doorbell) 1873127468Ssimokawa sbp_free_ocb(sdev, ocb); 1874111704Ssimokawadone: 1875111704Ssimokawa if (reset_agent) 1876111704Ssimokawa sbp_agent_reset(sdev); 1877103285Sikob 1878113584Ssimokawadone0: 1879120660Ssimokawa xfer->recv.pay_len = SBP_RECV_LEN; 1880103285Sikob/* The received packet is usually small enough to be stored within 1881103285Sikob * the buffer. In that case, the controller return ack_complete and 1882103285Sikob * no respose is necessary. 1883103285Sikob * 1884103285Sikob * XXX fwohci.c and firewire.c should inform event_code such as 1885103285Sikob * ack_complete or ack_pending to upper driver. 1886103285Sikob */ 1887103285Sikob#if NEED_RESPONSE 1888103285Sikob xfer->send.off = 0; 1889103285Sikob sfp = (struct fw_pkt *)xfer->send.buf; 1890103285Sikob sfp->mode.wres.dst = rfp->mode.wreqb.src; 1891113584Ssimokawa xfer->dst = sfp->mode.wres.dst; 1892103285Sikob xfer->spd = min(sdev->target->fwdev->speed, max_speed); 1893167632Ssimokawa xfer->hand = sbp_loginres_callback; 1894103285Sikob 1895103285Sikob sfp->mode.wres.tlrt = rfp->mode.wreqb.tlrt; 1896103285Sikob sfp->mode.wres.tcode = FWTCODE_WRES; 1897103285Sikob sfp->mode.wres.rtcode = 0; 1898103285Sikob sfp->mode.wres.pri = 0; 1899103285Sikob 1900103285Sikob fw_asyreq(xfer->fc, -1, xfer); 1901103285Sikob#else 1902113584Ssimokawa /* recycle */ 1903113584Ssimokawa STAILQ_INSERT_TAIL(&sbp->fwb.xferlist, xfer, link); 1904103285Sikob#endif 1905103285Sikob} 1906103285Sikob 1907103285Sikobstatic void 1908103285Sikobsbp_recv(struct fw_xfer *xfer) 1909103285Sikob{ 1910275978Ssmh struct sbp_softc *sbp; 1911103285Sikob 1912275978Ssmh sbp = (struct sbp_softc *)xfer->sc; 1913275978Ssmh SBP_LOCK(sbp); 1914103285Sikob sbp_recv1(xfer); 1915275978Ssmh SBP_UNLOCK(sbp); 1916103285Sikob} 1917103285Sikob/* 1918103285Sikob * sbp_attach() 1919103285Sikob */ 1920103285Sikobstatic int 1921103285Sikobsbp_attach(device_t dev) 1922103285Sikob{ 1923103285Sikob struct sbp_softc *sbp; 1924103285Sikob struct cam_devq *devq; 1925170374Ssimokawa struct firewire_comm *fc; 1926275978Ssmh int i, error; 1927103285Sikob 1928167624Ssimokawa if (DFLTPHYS > SBP_MAXPHYS) 1929167624Ssimokawa device_printf(dev, "Warning, DFLTPHYS(%dKB) is larger than " 1930167624Ssimokawa "SBP_MAXPHYS(%dKB).\n", DFLTPHYS / 1024, 1931167624Ssimokawa SBP_MAXPHYS / 1024); 1932167624Ssimokawa 1933170400Ssimokawa if (!firewire_phydma_enable) 1934170400Ssimokawa device_printf(dev, "Warning, hw.firewire.phydma_enable must be 1 " 1935170400Ssimokawa "for SBP over FireWire.\n"); 1936103285SikobSBP_DEBUG(0) 1937111199Ssimokawa printf("sbp_attach (cold=%d)\n", cold); 1938103285SikobEND_DEBUG 1939103285Sikob 1940111199Ssimokawa if (cold) 1941111199Ssimokawa sbp_cold ++; 1942275978Ssmh sbp = device_get_softc(dev); 1943103285Sikob sbp->fd.dev = dev; 1944170374Ssimokawa sbp->fd.fc = fc = device_get_ivars(dev); 1945170374Ssimokawa mtx_init(&sbp->mtx, "sbp", NULL, MTX_DEF); 1946124251Ssimokawa 1947124251Ssimokawa if (max_speed < 0) 1948170374Ssimokawa max_speed = fc->speed; 1949124251Ssimokawa 1950170374Ssimokawa error = bus_dma_tag_create(/*parent*/fc->dmat, 1951113584Ssimokawa /* XXX shoud be 4 for sane backend? */ 1952113584Ssimokawa /*alignment*/1, 1953103285Sikob /*boundary*/0, 1954103285Sikob /*lowaddr*/BUS_SPACE_MAXADDR_32BIT, 1955103285Sikob /*highaddr*/BUS_SPACE_MAXADDR, 1956103285Sikob /*filter*/NULL, /*filterarg*/NULL, 1957103285Sikob /*maxsize*/0x100000, /*nsegments*/SBP_IND_MAX, 1958113474Ssimokawa /*maxsegsz*/SBP_SEG_MAX, 1959103285Sikob /*flags*/BUS_DMA_ALLOCNOW, 1960127468Ssimokawa#if defined(__FreeBSD__) && __FreeBSD_version >= 501102 1961117126Sscottl /*lockfunc*/busdma_lock_mutex, 1962170374Ssimokawa /*lockarg*/&sbp->mtx, 1963117228Ssimokawa#endif 1964117228Ssimokawa &sbp->dmat); 1965103285Sikob if (error != 0) { 1966103285Sikob printf("sbp_attach: Could not allocate DMA tag " 1967103285Sikob "- error %d\n", error); 1968103285Sikob return (ENOMEM); 1969103285Sikob } 1970103285Sikob 1971103285Sikob devq = cam_simq_alloc(/*maxopenings*/SBP_NUM_OCB); 1972103285Sikob if (devq == NULL) 1973103285Sikob return (ENXIO); 1974103285Sikob 1975103285Sikob for( i = 0 ; i < SBP_NUM_TARGETS ; i++){ 1976103285Sikob sbp->targets[i].fwdev = NULL; 1977103285Sikob sbp->targets[i].luns = NULL; 1978103285Sikob } 1979103285Sikob 1980103285Sikob sbp->sim = cam_sim_alloc(sbp_action, sbp_poll, "sbp", sbp, 1981103285Sikob device_get_unit(dev), 1982170374Ssimokawa &sbp->mtx, 1983111615Ssimokawa /*untagged*/ 1, 1984122528Ssimokawa /*tagged*/ SBP_QUEUE_LEN - 1, 1985111615Ssimokawa devq); 1986103285Sikob 1987103285Sikob if (sbp->sim == NULL) { 1988103285Sikob cam_simq_free(devq); 1989103285Sikob return (ENXIO); 1990103285Sikob } 1991103285Sikob 1992170374Ssimokawa SBP_LOCK(sbp); 1993170872Sscottl if (xpt_bus_register(sbp->sim, dev, /*bus*/0) != CAM_SUCCESS) 1994111615Ssimokawa goto fail; 1995103285Sikob 1996249468Smav if (xpt_create_path(&sbp->path, NULL, cam_sim_path(sbp->sim), 1997120660Ssimokawa CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 1998120660Ssimokawa xpt_bus_deregister(cam_sim_path(sbp->sim)); 1999111615Ssimokawa goto fail; 2000120660Ssimokawa } 2001170374Ssimokawa SBP_UNLOCK(sbp); 2002111615Ssimokawa 2003103285Sikob /* We reserve 16 bit space (4 bytes X 64 targets X 256 luns) */ 2004120660Ssimokawa sbp->fwb.start = ((u_int64_t)SBP_BIND_HI << 32) | SBP_DEV2ADDR(0, 0); 2005120660Ssimokawa sbp->fwb.end = sbp->fwb.start + 0xffff; 2006113584Ssimokawa /* pre-allocate xfer */ 2007113584Ssimokawa STAILQ_INIT(&sbp->fwb.xferlist); 2008169130Ssimokawa fw_xferlist_add(&sbp->fwb.xferlist, M_SBP, 2009169130Ssimokawa /*send*/ 0, /*recv*/ SBP_RECV_LEN, SBP_NUM_OCB/2, 2010170374Ssimokawa fc, (void *)sbp, sbp_recv); 2011103285Sikob 2012170374Ssimokawa fw_bindadd(fc, &sbp->fwb); 2013170374Ssimokawa 2014113584Ssimokawa sbp->fd.post_busreset = sbp_post_busreset; 2015103285Sikob sbp->fd.post_explore = sbp_post_explore; 2016103285Sikob 2017170374Ssimokawa if (fc->status != -1) { 2018122387Ssimokawa sbp_post_busreset((void *)sbp); 2019111199Ssimokawa sbp_post_explore((void *)sbp); 2020111199Ssimokawa } 2021170374Ssimokawa SBP_LOCK(sbp); 2022122387Ssimokawa xpt_async(AC_BUS_RESET, sbp->path, /*arg*/ NULL); 2023170374Ssimokawa SBP_UNLOCK(sbp); 2024111199Ssimokawa 2025103285Sikob return (0); 2026111615Ssimokawafail: 2027170374Ssimokawa SBP_UNLOCK(sbp); 2028111615Ssimokawa cam_sim_free(sbp->sim, /*free_devq*/TRUE); 2029111615Ssimokawa return (ENXIO); 2030103285Sikob} 2031103285Sikob 2032103285Sikobstatic int 2033110145Ssimokawasbp_logout_all(struct sbp_softc *sbp) 2034110145Ssimokawa{ 2035110145Ssimokawa struct sbp_target *target; 2036110145Ssimokawa struct sbp_dev *sdev; 2037110145Ssimokawa int i, j; 2038110145Ssimokawa 2039110145SsimokawaSBP_DEBUG(0) 2040110145Ssimokawa printf("sbp_logout_all\n"); 2041110145SsimokawaEND_DEBUG 2042275978Ssmh SBP_LOCK_ASSERT(sbp); 2043110145Ssimokawa for (i = 0 ; i < SBP_NUM_TARGETS ; i ++) { 2044110145Ssimokawa target = &sbp->targets[i]; 2045110145Ssimokawa if (target->luns == NULL) 2046110145Ssimokawa continue; 2047110145Ssimokawa for (j = 0; j < target->num_lun; j++) { 2048121185Ssimokawa sdev = target->luns[j]; 2049121185Ssimokawa if (sdev == NULL) 2050121185Ssimokawa continue; 2051113584Ssimokawa callout_stop(&sdev->login_callout); 2052110336Ssimokawa if (sdev->status >= SBP_DEV_TOATTACH && 2053110336Ssimokawa sdev->status <= SBP_DEV_ATTACHED) 2054111615Ssimokawa sbp_mgm_orb(sdev, ORB_FUN_LGO, NULL); 2055110145Ssimokawa } 2056110145Ssimokawa } 2057113584Ssimokawa 2058110145Ssimokawa return 0; 2059110145Ssimokawa} 2060110145Ssimokawa 2061110145Ssimokawastatic int 2062110145Ssimokawasbp_shutdown(device_t dev) 2063110145Ssimokawa{ 2064110145Ssimokawa struct sbp_softc *sbp = ((struct sbp_softc *)device_get_softc(dev)); 2065110145Ssimokawa 2066275978Ssmh SBP_LOCK(sbp); 2067110145Ssimokawa sbp_logout_all(sbp); 2068275978Ssmh SBP_UNLOCK(sbp); 2069110145Ssimokawa return (0); 2070110145Ssimokawa} 2071110145Ssimokawa 2072121185Ssimokawastatic void 2073121185Ssimokawasbp_free_sdev(struct sbp_dev *sdev) 2074121185Ssimokawa{ 2075275978Ssmh struct sbp_softc *sbp; 2076121185Ssimokawa int i; 2077121185Ssimokawa 2078121185Ssimokawa if (sdev == NULL) 2079121185Ssimokawa return; 2080275978Ssmh sbp = sdev->target->sbp; 2081275978Ssmh SBP_UNLOCK(sbp); 2082275978Ssmh callout_drain(&sdev->login_callout); 2083275978Ssmh for (i = 0; i < SBP_QUEUE_LEN; i++) { 2084275978Ssmh callout_drain(&sdev->ocb[i].timer); 2085275978Ssmh bus_dmamap_destroy(sbp->dmat, sdev->ocb[i].dmamap); 2086275978Ssmh } 2087275978Ssmh fwdma_free(sbp->fd.fc, &sdev->dma); 2088121185Ssimokawa free(sdev, M_SBP); 2089275978Ssmh SBP_LOCK(sbp); 2090121185Ssimokawa} 2091121185Ssimokawa 2092121185Ssimokawastatic void 2093121185Ssimokawasbp_free_target(struct sbp_target *target) 2094121185Ssimokawa{ 2095121185Ssimokawa struct sbp_softc *sbp; 2096121185Ssimokawa struct fw_xfer *xfer, *next; 2097121185Ssimokawa int i; 2098121185Ssimokawa 2099121185Ssimokawa if (target->luns == NULL) 2100121185Ssimokawa return; 2101121185Ssimokawa sbp = target->sbp; 2102275978Ssmh SBP_LOCK_ASSERT(sbp); 2103275978Ssmh SBP_UNLOCK(sbp); 2104275978Ssmh callout_drain(&target->mgm_ocb_timeout); 2105275978Ssmh callout_drain(&target->scan_callout); 2106275978Ssmh SBP_LOCK(sbp); 2107121185Ssimokawa for (i = 0; i < target->num_lun; i++) 2108121185Ssimokawa sbp_free_sdev(target->luns[i]); 2109121185Ssimokawa 2110275978Ssmh STAILQ_FOREACH_SAFE(xfer, &target->xferlist, link, next) { 2111121185Ssimokawa fw_xfer_free_buf(xfer); 2112121185Ssimokawa } 2113121185Ssimokawa STAILQ_INIT(&target->xferlist); 2114121185Ssimokawa free(target->luns, M_SBP); 2115201758Smbr target->num_lun = 0; 2116121185Ssimokawa target->luns = NULL; 2117121185Ssimokawa target->fwdev = NULL; 2118121185Ssimokawa} 2119121185Ssimokawa 2120110145Ssimokawastatic int 2121103285Sikobsbp_detach(device_t dev) 2122103285Sikob{ 2123103285Sikob struct sbp_softc *sbp = ((struct sbp_softc *)device_get_softc(dev)); 2124103285Sikob struct firewire_comm *fc = sbp->fd.fc; 2125121185Ssimokawa int i; 2126103285Sikob 2127103285SikobSBP_DEBUG(0) 2128103285Sikob printf("sbp_detach\n"); 2129103285SikobEND_DEBUG 2130113584Ssimokawa 2131275978Ssmh SBP_LOCK(sbp); 2132103285Sikob for (i = 0; i < SBP_NUM_TARGETS; i ++) 2133110145Ssimokawa sbp_cam_detach_target(&sbp->targets[i]); 2134170374Ssimokawa 2135120660Ssimokawa xpt_async(AC_LOST_DEVICE, sbp->path, NULL); 2136111615Ssimokawa xpt_free_path(sbp->path); 2137103285Sikob xpt_bus_deregister(cam_sim_path(sbp->sim)); 2138170378Sgallatin cam_sim_free(sbp->sim, /*free_devq*/ TRUE); 2139110145Ssimokawa 2140110145Ssimokawa sbp_logout_all(sbp); 2141275978Ssmh SBP_UNLOCK(sbp); 2142113584Ssimokawa 2143110145Ssimokawa /* XXX wait for logout completion */ 2144167086Sjhb pause("sbpdtc", hz/2); 2145110145Ssimokawa 2146275978Ssmh SBP_LOCK(sbp); 2147121185Ssimokawa for (i = 0 ; i < SBP_NUM_TARGETS ; i ++) 2148121185Ssimokawa sbp_free_target(&sbp->targets[i]); 2149275978Ssmh SBP_UNLOCK(sbp); 2150113584Ssimokawa 2151110145Ssimokawa fw_bindremove(fc, &sbp->fwb); 2152169130Ssimokawa fw_xferlist_remove(&sbp->fwb.xferlist); 2153113584Ssimokawa 2154103285Sikob bus_dma_tag_destroy(sbp->dmat); 2155170374Ssimokawa mtx_destroy(&sbp->mtx); 2156110145Ssimokawa 2157103285Sikob return (0); 2158103285Sikob} 2159103285Sikob 2160103285Sikobstatic void 2161121185Ssimokawasbp_cam_detach_sdev(struct sbp_dev *sdev) 2162121185Ssimokawa{ 2163121185Ssimokawa if (sdev == NULL) 2164121185Ssimokawa return; 2165121185Ssimokawa if (sdev->status == SBP_DEV_DEAD) 2166121185Ssimokawa return; 2167121185Ssimokawa if (sdev->status == SBP_DEV_RESET) 2168121185Ssimokawa return; 2169275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2170170374Ssimokawa sbp_abort_all_ocbs(sdev, CAM_DEV_NOT_THERE); 2171121185Ssimokawa if (sdev->path) { 2172121185Ssimokawa xpt_release_devq(sdev->path, 2173121185Ssimokawa sdev->freeze, TRUE); 2174121185Ssimokawa sdev->freeze = 0; 2175121185Ssimokawa xpt_async(AC_LOST_DEVICE, sdev->path, NULL); 2176121185Ssimokawa xpt_free_path(sdev->path); 2177121185Ssimokawa sdev->path = NULL; 2178121185Ssimokawa } 2179121185Ssimokawa} 2180121185Ssimokawa 2181121185Ssimokawastatic void 2182110145Ssimokawasbp_cam_detach_target(struct sbp_target *target) 2183103285Sikob{ 2184103285Sikob int i; 2185103285Sikob 2186275978Ssmh SBP_LOCK_ASSERT(target->sbp); 2187103285Sikob if (target->luns != NULL) { 2188108529SsimokawaSBP_DEBUG(0) 2189103285Sikob printf("sbp_detach_target %d\n", target->target_id); 2190108529SsimokawaEND_DEBUG 2191111615Ssimokawa callout_stop(&target->scan_callout); 2192121185Ssimokawa for (i = 0; i < target->num_lun; i++) 2193121185Ssimokawa sbp_cam_detach_sdev(target->luns[i]); 2194103285Sikob } 2195103285Sikob} 2196103285Sikob 2197103285Sikobstatic void 2198114732Ssimokawasbp_target_reset(struct sbp_dev *sdev, int method) 2199114732Ssimokawa{ 2200114732Ssimokawa int i; 2201114732Ssimokawa struct sbp_target *target = sdev->target; 2202114732Ssimokawa struct sbp_dev *tsdev; 2203114732Ssimokawa 2204275978Ssmh SBP_LOCK_ASSERT(target->sbp); 2205114732Ssimokawa for (i = 0; i < target->num_lun; i++) { 2206121185Ssimokawa tsdev = target->luns[i]; 2207121185Ssimokawa if (tsdev == NULL) 2208121185Ssimokawa continue; 2209114732Ssimokawa if (tsdev->status == SBP_DEV_DEAD) 2210114732Ssimokawa continue; 2211114732Ssimokawa if (tsdev->status == SBP_DEV_RESET) 2212114732Ssimokawa continue; 2213114732Ssimokawa xpt_freeze_devq(tsdev->path, 1); 2214114732Ssimokawa tsdev->freeze ++; 2215114732Ssimokawa sbp_abort_all_ocbs(tsdev, CAM_CMD_TIMEOUT); 2216114732Ssimokawa if (method == 2) 2217114732Ssimokawa tsdev->status = SBP_DEV_LOGIN; 2218114732Ssimokawa } 2219114732Ssimokawa switch(method) { 2220114732Ssimokawa case 1: 2221114732Ssimokawa printf("target reset\n"); 2222114732Ssimokawa sbp_mgm_orb(sdev, ORB_FUN_RST, NULL); 2223114732Ssimokawa break; 2224114732Ssimokawa case 2: 2225114732Ssimokawa printf("reset start\n"); 2226114732Ssimokawa sbp_reset_start(sdev); 2227114732Ssimokawa break; 2228114732Ssimokawa } 2229114732Ssimokawa 2230114732Ssimokawa} 2231114732Ssimokawa 2232114732Ssimokawastatic void 2233114732Ssimokawasbp_mgm_timeout(void *arg) 2234114732Ssimokawa{ 2235114732Ssimokawa struct sbp_ocb *ocb = (struct sbp_ocb *)arg; 2236114732Ssimokawa struct sbp_dev *sdev = ocb->sdev; 2237114732Ssimokawa struct sbp_target *target = sdev->target; 2238114732Ssimokawa 2239275978Ssmh SBP_LOCK_ASSERT(target->sbp); 2240188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 2241188756Ssbruno "%s:%s request timeout(mgm orb:0x%08x)\n", 2242188756Ssbruno __func__, sdev->bustgtlun, (uint32_t)ocb->bus_addr); 2243114732Ssimokawa target->mgm_ocb_cur = NULL; 2244114732Ssimokawa sbp_free_ocb(sdev, ocb); 2245114732Ssimokawa#if 0 2246114732Ssimokawa /* XXX */ 2247121185Ssimokawa printf("run next request\n"); 2248114732Ssimokawa sbp_mgm_orb(sdev, ORB_FUN_RUNQUEUE, NULL); 2249114732Ssimokawa#endif 2250188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 2251188756Ssbruno "%s:%s reset start\n", 2252188756Ssbruno __func__, sdev->bustgtlun); 2253114732Ssimokawa sbp_reset_start(sdev); 2254114732Ssimokawa} 2255114732Ssimokawa 2256114732Ssimokawastatic void 2257103285Sikobsbp_timeout(void *arg) 2258103285Sikob{ 2259103285Sikob struct sbp_ocb *ocb = (struct sbp_ocb *)arg; 2260103285Sikob struct sbp_dev *sdev = ocb->sdev; 2261103285Sikob 2262188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 2263188756Ssbruno "%s:%s request timeout(cmd orb:0x%08x) ... ", 2264188756Ssbruno __func__, sdev->bustgtlun, (uint32_t)ocb->bus_addr); 2265103285Sikob 2266275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2267114732Ssimokawa sdev->timeout ++; 2268114732Ssimokawa switch(sdev->timeout) { 2269114732Ssimokawa case 1: 2270110336Ssimokawa printf("agent reset\n"); 2271114732Ssimokawa xpt_freeze_devq(sdev->path, 1); 2272114732Ssimokawa sdev->freeze ++; 2273114732Ssimokawa sbp_abort_all_ocbs(sdev, CAM_CMD_TIMEOUT); 2274110336Ssimokawa sbp_agent_reset(sdev); 2275114732Ssimokawa break; 2276114732Ssimokawa case 2: 2277114732Ssimokawa case 3: 2278114732Ssimokawa sbp_target_reset(sdev, sdev->timeout - 1); 2279114732Ssimokawa break; 2280114732Ssimokawa#if 0 2281114732Ssimokawa default: 2282114732Ssimokawa /* XXX give up */ 2283114732Ssimokawa sbp_cam_detach_target(target); 2284114732Ssimokawa if (target->luns != NULL) 2285114732Ssimokawa free(target->luns, M_SBP); 2286201758Smbr target->num_lun = 0; 2287114732Ssimokawa target->luns = NULL; 2288114732Ssimokawa target->fwdev = NULL; 2289114732Ssimokawa#endif 2290110336Ssimokawa } 2291103285Sikob} 2292103285Sikob 2293103285Sikobstatic void 2294275978Ssmhsbp_action(struct cam_sim *sim, union ccb *ccb) 2295103285Sikob{ 2296103285Sikob 2297103285Sikob struct sbp_softc *sbp = (struct sbp_softc *)sim->softc; 2298103285Sikob struct sbp_target *target = NULL; 2299103285Sikob struct sbp_dev *sdev = NULL; 2300103285Sikob 2301275978Ssmh if (sbp != NULL) 2302275978Ssmh SBP_LOCK_ASSERT(sbp); 2303103285Sikob /* target:lun -> sdev mapping */ 2304103285Sikob if (sbp != NULL 2305103285Sikob && ccb->ccb_h.target_id != CAM_TARGET_WILDCARD 2306103285Sikob && ccb->ccb_h.target_id < SBP_NUM_TARGETS) { 2307103285Sikob target = &sbp->targets[ccb->ccb_h.target_id]; 2308103285Sikob if (target->fwdev != NULL 2309103285Sikob && ccb->ccb_h.target_lun != CAM_LUN_WILDCARD 2310103285Sikob && ccb->ccb_h.target_lun < target->num_lun) { 2311121185Ssimokawa sdev = target->luns[ccb->ccb_h.target_lun]; 2312121185Ssimokawa if (sdev != NULL && sdev->status != SBP_DEV_ATTACHED && 2313103285Sikob sdev->status != SBP_DEV_PROBE) 2314103285Sikob sdev = NULL; 2315103285Sikob } 2316103285Sikob } 2317103285Sikob 2318103285SikobSBP_DEBUG(1) 2319103285Sikob if (sdev == NULL) 2320103285Sikob printf("invalid target %d lun %d\n", 2321103285Sikob ccb->ccb_h.target_id, ccb->ccb_h.target_lun); 2322103285SikobEND_DEBUG 2323103285Sikob 2324103285Sikob switch (ccb->ccb_h.func_code) { 2325103285Sikob case XPT_SCSI_IO: 2326103285Sikob case XPT_RESET_DEV: 2327103285Sikob case XPT_GET_TRAN_SETTINGS: 2328103285Sikob case XPT_SET_TRAN_SETTINGS: 2329103285Sikob case XPT_CALC_GEOMETRY: 2330103285Sikob if (sdev == NULL) { 2331103285SikobSBP_DEBUG(1) 2332103285Sikob printf("%s:%d:%d:func_code 0x%04x: " 2333103285Sikob "Invalid target (target needed)\n", 2334103285Sikob device_get_nameunit(sbp->fd.dev), 2335103285Sikob ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2336103285Sikob ccb->ccb_h.func_code); 2337103285SikobEND_DEBUG 2338103285Sikob 2339108276Ssimokawa ccb->ccb_h.status = CAM_DEV_NOT_THERE; 2340103285Sikob xpt_done(ccb); 2341103285Sikob return; 2342103285Sikob } 2343103285Sikob break; 2344103285Sikob case XPT_PATH_INQ: 2345103285Sikob case XPT_NOOP: 2346103285Sikob /* The opcodes sometimes aimed at a target (sc is valid), 2347103285Sikob * sometimes aimed at the SIM (sc is invalid and target is 2348103285Sikob * CAM_TARGET_WILDCARD) 2349103285Sikob */ 2350103285Sikob if (sbp == NULL && 2351103285Sikob ccb->ccb_h.target_id != CAM_TARGET_WILDCARD) { 2352103285SikobSBP_DEBUG(0) 2353103285Sikob printf("%s:%d:%d func_code 0x%04x: " 2354103285Sikob "Invalid target (no wildcard)\n", 2355103285Sikob device_get_nameunit(sbp->fd.dev), 2356103285Sikob ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2357103285Sikob ccb->ccb_h.func_code); 2358103285SikobEND_DEBUG 2359108276Ssimokawa ccb->ccb_h.status = CAM_DEV_NOT_THERE; 2360103285Sikob xpt_done(ccb); 2361103285Sikob return; 2362103285Sikob } 2363103285Sikob break; 2364103285Sikob default: 2365103285Sikob /* XXX Hm, we should check the input parameters */ 2366103285Sikob break; 2367103285Sikob } 2368103285Sikob 2369103285Sikob switch (ccb->ccb_h.func_code) { 2370103285Sikob case XPT_SCSI_IO: 2371103285Sikob { 2372103285Sikob struct ccb_scsiio *csio; 2373103285Sikob struct sbp_ocb *ocb; 2374113584Ssimokawa int speed; 2375106506Ssimokawa void *cdb; 2376103285Sikob 2377103285Sikob csio = &ccb->csio; 2378170374Ssimokawa mtx_assert(sim->mtx, MA_OWNED); 2379103285Sikob 2380121185SsimokawaSBP_DEBUG(2) 2381103285Sikob printf("%s:%d:%d XPT_SCSI_IO: " 2382103285Sikob "cmd: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x" 2383103285Sikob ", flags: 0x%02x, " 2384103285Sikob "%db cmd/%db data/%db sense\n", 2385103285Sikob device_get_nameunit(sbp->fd.dev), 2386103285Sikob ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2387103285Sikob csio->cdb_io.cdb_bytes[0], 2388103285Sikob csio->cdb_io.cdb_bytes[1], 2389103285Sikob csio->cdb_io.cdb_bytes[2], 2390103285Sikob csio->cdb_io.cdb_bytes[3], 2391103285Sikob csio->cdb_io.cdb_bytes[4], 2392103285Sikob csio->cdb_io.cdb_bytes[5], 2393103285Sikob csio->cdb_io.cdb_bytes[6], 2394103285Sikob csio->cdb_io.cdb_bytes[7], 2395103285Sikob csio->cdb_io.cdb_bytes[8], 2396103285Sikob csio->cdb_io.cdb_bytes[9], 2397103285Sikob ccb->ccb_h.flags & CAM_DIR_MASK, 2398103285Sikob csio->cdb_len, csio->dxfer_len, 2399103285Sikob csio->sense_len); 2400103285SikobEND_DEBUG 2401103285Sikob if(sdev == NULL){ 2402103285Sikob ccb->ccb_h.status = CAM_DEV_NOT_THERE; 2403103285Sikob xpt_done(ccb); 2404103285Sikob return; 2405103285Sikob } 2406103285Sikob#if 0 2407103285Sikob /* if we are in probe stage, pass only probe commands */ 2408103285Sikob if (sdev->status == SBP_DEV_PROBE) { 2409103285Sikob char *name; 2410103285Sikob name = xpt_path_periph(ccb->ccb_h.path)->periph_name; 2411103285Sikob printf("probe stage, periph name: %s\n", name); 2412103285Sikob if (strcmp(name, "probe") != 0) { 2413103285Sikob ccb->ccb_h.status = CAM_REQUEUE_REQ; 2414103285Sikob xpt_done(ccb); 2415103285Sikob return; 2416103285Sikob } 2417103285Sikob } 2418103285Sikob#endif 2419122528Ssimokawa if ((ocb = sbp_get_ocb(sdev)) == NULL) { 2420170807Ssimokawa ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 2421127468Ssimokawa if (sdev->freeze == 0) { 2422127468Ssimokawa xpt_freeze_devq(sdev->path, 1); 2423127468Ssimokawa sdev->freeze ++; 2424127468Ssimokawa } 2425122528Ssimokawa xpt_done(ccb); 2426103285Sikob return; 2427122528Ssimokawa } 2428113584Ssimokawa 2429103285Sikob ocb->flags = OCB_ACT_CMD; 2430103285Sikob ocb->sdev = sdev; 2431103285Sikob ocb->ccb = ccb; 2432103285Sikob ccb->ccb_h.ccb_sdev_ptr = sdev; 2433261455Seadler ocb->orb[0] = htonl(1U << 31); 2434103285Sikob ocb->orb[1] = 0; 2435103285Sikob ocb->orb[2] = htonl(((sbp->fd.fc->nodeid | FWLOCALBUS )<< 16) ); 2436113584Ssimokawa ocb->orb[3] = htonl(ocb->bus_addr + IND_PTR_OFFSET); 2437103285Sikob speed = min(target->fwdev->speed, max_speed); 2438103285Sikob ocb->orb[4] = htonl(ORB_NOTIFY | ORB_CMD_SPD(speed) 2439103285Sikob | ORB_CMD_MAXP(speed + 7)); 2440103285Sikob if((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN){ 2441103285Sikob ocb->orb[4] |= htonl(ORB_CMD_IN); 2442103285Sikob } 2443103285Sikob 2444106506Ssimokawa if (csio->ccb_h.flags & CAM_CDB_POINTER) 2445106506Ssimokawa cdb = (void *)csio->cdb_io.cdb_ptr; 2446106506Ssimokawa else 2447106506Ssimokawa cdb = (void *)&csio->cdb_io.cdb_bytes; 2448120660Ssimokawa bcopy(cdb, (void *)&ocb->orb[5], csio->cdb_len); 2449103285Sikob/* 2450103285Sikobprintf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[0]), ntohl(ocb->orb[1]), ntohl(ocb->orb[2]), ntohl(ocb->orb[3])); 2451103285Sikobprintf("ORB %08x %08x %08x %08x\n", ntohl(ocb->orb[4]), ntohl(ocb->orb[5]), ntohl(ocb->orb[6]), ntohl(ocb->orb[7])); 2452103285Sikob*/ 2453103285Sikob if (ccb->csio.dxfer_len > 0) { 2454247109Simp int error; 2455103285Sikob 2456246713Skib error = bus_dmamap_load_ccb(/*dma tag*/sbp->dmat, 2457103285Sikob /*dma map*/ocb->dmamap, 2458246713Skib ccb, 2459103285Sikob sbp_execute_ocb, 2460103285Sikob ocb, 2461103285Sikob /*flags*/0); 2462113584Ssimokawa if (error) 2463113584Ssimokawa printf("sbp: bus_dmamap_load error %d\n", error); 2464103285Sikob } else 2465103285Sikob sbp_execute_ocb(ocb, NULL, 0, 0); 2466103285Sikob break; 2467103285Sikob } 2468103285Sikob case XPT_CALC_GEOMETRY: 2469103285Sikob { 2470103285Sikob struct ccb_calc_geometry *ccg; 2471127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 501100 2472129585Sdfr uint32_t size_mb; 2473129585Sdfr uint32_t secs_per_cylinder; 2474116429Ssimokawa int extended = 1; 2475116429Ssimokawa#endif 2476116351Snjl 2477103285Sikob ccg = &ccb->ccg; 2478103285Sikob if (ccg->block_size == 0) { 2479275978Ssmh printf("sbp_action: block_size is 0.\n"); 2480103285Sikob ccb->ccb_h.status = CAM_REQ_INVALID; 2481103285Sikob xpt_done(ccb); 2482103285Sikob break; 2483103285Sikob } 2484103285SikobSBP_DEBUG(1) 2485103285Sikob printf("%s:%d:%d:%d:XPT_CALC_GEOMETRY: " 2486127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 2487127468Ssimokawa "Volume size = %d\n", 2488127468Ssimokawa#else 2489114540Sjake "Volume size = %jd\n", 2490114927Ssimokawa#endif 2491114927Ssimokawa device_get_nameunit(sbp->fd.dev), 2492114927Ssimokawa cam_sim_path(sbp->sim), 2493103285Sikob ccb->ccb_h.target_id, ccb->ccb_h.target_lun, 2494127468Ssimokawa#if defined(__FreeBSD__) && __FreeBSD_version >= 500000 2495114927Ssimokawa (uintmax_t) 2496114927Ssimokawa#endif 2497114927Ssimokawa ccg->volume_size); 2498103285SikobEND_DEBUG 2499103285Sikob 2500127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 501100 2501116429Ssimokawa size_mb = ccg->volume_size 2502116429Ssimokawa / ((1024L * 1024L) / ccg->block_size); 2503116429Ssimokawa 2504116429Ssimokawa if (size_mb > 1024 && extended) { 2505116429Ssimokawa ccg->heads = 255; 2506116429Ssimokawa ccg->secs_per_track = 63; 2507116429Ssimokawa } else { 2508116429Ssimokawa ccg->heads = 64; 2509116429Ssimokawa ccg->secs_per_track = 32; 2510116429Ssimokawa } 2511116429Ssimokawa secs_per_cylinder = ccg->heads * ccg->secs_per_track; 2512116429Ssimokawa ccg->cylinders = ccg->volume_size / secs_per_cylinder; 2513116429Ssimokawa ccb->ccb_h.status = CAM_REQ_CMP; 2514116429Ssimokawa#else 2515116351Snjl cam_calc_geometry(ccg, /*extended*/1); 2516116429Ssimokawa#endif 2517103285Sikob xpt_done(ccb); 2518103285Sikob break; 2519103285Sikob } 2520103285Sikob case XPT_RESET_BUS: /* Reset the specified SCSI bus */ 2521103285Sikob { 2522103285Sikob 2523103285SikobSBP_DEBUG(1) 2524103285Sikob printf("%s:%d:XPT_RESET_BUS: \n", 2525103285Sikob device_get_nameunit(sbp->fd.dev), cam_sim_path(sbp->sim)); 2526103285SikobEND_DEBUG 2527103285Sikob 2528103285Sikob ccb->ccb_h.status = CAM_REQ_INVALID; 2529103285Sikob xpt_done(ccb); 2530103285Sikob break; 2531103285Sikob } 2532103285Sikob case XPT_PATH_INQ: /* Path routing inquiry */ 2533103285Sikob { 2534103285Sikob struct ccb_pathinq *cpi = &ccb->cpi; 2535103285Sikob 2536103285SikobSBP_DEBUG(1) 2537103285Sikob printf("%s:%d:%d XPT_PATH_INQ:.\n", 2538103285Sikob device_get_nameunit(sbp->fd.dev), 2539103285Sikob ccb->ccb_h.target_id, ccb->ccb_h.target_lun); 2540103285SikobEND_DEBUG 2541103285Sikob cpi->version_num = 1; /* XXX??? */ 2542111615Ssimokawa cpi->hba_inquiry = PI_TAG_ABLE; 2543103285Sikob cpi->target_sprt = 0; 2544118105Snjl cpi->hba_misc = PIM_NOBUSRESET | PIM_NO_6_BYTE; 2545103285Sikob cpi->hba_eng_cnt = 0; 2546103285Sikob cpi->max_target = SBP_NUM_TARGETS - 1; 2547103285Sikob cpi->max_lun = SBP_NUM_LUNS - 1; 2548103285Sikob cpi->initiator_id = SBP_INITIATOR; 2549103285Sikob cpi->bus_id = sim->bus_id; 2550103285Sikob cpi->base_transfer_speed = 400 * 1000 / 8; 2551103285Sikob strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 2552103285Sikob strncpy(cpi->hba_vid, "SBP", HBA_IDLEN); 2553103285Sikob strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN); 2554103285Sikob cpi->unit_number = sim->unit_number; 2555163816Smjacob cpi->transport = XPORT_SPI; /* XX should have a FireWire */ 2556163816Smjacob cpi->transport_version = 2; 2557163816Smjacob cpi->protocol = PROTO_SCSI; 2558163816Smjacob cpi->protocol_version = SCSI_REV_2; 2559103285Sikob 2560103285Sikob cpi->ccb_h.status = CAM_REQ_CMP; 2561103285Sikob xpt_done(ccb); 2562103285Sikob break; 2563103285Sikob } 2564103285Sikob case XPT_GET_TRAN_SETTINGS: 2565103285Sikob { 2566103285Sikob struct ccb_trans_settings *cts = &ccb->cts; 2567163816Smjacob struct ccb_trans_settings_scsi *scsi = 2568163816Smjacob &cts->proto_specific.scsi; 2569163816Smjacob struct ccb_trans_settings_spi *spi = 2570163816Smjacob &cts->xport_specific.spi; 2571163816Smjacob 2572163816Smjacob cts->protocol = PROTO_SCSI; 2573163816Smjacob cts->protocol_version = SCSI_REV_2; 2574163816Smjacob cts->transport = XPORT_SPI; /* should have a FireWire */ 2575163816Smjacob cts->transport_version = 2; 2576163816Smjacob spi->valid = CTS_SPI_VALID_DISC; 2577163816Smjacob spi->flags = CTS_SPI_FLAGS_DISC_ENB; 2578163816Smjacob scsi->valid = CTS_SCSI_VALID_TQ; 2579163816Smjacob scsi->flags = CTS_SCSI_FLAGS_TAG_ENB; 2580103285SikobSBP_DEBUG(1) 2581103285Sikob printf("%s:%d:%d XPT_GET_TRAN_SETTINGS:.\n", 2582103285Sikob device_get_nameunit(sbp->fd.dev), 2583103285Sikob ccb->ccb_h.target_id, ccb->ccb_h.target_lun); 2584103285SikobEND_DEBUG 2585103285Sikob cts->ccb_h.status = CAM_REQ_CMP; 2586103285Sikob xpt_done(ccb); 2587103285Sikob break; 2588103285Sikob } 2589103285Sikob case XPT_ABORT: 2590103285Sikob ccb->ccb_h.status = CAM_UA_ABORT; 2591103285Sikob xpt_done(ccb); 2592103285Sikob break; 2593111615Ssimokawa case XPT_SET_TRAN_SETTINGS: 2594111615Ssimokawa /* XXX */ 2595103285Sikob default: 2596103285Sikob ccb->ccb_h.status = CAM_REQ_INVALID; 2597103285Sikob xpt_done(ccb); 2598103285Sikob break; 2599103285Sikob } 2600103285Sikob return; 2601103285Sikob} 2602103285Sikob 2603103285Sikobstatic void 2604103285Sikobsbp_execute_ocb(void *arg, bus_dma_segment_t *segments, int seg, int error) 2605103285Sikob{ 2606103285Sikob int i; 2607103285Sikob struct sbp_ocb *ocb; 2608103285Sikob struct sbp_ocb *prev; 2609105633Ssimokawa bus_dma_segment_t *s; 2610103285Sikob 2611103285Sikob if (error) 2612103285Sikob printf("sbp_execute_ocb: error=%d\n", error); 2613103285Sikob 2614103285Sikob ocb = (struct sbp_ocb *)arg; 2615113584Ssimokawa 2616121185SsimokawaSBP_DEBUG(2) 2617113584Ssimokawa printf("sbp_execute_ocb: seg %d", seg); 2618113584Ssimokawa for (i = 0; i < seg; i++) 2619127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 2620127468Ssimokawa printf(", %x:%d", segments[i].ds_addr, segments[i].ds_len); 2621127468Ssimokawa#else 2622113972Ssimokawa printf(", %jx:%jd", (uintmax_t)segments[i].ds_addr, 2623113972Ssimokawa (uintmax_t)segments[i].ds_len); 2624113584Ssimokawa#endif 2625113584Ssimokawa printf("\n"); 2626113584SsimokawaEND_DEBUG 2627113584Ssimokawa 2628103285Sikob if (seg == 1) { 2629103285Sikob /* direct pointer */ 2630113474Ssimokawa s = &segments[0]; 2631113474Ssimokawa if (s->ds_len > SBP_SEG_MAX) 2632113474Ssimokawa panic("ds_len > SBP_SEG_MAX, fix busdma code"); 2633113474Ssimokawa ocb->orb[3] = htonl(s->ds_addr); 2634113474Ssimokawa ocb->orb[4] |= htonl(s->ds_len); 2635103285Sikob } else if(seg > 1) { 2636103285Sikob /* page table */ 2637103285Sikob for (i = 0; i < seg; i++) { 2638105633Ssimokawa s = &segments[i]; 2639108877SsimokawaSBP_DEBUG(0) 2640108877Ssimokawa /* XXX LSI Logic "< 16 byte" bug might be hit */ 2641105633Ssimokawa if (s->ds_len < 16) 2642105633Ssimokawa printf("sbp_execute_ocb: warning, " 2643127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 2644127468Ssimokawa "segment length(%d) is less than 16." 2645127468Ssimokawa#else 2646106543Ssimokawa "segment length(%zd) is less than 16." 2647108877Ssimokawa#endif 2648205842Simp "(seg=%d/%d)\n", (size_t)s->ds_len, i+1, seg); 2649108877SsimokawaEND_DEBUG 2650113474Ssimokawa if (s->ds_len > SBP_SEG_MAX) 2651113474Ssimokawa panic("ds_len > SBP_SEG_MAX, fix busdma code"); 2652105633Ssimokawa ocb->ind_ptr[i].hi = htonl(s->ds_len << 16); 2653105633Ssimokawa ocb->ind_ptr[i].lo = htonl(s->ds_addr); 2654103285Sikob } 2655103285Sikob ocb->orb[4] |= htonl(ORB_CMD_PTBL | seg); 2656103285Sikob } 2657103285Sikob 2658113584Ssimokawa if (seg > 0) 2659113584Ssimokawa bus_dmamap_sync(ocb->sdev->target->sbp->dmat, ocb->dmamap, 2660113584Ssimokawa (ntohl(ocb->orb[4]) & ORB_CMD_IN) ? 2661113584Ssimokawa BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 2662103285Sikob prev = sbp_enqueue_ocb(ocb->sdev, ocb); 2663113584Ssimokawa fwdma_sync(&ocb->sdev->dma, BUS_DMASYNC_PREWRITE); 2664127468Ssimokawa if (use_doorbell) { 2665127468Ssimokawa if (prev == NULL) { 2666127468Ssimokawa if (ocb->sdev->last_ocb != NULL) 2667127468Ssimokawa sbp_doorbell(ocb->sdev); 2668127468Ssimokawa else 2669127468Ssimokawa sbp_orb_pointer(ocb->sdev, ocb); 2670127468Ssimokawa } 2671127468Ssimokawa } else { 2672127468Ssimokawa if (prev == NULL || (ocb->sdev->flags & ORB_LINK_DEAD) != 0) { 2673127468Ssimokawa ocb->sdev->flags &= ~ORB_LINK_DEAD; 2674127468Ssimokawa sbp_orb_pointer(ocb->sdev, ocb); 2675127468Ssimokawa } 2676120842Ssimokawa } 2677103285Sikob} 2678103285Sikob 2679103285Sikobstatic void 2680103285Sikobsbp_poll(struct cam_sim *sim) 2681103285Sikob{ 2682120847Ssimokawa struct sbp_softc *sbp; 2683120847Ssimokawa struct firewire_comm *fc; 2684120847Ssimokawa 2685120847Ssimokawa sbp = (struct sbp_softc *)sim->softc; 2686120847Ssimokawa fc = sbp->fd.fc; 2687120847Ssimokawa 2688120847Ssimokawa fc->poll(fc, 0, -1); 2689120847Ssimokawa 2690103285Sikob return; 2691103285Sikob} 2692120847Ssimokawa 2693103285Sikobstatic struct sbp_ocb * 2694111615Ssimokawasbp_dequeue_ocb(struct sbp_dev *sdev, struct sbp_status *sbp_status) 2695103285Sikob{ 2696103285Sikob struct sbp_ocb *ocb; 2697103285Sikob struct sbp_ocb *next; 2698275978Ssmh int order = 0; 2699103285Sikob 2700103285SikobSBP_DEBUG(1) 2701188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 2702127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 2703188756Ssbruno "%s:%s 0x%08lx src %d\n", 2704127468Ssimokawa#else 2705188756Ssbruno "%s:%s 0x%08x src %d\n", 2706108712Ssimokawa#endif 2707188756Ssbruno __func__, sdev->bustgtlun, ntohl(sbp_status->orb_lo), sbp_status->src); 2708103285SikobEND_DEBUG 2709275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2710275978Ssmh STAILQ_FOREACH_SAFE(ocb, &sdev->ocbs, ocb, next) { 2711111615Ssimokawa if (OCB_MATCH(ocb, sbp_status)) { 2712103285Sikob /* found */ 2713111819Ssimokawa STAILQ_REMOVE(&sdev->ocbs, ocb, sbp_ocb, ocb); 2714103285Sikob if (ocb->ccb != NULL) 2715275978Ssmh callout_stop(&ocb->timer); 2716113584Ssimokawa if (ntohl(ocb->orb[4]) & 0xffff) { 2717113584Ssimokawa bus_dmamap_sync(sdev->target->sbp->dmat, 2718113584Ssimokawa ocb->dmamap, 2719113584Ssimokawa (ntohl(ocb->orb[4]) & ORB_CMD_IN) ? 2720113584Ssimokawa BUS_DMASYNC_POSTREAD : 2721113584Ssimokawa BUS_DMASYNC_POSTWRITE); 2722113584Ssimokawa bus_dmamap_unload(sdev->target->sbp->dmat, 2723113584Ssimokawa ocb->dmamap); 2724103285Sikob } 2725127468Ssimokawa if (!use_doorbell) { 2726127468Ssimokawa if (sbp_status->src == SRC_NO_NEXT) { 2727127468Ssimokawa if (next != NULL) 2728127468Ssimokawa sbp_orb_pointer(sdev, next); 2729127468Ssimokawa else if (order > 0) { 2730127468Ssimokawa /* 2731127468Ssimokawa * Unordered execution 2732127468Ssimokawa * We need to send pointer for 2733127468Ssimokawa * next ORB 2734127468Ssimokawa */ 2735127468Ssimokawa sdev->flags |= ORB_LINK_DEAD; 2736127468Ssimokawa } 2737120842Ssimokawa } 2738127468Ssimokawa } else { 2739127468Ssimokawa /* 2740127468Ssimokawa * XXX this is not correct for unordered 2741127468Ssimokawa * execution. 2742127468Ssimokawa */ 2743170807Ssimokawa if (sdev->last_ocb != NULL) { 2744127468Ssimokawa sbp_free_ocb(sdev, sdev->last_ocb); 2745170807Ssimokawa } 2746127468Ssimokawa sdev->last_ocb = ocb; 2747127468Ssimokawa if (next != NULL && 2748127468Ssimokawa sbp_status->src == SRC_NO_NEXT) 2749127468Ssimokawa sbp_doorbell(sdev); 2750120842Ssimokawa } 2751103285Sikob break; 2752111819Ssimokawa } else 2753111819Ssimokawa order ++; 2754103285Sikob } 2755103285SikobSBP_DEBUG(0) 2756103285Sikob if (ocb && order > 0) { 2757188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 2758188756Ssbruno "%s:%s unordered execution order:%d\n", 2759188756Ssbruno __func__, sdev->bustgtlun, order); 2760103285Sikob } 2761103285SikobEND_DEBUG 2762103285Sikob return (ocb); 2763103285Sikob} 2764103285Sikob 2765103285Sikobstatic struct sbp_ocb * 2766103285Sikobsbp_enqueue_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb) 2767103285Sikob{ 2768127468Ssimokawa struct sbp_ocb *prev, *prev2; 2769103285Sikob 2770275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2771121185SsimokawaSBP_DEBUG(1) 2772188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 2773127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 2774188756Ssbruno "%s:%s 0x%08x\n", __func__, sdev->bustgtlun, ocb->bus_addr); 2775108712Ssimokawa#else 2776188756Ssbruno "%s:%s 0x%08jx\n", __func__, sdev->bustgtlun, (uintmax_t)ocb->bus_addr); 2777108712Ssimokawa#endif 2778103285SikobEND_DEBUG 2779127468Ssimokawa prev2 = prev = STAILQ_LAST(&sdev->ocbs, sbp_ocb, ocb); 2780103285Sikob STAILQ_INSERT_TAIL(&sdev->ocbs, ocb, ocb); 2781103285Sikob 2782275982Ssmh if (ocb->ccb != NULL) { 2783275982Ssmh callout_reset_sbt(&ocb->timer, 2784275982Ssmh SBT_1MS * ocb->ccb->ccb_h.timeout, 0, sbp_timeout, 2785275982Ssmh ocb, 0); 2786275982Ssmh } 2787103285Sikob 2788127468Ssimokawa if (use_doorbell && prev == NULL) 2789127468Ssimokawa prev2 = sdev->last_ocb; 2790127468Ssimokawa 2791170807Ssimokawa if (prev2 != NULL && (ocb->sdev->flags & ORB_LINK_DEAD) == 0) { 2792170807SsimokawaSBP_DEBUG(1) 2793127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 2794127468Ssimokawa printf("linking chain 0x%x -> 0x%x\n", 2795127468Ssimokawa prev2->bus_addr, ocb->bus_addr); 2796127468Ssimokawa#else 2797120842Ssimokawa printf("linking chain 0x%jx -> 0x%jx\n", 2798127468Ssimokawa (uintmax_t)prev2->bus_addr, (uintmax_t)ocb->bus_addr); 2799108712Ssimokawa#endif 2800103285SikobEND_DEBUG 2801170724Ssimokawa /* 2802170724Ssimokawa * Suppress compiler optimization so that orb[1] must be written first. 2803170724Ssimokawa * XXX We may need an explicit memory barrier for other architectures 2804170724Ssimokawa * other than i386/amd64. 2805170724Ssimokawa */ 2806170724Ssimokawa *(volatile uint32_t *)&prev2->orb[1] = htonl(ocb->bus_addr); 2807170724Ssimokawa *(volatile uint32_t *)&prev2->orb[0] = 0; 2808103285Sikob } 2809103285Sikob 2810103285Sikob return prev; 2811103285Sikob} 2812103285Sikob 2813103285Sikobstatic struct sbp_ocb * 2814113584Ssimokawasbp_get_ocb(struct sbp_dev *sdev) 2815103285Sikob{ 2816103285Sikob struct sbp_ocb *ocb; 2817170374Ssimokawa 2818275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2819113584Ssimokawa ocb = STAILQ_FIRST(&sdev->free_ocbs); 2820103285Sikob if (ocb == NULL) { 2821127468Ssimokawa sdev->flags |= ORB_SHORTAGE; 2822103285Sikob printf("ocb shortage!!!\n"); 2823103285Sikob return NULL; 2824103285Sikob } 2825113584Ssimokawa STAILQ_REMOVE_HEAD(&sdev->free_ocbs, ocb); 2826103285Sikob ocb->ccb = NULL; 2827103285Sikob return (ocb); 2828103285Sikob} 2829103285Sikob 2830103285Sikobstatic void 2831113584Ssimokawasbp_free_ocb(struct sbp_dev *sdev, struct sbp_ocb *ocb) 2832103285Sikob{ 2833103285Sikob ocb->flags = 0; 2834103285Sikob ocb->ccb = NULL; 2835170374Ssimokawa 2836275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2837113584Ssimokawa STAILQ_INSERT_TAIL(&sdev->free_ocbs, ocb, ocb); 2838127468Ssimokawa if ((sdev->flags & ORB_SHORTAGE) != 0) { 2839127468Ssimokawa int count; 2840127468Ssimokawa 2841127468Ssimokawa sdev->flags &= ~ORB_SHORTAGE; 2842127468Ssimokawa count = sdev->freeze; 2843127468Ssimokawa sdev->freeze = 0; 2844127468Ssimokawa xpt_release_devq(sdev->path, count, TRUE); 2845127468Ssimokawa } 2846103285Sikob} 2847103285Sikob 2848103285Sikobstatic void 2849103285Sikobsbp_abort_ocb(struct sbp_ocb *ocb, int status) 2850103285Sikob{ 2851103285Sikob struct sbp_dev *sdev; 2852103285Sikob 2853103285Sikob sdev = ocb->sdev; 2854275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2855113584SsimokawaSBP_DEBUG(0) 2856188756Ssbruno device_printf(sdev->target->sbp->fd.dev, 2857127468Ssimokawa#if defined(__DragonFly__) || __FreeBSD_version < 500000 2858188756Ssbruno "%s:%s 0x%x\n", __func__, sdev->bustgtlun, ocb->bus_addr); 2859127468Ssimokawa#else 2860188756Ssbruno "%s:%s 0x%jx\n", __func__, sdev->bustgtlun, (uintmax_t)ocb->bus_addr); 2861111819Ssimokawa#endif 2862113584SsimokawaEND_DEBUG 2863113584SsimokawaSBP_DEBUG(1) 2864105792Ssimokawa if (ocb->ccb != NULL) 2865105792Ssimokawa sbp_print_scsi_cmd(ocb); 2866103285SikobEND_DEBUG 2867113584Ssimokawa if (ntohl(ocb->orb[4]) & 0xffff) { 2868113584Ssimokawa bus_dmamap_sync(sdev->target->sbp->dmat, ocb->dmamap, 2869113584Ssimokawa (ntohl(ocb->orb[4]) & ORB_CMD_IN) ? 2870113584Ssimokawa BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 2871113584Ssimokawa bus_dmamap_unload(sdev->target->sbp->dmat, ocb->dmamap); 2872113584Ssimokawa } 2873111819Ssimokawa if (ocb->ccb != NULL) { 2874275978Ssmh callout_stop(&ocb->timer); 2875103285Sikob ocb->ccb->ccb_h.status = status; 2876103285Sikob xpt_done(ocb->ccb); 2877103285Sikob } 2878113584Ssimokawa sbp_free_ocb(sdev, ocb); 2879103285Sikob} 2880103285Sikob 2881103285Sikobstatic void 2882103285Sikobsbp_abort_all_ocbs(struct sbp_dev *sdev, int status) 2883103285Sikob{ 2884105792Ssimokawa struct sbp_ocb *ocb, *next; 2885105792Ssimokawa STAILQ_HEAD(, sbp_ocb) temp; 2886103285Sikob 2887170807Ssimokawa STAILQ_INIT(&temp); 2888275978Ssmh SBP_LOCK_ASSERT(sdev->target->sbp); 2889170807Ssimokawa STAILQ_CONCAT(&temp, &sdev->ocbs); 2890105792Ssimokawa STAILQ_INIT(&sdev->ocbs); 2891170807Ssimokawa 2892275978Ssmh STAILQ_FOREACH_SAFE(ocb, &temp, ocb, next) { 2893103285Sikob sbp_abort_ocb(ocb, status); 2894103285Sikob } 2895127468Ssimokawa if (sdev->last_ocb != NULL) { 2896127468Ssimokawa sbp_free_ocb(sdev, sdev->last_ocb); 2897127468Ssimokawa sdev->last_ocb = NULL; 2898127468Ssimokawa } 2899103285Sikob} 2900103285Sikob 2901103285Sikobstatic devclass_t sbp_devclass; 2902103285Sikob 2903103285Sikobstatic device_method_t sbp_methods[] = { 2904103285Sikob /* device interface */ 2905103285Sikob DEVMETHOD(device_identify, sbp_identify), 2906103285Sikob DEVMETHOD(device_probe, sbp_probe), 2907103285Sikob DEVMETHOD(device_attach, sbp_attach), 2908103285Sikob DEVMETHOD(device_detach, sbp_detach), 2909110145Ssimokawa DEVMETHOD(device_shutdown, sbp_shutdown), 2910103285Sikob 2911103285Sikob { 0, 0 } 2912103285Sikob}; 2913103285Sikob 2914103285Sikobstatic driver_t sbp_driver = { 2915103285Sikob "sbp", 2916103285Sikob sbp_methods, 2917103285Sikob sizeof(struct sbp_softc), 2918103285Sikob}; 2919127468Ssimokawa#ifdef __DragonFly__ 2920127468SsimokawaDECLARE_DUMMY_MODULE(sbp); 2921127468Ssimokawa#endif 2922103285SikobDRIVER_MODULE(sbp, firewire, sbp_driver, sbp_devclass, 0, 0); 2923103285SikobMODULE_VERSION(sbp, 1); 2924103285SikobMODULE_DEPEND(sbp, firewire, 1, 1, 1); 2925103285SikobMODULE_DEPEND(sbp, cam, 1, 1, 1); 2926