1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* ------------------------------------------------------------ 3 * ibmvscsi.c 4 * (C) Copyright IBM Corporation 1994, 2004 5 * Authors: Colin DeVilbiss (devilbis@us.ibm.com) 6 * Santiago Leon (santil@us.ibm.com) 7 * Dave Boutcher (sleddog@us.ibm.com) 8 * 9 * ------------------------------------------------------------ 10 * Emulation of a SCSI host adapter for Virtual I/O devices 11 * 12 * This driver supports the SCSI adapter implemented by the IBM 13 * Power5 firmware. That SCSI adapter is not a physical adapter, 14 * but allows Linux SCSI peripheral drivers to directly 15 * access devices in another logical partition on the physical system. 16 * 17 * The virtual adapter(s) are present in the open firmware device 18 * tree just like real adapters. 19 * 20 * One of the capabilities provided on these systems is the ability 21 * to DMA between partitions. The architecture states that for VSCSI, 22 * the server side is allowed to DMA to and from the client. The client 23 * is never trusted to DMA to or from the server directly. 24 * 25 * Messages are sent between partitions on a "Command/Response Queue" 26 * (CRQ), which is just a buffer of 16 byte entries in the receiver's 27 * Senders cannot access the buffer directly, but send messages by 28 * making a hypervisor call and passing in the 16 bytes. The hypervisor 29 * puts the message in the next 16 byte space in round-robin fashion, 30 * turns on the high order bit of the message (the valid bit), and 31 * generates an interrupt to the receiver (if interrupts are turned on.) 32 * The receiver just turns off the valid bit when they have copied out 33 * the message. 34 * 35 * The VSCSI client builds a SCSI Remote Protocol (SRP) Information Unit 36 * (IU) (as defined in the T10 standard available at www.t10.org), gets 37 * a DMA address for the message, and sends it to the server as the 38 * payload of a CRQ message. The server DMAs the SRP IU and processes it, 39 * including doing any additional data transfers. When it is done, it 40 * DMAs the SRP response back to the same address as the request came from, 41 * and sends a CRQ message back to inform the client that the request has 42 * completed. 43 * 44 * TODO: This is currently pretty tied to the IBM pSeries hypervisor 45 * interfaces. It would be really nice to abstract this above an RDMA 46 * layer. 47 */ 48 49 #include <linux/module.h> 50 #include <linux/moduleparam.h> 51 #include <linux/dma-mapping.h> 52 #include <linux/delay.h> 53 #include <linux/slab.h> 54 #include <linux/of.h> 55 #include <linux/pm.h> 56 #include <linux/kthread.h> 57 #include <asm/firmware.h> 58 #include <asm/vio.h> 59 #include <scsi/scsi.h> 60 #include <scsi/scsi_cmnd.h> 61 #include <scsi/scsi_host.h> 62 #include <scsi/scsi_device.h> 63 #include <scsi/scsi_transport_srp.h> 64 #include "ibmvscsi.h" 65 66 /* The values below are somewhat arbitrary default values, but 67 * OS/400 will use 3 busses (disks, CDs, tapes, I think.) 68 * Note that there are 3 bits of channel value, 6 bits of id, and 69 * 5 bits of LUN. 70 */ 71 static int max_id = 64; 72 static int max_channel = 3; 73 static int init_timeout = 300; 74 static int login_timeout = 60; 75 static int info_timeout = 30; 76 static int abort_timeout = 60; 77 static int reset_timeout = 60; 78 static int max_requests = IBMVSCSI_MAX_REQUESTS_DEFAULT; 79 static int max_events = IBMVSCSI_MAX_REQUESTS_DEFAULT + 2; 80 static int fast_fail = 1; 81 static int client_reserve = 1; 82 static char partition_name[96] = "UNKNOWN"; 83 static unsigned int partition_number = -1; 84 static LIST_HEAD(ibmvscsi_head); 85 static DEFINE_SPINLOCK(ibmvscsi_driver_lock); 86 87 static struct scsi_transport_template *ibmvscsi_transport_template; 88 89 #define IBMVSCSI_VERSION "1.5.9" 90 91 MODULE_DESCRIPTION("IBM Virtual SCSI"); 92 MODULE_AUTHOR("Dave Boutcher"); 93 MODULE_LICENSE("GPL"); 94 MODULE_VERSION(IBMVSCSI_VERSION); 95 96 module_param_named(max_id, max_id, int, S_IRUGO | S_IWUSR); 97 MODULE_PARM_DESC(max_id, "Largest ID value for each channel [Default=64]"); 98 module_param_named(max_channel, max_channel, int, S_IRUGO | S_IWUSR); 99 MODULE_PARM_DESC(max_channel, "Largest channel value [Default=3]"); 100 module_param_named(init_timeout, init_timeout, int, S_IRUGO | S_IWUSR); 101 MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds"); 102 module_param_named(max_requests, max_requests, int, S_IRUGO); 103 MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter"); 104 module_param_named(fast_fail, fast_fail, int, S_IRUGO | S_IWUSR); 105 MODULE_PARM_DESC(fast_fail, "Enable fast fail. [Default=1]"); 106 module_param_named(client_reserve, client_reserve, int, S_IRUGO ); 107 MODULE_PARM_DESC(client_reserve, "Attempt client managed reserve/release"); 108 109 static void ibmvscsi_handle_crq(struct viosrp_crq *crq, 110 struct ibmvscsi_host_data *hostdata); 111 112 /* ------------------------------------------------------------ 113 * Routines for managing the command/response queue 114 */ 115 /** 116 * ibmvscsi_handle_event: - Interrupt handler for crq events 117 * @irq: number of irq to handle, not used 118 * @dev_instance: ibmvscsi_host_data of host that received interrupt 119 * 120 * Disables interrupts and schedules srp_task 121 * Always returns IRQ_HANDLED 122 */ 123 static irqreturn_t ibmvscsi_handle_event(int irq, void *dev_instance) 124 { 125 struct ibmvscsi_host_data *hostdata = 126 (struct ibmvscsi_host_data *)dev_instance; 127 vio_disable_interrupts(to_vio_dev(hostdata->dev)); 128 tasklet_schedule(&hostdata->srp_task); 129 return IRQ_HANDLED; 130 } 131 132 /** 133 * ibmvscsi_release_crq_queue() - Deallocates data and unregisters CRQ 134 * @queue: crq_queue to initialize and register 135 * @hostdata: ibmvscsi_host_data of host 136 * @max_requests: maximum requests (unused) 137 * 138 * Frees irq, deallocates a page for messages, unmaps dma, and unregisters 139 * the crq with the hypervisor. 140 */ 141 static void ibmvscsi_release_crq_queue(struct crq_queue *queue, 142 struct ibmvscsi_host_data *hostdata, 143 int max_requests) 144 { 145 long rc = 0; 146 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 147 free_irq(vdev->irq, (void *)hostdata); 148 tasklet_kill(&hostdata->srp_task); 149 do { 150 if (rc) 151 msleep(100); 152 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 153 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 154 dma_unmap_single(hostdata->dev, 155 queue->msg_token, 156 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); 157 free_page((unsigned long)queue->msgs); 158 } 159 160 /** 161 * crq_queue_next_crq: - Returns the next entry in message queue 162 * @queue: crq_queue to use 163 * 164 * Returns pointer to next entry in queue, or NULL if there are no new 165 * entried in the CRQ. 166 */ 167 static struct viosrp_crq *crq_queue_next_crq(struct crq_queue *queue) 168 { 169 struct viosrp_crq *crq; 170 unsigned long flags; 171 172 spin_lock_irqsave(&queue->lock, flags); 173 crq = &queue->msgs[queue->cur]; 174 if (crq->valid != VIOSRP_CRQ_FREE) { 175 if (++queue->cur == queue->size) 176 queue->cur = 0; 177 178 /* Ensure the read of the valid bit occurs before reading any 179 * other bits of the CRQ entry 180 */ 181 rmb(); 182 } else 183 crq = NULL; 184 spin_unlock_irqrestore(&queue->lock, flags); 185 186 return crq; 187 } 188 189 /** 190 * ibmvscsi_send_crq: - Send a CRQ 191 * @hostdata: the adapter 192 * @word1: the first 64 bits of the data 193 * @word2: the second 64 bits of the data 194 */ 195 static int ibmvscsi_send_crq(struct ibmvscsi_host_data *hostdata, 196 u64 word1, u64 word2) 197 { 198 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 199 200 /* 201 * Ensure the command buffer is flushed to memory before handing it 202 * over to the VIOS to prevent it from fetching any stale data. 203 */ 204 mb(); 205 return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2); 206 } 207 208 /** 209 * ibmvscsi_task: - Process srps asynchronously 210 * @data: ibmvscsi_host_data of host 211 */ 212 static void ibmvscsi_task(void *data) 213 { 214 struct ibmvscsi_host_data *hostdata = (struct ibmvscsi_host_data *)data; 215 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 216 struct viosrp_crq *crq; 217 int done = 0; 218 219 while (!done) { 220 /* Pull all the valid messages off the CRQ */ 221 while ((crq = crq_queue_next_crq(&hostdata->queue)) != NULL) { 222 ibmvscsi_handle_crq(crq, hostdata); 223 crq->valid = VIOSRP_CRQ_FREE; 224 wmb(); 225 } 226 227 vio_enable_interrupts(vdev); 228 crq = crq_queue_next_crq(&hostdata->queue); 229 if (crq != NULL) { 230 vio_disable_interrupts(vdev); 231 ibmvscsi_handle_crq(crq, hostdata); 232 crq->valid = VIOSRP_CRQ_FREE; 233 wmb(); 234 } else { 235 done = 1; 236 } 237 } 238 } 239 240 static void gather_partition_info(void) 241 { 242 const char *ppartition_name; 243 const __be32 *p_number_ptr; 244 245 /* Retrieve information about this partition */ 246 if (!of_root) 247 return; 248 249 of_node_get(of_root); 250 251 ppartition_name = of_get_property(of_root, "ibm,partition-name", NULL); 252 if (ppartition_name) 253 strlcpy(partition_name, ppartition_name, 254 sizeof(partition_name)); 255 p_number_ptr = of_get_property(of_root, "ibm,partition-no", NULL); 256 if (p_number_ptr) 257 partition_number = of_read_number(p_number_ptr, 1); 258 of_node_put(of_root); 259 } 260 261 static void set_adapter_info(struct ibmvscsi_host_data *hostdata) 262 { 263 memset(&hostdata->madapter_info, 0x00, 264 sizeof(hostdata->madapter_info)); 265 266 dev_info(hostdata->dev, "SRP_VERSION: %s\n", SRP_VERSION); 267 strcpy(hostdata->madapter_info.srp_version, SRP_VERSION); 268 269 strncpy(hostdata->madapter_info.partition_name, partition_name, 270 sizeof(hostdata->madapter_info.partition_name)); 271 272 hostdata->madapter_info.partition_number = 273 cpu_to_be32(partition_number); 274 275 hostdata->madapter_info.mad_version = cpu_to_be32(SRP_MAD_VERSION_1); 276 hostdata->madapter_info.os_type = cpu_to_be32(SRP_MAD_OS_LINUX); 277 } 278 279 /** 280 * ibmvscsi_reset_crq_queue() - resets a crq after a failure 281 * @queue: crq_queue to initialize and register 282 * @hostdata: ibmvscsi_host_data of host 283 */ 284 static int ibmvscsi_reset_crq_queue(struct crq_queue *queue, 285 struct ibmvscsi_host_data *hostdata) 286 { 287 int rc = 0; 288 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 289 290 /* Close the CRQ */ 291 do { 292 if (rc) 293 msleep(100); 294 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 295 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 296 297 /* Clean out the queue */ 298 memset(queue->msgs, 0x00, PAGE_SIZE); 299 queue->cur = 0; 300 301 set_adapter_info(hostdata); 302 303 /* And re-open it again */ 304 rc = plpar_hcall_norets(H_REG_CRQ, 305 vdev->unit_address, 306 queue->msg_token, PAGE_SIZE); 307 if (rc == H_CLOSED) { 308 /* Adapter is good, but other end is not ready */ 309 dev_warn(hostdata->dev, "Partner adapter not ready\n"); 310 } else if (rc != 0) { 311 dev_warn(hostdata->dev, "couldn't register crq--rc 0x%x\n", rc); 312 } 313 return rc; 314 } 315 316 /** 317 * ibmvscsi_init_crq_queue() - Initializes and registers CRQ with hypervisor 318 * @queue: crq_queue to initialize and register 319 * @hostdata: ibmvscsi_host_data of host 320 * @max_requests: maximum requests (unused) 321 * 322 * Allocates a page for messages, maps it for dma, and registers 323 * the crq with the hypervisor. 324 * Returns zero on success. 325 */ 326 static int ibmvscsi_init_crq_queue(struct crq_queue *queue, 327 struct ibmvscsi_host_data *hostdata, 328 int max_requests) 329 { 330 int rc; 331 int retrc; 332 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 333 334 queue->msgs = (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL); 335 336 if (!queue->msgs) 337 goto malloc_failed; 338 queue->size = PAGE_SIZE / sizeof(*queue->msgs); 339 340 queue->msg_token = dma_map_single(hostdata->dev, queue->msgs, 341 queue->size * sizeof(*queue->msgs), 342 DMA_BIDIRECTIONAL); 343 344 if (dma_mapping_error(hostdata->dev, queue->msg_token)) 345 goto map_failed; 346 347 gather_partition_info(); 348 set_adapter_info(hostdata); 349 350 retrc = rc = plpar_hcall_norets(H_REG_CRQ, 351 vdev->unit_address, 352 queue->msg_token, PAGE_SIZE); 353 if (rc == H_RESOURCE) 354 /* maybe kexecing and resource is busy. try a reset */ 355 rc = ibmvscsi_reset_crq_queue(queue, 356 hostdata); 357 358 if (rc == H_CLOSED) { 359 /* Adapter is good, but other end is not ready */ 360 dev_warn(hostdata->dev, "Partner adapter not ready\n"); 361 retrc = 0; 362 } else if (rc != 0) { 363 dev_warn(hostdata->dev, "Error %d opening adapter\n", rc); 364 goto reg_crq_failed; 365 } 366 367 queue->cur = 0; 368 spin_lock_init(&queue->lock); 369 370 tasklet_init(&hostdata->srp_task, (void *)ibmvscsi_task, 371 (unsigned long)hostdata); 372 373 if (request_irq(vdev->irq, 374 ibmvscsi_handle_event, 375 0, "ibmvscsi", (void *)hostdata) != 0) { 376 dev_err(hostdata->dev, "couldn't register irq 0x%x\n", 377 vdev->irq); 378 goto req_irq_failed; 379 } 380 381 rc = vio_enable_interrupts(vdev); 382 if (rc != 0) { 383 dev_err(hostdata->dev, "Error %d enabling interrupts!!!\n", rc); 384 goto req_irq_failed; 385 } 386 387 return retrc; 388 389 req_irq_failed: 390 tasklet_kill(&hostdata->srp_task); 391 rc = 0; 392 do { 393 if (rc) 394 msleep(100); 395 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 396 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 397 reg_crq_failed: 398 dma_unmap_single(hostdata->dev, 399 queue->msg_token, 400 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); 401 map_failed: 402 free_page((unsigned long)queue->msgs); 403 malloc_failed: 404 return -1; 405 } 406 407 /** 408 * ibmvscsi_reenable_crq_queue() - reenables a crq after 409 * @queue: crq_queue to initialize and register 410 * @hostdata: ibmvscsi_host_data of host 411 */ 412 static int ibmvscsi_reenable_crq_queue(struct crq_queue *queue, 413 struct ibmvscsi_host_data *hostdata) 414 { 415 int rc = 0; 416 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 417 418 set_adapter_info(hostdata); 419 420 /* Re-enable the CRQ */ 421 do { 422 if (rc) 423 msleep(100); 424 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address); 425 } while ((rc == H_IN_PROGRESS) || (rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 426 427 if (rc) 428 dev_err(hostdata->dev, "Error %d enabling adapter\n", rc); 429 return rc; 430 } 431 432 /* ------------------------------------------------------------ 433 * Routines for the event pool and event structs 434 */ 435 /** 436 * initialize_event_pool: - Allocates and initializes the event pool for a host 437 * @pool: event_pool to be initialized 438 * @size: Number of events in pool 439 * @hostdata: ibmvscsi_host_data who owns the event pool 440 * 441 * Returns zero on success. 442 */ 443 static int initialize_event_pool(struct event_pool *pool, 444 int size, struct ibmvscsi_host_data *hostdata) 445 { 446 int i; 447 448 pool->size = size; 449 pool->next = 0; 450 pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL); 451 if (!pool->events) 452 return -ENOMEM; 453 454 pool->iu_storage = 455 dma_alloc_coherent(hostdata->dev, 456 pool->size * sizeof(*pool->iu_storage), 457 &pool->iu_token, 0); 458 if (!pool->iu_storage) { 459 kfree(pool->events); 460 return -ENOMEM; 461 } 462 463 for (i = 0; i < pool->size; ++i) { 464 struct srp_event_struct *evt = &pool->events[i]; 465 memset(&evt->crq, 0x00, sizeof(evt->crq)); 466 atomic_set(&evt->free, 1); 467 evt->crq.valid = VIOSRP_CRQ_CMD_RSP; 468 evt->crq.IU_length = cpu_to_be16(sizeof(*evt->xfer_iu)); 469 evt->crq.IU_data_ptr = cpu_to_be64(pool->iu_token + 470 sizeof(*evt->xfer_iu) * i); 471 evt->xfer_iu = pool->iu_storage + i; 472 evt->hostdata = hostdata; 473 evt->ext_list = NULL; 474 evt->ext_list_token = 0; 475 } 476 477 return 0; 478 } 479 480 /** 481 * release_event_pool() - Frees memory of an event pool of a host 482 * @pool: event_pool to be released 483 * @hostdata: ibmvscsi_host_data who owns the even pool 484 * 485 * Returns zero on success. 486 */ 487 static void release_event_pool(struct event_pool *pool, 488 struct ibmvscsi_host_data *hostdata) 489 { 490 int i, in_use = 0; 491 for (i = 0; i < pool->size; ++i) { 492 if (atomic_read(&pool->events[i].free) != 1) 493 ++in_use; 494 if (pool->events[i].ext_list) { 495 dma_free_coherent(hostdata->dev, 496 SG_ALL * sizeof(struct srp_direct_buf), 497 pool->events[i].ext_list, 498 pool->events[i].ext_list_token); 499 } 500 } 501 if (in_use) 502 dev_warn(hostdata->dev, "releasing event pool with %d " 503 "events still in use?\n", in_use); 504 kfree(pool->events); 505 dma_free_coherent(hostdata->dev, 506 pool->size * sizeof(*pool->iu_storage), 507 pool->iu_storage, pool->iu_token); 508 } 509 510 /** 511 * valid_event_struct: - Determines if event is valid. 512 * @pool: event_pool that contains the event 513 * @evt: srp_event_struct to be checked for validity 514 * 515 * Returns zero if event is invalid, one otherwise. 516 */ 517 static int valid_event_struct(struct event_pool *pool, 518 struct srp_event_struct *evt) 519 { 520 int index = evt - pool->events; 521 if (index < 0 || index >= pool->size) /* outside of bounds */ 522 return 0; 523 if (evt != pool->events + index) /* unaligned */ 524 return 0; 525 return 1; 526 } 527 528 /** 529 * free_event_struct() - Changes status of event to "free" 530 * @pool: event_pool that contains the event 531 * @evt: srp_event_struct to be modified 532 */ 533 static void free_event_struct(struct event_pool *pool, 534 struct srp_event_struct *evt) 535 { 536 if (!valid_event_struct(pool, evt)) { 537 dev_err(evt->hostdata->dev, "Freeing invalid event_struct %p " 538 "(not in pool %p)\n", evt, pool->events); 539 return; 540 } 541 if (atomic_inc_return(&evt->free) != 1) { 542 dev_err(evt->hostdata->dev, "Freeing event_struct %p " 543 "which is not in use!\n", evt); 544 return; 545 } 546 } 547 548 /** 549 * get_event_struct() - Gets the next free event in pool 550 * @pool: event_pool that contains the events to be searched 551 * 552 * Returns the next event in "free" state, and NULL if none are free. 553 * Note that no synchronization is done here, we assume the host_lock 554 * will syncrhonze things. 555 */ 556 static struct srp_event_struct *get_event_struct(struct event_pool *pool) 557 { 558 int i; 559 int poolsize = pool->size; 560 int offset = pool->next; 561 562 for (i = 0; i < poolsize; i++) { 563 offset = (offset + 1) % poolsize; 564 if (!atomic_dec_if_positive(&pool->events[offset].free)) { 565 pool->next = offset; 566 return &pool->events[offset]; 567 } 568 } 569 570 printk(KERN_ERR "ibmvscsi: found no event struct in pool!\n"); 571 return NULL; 572 } 573 574 /** 575 * init_event_struct: Initialize fields in an event struct that are always 576 * required. 577 * @evt_struct: The event 578 * @done: Routine to call when the event is responded to 579 * @format: SRP or MAD format 580 * @timeout: timeout value set in the CRQ 581 */ 582 static void init_event_struct(struct srp_event_struct *evt_struct, 583 void (*done) (struct srp_event_struct *), 584 u8 format, 585 int timeout) 586 { 587 evt_struct->cmnd = NULL; 588 evt_struct->cmnd_done = NULL; 589 evt_struct->sync_srp = NULL; 590 evt_struct->crq.format = format; 591 evt_struct->crq.timeout = cpu_to_be16(timeout); 592 evt_struct->done = done; 593 } 594 595 /* ------------------------------------------------------------ 596 * Routines for receiving SCSI responses from the hosting partition 597 */ 598 599 /* 600 * set_srp_direction: Set the fields in the srp related to data 601 * direction and number of buffers based on the direction in 602 * the scsi_cmnd and the number of buffers 603 */ 604 static void set_srp_direction(struct scsi_cmnd *cmd, 605 struct srp_cmd *srp_cmd, 606 int numbuf) 607 { 608 u8 fmt; 609 610 if (numbuf == 0) 611 return; 612 613 if (numbuf == 1) 614 fmt = SRP_DATA_DESC_DIRECT; 615 else { 616 fmt = SRP_DATA_DESC_INDIRECT; 617 numbuf = min(numbuf, MAX_INDIRECT_BUFS); 618 619 if (cmd->sc_data_direction == DMA_TO_DEVICE) 620 srp_cmd->data_out_desc_cnt = numbuf; 621 else 622 srp_cmd->data_in_desc_cnt = numbuf; 623 } 624 625 if (cmd->sc_data_direction == DMA_TO_DEVICE) 626 srp_cmd->buf_fmt = fmt << 4; 627 else 628 srp_cmd->buf_fmt = fmt; 629 } 630 631 /** 632 * unmap_cmd_data: - Unmap data pointed in srp_cmd based on the format 633 * @cmd: srp_cmd whose additional_data member will be unmapped 634 * @evt_struct: the event 635 * @dev: device for which the memory is mapped 636 */ 637 static void unmap_cmd_data(struct srp_cmd *cmd, 638 struct srp_event_struct *evt_struct, 639 struct device *dev) 640 { 641 u8 out_fmt, in_fmt; 642 643 out_fmt = cmd->buf_fmt >> 4; 644 in_fmt = cmd->buf_fmt & ((1U << 4) - 1); 645 646 if (out_fmt == SRP_NO_DATA_DESC && in_fmt == SRP_NO_DATA_DESC) 647 return; 648 649 if (evt_struct->cmnd) 650 scsi_dma_unmap(evt_struct->cmnd); 651 } 652 653 static int map_sg_list(struct scsi_cmnd *cmd, int nseg, 654 struct srp_direct_buf *md) 655 { 656 int i; 657 struct scatterlist *sg; 658 u64 total_length = 0; 659 660 scsi_for_each_sg(cmd, sg, nseg, i) { 661 struct srp_direct_buf *descr = md + i; 662 descr->va = cpu_to_be64(sg_dma_address(sg)); 663 descr->len = cpu_to_be32(sg_dma_len(sg)); 664 descr->key = 0; 665 total_length += sg_dma_len(sg); 666 } 667 return total_length; 668 } 669 670 /** 671 * map_sg_data: - Maps dma for a scatterlist and initializes descriptor fields 672 * @cmd: struct scsi_cmnd with the scatterlist 673 * @evt_struct: struct srp_event_struct to map 674 * @srp_cmd: srp_cmd that contains the memory descriptor 675 * @dev: device for which to map dma memory 676 * 677 * Called by map_data_for_srp_cmd() when building srp cmd from scsi cmd. 678 * Returns 1 on success. 679 */ 680 static int map_sg_data(struct scsi_cmnd *cmd, 681 struct srp_event_struct *evt_struct, 682 struct srp_cmd *srp_cmd, struct device *dev) 683 { 684 685 int sg_mapped; 686 u64 total_length = 0; 687 struct srp_direct_buf *data = 688 (struct srp_direct_buf *) srp_cmd->add_data; 689 struct srp_indirect_buf *indirect = 690 (struct srp_indirect_buf *) data; 691 692 sg_mapped = scsi_dma_map(cmd); 693 if (!sg_mapped) 694 return 1; 695 else if (sg_mapped < 0) 696 return 0; 697 698 set_srp_direction(cmd, srp_cmd, sg_mapped); 699 700 /* special case; we can use a single direct descriptor */ 701 if (sg_mapped == 1) { 702 map_sg_list(cmd, sg_mapped, data); 703 return 1; 704 } 705 706 indirect->table_desc.va = 0; 707 indirect->table_desc.len = cpu_to_be32(sg_mapped * 708 sizeof(struct srp_direct_buf)); 709 indirect->table_desc.key = 0; 710 711 if (sg_mapped <= MAX_INDIRECT_BUFS) { 712 total_length = map_sg_list(cmd, sg_mapped, 713 &indirect->desc_list[0]); 714 indirect->len = cpu_to_be32(total_length); 715 return 1; 716 } 717 718 /* get indirect table */ 719 if (!evt_struct->ext_list) { 720 evt_struct->ext_list = dma_alloc_coherent(dev, 721 SG_ALL * sizeof(struct srp_direct_buf), 722 &evt_struct->ext_list_token, 0); 723 if (!evt_struct->ext_list) { 724 if (!firmware_has_feature(FW_FEATURE_CMO)) 725 sdev_printk(KERN_ERR, cmd->device, 726 "Can't allocate memory " 727 "for indirect table\n"); 728 scsi_dma_unmap(cmd); 729 return 0; 730 } 731 } 732 733 total_length = map_sg_list(cmd, sg_mapped, evt_struct->ext_list); 734 735 indirect->len = cpu_to_be32(total_length); 736 indirect->table_desc.va = cpu_to_be64(evt_struct->ext_list_token); 737 indirect->table_desc.len = cpu_to_be32(sg_mapped * 738 sizeof(indirect->desc_list[0])); 739 memcpy(indirect->desc_list, evt_struct->ext_list, 740 MAX_INDIRECT_BUFS * sizeof(struct srp_direct_buf)); 741 return 1; 742 } 743 744 /** 745 * map_data_for_srp_cmd: - Calls functions to map data for srp cmds 746 * @cmd: struct scsi_cmnd with the memory to be mapped 747 * @evt_struct: struct srp_event_struct to map 748 * @srp_cmd: srp_cmd that contains the memory descriptor 749 * @dev: dma device for which to map dma memory 750 * 751 * Called by scsi_cmd_to_srp_cmd() when converting scsi cmds to srp cmds 752 * Returns 1 on success. 753 */ 754 static int map_data_for_srp_cmd(struct scsi_cmnd *cmd, 755 struct srp_event_struct *evt_struct, 756 struct srp_cmd *srp_cmd, struct device *dev) 757 { 758 switch (cmd->sc_data_direction) { 759 case DMA_FROM_DEVICE: 760 case DMA_TO_DEVICE: 761 break; 762 case DMA_NONE: 763 return 1; 764 case DMA_BIDIRECTIONAL: 765 sdev_printk(KERN_ERR, cmd->device, 766 "Can't map DMA_BIDIRECTIONAL to read/write\n"); 767 return 0; 768 default: 769 sdev_printk(KERN_ERR, cmd->device, 770 "Unknown data direction 0x%02x; can't map!\n", 771 cmd->sc_data_direction); 772 return 0; 773 } 774 775 return map_sg_data(cmd, evt_struct, srp_cmd, dev); 776 } 777 778 /** 779 * purge_requests: Our virtual adapter just shut down. purge any sent requests 780 * @hostdata: the adapter 781 * @error_code: error code to return as the 'result' 782 */ 783 static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code) 784 { 785 struct srp_event_struct *evt; 786 unsigned long flags; 787 788 spin_lock_irqsave(hostdata->host->host_lock, flags); 789 while (!list_empty(&hostdata->sent)) { 790 evt = list_first_entry(&hostdata->sent, struct srp_event_struct, list); 791 list_del(&evt->list); 792 del_timer(&evt->timer); 793 794 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 795 if (evt->cmnd) { 796 evt->cmnd->result = (error_code << 16); 797 unmap_cmd_data(&evt->iu.srp.cmd, evt, 798 evt->hostdata->dev); 799 if (evt->cmnd_done) 800 evt->cmnd_done(evt->cmnd); 801 } else if (evt->done && evt->crq.format != VIOSRP_MAD_FORMAT && 802 evt->iu.srp.login_req.opcode != SRP_LOGIN_REQ) 803 evt->done(evt); 804 free_event_struct(&evt->hostdata->pool, evt); 805 spin_lock_irqsave(hostdata->host->host_lock, flags); 806 } 807 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 808 } 809 810 /** 811 * ibmvscsi_set_request_limit - Set the adapter request_limit in response to 812 * an adapter failure, reset, or SRP Login. Done under host lock to prevent 813 * race with SCSI command submission. 814 * @hostdata: adapter to adjust 815 * @limit: new request limit 816 */ 817 static void ibmvscsi_set_request_limit(struct ibmvscsi_host_data *hostdata, int limit) 818 { 819 unsigned long flags; 820 821 spin_lock_irqsave(hostdata->host->host_lock, flags); 822 atomic_set(&hostdata->request_limit, limit); 823 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 824 } 825 826 /** 827 * ibmvscsi_reset_host - Reset the connection to the server 828 * @hostdata: struct ibmvscsi_host_data to reset 829 */ 830 static void ibmvscsi_reset_host(struct ibmvscsi_host_data *hostdata) 831 { 832 scsi_block_requests(hostdata->host); 833 ibmvscsi_set_request_limit(hostdata, 0); 834 835 purge_requests(hostdata, DID_ERROR); 836 hostdata->action = IBMVSCSI_HOST_ACTION_RESET; 837 wake_up(&hostdata->work_wait_q); 838 } 839 840 /** 841 * ibmvscsi_timeout - Internal command timeout handler 842 * @t: struct srp_event_struct that timed out 843 * 844 * Called when an internally generated command times out 845 */ 846 static void ibmvscsi_timeout(struct timer_list *t) 847 { 848 struct srp_event_struct *evt_struct = from_timer(evt_struct, t, timer); 849 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 850 851 dev_err(hostdata->dev, "Command timed out (%x). Resetting connection\n", 852 evt_struct->iu.srp.cmd.opcode); 853 854 ibmvscsi_reset_host(hostdata); 855 } 856 857 858 /* ------------------------------------------------------------ 859 * Routines for sending and receiving SRPs 860 */ 861 /** 862 * ibmvscsi_send_srp_event: - Transforms event to u64 array and calls send_crq() 863 * @evt_struct: evt_struct to be sent 864 * @hostdata: ibmvscsi_host_data of host 865 * @timeout: timeout in seconds - 0 means do not time command 866 * 867 * Returns the value returned from ibmvscsi_send_crq(). (Zero for success) 868 * Note that this routine assumes that host_lock is held for synchronization 869 */ 870 static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct, 871 struct ibmvscsi_host_data *hostdata, 872 unsigned long timeout) 873 { 874 __be64 *crq_as_u64 = (__be64 *)&evt_struct->crq; 875 int request_status = 0; 876 int rc; 877 int srp_req = 0; 878 879 /* If we have exhausted our request limit, just fail this request, 880 * unless it is for a reset or abort. 881 * Note that there are rare cases involving driver generated requests 882 * (such as task management requests) that the mid layer may think we 883 * can handle more requests (can_queue) when we actually can't 884 */ 885 if (evt_struct->crq.format == VIOSRP_SRP_FORMAT) { 886 srp_req = 1; 887 request_status = 888 atomic_dec_if_positive(&hostdata->request_limit); 889 /* If request limit was -1 when we started, it is now even 890 * less than that 891 */ 892 if (request_status < -1) 893 goto send_error; 894 /* Otherwise, we may have run out of requests. */ 895 /* If request limit was 0 when we started the adapter is in the 896 * process of performing a login with the server adapter, or 897 * we may have run out of requests. 898 */ 899 else if (request_status == -1 && 900 evt_struct->iu.srp.login_req.opcode != SRP_LOGIN_REQ) 901 goto send_busy; 902 /* Abort and reset calls should make it through. 903 * Nothing except abort and reset should use the last two 904 * slots unless we had two or less to begin with. 905 */ 906 else if (request_status < 2 && 907 evt_struct->iu.srp.cmd.opcode != SRP_TSK_MGMT) { 908 /* In the case that we have less than two requests 909 * available, check the server limit as a combination 910 * of the request limit and the number of requests 911 * in-flight (the size of the send list). If the 912 * server limit is greater than 2, return busy so 913 * that the last two are reserved for reset and abort. 914 */ 915 int server_limit = request_status; 916 struct srp_event_struct *tmp_evt; 917 918 list_for_each_entry(tmp_evt, &hostdata->sent, list) { 919 server_limit++; 920 } 921 922 if (server_limit > 2) 923 goto send_busy; 924 } 925 } 926 927 /* Copy the IU into the transfer area */ 928 *evt_struct->xfer_iu = evt_struct->iu; 929 evt_struct->xfer_iu->srp.rsp.tag = (u64)evt_struct; 930 931 /* Add this to the sent list. We need to do this 932 * before we actually send 933 * in case it comes back REALLY fast 934 */ 935 list_add_tail(&evt_struct->list, &hostdata->sent); 936 937 timer_setup(&evt_struct->timer, ibmvscsi_timeout, 0); 938 if (timeout) { 939 evt_struct->timer.expires = jiffies + (timeout * HZ); 940 add_timer(&evt_struct->timer); 941 } 942 943 rc = ibmvscsi_send_crq(hostdata, be64_to_cpu(crq_as_u64[0]), 944 be64_to_cpu(crq_as_u64[1])); 945 if (rc != 0) { 946 list_del(&evt_struct->list); 947 del_timer(&evt_struct->timer); 948 949 /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY. 950 * Firmware will send a CRQ with a transport event (0xFF) to 951 * tell this client what has happened to the transport. This 952 * will be handled in ibmvscsi_handle_crq() 953 */ 954 if (rc == H_CLOSED) { 955 dev_warn(hostdata->dev, "send warning. " 956 "Receive queue closed, will retry.\n"); 957 goto send_busy; 958 } 959 dev_err(hostdata->dev, "send error %d\n", rc); 960 if (srp_req) 961 atomic_inc(&hostdata->request_limit); 962 goto send_error; 963 } 964 965 return 0; 966 967 send_busy: 968 unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev); 969 970 free_event_struct(&hostdata->pool, evt_struct); 971 if (srp_req && request_status != -1) 972 atomic_inc(&hostdata->request_limit); 973 return SCSI_MLQUEUE_HOST_BUSY; 974 975 send_error: 976 unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev); 977 978 if (evt_struct->cmnd != NULL) { 979 evt_struct->cmnd->result = DID_ERROR << 16; 980 evt_struct->cmnd_done(evt_struct->cmnd); 981 } else if (evt_struct->done) 982 evt_struct->done(evt_struct); 983 984 free_event_struct(&hostdata->pool, evt_struct); 985 return 0; 986 } 987 988 /** 989 * handle_cmd_rsp: - Handle responses from commands 990 * @evt_struct: srp_event_struct to be handled 991 * 992 * Used as a callback by when sending scsi cmds. 993 * Gets called by ibmvscsi_handle_crq() 994 */ 995 static void handle_cmd_rsp(struct srp_event_struct *evt_struct) 996 { 997 struct srp_rsp *rsp = &evt_struct->xfer_iu->srp.rsp; 998 struct scsi_cmnd *cmnd = evt_struct->cmnd; 999 1000 if (unlikely(rsp->opcode != SRP_RSP)) { 1001 if (printk_ratelimit()) 1002 dev_warn(evt_struct->hostdata->dev, 1003 "bad SRP RSP type %#02x\n", rsp->opcode); 1004 } 1005 1006 if (cmnd) { 1007 cmnd->result |= rsp->status; 1008 if (scsi_status_is_check_condition(cmnd->result)) 1009 memcpy(cmnd->sense_buffer, 1010 rsp->data, 1011 be32_to_cpu(rsp->sense_data_len)); 1012 unmap_cmd_data(&evt_struct->iu.srp.cmd, 1013 evt_struct, 1014 evt_struct->hostdata->dev); 1015 1016 if (rsp->flags & SRP_RSP_FLAG_DOOVER) 1017 scsi_set_resid(cmnd, 1018 be32_to_cpu(rsp->data_out_res_cnt)); 1019 else if (rsp->flags & SRP_RSP_FLAG_DIOVER) 1020 scsi_set_resid(cmnd, be32_to_cpu(rsp->data_in_res_cnt)); 1021 } 1022 1023 if (evt_struct->cmnd_done) 1024 evt_struct->cmnd_done(cmnd); 1025 } 1026 1027 /** 1028 * lun_from_dev: - Returns the lun of the scsi device 1029 * @dev: struct scsi_device 1030 * 1031 */ 1032 static inline u16 lun_from_dev(struct scsi_device *dev) 1033 { 1034 return (0x2 << 14) | (dev->id << 8) | (dev->channel << 5) | dev->lun; 1035 } 1036 1037 /** 1038 * ibmvscsi_queuecommand_lck() - The queuecommand function of the scsi template 1039 * @cmnd: struct scsi_cmnd to be executed 1040 * @done: Callback function to be called when cmd is completed 1041 */ 1042 static int ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd, 1043 void (*done) (struct scsi_cmnd *)) 1044 { 1045 struct srp_cmd *srp_cmd; 1046 struct srp_event_struct *evt_struct; 1047 struct srp_indirect_buf *indirect; 1048 struct ibmvscsi_host_data *hostdata = shost_priv(cmnd->device->host); 1049 u16 lun = lun_from_dev(cmnd->device); 1050 u8 out_fmt, in_fmt; 1051 1052 cmnd->result = (DID_OK << 16); 1053 evt_struct = get_event_struct(&hostdata->pool); 1054 if (!evt_struct) 1055 return SCSI_MLQUEUE_HOST_BUSY; 1056 1057 /* Set up the actual SRP IU */ 1058 srp_cmd = &evt_struct->iu.srp.cmd; 1059 memset(srp_cmd, 0x00, SRP_MAX_IU_LEN); 1060 srp_cmd->opcode = SRP_CMD; 1061 memcpy(srp_cmd->cdb, cmnd->cmnd, sizeof(srp_cmd->cdb)); 1062 int_to_scsilun(lun, &srp_cmd->lun); 1063 1064 if (!map_data_for_srp_cmd(cmnd, evt_struct, srp_cmd, hostdata->dev)) { 1065 if (!firmware_has_feature(FW_FEATURE_CMO)) 1066 sdev_printk(KERN_ERR, cmnd->device, 1067 "couldn't convert cmd to srp_cmd\n"); 1068 free_event_struct(&hostdata->pool, evt_struct); 1069 return SCSI_MLQUEUE_HOST_BUSY; 1070 } 1071 1072 init_event_struct(evt_struct, 1073 handle_cmd_rsp, 1074 VIOSRP_SRP_FORMAT, 1075 cmnd->request->timeout/HZ); 1076 1077 evt_struct->cmnd = cmnd; 1078 evt_struct->cmnd_done = done; 1079 1080 /* Fix up dma address of the buffer itself */ 1081 indirect = (struct srp_indirect_buf *) srp_cmd->add_data; 1082 out_fmt = srp_cmd->buf_fmt >> 4; 1083 in_fmt = srp_cmd->buf_fmt & ((1U << 4) - 1); 1084 if ((in_fmt == SRP_DATA_DESC_INDIRECT || 1085 out_fmt == SRP_DATA_DESC_INDIRECT) && 1086 indirect->table_desc.va == 0) { 1087 indirect->table_desc.va = 1088 cpu_to_be64(be64_to_cpu(evt_struct->crq.IU_data_ptr) + 1089 offsetof(struct srp_cmd, add_data) + 1090 offsetof(struct srp_indirect_buf, desc_list)); 1091 } 1092 1093 return ibmvscsi_send_srp_event(evt_struct, hostdata, 0); 1094 } 1095 1096 static DEF_SCSI_QCMD(ibmvscsi_queuecommand) 1097 1098 /* ------------------------------------------------------------ 1099 * Routines for driver initialization 1100 */ 1101 1102 /** 1103 * map_persist_bufs: - Pre-map persistent data for adapter logins 1104 * @hostdata: ibmvscsi_host_data of host 1105 * 1106 * Map the capabilities and adapter info DMA buffers to avoid runtime failures. 1107 * Return 1 on error, 0 on success. 1108 */ 1109 static int map_persist_bufs(struct ibmvscsi_host_data *hostdata) 1110 { 1111 1112 hostdata->caps_addr = dma_map_single(hostdata->dev, &hostdata->caps, 1113 sizeof(hostdata->caps), DMA_BIDIRECTIONAL); 1114 1115 if (dma_mapping_error(hostdata->dev, hostdata->caps_addr)) { 1116 dev_err(hostdata->dev, "Unable to map capabilities buffer!\n"); 1117 return 1; 1118 } 1119 1120 hostdata->adapter_info_addr = dma_map_single(hostdata->dev, 1121 &hostdata->madapter_info, 1122 sizeof(hostdata->madapter_info), 1123 DMA_BIDIRECTIONAL); 1124 if (dma_mapping_error(hostdata->dev, hostdata->adapter_info_addr)) { 1125 dev_err(hostdata->dev, "Unable to map adapter info buffer!\n"); 1126 dma_unmap_single(hostdata->dev, hostdata->caps_addr, 1127 sizeof(hostdata->caps), DMA_BIDIRECTIONAL); 1128 return 1; 1129 } 1130 1131 return 0; 1132 } 1133 1134 /** 1135 * unmap_persist_bufs: - Unmap persistent data needed for adapter logins 1136 * @hostdata: ibmvscsi_host_data of host 1137 * 1138 * Unmap the capabilities and adapter info DMA buffers 1139 */ 1140 static void unmap_persist_bufs(struct ibmvscsi_host_data *hostdata) 1141 { 1142 dma_unmap_single(hostdata->dev, hostdata->caps_addr, 1143 sizeof(hostdata->caps), DMA_BIDIRECTIONAL); 1144 1145 dma_unmap_single(hostdata->dev, hostdata->adapter_info_addr, 1146 sizeof(hostdata->madapter_info), DMA_BIDIRECTIONAL); 1147 } 1148 1149 /** 1150 * login_rsp: - Handle response to SRP login request 1151 * @evt_struct: srp_event_struct with the response 1152 * 1153 * Used as a "done" callback by when sending srp_login. Gets called 1154 * by ibmvscsi_handle_crq() 1155 */ 1156 static void login_rsp(struct srp_event_struct *evt_struct) 1157 { 1158 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 1159 switch (evt_struct->xfer_iu->srp.login_rsp.opcode) { 1160 case SRP_LOGIN_RSP: /* it worked! */ 1161 break; 1162 case SRP_LOGIN_REJ: /* refused! */ 1163 dev_info(hostdata->dev, "SRP_LOGIN_REJ reason %u\n", 1164 evt_struct->xfer_iu->srp.login_rej.reason); 1165 /* Login failed. */ 1166 ibmvscsi_set_request_limit(hostdata, -1); 1167 return; 1168 default: 1169 dev_err(hostdata->dev, "Invalid login response typecode 0x%02x!\n", 1170 evt_struct->xfer_iu->srp.login_rsp.opcode); 1171 /* Login failed. */ 1172 ibmvscsi_set_request_limit(hostdata, -1); 1173 return; 1174 } 1175 1176 dev_info(hostdata->dev, "SRP_LOGIN succeeded\n"); 1177 hostdata->client_migrated = 0; 1178 1179 /* Now we know what the real request-limit is. 1180 * This value is set rather than added to request_limit because 1181 * request_limit could have been set to -1 by this client. 1182 */ 1183 ibmvscsi_set_request_limit(hostdata, 1184 be32_to_cpu(evt_struct->xfer_iu->srp.login_rsp.req_lim_delta)); 1185 1186 /* If we had any pending I/Os, kick them */ 1187 hostdata->action = IBMVSCSI_HOST_ACTION_UNBLOCK; 1188 wake_up(&hostdata->work_wait_q); 1189 } 1190 1191 /** 1192 * send_srp_login: - Sends the srp login 1193 * @hostdata: ibmvscsi_host_data of host 1194 * 1195 * Returns zero if successful. 1196 */ 1197 static int send_srp_login(struct ibmvscsi_host_data *hostdata) 1198 { 1199 int rc; 1200 unsigned long flags; 1201 struct srp_login_req *login; 1202 struct srp_event_struct *evt_struct = get_event_struct(&hostdata->pool); 1203 1204 BUG_ON(!evt_struct); 1205 init_event_struct(evt_struct, login_rsp, 1206 VIOSRP_SRP_FORMAT, login_timeout); 1207 1208 login = &evt_struct->iu.srp.login_req; 1209 memset(login, 0, sizeof(*login)); 1210 login->opcode = SRP_LOGIN_REQ; 1211 login->req_it_iu_len = cpu_to_be32(sizeof(union srp_iu)); 1212 login->req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | 1213 SRP_BUF_FORMAT_INDIRECT); 1214 1215 /* Start out with a request limit of 0, since this is negotiated in 1216 * the login request we are just sending and login requests always 1217 * get sent by the driver regardless of request_limit. 1218 */ 1219 ibmvscsi_set_request_limit(hostdata, 0); 1220 1221 spin_lock_irqsave(hostdata->host->host_lock, flags); 1222 rc = ibmvscsi_send_srp_event(evt_struct, hostdata, login_timeout * 2); 1223 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1224 dev_info(hostdata->dev, "sent SRP login\n"); 1225 return rc; 1226 }; 1227 1228 /** 1229 * capabilities_rsp: - Handle response to MAD adapter capabilities request 1230 * @evt_struct: srp_event_struct with the response 1231 * 1232 * Used as a "done" callback by when sending adapter_info. 1233 */ 1234 static void capabilities_rsp(struct srp_event_struct *evt_struct) 1235 { 1236 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 1237 1238 if (evt_struct->xfer_iu->mad.capabilities.common.status) { 1239 dev_err(hostdata->dev, "error 0x%X getting capabilities info\n", 1240 evt_struct->xfer_iu->mad.capabilities.common.status); 1241 } else { 1242 if (hostdata->caps.migration.common.server_support != 1243 cpu_to_be16(SERVER_SUPPORTS_CAP)) 1244 dev_info(hostdata->dev, "Partition migration not supported\n"); 1245 1246 if (client_reserve) { 1247 if (hostdata->caps.reserve.common.server_support == 1248 cpu_to_be16(SERVER_SUPPORTS_CAP)) 1249 dev_info(hostdata->dev, "Client reserve enabled\n"); 1250 else 1251 dev_info(hostdata->dev, "Client reserve not supported\n"); 1252 } 1253 } 1254 1255 send_srp_login(hostdata); 1256 } 1257 1258 /** 1259 * send_mad_capabilities: - Sends the mad capabilities request 1260 * and stores the result so it can be retrieved with 1261 * @hostdata: ibmvscsi_host_data of host 1262 */ 1263 static void send_mad_capabilities(struct ibmvscsi_host_data *hostdata) 1264 { 1265 struct viosrp_capabilities *req; 1266 struct srp_event_struct *evt_struct; 1267 unsigned long flags; 1268 struct device_node *of_node = hostdata->dev->of_node; 1269 const char *location; 1270 1271 evt_struct = get_event_struct(&hostdata->pool); 1272 BUG_ON(!evt_struct); 1273 1274 init_event_struct(evt_struct, capabilities_rsp, 1275 VIOSRP_MAD_FORMAT, info_timeout); 1276 1277 req = &evt_struct->iu.mad.capabilities; 1278 memset(req, 0, sizeof(*req)); 1279 1280 hostdata->caps.flags = cpu_to_be32(CAP_LIST_SUPPORTED); 1281 if (hostdata->client_migrated) 1282 hostdata->caps.flags |= cpu_to_be32(CLIENT_MIGRATED); 1283 1284 strlcpy(hostdata->caps.name, dev_name(&hostdata->host->shost_gendev), 1285 sizeof(hostdata->caps.name)); 1286 1287 location = of_get_property(of_node, "ibm,loc-code", NULL); 1288 location = location ? location : dev_name(hostdata->dev); 1289 strlcpy(hostdata->caps.loc, location, sizeof(hostdata->caps.loc)); 1290 1291 req->common.type = cpu_to_be32(VIOSRP_CAPABILITIES_TYPE); 1292 req->buffer = cpu_to_be64(hostdata->caps_addr); 1293 1294 hostdata->caps.migration.common.cap_type = 1295 cpu_to_be32(MIGRATION_CAPABILITIES); 1296 hostdata->caps.migration.common.length = 1297 cpu_to_be16(sizeof(hostdata->caps.migration)); 1298 hostdata->caps.migration.common.server_support = 1299 cpu_to_be16(SERVER_SUPPORTS_CAP); 1300 hostdata->caps.migration.ecl = cpu_to_be32(1); 1301 1302 if (client_reserve) { 1303 hostdata->caps.reserve.common.cap_type = 1304 cpu_to_be32(RESERVATION_CAPABILITIES); 1305 hostdata->caps.reserve.common.length = 1306 cpu_to_be16(sizeof(hostdata->caps.reserve)); 1307 hostdata->caps.reserve.common.server_support = 1308 cpu_to_be16(SERVER_SUPPORTS_CAP); 1309 hostdata->caps.reserve.type = 1310 cpu_to_be32(CLIENT_RESERVE_SCSI_2); 1311 req->common.length = 1312 cpu_to_be16(sizeof(hostdata->caps)); 1313 } else 1314 req->common.length = cpu_to_be16(sizeof(hostdata->caps) - 1315 sizeof(hostdata->caps.reserve)); 1316 1317 spin_lock_irqsave(hostdata->host->host_lock, flags); 1318 if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2)) 1319 dev_err(hostdata->dev, "couldn't send CAPABILITIES_REQ!\n"); 1320 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1321 }; 1322 1323 /** 1324 * fast_fail_rsp: - Handle response to MAD enable fast fail 1325 * @evt_struct: srp_event_struct with the response 1326 * 1327 * Used as a "done" callback by when sending enable fast fail. Gets called 1328 * by ibmvscsi_handle_crq() 1329 */ 1330 static void fast_fail_rsp(struct srp_event_struct *evt_struct) 1331 { 1332 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 1333 u16 status = be16_to_cpu(evt_struct->xfer_iu->mad.fast_fail.common.status); 1334 1335 if (status == VIOSRP_MAD_NOT_SUPPORTED) 1336 dev_err(hostdata->dev, "fast_fail not supported in server\n"); 1337 else if (status == VIOSRP_MAD_FAILED) 1338 dev_err(hostdata->dev, "fast_fail request failed\n"); 1339 else if (status != VIOSRP_MAD_SUCCESS) 1340 dev_err(hostdata->dev, "error 0x%X enabling fast_fail\n", status); 1341 1342 send_mad_capabilities(hostdata); 1343 } 1344 1345 /** 1346 * enable_fast_fail() - Start host initialization 1347 * @hostdata: ibmvscsi_host_data of host 1348 * 1349 * Returns zero if successful. 1350 */ 1351 static int enable_fast_fail(struct ibmvscsi_host_data *hostdata) 1352 { 1353 int rc; 1354 unsigned long flags; 1355 struct viosrp_fast_fail *fast_fail_mad; 1356 struct srp_event_struct *evt_struct; 1357 1358 if (!fast_fail) { 1359 send_mad_capabilities(hostdata); 1360 return 0; 1361 } 1362 1363 evt_struct = get_event_struct(&hostdata->pool); 1364 BUG_ON(!evt_struct); 1365 1366 init_event_struct(evt_struct, fast_fail_rsp, VIOSRP_MAD_FORMAT, info_timeout); 1367 1368 fast_fail_mad = &evt_struct->iu.mad.fast_fail; 1369 memset(fast_fail_mad, 0, sizeof(*fast_fail_mad)); 1370 fast_fail_mad->common.type = cpu_to_be32(VIOSRP_ENABLE_FAST_FAIL); 1371 fast_fail_mad->common.length = cpu_to_be16(sizeof(*fast_fail_mad)); 1372 1373 spin_lock_irqsave(hostdata->host->host_lock, flags); 1374 rc = ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2); 1375 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1376 return rc; 1377 } 1378 1379 /** 1380 * adapter_info_rsp: - Handle response to MAD adapter info request 1381 * @evt_struct: srp_event_struct with the response 1382 * 1383 * Used as a "done" callback by when sending adapter_info. Gets called 1384 * by ibmvscsi_handle_crq() 1385 */ 1386 static void adapter_info_rsp(struct srp_event_struct *evt_struct) 1387 { 1388 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 1389 1390 if (evt_struct->xfer_iu->mad.adapter_info.common.status) { 1391 dev_err(hostdata->dev, "error %d getting adapter info\n", 1392 evt_struct->xfer_iu->mad.adapter_info.common.status); 1393 } else { 1394 dev_info(hostdata->dev, "host srp version: %s, " 1395 "host partition %s (%d), OS %d, max io %u\n", 1396 hostdata->madapter_info.srp_version, 1397 hostdata->madapter_info.partition_name, 1398 be32_to_cpu(hostdata->madapter_info.partition_number), 1399 be32_to_cpu(hostdata->madapter_info.os_type), 1400 be32_to_cpu(hostdata->madapter_info.port_max_txu[0])); 1401 1402 if (hostdata->madapter_info.port_max_txu[0]) 1403 hostdata->host->max_sectors = 1404 be32_to_cpu(hostdata->madapter_info.port_max_txu[0]) >> 9; 1405 1406 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX && 1407 strcmp(hostdata->madapter_info.srp_version, "1.6a") <= 0) { 1408 dev_err(hostdata->dev, "host (Ver. %s) doesn't support large transfers\n", 1409 hostdata->madapter_info.srp_version); 1410 dev_err(hostdata->dev, "limiting scatterlists to %d\n", 1411 MAX_INDIRECT_BUFS); 1412 hostdata->host->sg_tablesize = MAX_INDIRECT_BUFS; 1413 } 1414 1415 if (be32_to_cpu(hostdata->madapter_info.os_type) == SRP_MAD_OS_AIX) { 1416 enable_fast_fail(hostdata); 1417 return; 1418 } 1419 } 1420 1421 send_srp_login(hostdata); 1422 } 1423 1424 /** 1425 * send_mad_adapter_info: - Sends the mad adapter info request 1426 * and stores the result so it can be retrieved with 1427 * sysfs. We COULD consider causing a failure if the 1428 * returned SRP version doesn't match ours. 1429 * @hostdata: ibmvscsi_host_data of host 1430 * 1431 * Returns zero if successful. 1432 */ 1433 static void send_mad_adapter_info(struct ibmvscsi_host_data *hostdata) 1434 { 1435 struct viosrp_adapter_info *req; 1436 struct srp_event_struct *evt_struct; 1437 unsigned long flags; 1438 1439 evt_struct = get_event_struct(&hostdata->pool); 1440 BUG_ON(!evt_struct); 1441 1442 init_event_struct(evt_struct, 1443 adapter_info_rsp, 1444 VIOSRP_MAD_FORMAT, 1445 info_timeout); 1446 1447 req = &evt_struct->iu.mad.adapter_info; 1448 memset(req, 0x00, sizeof(*req)); 1449 1450 req->common.type = cpu_to_be32(VIOSRP_ADAPTER_INFO_TYPE); 1451 req->common.length = cpu_to_be16(sizeof(hostdata->madapter_info)); 1452 req->buffer = cpu_to_be64(hostdata->adapter_info_addr); 1453 1454 spin_lock_irqsave(hostdata->host->host_lock, flags); 1455 if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2)) 1456 dev_err(hostdata->dev, "couldn't send ADAPTER_INFO_REQ!\n"); 1457 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1458 }; 1459 1460 /* 1461 * init_adapter() - Start virtual adapter initialization sequence 1462 */ 1463 static void init_adapter(struct ibmvscsi_host_data *hostdata) 1464 { 1465 send_mad_adapter_info(hostdata); 1466 } 1467 1468 /* 1469 * sync_completion: Signal that a synchronous command has completed 1470 * Note that after returning from this call, the evt_struct is freed. 1471 * the caller waiting on this completion shouldn't touch the evt_struct 1472 * again. 1473 */ 1474 static void sync_completion(struct srp_event_struct *evt_struct) 1475 { 1476 /* copy the response back */ 1477 if (evt_struct->sync_srp) 1478 *evt_struct->sync_srp = *evt_struct->xfer_iu; 1479 1480 complete(&evt_struct->comp); 1481 } 1482 1483 /* 1484 * ibmvscsi_eh_abort_handler: Abort a command...from scsi host template 1485 * send this over to the server and wait synchronously for the response 1486 */ 1487 static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd) 1488 { 1489 struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host); 1490 struct srp_tsk_mgmt *tsk_mgmt; 1491 struct srp_event_struct *evt; 1492 struct srp_event_struct *tmp_evt, *found_evt; 1493 union viosrp_iu srp_rsp; 1494 int rsp_rc; 1495 unsigned long flags; 1496 u16 lun = lun_from_dev(cmd->device); 1497 unsigned long wait_switch = 0; 1498 1499 /* First, find this command in our sent list so we can figure 1500 * out the correct tag 1501 */ 1502 spin_lock_irqsave(hostdata->host->host_lock, flags); 1503 wait_switch = jiffies + (init_timeout * HZ); 1504 do { 1505 found_evt = NULL; 1506 list_for_each_entry(tmp_evt, &hostdata->sent, list) { 1507 if (tmp_evt->cmnd == cmd) { 1508 found_evt = tmp_evt; 1509 break; 1510 } 1511 } 1512 1513 if (!found_evt) { 1514 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1515 return SUCCESS; 1516 } 1517 1518 evt = get_event_struct(&hostdata->pool); 1519 if (evt == NULL) { 1520 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1521 sdev_printk(KERN_ERR, cmd->device, 1522 "failed to allocate abort event\n"); 1523 return FAILED; 1524 } 1525 1526 init_event_struct(evt, 1527 sync_completion, 1528 VIOSRP_SRP_FORMAT, 1529 abort_timeout); 1530 1531 tsk_mgmt = &evt->iu.srp.tsk_mgmt; 1532 1533 /* Set up an abort SRP command */ 1534 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt)); 1535 tsk_mgmt->opcode = SRP_TSK_MGMT; 1536 int_to_scsilun(lun, &tsk_mgmt->lun); 1537 tsk_mgmt->tsk_mgmt_func = SRP_TSK_ABORT_TASK; 1538 tsk_mgmt->task_tag = (u64) found_evt; 1539 1540 evt->sync_srp = &srp_rsp; 1541 1542 init_completion(&evt->comp); 1543 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, abort_timeout * 2); 1544 1545 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY) 1546 break; 1547 1548 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1549 msleep(10); 1550 spin_lock_irqsave(hostdata->host->host_lock, flags); 1551 } while (time_before(jiffies, wait_switch)); 1552 1553 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1554 1555 if (rsp_rc != 0) { 1556 sdev_printk(KERN_ERR, cmd->device, 1557 "failed to send abort() event. rc=%d\n", rsp_rc); 1558 return FAILED; 1559 } 1560 1561 sdev_printk(KERN_INFO, cmd->device, 1562 "aborting command. lun 0x%llx, tag 0x%llx\n", 1563 (((u64) lun) << 48), (u64) found_evt); 1564 1565 wait_for_completion(&evt->comp); 1566 1567 /* make sure we got a good response */ 1568 if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) { 1569 if (printk_ratelimit()) 1570 sdev_printk(KERN_WARNING, cmd->device, "abort bad SRP RSP type %d\n", 1571 srp_rsp.srp.rsp.opcode); 1572 return FAILED; 1573 } 1574 1575 if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID) 1576 rsp_rc = *((int *)srp_rsp.srp.rsp.data); 1577 else 1578 rsp_rc = srp_rsp.srp.rsp.status; 1579 1580 if (rsp_rc) { 1581 if (printk_ratelimit()) 1582 sdev_printk(KERN_WARNING, cmd->device, 1583 "abort code %d for task tag 0x%llx\n", 1584 rsp_rc, tsk_mgmt->task_tag); 1585 return FAILED; 1586 } 1587 1588 /* Because we dropped the spinlock above, it's possible 1589 * The event is no longer in our list. Make sure it didn't 1590 * complete while we were aborting 1591 */ 1592 spin_lock_irqsave(hostdata->host->host_lock, flags); 1593 found_evt = NULL; 1594 list_for_each_entry(tmp_evt, &hostdata->sent, list) { 1595 if (tmp_evt->cmnd == cmd) { 1596 found_evt = tmp_evt; 1597 break; 1598 } 1599 } 1600 1601 if (found_evt == NULL) { 1602 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1603 sdev_printk(KERN_INFO, cmd->device, "aborted task tag 0x%llx completed\n", 1604 tsk_mgmt->task_tag); 1605 return SUCCESS; 1606 } 1607 1608 sdev_printk(KERN_INFO, cmd->device, "successfully aborted task tag 0x%llx\n", 1609 tsk_mgmt->task_tag); 1610 1611 cmd->result = (DID_ABORT << 16); 1612 list_del(&found_evt->list); 1613 unmap_cmd_data(&found_evt->iu.srp.cmd, found_evt, 1614 found_evt->hostdata->dev); 1615 free_event_struct(&found_evt->hostdata->pool, found_evt); 1616 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1617 atomic_inc(&hostdata->request_limit); 1618 return SUCCESS; 1619 } 1620 1621 /* 1622 * ibmvscsi_eh_device_reset_handler: Reset a single LUN...from scsi host 1623 * template send this over to the server and wait synchronously for the 1624 * response 1625 */ 1626 static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd) 1627 { 1628 struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host); 1629 struct srp_tsk_mgmt *tsk_mgmt; 1630 struct srp_event_struct *evt; 1631 struct srp_event_struct *tmp_evt, *pos; 1632 union viosrp_iu srp_rsp; 1633 int rsp_rc; 1634 unsigned long flags; 1635 u16 lun = lun_from_dev(cmd->device); 1636 unsigned long wait_switch = 0; 1637 1638 spin_lock_irqsave(hostdata->host->host_lock, flags); 1639 wait_switch = jiffies + (init_timeout * HZ); 1640 do { 1641 evt = get_event_struct(&hostdata->pool); 1642 if (evt == NULL) { 1643 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1644 sdev_printk(KERN_ERR, cmd->device, 1645 "failed to allocate reset event\n"); 1646 return FAILED; 1647 } 1648 1649 init_event_struct(evt, 1650 sync_completion, 1651 VIOSRP_SRP_FORMAT, 1652 reset_timeout); 1653 1654 tsk_mgmt = &evt->iu.srp.tsk_mgmt; 1655 1656 /* Set up a lun reset SRP command */ 1657 memset(tsk_mgmt, 0x00, sizeof(*tsk_mgmt)); 1658 tsk_mgmt->opcode = SRP_TSK_MGMT; 1659 int_to_scsilun(lun, &tsk_mgmt->lun); 1660 tsk_mgmt->tsk_mgmt_func = SRP_TSK_LUN_RESET; 1661 1662 evt->sync_srp = &srp_rsp; 1663 1664 init_completion(&evt->comp); 1665 rsp_rc = ibmvscsi_send_srp_event(evt, hostdata, reset_timeout * 2); 1666 1667 if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY) 1668 break; 1669 1670 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1671 msleep(10); 1672 spin_lock_irqsave(hostdata->host->host_lock, flags); 1673 } while (time_before(jiffies, wait_switch)); 1674 1675 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1676 1677 if (rsp_rc != 0) { 1678 sdev_printk(KERN_ERR, cmd->device, 1679 "failed to send reset event. rc=%d\n", rsp_rc); 1680 return FAILED; 1681 } 1682 1683 sdev_printk(KERN_INFO, cmd->device, "resetting device. lun 0x%llx\n", 1684 (((u64) lun) << 48)); 1685 1686 wait_for_completion(&evt->comp); 1687 1688 /* make sure we got a good response */ 1689 if (unlikely(srp_rsp.srp.rsp.opcode != SRP_RSP)) { 1690 if (printk_ratelimit()) 1691 sdev_printk(KERN_WARNING, cmd->device, "reset bad SRP RSP type %d\n", 1692 srp_rsp.srp.rsp.opcode); 1693 return FAILED; 1694 } 1695 1696 if (srp_rsp.srp.rsp.flags & SRP_RSP_FLAG_RSPVALID) 1697 rsp_rc = *((int *)srp_rsp.srp.rsp.data); 1698 else 1699 rsp_rc = srp_rsp.srp.rsp.status; 1700 1701 if (rsp_rc) { 1702 if (printk_ratelimit()) 1703 sdev_printk(KERN_WARNING, cmd->device, 1704 "reset code %d for task tag 0x%llx\n", 1705 rsp_rc, tsk_mgmt->task_tag); 1706 return FAILED; 1707 } 1708 1709 /* We need to find all commands for this LUN that have not yet been 1710 * responded to, and fail them with DID_RESET 1711 */ 1712 spin_lock_irqsave(hostdata->host->host_lock, flags); 1713 list_for_each_entry_safe(tmp_evt, pos, &hostdata->sent, list) { 1714 if ((tmp_evt->cmnd) && (tmp_evt->cmnd->device == cmd->device)) { 1715 if (tmp_evt->cmnd) 1716 tmp_evt->cmnd->result = (DID_RESET << 16); 1717 list_del(&tmp_evt->list); 1718 unmap_cmd_data(&tmp_evt->iu.srp.cmd, tmp_evt, 1719 tmp_evt->hostdata->dev); 1720 free_event_struct(&tmp_evt->hostdata->pool, 1721 tmp_evt); 1722 atomic_inc(&hostdata->request_limit); 1723 if (tmp_evt->cmnd_done) 1724 tmp_evt->cmnd_done(tmp_evt->cmnd); 1725 else if (tmp_evt->done) 1726 tmp_evt->done(tmp_evt); 1727 } 1728 } 1729 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1730 return SUCCESS; 1731 } 1732 1733 /** 1734 * ibmvscsi_eh_host_reset_handler - Reset the connection to the server 1735 * @cmd: struct scsi_cmnd having problems 1736 */ 1737 static int ibmvscsi_eh_host_reset_handler(struct scsi_cmnd *cmd) 1738 { 1739 unsigned long wait_switch = 0; 1740 struct ibmvscsi_host_data *hostdata = shost_priv(cmd->device->host); 1741 1742 dev_err(hostdata->dev, "Resetting connection due to error recovery\n"); 1743 1744 ibmvscsi_reset_host(hostdata); 1745 1746 for (wait_switch = jiffies + (init_timeout * HZ); 1747 time_before(jiffies, wait_switch) && 1748 atomic_read(&hostdata->request_limit) < 2;) { 1749 1750 msleep(10); 1751 } 1752 1753 if (atomic_read(&hostdata->request_limit) <= 0) 1754 return FAILED; 1755 1756 return SUCCESS; 1757 } 1758 1759 /** 1760 * ibmvscsi_handle_crq: - Handles and frees received events in the CRQ 1761 * @crq: Command/Response queue 1762 * @hostdata: ibmvscsi_host_data of host 1763 * 1764 */ 1765 static void ibmvscsi_handle_crq(struct viosrp_crq *crq, 1766 struct ibmvscsi_host_data *hostdata) 1767 { 1768 long rc; 1769 unsigned long flags; 1770 /* The hypervisor copies our tag value here so no byteswapping */ 1771 struct srp_event_struct *evt_struct = 1772 (__force struct srp_event_struct *)crq->IU_data_ptr; 1773 switch (crq->valid) { 1774 case VIOSRP_CRQ_INIT_RSP: /* initialization */ 1775 switch (crq->format) { 1776 case VIOSRP_CRQ_INIT: /* Initialization message */ 1777 dev_info(hostdata->dev, "partner initialized\n"); 1778 /* Send back a response */ 1779 rc = ibmvscsi_send_crq(hostdata, 0xC002000000000000LL, 0); 1780 if (rc == 0) { 1781 /* Now login */ 1782 init_adapter(hostdata); 1783 } else { 1784 dev_err(hostdata->dev, "Unable to send init rsp. rc=%ld\n", rc); 1785 } 1786 1787 break; 1788 case VIOSRP_CRQ_INIT_COMPLETE: /* Initialization response */ 1789 dev_info(hostdata->dev, "partner initialization complete\n"); 1790 1791 /* Now login */ 1792 init_adapter(hostdata); 1793 break; 1794 default: 1795 dev_err(hostdata->dev, "unknown crq message type: %d\n", crq->format); 1796 } 1797 return; 1798 case VIOSRP_CRQ_XPORT_EVENT: /* Hypervisor telling us the connection is closed */ 1799 scsi_block_requests(hostdata->host); 1800 ibmvscsi_set_request_limit(hostdata, 0); 1801 if (crq->format == 0x06) { 1802 /* We need to re-setup the interpartition connection */ 1803 dev_info(hostdata->dev, "Re-enabling adapter!\n"); 1804 hostdata->client_migrated = 1; 1805 hostdata->action = IBMVSCSI_HOST_ACTION_REENABLE; 1806 purge_requests(hostdata, DID_REQUEUE); 1807 wake_up(&hostdata->work_wait_q); 1808 } else { 1809 dev_err(hostdata->dev, "Virtual adapter failed rc %d!\n", 1810 crq->format); 1811 ibmvscsi_reset_host(hostdata); 1812 } 1813 return; 1814 case VIOSRP_CRQ_CMD_RSP: /* real payload */ 1815 break; 1816 default: 1817 dev_err(hostdata->dev, "got an invalid message type 0x%02x\n", 1818 crq->valid); 1819 return; 1820 } 1821 1822 /* The only kind of payload CRQs we should get are responses to 1823 * things we send. Make sure this response is to something we 1824 * actually sent 1825 */ 1826 if (!valid_event_struct(&hostdata->pool, evt_struct)) { 1827 dev_err(hostdata->dev, "returned correlation_token 0x%p is invalid!\n", 1828 evt_struct); 1829 return; 1830 } 1831 1832 if (atomic_read(&evt_struct->free)) { 1833 dev_err(hostdata->dev, "received duplicate correlation_token 0x%p!\n", 1834 evt_struct); 1835 return; 1836 } 1837 1838 if (crq->format == VIOSRP_SRP_FORMAT) 1839 atomic_add(be32_to_cpu(evt_struct->xfer_iu->srp.rsp.req_lim_delta), 1840 &hostdata->request_limit); 1841 1842 del_timer(&evt_struct->timer); 1843 1844 if ((crq->status != VIOSRP_OK && crq->status != VIOSRP_OK2) && evt_struct->cmnd) 1845 evt_struct->cmnd->result = DID_ERROR << 16; 1846 if (evt_struct->done) 1847 evt_struct->done(evt_struct); 1848 else 1849 dev_err(hostdata->dev, "returned done() is NULL; not running it!\n"); 1850 1851 /* 1852 * Lock the host_lock before messing with these structures, since we 1853 * are running in a task context 1854 */ 1855 spin_lock_irqsave(evt_struct->hostdata->host->host_lock, flags); 1856 list_del(&evt_struct->list); 1857 free_event_struct(&evt_struct->hostdata->pool, evt_struct); 1858 spin_unlock_irqrestore(evt_struct->hostdata->host->host_lock, flags); 1859 } 1860 1861 /** 1862 * ibmvscsi_slave_configure: Set the "allow_restart" flag for each disk. 1863 * @sdev: struct scsi_device device to configure 1864 * 1865 * Enable allow_restart for a device if it is a disk. Adjust the 1866 * queue_depth here also as is required by the documentation for 1867 * struct scsi_host_template. 1868 */ 1869 static int ibmvscsi_slave_configure(struct scsi_device *sdev) 1870 { 1871 struct Scsi_Host *shost = sdev->host; 1872 unsigned long lock_flags = 0; 1873 1874 spin_lock_irqsave(shost->host_lock, lock_flags); 1875 if (sdev->type == TYPE_DISK) { 1876 sdev->allow_restart = 1; 1877 blk_queue_rq_timeout(sdev->request_queue, 120 * HZ); 1878 } 1879 spin_unlock_irqrestore(shost->host_lock, lock_flags); 1880 return 0; 1881 } 1882 1883 /** 1884 * ibmvscsi_change_queue_depth - Change the device's queue depth 1885 * @sdev: scsi device struct 1886 * @qdepth: depth to set 1887 * 1888 * Return value: 1889 * actual depth set 1890 **/ 1891 static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth) 1892 { 1893 if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN) 1894 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN; 1895 return scsi_change_queue_depth(sdev, qdepth); 1896 } 1897 1898 /* ------------------------------------------------------------ 1899 * sysfs attributes 1900 */ 1901 static ssize_t show_host_vhost_loc(struct device *dev, 1902 struct device_attribute *attr, char *buf) 1903 { 1904 struct Scsi_Host *shost = class_to_shost(dev); 1905 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1906 int len; 1907 1908 len = snprintf(buf, sizeof(hostdata->caps.loc), "%s\n", 1909 hostdata->caps.loc); 1910 return len; 1911 } 1912 1913 static struct device_attribute ibmvscsi_host_vhost_loc = { 1914 .attr = { 1915 .name = "vhost_loc", 1916 .mode = S_IRUGO, 1917 }, 1918 .show = show_host_vhost_loc, 1919 }; 1920 1921 static ssize_t show_host_vhost_name(struct device *dev, 1922 struct device_attribute *attr, char *buf) 1923 { 1924 struct Scsi_Host *shost = class_to_shost(dev); 1925 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1926 int len; 1927 1928 len = snprintf(buf, sizeof(hostdata->caps.name), "%s\n", 1929 hostdata->caps.name); 1930 return len; 1931 } 1932 1933 static struct device_attribute ibmvscsi_host_vhost_name = { 1934 .attr = { 1935 .name = "vhost_name", 1936 .mode = S_IRUGO, 1937 }, 1938 .show = show_host_vhost_name, 1939 }; 1940 1941 static ssize_t show_host_srp_version(struct device *dev, 1942 struct device_attribute *attr, char *buf) 1943 { 1944 struct Scsi_Host *shost = class_to_shost(dev); 1945 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1946 int len; 1947 1948 len = snprintf(buf, PAGE_SIZE, "%s\n", 1949 hostdata->madapter_info.srp_version); 1950 return len; 1951 } 1952 1953 static struct device_attribute ibmvscsi_host_srp_version = { 1954 .attr = { 1955 .name = "srp_version", 1956 .mode = S_IRUGO, 1957 }, 1958 .show = show_host_srp_version, 1959 }; 1960 1961 static ssize_t show_host_partition_name(struct device *dev, 1962 struct device_attribute *attr, 1963 char *buf) 1964 { 1965 struct Scsi_Host *shost = class_to_shost(dev); 1966 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1967 int len; 1968 1969 len = snprintf(buf, PAGE_SIZE, "%s\n", 1970 hostdata->madapter_info.partition_name); 1971 return len; 1972 } 1973 1974 static struct device_attribute ibmvscsi_host_partition_name = { 1975 .attr = { 1976 .name = "partition_name", 1977 .mode = S_IRUGO, 1978 }, 1979 .show = show_host_partition_name, 1980 }; 1981 1982 static ssize_t show_host_partition_number(struct device *dev, 1983 struct device_attribute *attr, 1984 char *buf) 1985 { 1986 struct Scsi_Host *shost = class_to_shost(dev); 1987 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1988 int len; 1989 1990 len = snprintf(buf, PAGE_SIZE, "%d\n", 1991 be32_to_cpu(hostdata->madapter_info.partition_number)); 1992 return len; 1993 } 1994 1995 static struct device_attribute ibmvscsi_host_partition_number = { 1996 .attr = { 1997 .name = "partition_number", 1998 .mode = S_IRUGO, 1999 }, 2000 .show = show_host_partition_number, 2001 }; 2002 2003 static ssize_t show_host_mad_version(struct device *dev, 2004 struct device_attribute *attr, char *buf) 2005 { 2006 struct Scsi_Host *shost = class_to_shost(dev); 2007 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2008 int len; 2009 2010 len = snprintf(buf, PAGE_SIZE, "%d\n", 2011 be32_to_cpu(hostdata->madapter_info.mad_version)); 2012 return len; 2013 } 2014 2015 static struct device_attribute ibmvscsi_host_mad_version = { 2016 .attr = { 2017 .name = "mad_version", 2018 .mode = S_IRUGO, 2019 }, 2020 .show = show_host_mad_version, 2021 }; 2022 2023 static ssize_t show_host_os_type(struct device *dev, 2024 struct device_attribute *attr, char *buf) 2025 { 2026 struct Scsi_Host *shost = class_to_shost(dev); 2027 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2028 int len; 2029 2030 len = snprintf(buf, PAGE_SIZE, "%d\n", 2031 be32_to_cpu(hostdata->madapter_info.os_type)); 2032 return len; 2033 } 2034 2035 static struct device_attribute ibmvscsi_host_os_type = { 2036 .attr = { 2037 .name = "os_type", 2038 .mode = S_IRUGO, 2039 }, 2040 .show = show_host_os_type, 2041 }; 2042 2043 static ssize_t show_host_config(struct device *dev, 2044 struct device_attribute *attr, char *buf) 2045 { 2046 return 0; 2047 } 2048 2049 static struct device_attribute ibmvscsi_host_config = { 2050 .attr = { 2051 .name = "config", 2052 .mode = S_IRUGO, 2053 }, 2054 .show = show_host_config, 2055 }; 2056 2057 static int ibmvscsi_host_reset(struct Scsi_Host *shost, int reset_type) 2058 { 2059 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2060 2061 dev_info(hostdata->dev, "Initiating adapter reset!\n"); 2062 ibmvscsi_reset_host(hostdata); 2063 2064 return 0; 2065 } 2066 2067 static struct device_attribute *ibmvscsi_attrs[] = { 2068 &ibmvscsi_host_vhost_loc, 2069 &ibmvscsi_host_vhost_name, 2070 &ibmvscsi_host_srp_version, 2071 &ibmvscsi_host_partition_name, 2072 &ibmvscsi_host_partition_number, 2073 &ibmvscsi_host_mad_version, 2074 &ibmvscsi_host_os_type, 2075 &ibmvscsi_host_config, 2076 NULL 2077 }; 2078 2079 /* ------------------------------------------------------------ 2080 * SCSI driver registration 2081 */ 2082 static struct scsi_host_template driver_template = { 2083 .module = THIS_MODULE, 2084 .name = "IBM POWER Virtual SCSI Adapter " IBMVSCSI_VERSION, 2085 .proc_name = "ibmvscsi", 2086 .queuecommand = ibmvscsi_queuecommand, 2087 .eh_timed_out = srp_timed_out, 2088 .eh_abort_handler = ibmvscsi_eh_abort_handler, 2089 .eh_device_reset_handler = ibmvscsi_eh_device_reset_handler, 2090 .eh_host_reset_handler = ibmvscsi_eh_host_reset_handler, 2091 .slave_configure = ibmvscsi_slave_configure, 2092 .change_queue_depth = ibmvscsi_change_queue_depth, 2093 .host_reset = ibmvscsi_host_reset, 2094 .cmd_per_lun = IBMVSCSI_CMDS_PER_LUN_DEFAULT, 2095 .can_queue = IBMVSCSI_MAX_REQUESTS_DEFAULT, 2096 .this_id = -1, 2097 .sg_tablesize = SG_ALL, 2098 .shost_attrs = ibmvscsi_attrs, 2099 }; 2100 2101 /** 2102 * ibmvscsi_get_desired_dma - Calculate IO memory desired by the driver 2103 * 2104 * @vdev: struct vio_dev for the device whose desired IO mem is to be returned 2105 * 2106 * Return value: 2107 * Number of bytes of IO data the driver will need to perform well. 2108 */ 2109 static unsigned long ibmvscsi_get_desired_dma(struct vio_dev *vdev) 2110 { 2111 /* iu_storage data allocated in initialize_event_pool */ 2112 unsigned long desired_io = max_events * sizeof(union viosrp_iu); 2113 2114 /* add io space for sg data */ 2115 desired_io += (IBMVSCSI_MAX_SECTORS_DEFAULT * 512 * 2116 IBMVSCSI_CMDS_PER_LUN_DEFAULT); 2117 2118 return desired_io; 2119 } 2120 2121 static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata) 2122 { 2123 unsigned long flags; 2124 int rc; 2125 char *action = "reset"; 2126 2127 spin_lock_irqsave(hostdata->host->host_lock, flags); 2128 switch (hostdata->action) { 2129 case IBMVSCSI_HOST_ACTION_UNBLOCK: 2130 rc = 0; 2131 break; 2132 case IBMVSCSI_HOST_ACTION_RESET: 2133 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 2134 rc = ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata); 2135 spin_lock_irqsave(hostdata->host->host_lock, flags); 2136 if (!rc) 2137 rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0); 2138 vio_enable_interrupts(to_vio_dev(hostdata->dev)); 2139 break; 2140 case IBMVSCSI_HOST_ACTION_REENABLE: 2141 action = "enable"; 2142 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 2143 rc = ibmvscsi_reenable_crq_queue(&hostdata->queue, hostdata); 2144 spin_lock_irqsave(hostdata->host->host_lock, flags); 2145 if (!rc) 2146 rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0); 2147 break; 2148 case IBMVSCSI_HOST_ACTION_NONE: 2149 default: 2150 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 2151 return; 2152 } 2153 2154 hostdata->action = IBMVSCSI_HOST_ACTION_NONE; 2155 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 2156 2157 if (rc) { 2158 ibmvscsi_set_request_limit(hostdata, -1); 2159 dev_err(hostdata->dev, "error after %s\n", action); 2160 } 2161 2162 scsi_unblock_requests(hostdata->host); 2163 } 2164 2165 static int __ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata) 2166 { 2167 if (kthread_should_stop()) 2168 return 1; 2169 switch (hostdata->action) { 2170 case IBMVSCSI_HOST_ACTION_NONE: 2171 return 0; 2172 case IBMVSCSI_HOST_ACTION_RESET: 2173 case IBMVSCSI_HOST_ACTION_REENABLE: 2174 case IBMVSCSI_HOST_ACTION_UNBLOCK: 2175 default: 2176 break; 2177 } 2178 2179 return 1; 2180 } 2181 2182 static int ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata) 2183 { 2184 unsigned long flags; 2185 int rc; 2186 2187 spin_lock_irqsave(hostdata->host->host_lock, flags); 2188 rc = __ibmvscsi_work_to_do(hostdata); 2189 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 2190 2191 return rc; 2192 } 2193 2194 static int ibmvscsi_work(void *data) 2195 { 2196 struct ibmvscsi_host_data *hostdata = data; 2197 int rc; 2198 2199 set_user_nice(current, MIN_NICE); 2200 2201 while (1) { 2202 rc = wait_event_interruptible(hostdata->work_wait_q, 2203 ibmvscsi_work_to_do(hostdata)); 2204 2205 BUG_ON(rc); 2206 2207 if (kthread_should_stop()) 2208 break; 2209 2210 ibmvscsi_do_work(hostdata); 2211 } 2212 2213 return 0; 2214 } 2215 2216 /* 2217 * Called by bus code for each adapter 2218 */ 2219 static int ibmvscsi_probe(struct vio_dev *vdev, const struct vio_device_id *id) 2220 { 2221 struct ibmvscsi_host_data *hostdata; 2222 struct Scsi_Host *host; 2223 struct device *dev = &vdev->dev; 2224 struct srp_rport_identifiers ids; 2225 struct srp_rport *rport; 2226 unsigned long wait_switch = 0; 2227 int rc; 2228 2229 dev_set_drvdata(&vdev->dev, NULL); 2230 2231 host = scsi_host_alloc(&driver_template, sizeof(*hostdata)); 2232 if (!host) { 2233 dev_err(&vdev->dev, "couldn't allocate host data\n"); 2234 goto scsi_host_alloc_failed; 2235 } 2236 2237 host->transportt = ibmvscsi_transport_template; 2238 hostdata = shost_priv(host); 2239 memset(hostdata, 0x00, sizeof(*hostdata)); 2240 INIT_LIST_HEAD(&hostdata->sent); 2241 init_waitqueue_head(&hostdata->work_wait_q); 2242 hostdata->host = host; 2243 hostdata->dev = dev; 2244 ibmvscsi_set_request_limit(hostdata, -1); 2245 hostdata->host->max_sectors = IBMVSCSI_MAX_SECTORS_DEFAULT; 2246 2247 if (map_persist_bufs(hostdata)) { 2248 dev_err(&vdev->dev, "couldn't map persistent buffers\n"); 2249 goto persist_bufs_failed; 2250 } 2251 2252 hostdata->work_thread = kthread_run(ibmvscsi_work, hostdata, "%s_%d", 2253 "ibmvscsi", host->host_no); 2254 2255 if (IS_ERR(hostdata->work_thread)) { 2256 dev_err(&vdev->dev, "couldn't initialize kthread. rc=%ld\n", 2257 PTR_ERR(hostdata->work_thread)); 2258 goto init_crq_failed; 2259 } 2260 2261 rc = ibmvscsi_init_crq_queue(&hostdata->queue, hostdata, max_events); 2262 if (rc != 0 && rc != H_RESOURCE) { 2263 dev_err(&vdev->dev, "couldn't initialize crq. rc=%d\n", rc); 2264 goto kill_kthread; 2265 } 2266 if (initialize_event_pool(&hostdata->pool, max_events, hostdata) != 0) { 2267 dev_err(&vdev->dev, "couldn't initialize event pool\n"); 2268 goto init_pool_failed; 2269 } 2270 2271 host->max_lun = IBMVSCSI_MAX_LUN; 2272 host->max_id = max_id; 2273 host->max_channel = max_channel; 2274 host->max_cmd_len = 16; 2275 2276 dev_info(dev, 2277 "Maximum ID: %d Maximum LUN: %llu Maximum Channel: %d\n", 2278 host->max_id, host->max_lun, host->max_channel); 2279 2280 if (scsi_add_host(hostdata->host, hostdata->dev)) 2281 goto add_host_failed; 2282 2283 /* we don't have a proper target_port_id so let's use the fake one */ 2284 memcpy(ids.port_id, hostdata->madapter_info.partition_name, 2285 sizeof(ids.port_id)); 2286 ids.roles = SRP_RPORT_ROLE_TARGET; 2287 rport = srp_rport_add(host, &ids); 2288 if (IS_ERR(rport)) 2289 goto add_srp_port_failed; 2290 2291 /* Try to send an initialization message. Note that this is allowed 2292 * to fail if the other end is not acive. In that case we don't 2293 * want to scan 2294 */ 2295 if (ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0) == 0 2296 || rc == H_RESOURCE) { 2297 /* 2298 * Wait around max init_timeout secs for the adapter to finish 2299 * initializing. When we are done initializing, we will have a 2300 * valid request_limit. We don't want Linux scanning before 2301 * we are ready. 2302 */ 2303 for (wait_switch = jiffies + (init_timeout * HZ); 2304 time_before(jiffies, wait_switch) && 2305 atomic_read(&hostdata->request_limit) < 2;) { 2306 2307 msleep(10); 2308 } 2309 2310 /* if we now have a valid request_limit, initiate a scan */ 2311 if (atomic_read(&hostdata->request_limit) > 0) 2312 scsi_scan_host(host); 2313 } 2314 2315 dev_set_drvdata(&vdev->dev, hostdata); 2316 spin_lock(&ibmvscsi_driver_lock); 2317 list_add_tail(&hostdata->host_list, &ibmvscsi_head); 2318 spin_unlock(&ibmvscsi_driver_lock); 2319 return 0; 2320 2321 add_srp_port_failed: 2322 scsi_remove_host(hostdata->host); 2323 add_host_failed: 2324 release_event_pool(&hostdata->pool, hostdata); 2325 init_pool_failed: 2326 ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, max_events); 2327 kill_kthread: 2328 kthread_stop(hostdata->work_thread); 2329 init_crq_failed: 2330 unmap_persist_bufs(hostdata); 2331 persist_bufs_failed: 2332 scsi_host_put(host); 2333 scsi_host_alloc_failed: 2334 return -1; 2335 } 2336 2337 static void ibmvscsi_remove(struct vio_dev *vdev) 2338 { 2339 struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev); 2340 2341 srp_remove_host(hostdata->host); 2342 scsi_remove_host(hostdata->host); 2343 2344 purge_requests(hostdata, DID_ERROR); 2345 release_event_pool(&hostdata->pool, hostdata); 2346 2347 ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, 2348 max_events); 2349 2350 kthread_stop(hostdata->work_thread); 2351 unmap_persist_bufs(hostdata); 2352 2353 spin_lock(&ibmvscsi_driver_lock); 2354 list_del(&hostdata->host_list); 2355 spin_unlock(&ibmvscsi_driver_lock); 2356 2357 scsi_host_put(hostdata->host); 2358 } 2359 2360 /** 2361 * ibmvscsi_resume: Resume from suspend 2362 * @dev: device struct 2363 * 2364 * We may have lost an interrupt across suspend/resume, so kick the 2365 * interrupt handler 2366 */ 2367 static int ibmvscsi_resume(struct device *dev) 2368 { 2369 struct ibmvscsi_host_data *hostdata = dev_get_drvdata(dev); 2370 vio_disable_interrupts(to_vio_dev(hostdata->dev)); 2371 tasklet_schedule(&hostdata->srp_task); 2372 2373 return 0; 2374 } 2375 2376 /* 2377 * ibmvscsi_device_table: Used by vio.c to match devices in the device tree we 2378 * support. 2379 */ 2380 static const struct vio_device_id ibmvscsi_device_table[] = { 2381 {"vscsi", "IBM,v-scsi"}, 2382 { "", "" } 2383 }; 2384 MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table); 2385 2386 static const struct dev_pm_ops ibmvscsi_pm_ops = { 2387 .resume = ibmvscsi_resume 2388 }; 2389 2390 static struct vio_driver ibmvscsi_driver = { 2391 .id_table = ibmvscsi_device_table, 2392 .probe = ibmvscsi_probe, 2393 .remove = ibmvscsi_remove, 2394 .get_desired_dma = ibmvscsi_get_desired_dma, 2395 .name = "ibmvscsi", 2396 .pm = &ibmvscsi_pm_ops, 2397 }; 2398 2399 static struct srp_function_template ibmvscsi_transport_functions = { 2400 }; 2401 2402 static int __init ibmvscsi_module_init(void) 2403 { 2404 int ret; 2405 2406 /* Ensure we have two requests to do error recovery */ 2407 driver_template.can_queue = max_requests; 2408 max_events = max_requests + 2; 2409 2410 if (!firmware_has_feature(FW_FEATURE_VIO)) 2411 return -ENODEV; 2412 2413 ibmvscsi_transport_template = 2414 srp_attach_transport(&ibmvscsi_transport_functions); 2415 if (!ibmvscsi_transport_template) 2416 return -ENOMEM; 2417 2418 ret = vio_register_driver(&ibmvscsi_driver); 2419 if (ret) 2420 srp_release_transport(ibmvscsi_transport_template); 2421 return ret; 2422 } 2423 2424 static void __exit ibmvscsi_module_exit(void) 2425 { 2426 vio_unregister_driver(&ibmvscsi_driver); 2427 srp_release_transport(ibmvscsi_transport_template); 2428 } 2429 2430 module_init(ibmvscsi_module_init); 2431 module_exit(ibmvscsi_module_exit); 2432