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