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