1 /* 2 * QLogic iSCSI HBA Driver 3 * Copyright (c) 2003-2006 QLogic Corporation 4 * 5 * See LICENSE.qla4xxx for copyright and licensing details. 6 */ 7 8 #include "ql4_def.h" 9 #include "ql4_glbl.h" 10 #include "ql4_dbg.h" 11 #include "ql4_inline.h" 12 13 14 #include <scsi/scsi_tcq.h> 15 16 /** 17 * qla4xxx_get_req_pkt - returns a valid entry in request queue. 18 * @ha: Pointer to host adapter structure. 19 * @queue_entry: Pointer to pointer to queue entry structure 20 * 21 * This routine performs the following tasks: 22 * - returns the current request_in pointer (if queue not full) 23 * - advances the request_in pointer 24 * - checks for queue full 25 **/ 26 static int qla4xxx_get_req_pkt(struct scsi_qla_host *ha, 27 struct queue_entry **queue_entry) 28 { 29 uint16_t request_in; 30 uint8_t status = QLA_SUCCESS; 31 32 *queue_entry = ha->request_ptr; 33 34 /* get the latest request_in and request_out index */ 35 request_in = ha->request_in; 36 ha->request_out = (uint16_t) le32_to_cpu(ha->shadow_regs->req_q_out); 37 38 /* Advance request queue pointer and check for queue full */ 39 if (request_in == (REQUEST_QUEUE_DEPTH - 1)) { 40 request_in = 0; 41 ha->request_ptr = ha->request_ring; 42 } else { 43 request_in++; 44 ha->request_ptr++; 45 } 46 47 /* request queue is full, try again later */ 48 if ((ha->iocb_cnt + 1) >= ha->iocb_hiwat) { 49 /* restore request pointer */ 50 ha->request_ptr = *queue_entry; 51 status = QLA_ERROR; 52 } else { 53 ha->request_in = request_in; 54 memset(*queue_entry, 0, sizeof(**queue_entry)); 55 } 56 57 return status; 58 } 59 60 /** 61 * qla4xxx_send_marker_iocb - issues marker iocb to HBA 62 * @ha: Pointer to host adapter structure. 63 * @ddb_entry: Pointer to device database entry 64 * @lun: SCSI LUN 65 * @marker_type: marker identifier 66 * 67 * This routine issues a marker IOCB. 68 **/ 69 static int qla4xxx_send_marker_iocb(struct scsi_qla_host *ha, 70 struct ddb_entry *ddb_entry, int lun) 71 { 72 struct qla4_marker_entry *marker_entry; 73 unsigned long flags = 0; 74 uint8_t status = QLA_SUCCESS; 75 76 /* Acquire hardware specific lock */ 77 spin_lock_irqsave(&ha->hardware_lock, flags); 78 79 /* Get pointer to the queue entry for the marker */ 80 if (qla4xxx_get_req_pkt(ha, (struct queue_entry **) &marker_entry) != 81 QLA_SUCCESS) { 82 status = QLA_ERROR; 83 goto exit_send_marker; 84 } 85 86 /* Put the marker in the request queue */ 87 marker_entry->hdr.entryType = ET_MARKER; 88 marker_entry->hdr.entryCount = 1; 89 marker_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index); 90 marker_entry->modifier = cpu_to_le16(MM_LUN_RESET); 91 int_to_scsilun(lun, &marker_entry->lun); 92 wmb(); 93 94 /* Tell ISP it's got a new I/O request */ 95 writel(ha->request_in, &ha->reg->req_q_in); 96 readl(&ha->reg->req_q_in); 97 98 exit_send_marker: 99 spin_unlock_irqrestore(&ha->hardware_lock, flags); 100 return status; 101 } 102 103 static struct continuation_t1_entry* qla4xxx_alloc_cont_entry( 104 struct scsi_qla_host *ha) 105 { 106 struct continuation_t1_entry *cont_entry; 107 108 cont_entry = (struct continuation_t1_entry *)ha->request_ptr; 109 110 /* Advance request queue pointer */ 111 if (ha->request_in == (REQUEST_QUEUE_DEPTH - 1)) { 112 ha->request_in = 0; 113 ha->request_ptr = ha->request_ring; 114 } else { 115 ha->request_in++; 116 ha->request_ptr++; 117 } 118 119 /* Load packet defaults */ 120 cont_entry->hdr.entryType = ET_CONTINUE; 121 cont_entry->hdr.entryCount = 1; 122 cont_entry->hdr.systemDefined = (uint8_t) cpu_to_le16(ha->request_in); 123 124 return cont_entry; 125 } 126 127 static uint16_t qla4xxx_calc_request_entries(uint16_t dsds) 128 { 129 uint16_t iocbs; 130 131 iocbs = 1; 132 if (dsds > COMMAND_SEG) { 133 iocbs += (dsds - COMMAND_SEG) / CONTINUE_SEG; 134 if ((dsds - COMMAND_SEG) % CONTINUE_SEG) 135 iocbs++; 136 } 137 return iocbs; 138 } 139 140 static void qla4xxx_build_scsi_iocbs(struct srb *srb, 141 struct command_t3_entry *cmd_entry, 142 uint16_t tot_dsds) 143 { 144 struct scsi_qla_host *ha; 145 uint16_t avail_dsds; 146 struct data_seg_a64 *cur_dsd; 147 struct scsi_cmnd *cmd; 148 struct scatterlist *sg; 149 int i; 150 151 cmd = srb->cmd; 152 ha = srb->ha; 153 154 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) { 155 /* No data being transferred */ 156 cmd_entry->ttlByteCnt = __constant_cpu_to_le32(0); 157 return; 158 } 159 160 avail_dsds = COMMAND_SEG; 161 cur_dsd = (struct data_seg_a64 *) & (cmd_entry->dataseg[0]); 162 163 scsi_for_each_sg(cmd, sg, tot_dsds, i) { 164 dma_addr_t sle_dma; 165 166 /* Allocate additional continuation packets? */ 167 if (avail_dsds == 0) { 168 struct continuation_t1_entry *cont_entry; 169 170 cont_entry = qla4xxx_alloc_cont_entry(ha); 171 cur_dsd = 172 (struct data_seg_a64 *) 173 &cont_entry->dataseg[0]; 174 avail_dsds = CONTINUE_SEG; 175 } 176 177 sle_dma = sg_dma_address(sg); 178 cur_dsd->base.addrLow = cpu_to_le32(LSDW(sle_dma)); 179 cur_dsd->base.addrHigh = cpu_to_le32(MSDW(sle_dma)); 180 cur_dsd->count = cpu_to_le32(sg_dma_len(sg)); 181 avail_dsds--; 182 183 cur_dsd++; 184 } 185 } 186 187 /** 188 * qla4xxx_send_command_to_isp - issues command to HBA 189 * @ha: pointer to host adapter structure. 190 * @srb: pointer to SCSI Request Block to be sent to ISP 191 * 192 * This routine is called by qla4xxx_queuecommand to build an ISP 193 * command and pass it to the ISP for execution. 194 **/ 195 int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb) 196 { 197 struct scsi_cmnd *cmd = srb->cmd; 198 struct ddb_entry *ddb_entry; 199 struct command_t3_entry *cmd_entry; 200 201 int nseg; 202 uint16_t tot_dsds; 203 uint16_t req_cnt; 204 205 unsigned long flags; 206 uint16_t cnt; 207 uint32_t index; 208 char tag[2]; 209 210 /* Get real lun and adapter */ 211 ddb_entry = srb->ddb; 212 213 /* Send marker(s) if needed. */ 214 if (ha->marker_needed == 1) { 215 if (qla4xxx_send_marker_iocb(ha, ddb_entry, 216 cmd->device->lun) != QLA_SUCCESS) 217 return QLA_ERROR; 218 219 ha->marker_needed = 0; 220 } 221 tot_dsds = 0; 222 223 /* Acquire hardware specific lock */ 224 spin_lock_irqsave(&ha->hardware_lock, flags); 225 226 index = (uint32_t)cmd->request->tag; 227 228 /* Calculate the number of request entries needed. */ 229 nseg = scsi_dma_map(cmd); 230 if (nseg < 0) 231 goto queuing_error; 232 tot_dsds = nseg; 233 234 req_cnt = qla4xxx_calc_request_entries(tot_dsds); 235 236 if (ha->req_q_count < (req_cnt + 2)) { 237 cnt = (uint16_t) le32_to_cpu(ha->shadow_regs->req_q_out); 238 if (ha->request_in < cnt) 239 ha->req_q_count = cnt - ha->request_in; 240 else 241 ha->req_q_count = REQUEST_QUEUE_DEPTH - 242 (ha->request_in - cnt); 243 } 244 245 if (ha->req_q_count < (req_cnt + 2)) 246 goto queuing_error; 247 248 /* total iocbs active */ 249 if ((ha->iocb_cnt + req_cnt) >= REQUEST_QUEUE_DEPTH) 250 goto queuing_error; 251 252 /* Build command packet */ 253 cmd_entry = (struct command_t3_entry *) ha->request_ptr; 254 memset(cmd_entry, 0, sizeof(struct command_t3_entry)); 255 cmd_entry->hdr.entryType = ET_COMMAND; 256 cmd_entry->handle = cpu_to_le32(index); 257 cmd_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index); 258 cmd_entry->connection_id = cpu_to_le16(ddb_entry->connection_id); 259 260 int_to_scsilun(cmd->device->lun, &cmd_entry->lun); 261 cmd_entry->cmdSeqNum = cpu_to_le32(ddb_entry->CmdSn); 262 cmd_entry->ttlByteCnt = cpu_to_le32(scsi_bufflen(cmd)); 263 memcpy(cmd_entry->cdb, cmd->cmnd, cmd->cmd_len); 264 cmd_entry->dataSegCnt = cpu_to_le16(tot_dsds); 265 cmd_entry->hdr.entryCount = req_cnt; 266 267 /* Set data transfer direction control flags 268 * NOTE: Look at data_direction bits iff there is data to be 269 * transferred, as the data direction bit is sometimed filled 270 * in when there is no data to be transferred */ 271 cmd_entry->control_flags = CF_NO_DATA; 272 if (scsi_bufflen(cmd)) { 273 if (cmd->sc_data_direction == DMA_TO_DEVICE) 274 cmd_entry->control_flags = CF_WRITE; 275 else if (cmd->sc_data_direction == DMA_FROM_DEVICE) 276 cmd_entry->control_flags = CF_READ; 277 278 ha->bytes_xfered += scsi_bufflen(cmd); 279 if (ha->bytes_xfered & ~0xFFFFF){ 280 ha->total_mbytes_xferred += ha->bytes_xfered >> 20; 281 ha->bytes_xfered &= 0xFFFFF; 282 } 283 } 284 285 /* Set tagged queueing control flags */ 286 cmd_entry->control_flags |= CF_SIMPLE_TAG; 287 if (scsi_populate_tag_msg(cmd, tag)) 288 switch (tag[0]) { 289 case MSG_HEAD_TAG: 290 cmd_entry->control_flags |= CF_HEAD_TAG; 291 break; 292 case MSG_ORDERED_TAG: 293 cmd_entry->control_flags |= CF_ORDERED_TAG; 294 break; 295 } 296 297 298 /* Advance request queue pointer */ 299 ha->request_in++; 300 if (ha->request_in == REQUEST_QUEUE_DEPTH) { 301 ha->request_in = 0; 302 ha->request_ptr = ha->request_ring; 303 } else 304 ha->request_ptr++; 305 306 307 qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds); 308 wmb(); 309 310 /* 311 * Check to see if adapter is online before placing request on 312 * request queue. If a reset occurs and a request is in the queue, 313 * the firmware will still attempt to process the request, retrieving 314 * garbage for pointers. 315 */ 316 if (!test_bit(AF_ONLINE, &ha->flags)) { 317 DEBUG2(printk("scsi%ld: %s: Adapter OFFLINE! " 318 "Do not issue command.\n", 319 ha->host_no, __func__)); 320 goto queuing_error; 321 } 322 323 srb->cmd->host_scribble = (unsigned char *)srb; 324 325 /* update counters */ 326 srb->state = SRB_ACTIVE_STATE; 327 srb->flags |= SRB_DMA_VALID; 328 329 /* Track IOCB used */ 330 ha->iocb_cnt += req_cnt; 331 srb->iocb_cnt = req_cnt; 332 ha->req_q_count -= req_cnt; 333 334 /* Debug print statements */ 335 writel(ha->request_in, &ha->reg->req_q_in); 336 readl(&ha->reg->req_q_in); 337 spin_unlock_irqrestore(&ha->hardware_lock, flags); 338 339 return QLA_SUCCESS; 340 341 queuing_error: 342 if (tot_dsds) 343 scsi_dma_unmap(cmd); 344 345 spin_unlock_irqrestore(&ha->hardware_lock, flags); 346 347 return QLA_ERROR; 348 } 349 350