zfcp_qdio.c revision ff3b24fa5370a7ca618f212284d9b36fcedb9c0e
1/* 2 * zfcp device driver 3 * 4 * Setup and helper functions to access QDIO. 5 * 6 * Copyright IBM Corporation 2002, 2008 7 */ 8 9#include "zfcp_ext.h" 10 11/* FIXME(tune): free space should be one max. SBAL chain plus what? */ 12#define ZFCP_QDIO_PCI_INTERVAL (QDIO_MAX_BUFFERS_PER_Q \ 13 - (FSF_MAX_SBALS_PER_REQ + 4)) 14#define QBUFF_PER_PAGE (PAGE_SIZE / sizeof(struct qdio_buffer)) 15 16static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal) 17{ 18 int pos; 19 20 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos += QBUFF_PER_PAGE) { 21 sbal[pos] = (struct qdio_buffer *) get_zeroed_page(GFP_KERNEL); 22 if (!sbal[pos]) 23 return -ENOMEM; 24 } 25 for (pos = 0; pos < QDIO_MAX_BUFFERS_PER_Q; pos++) 26 if (pos % QBUFF_PER_PAGE) 27 sbal[pos] = sbal[pos - 1] + 1; 28 return 0; 29} 30 31static volatile struct qdio_buffer_element * 32zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx) 33{ 34 return &q->sbal[sbal_idx]->element[sbale_idx]; 35} 36 37/** 38 * zfcp_qdio_free - free memory used by request- and resposne queue 39 * @adapter: pointer to the zfcp_adapter structure 40 */ 41void zfcp_qdio_free(struct zfcp_adapter *adapter) 42{ 43 struct qdio_buffer **sbal_req, **sbal_resp; 44 int p; 45 46 if (adapter->ccw_device) 47 qdio_free(adapter->ccw_device); 48 49 sbal_req = adapter->req_q.sbal; 50 sbal_resp = adapter->resp_q.sbal; 51 52 for (p = 0; p < QDIO_MAX_BUFFERS_PER_Q; p += QBUFF_PER_PAGE) { 53 free_page((unsigned long) sbal_req[p]); 54 free_page((unsigned long) sbal_resp[p]); 55 } 56} 57 58static void zfcp_qdio_handler_error(struct zfcp_adapter *adapter, u8 id) 59{ 60 dev_warn(&adapter->ccw_device->dev, "A QDIO problem occurred\n"); 61 62 zfcp_erp_adapter_reopen(adapter, 63 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 64 ZFCP_STATUS_COMMON_ERP_FAILED, id, NULL); 65} 66 67static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt) 68{ 69 int i, sbal_idx; 70 71 for (i = first; i < first + cnt; i++) { 72 sbal_idx = i % QDIO_MAX_BUFFERS_PER_Q; 73 memset(sbal[sbal_idx], 0, sizeof(struct qdio_buffer)); 74 } 75} 76 77static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err, 78 int queue_no, int first, int count, 79 unsigned long parm) 80{ 81 struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm; 82 struct zfcp_qdio_queue *queue = &adapter->req_q; 83 84 if (unlikely(qdio_err)) { 85 zfcp_hba_dbf_event_qdio(adapter, qdio_err, first, count); 86 zfcp_qdio_handler_error(adapter, 140); 87 return; 88 } 89 90 /* cleanup all SBALs being program-owned now */ 91 zfcp_qdio_zero_sbals(queue->sbal, first, count); 92 93 atomic_add(count, &queue->count); 94 wake_up(&adapter->request_wq); 95} 96 97static void zfcp_qdio_reqid_check(struct zfcp_adapter *adapter, 98 unsigned long req_id, int sbal_idx) 99{ 100 struct zfcp_fsf_req *fsf_req; 101 unsigned long flags; 102 103 spin_lock_irqsave(&adapter->req_list_lock, flags); 104 fsf_req = zfcp_reqlist_find(adapter, req_id); 105 106 if (!fsf_req) 107 /* 108 * Unknown request means that we have potentially memory 109 * corruption and must stop the machine immediatly. 110 */ 111 panic("error: unknown request id (%lx) on adapter %s.\n", 112 req_id, zfcp_get_busid_by_adapter(adapter)); 113 114 zfcp_reqlist_remove(adapter, fsf_req); 115 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 116 117 fsf_req->sbal_response = sbal_idx; 118 zfcp_fsf_req_complete(fsf_req); 119} 120 121static void zfcp_qdio_resp_put_back(struct zfcp_adapter *adapter, int processed) 122{ 123 struct zfcp_qdio_queue *queue = &adapter->resp_q; 124 struct ccw_device *cdev = adapter->ccw_device; 125 u8 count, start = queue->first; 126 unsigned int retval; 127 128 count = atomic_read(&queue->count) + processed; 129 130 retval = do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, start, count); 131 132 if (unlikely(retval)) { 133 atomic_set(&queue->count, count); 134 /* FIXME: Recover this with an adapter reopen? */ 135 } else { 136 queue->first += count; 137 queue->first %= QDIO_MAX_BUFFERS_PER_Q; 138 atomic_set(&queue->count, 0); 139 } 140} 141 142static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err, 143 int queue_no, int first, int count, 144 unsigned long parm) 145{ 146 struct zfcp_adapter *adapter = (struct zfcp_adapter *) parm; 147 struct zfcp_qdio_queue *queue = &adapter->resp_q; 148 volatile struct qdio_buffer_element *sbale; 149 int sbal_idx, sbale_idx, sbal_no; 150 151 if (unlikely(qdio_err)) { 152 zfcp_hba_dbf_event_qdio(adapter, qdio_err, first, count); 153 zfcp_qdio_handler_error(adapter, 147); 154 return; 155 } 156 157 /* 158 * go through all SBALs from input queue currently 159 * returned by QDIO layer 160 */ 161 for (sbal_no = 0; sbal_no < count; sbal_no++) { 162 sbal_idx = (first + sbal_no) % QDIO_MAX_BUFFERS_PER_Q; 163 164 /* go through all SBALEs of SBAL */ 165 for (sbale_idx = 0; sbale_idx < QDIO_MAX_ELEMENTS_PER_BUFFER; 166 sbale_idx++) { 167 sbale = zfcp_qdio_sbale(queue, sbal_idx, sbale_idx); 168 zfcp_qdio_reqid_check(adapter, 169 (unsigned long) sbale->addr, 170 sbal_idx); 171 if (likely(sbale->flags & SBAL_FLAGS_LAST_ENTRY)) 172 break; 173 }; 174 175 if (unlikely(!(sbale->flags & SBAL_FLAGS_LAST_ENTRY))) 176 dev_warn(&adapter->ccw_device->dev, 177 "A QDIO protocol error occurred, " 178 "operations continue\n"); 179 } 180 181 /* 182 * put range of SBALs back to response queue 183 * (including SBALs which have already been free before) 184 */ 185 zfcp_qdio_resp_put_back(adapter, count); 186} 187 188/** 189 * zfcp_qdio_sbale_req - return ptr to SBALE of req_q for a struct zfcp_fsf_req 190 * @fsf_req: pointer to struct fsf_req 191 * Returns: pointer to qdio_buffer_element (SBALE) structure 192 */ 193volatile struct qdio_buffer_element * 194zfcp_qdio_sbale_req(struct zfcp_fsf_req *req) 195{ 196 return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last, 0); 197} 198 199/** 200 * zfcp_qdio_sbale_curr - return curr SBALE on req_q for a struct zfcp_fsf_req 201 * @fsf_req: pointer to struct fsf_req 202 * Returns: pointer to qdio_buffer_element (SBALE) structure 203 */ 204volatile struct qdio_buffer_element * 205zfcp_qdio_sbale_curr(struct zfcp_fsf_req *req) 206{ 207 return zfcp_qdio_sbale(&req->adapter->req_q, req->sbal_last, 208 req->sbale_curr); 209} 210 211static void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals) 212{ 213 int count = atomic_read(&fsf_req->adapter->req_q.count); 214 count = min(count, max_sbals); 215 fsf_req->sbal_limit = (fsf_req->sbal_first + count - 1) 216 % QDIO_MAX_BUFFERS_PER_Q; 217} 218 219static volatile struct qdio_buffer_element * 220zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype) 221{ 222 volatile struct qdio_buffer_element *sbale; 223 224 /* set last entry flag in current SBALE of current SBAL */ 225 sbale = zfcp_qdio_sbale_curr(fsf_req); 226 sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 227 228 /* don't exceed last allowed SBAL */ 229 if (fsf_req->sbal_last == fsf_req->sbal_limit) 230 return NULL; 231 232 /* set chaining flag in first SBALE of current SBAL */ 233 sbale = zfcp_qdio_sbale_req(fsf_req); 234 sbale->flags |= SBAL_FLAGS0_MORE_SBALS; 235 236 /* calculate index of next SBAL */ 237 fsf_req->sbal_last++; 238 fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q; 239 240 /* keep this requests number of SBALs up-to-date */ 241 fsf_req->sbal_number++; 242 243 /* start at first SBALE of new SBAL */ 244 fsf_req->sbale_curr = 0; 245 246 /* set storage-block type for new SBAL */ 247 sbale = zfcp_qdio_sbale_curr(fsf_req); 248 sbale->flags |= sbtype; 249 250 return sbale; 251} 252 253static volatile struct qdio_buffer_element * 254zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype) 255{ 256 if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL) 257 return zfcp_qdio_sbal_chain(fsf_req, sbtype); 258 fsf_req->sbale_curr++; 259 return zfcp_qdio_sbale_curr(fsf_req); 260} 261 262static void zfcp_qdio_undo_sbals(struct zfcp_fsf_req *fsf_req) 263{ 264 struct qdio_buffer **sbal = fsf_req->adapter->req_q.sbal; 265 int first = fsf_req->sbal_first; 266 int last = fsf_req->sbal_last; 267 int count = (last - first + QDIO_MAX_BUFFERS_PER_Q) % 268 QDIO_MAX_BUFFERS_PER_Q + 1; 269 zfcp_qdio_zero_sbals(sbal, first, count); 270} 271 272static int zfcp_qdio_fill_sbals(struct zfcp_fsf_req *fsf_req, 273 unsigned int sbtype, void *start_addr, 274 unsigned int total_length) 275{ 276 volatile struct qdio_buffer_element *sbale; 277 unsigned long remaining, length; 278 void *addr; 279 280 /* split segment up */ 281 for (addr = start_addr, remaining = total_length; remaining > 0; 282 addr += length, remaining -= length) { 283 sbale = zfcp_qdio_sbale_next(fsf_req, sbtype); 284 if (!sbale) { 285 atomic_inc(&fsf_req->adapter->qdio_outb_full); 286 zfcp_qdio_undo_sbals(fsf_req); 287 return -EINVAL; 288 } 289 290 /* new piece must not exceed next page boundary */ 291 length = min(remaining, 292 (PAGE_SIZE - ((unsigned long)addr & 293 (PAGE_SIZE - 1)))); 294 sbale->addr = addr; 295 sbale->length = length; 296 } 297 return 0; 298} 299 300/** 301 * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list 302 * @fsf_req: request to be processed 303 * @sbtype: SBALE flags 304 * @sg: scatter-gather list 305 * @max_sbals: upper bound for number of SBALs to be used 306 * Returns: number of bytes, or error (negativ) 307 */ 308int zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype, 309 struct scatterlist *sg, int max_sbals) 310{ 311 volatile struct qdio_buffer_element *sbale; 312 int retval, bytes = 0; 313 314 /* figure out last allowed SBAL */ 315 zfcp_qdio_sbal_limit(fsf_req, max_sbals); 316 317 /* set storage-block type for this request */ 318 sbale = zfcp_qdio_sbale_req(fsf_req); 319 sbale->flags |= sbtype; 320 321 for (; sg; sg = sg_next(sg)) { 322 retval = zfcp_qdio_fill_sbals(fsf_req, sbtype, sg_virt(sg), 323 sg->length); 324 if (retval < 0) 325 return retval; 326 bytes += sg->length; 327 } 328 329 /* assume that no other SBALEs are to follow in the same SBAL */ 330 sbale = zfcp_qdio_sbale_curr(fsf_req); 331 sbale->flags |= SBAL_FLAGS_LAST_ENTRY; 332 333 return bytes; 334} 335 336/** 337 * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO 338 * @fsf_req: pointer to struct zfcp_fsf_req 339 * Returns: 0 on success, error otherwise 340 */ 341int zfcp_qdio_send(struct zfcp_fsf_req *fsf_req) 342{ 343 struct zfcp_adapter *adapter = fsf_req->adapter; 344 struct zfcp_qdio_queue *req_q = &adapter->req_q; 345 int first = fsf_req->sbal_first; 346 int count = fsf_req->sbal_number; 347 int retval, pci, pci_batch; 348 volatile struct qdio_buffer_element *sbale; 349 350 /* acknowledgements for transferred buffers */ 351 pci_batch = req_q->pci_batch + count; 352 if (unlikely(pci_batch >= ZFCP_QDIO_PCI_INTERVAL)) { 353 pci_batch %= ZFCP_QDIO_PCI_INTERVAL; 354 pci = first + count - (pci_batch + 1); 355 pci %= QDIO_MAX_BUFFERS_PER_Q; 356 sbale = zfcp_qdio_sbale(req_q, pci, 0); 357 sbale->flags |= SBAL_FLAGS0_PCI; 358 } 359 360 retval = do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0, first, 361 count); 362 if (unlikely(retval)) { 363 zfcp_qdio_zero_sbals(req_q->sbal, first, count); 364 return retval; 365 } 366 367 /* account for transferred buffers */ 368 atomic_sub(count, &req_q->count); 369 req_q->first += count; 370 req_q->first %= QDIO_MAX_BUFFERS_PER_Q; 371 req_q->pci_batch = pci_batch; 372 return 0; 373} 374 375/** 376 * zfcp_qdio_allocate - allocate queue memory and initialize QDIO data 377 * @adapter: pointer to struct zfcp_adapter 378 * Returns: -ENOMEM on memory allocation error or return value from 379 * qdio_allocate 380 */ 381int zfcp_qdio_allocate(struct zfcp_adapter *adapter) 382{ 383 struct qdio_initialize *init_data; 384 385 if (zfcp_qdio_buffers_enqueue(adapter->req_q.sbal) || 386 zfcp_qdio_buffers_enqueue(adapter->resp_q.sbal)) 387 return -ENOMEM; 388 389 init_data = &adapter->qdio_init_data; 390 391 init_data->cdev = adapter->ccw_device; 392 init_data->q_format = QDIO_ZFCP_QFMT; 393 memcpy(init_data->adapter_name, zfcp_get_busid_by_adapter(adapter), 8); 394 ASCEBC(init_data->adapter_name, 8); 395 init_data->qib_param_field_format = 0; 396 init_data->qib_param_field = NULL; 397 init_data->input_slib_elements = NULL; 398 init_data->output_slib_elements = NULL; 399 init_data->no_input_qs = 1; 400 init_data->no_output_qs = 1; 401 init_data->input_handler = zfcp_qdio_int_resp; 402 init_data->output_handler = zfcp_qdio_int_req; 403 init_data->int_parm = (unsigned long) adapter; 404 init_data->flags = QDIO_INBOUND_0COPY_SBALS | 405 QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS; 406 init_data->input_sbal_addr_array = 407 (void **) (adapter->resp_q.sbal); 408 init_data->output_sbal_addr_array = 409 (void **) (adapter->req_q.sbal); 410 411 return qdio_allocate(init_data); 412} 413 414/** 415 * zfcp_close_qdio - close qdio queues for an adapter 416 */ 417void zfcp_qdio_close(struct zfcp_adapter *adapter) 418{ 419 struct zfcp_qdio_queue *req_q; 420 int first, count; 421 422 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) 423 return; 424 425 /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */ 426 req_q = &adapter->req_q; 427 spin_lock_bh(&req_q->lock); 428 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status); 429 spin_unlock_bh(&req_q->lock); 430 431 qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR); 432 433 /* cleanup used outbound sbals */ 434 count = atomic_read(&req_q->count); 435 if (count < QDIO_MAX_BUFFERS_PER_Q) { 436 first = (req_q->first + count) % QDIO_MAX_BUFFERS_PER_Q; 437 count = QDIO_MAX_BUFFERS_PER_Q - count; 438 zfcp_qdio_zero_sbals(req_q->sbal, first, count); 439 } 440 req_q->first = 0; 441 atomic_set(&req_q->count, 0); 442 req_q->pci_batch = 0; 443 adapter->resp_q.first = 0; 444 atomic_set(&adapter->resp_q.count, 0); 445} 446 447/** 448 * zfcp_qdio_open - prepare and initialize response queue 449 * @adapter: pointer to struct zfcp_adapter 450 * Returns: 0 on success, otherwise -EIO 451 */ 452int zfcp_qdio_open(struct zfcp_adapter *adapter) 453{ 454 volatile struct qdio_buffer_element *sbale; 455 int cc; 456 457 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) 458 return -EIO; 459 460 if (qdio_establish(&adapter->qdio_init_data)) 461 goto failed_establish; 462 463 if (qdio_activate(adapter->ccw_device)) 464 goto failed_qdio; 465 466 for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) { 467 sbale = &(adapter->resp_q.sbal[cc]->element[0]); 468 sbale->length = 0; 469 sbale->flags = SBAL_FLAGS_LAST_ENTRY; 470 sbale->addr = NULL; 471 } 472 473 if (do_QDIO(adapter->ccw_device, QDIO_FLAG_SYNC_INPUT, 0, 0, 474 QDIO_MAX_BUFFERS_PER_Q)) 475 goto failed_qdio; 476 477 /* set index of first avalable SBALS / number of available SBALS */ 478 adapter->req_q.first = 0; 479 atomic_set(&adapter->req_q.count, QDIO_MAX_BUFFERS_PER_Q); 480 adapter->req_q.pci_batch = 0; 481 482 return 0; 483 484failed_qdio: 485 qdio_shutdown(adapter->ccw_device, QDIO_FLAG_CLEANUP_USING_CLEAR); 486failed_establish: 487 dev_err(&adapter->ccw_device->dev, 488 "Setting up the QDIO connection to the FCP adapter failed\n"); 489 return -EIO; 490} 491