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 */ 85static int max_id = 64; 86static int max_channel = 3; 87static int init_timeout = 300; 88static int login_timeout = 60; 89static int info_timeout = 30; 90static int abort_timeout = 60; 91static int reset_timeout = 60; 92static int max_requests = IBMVSCSI_MAX_REQUESTS_DEFAULT; 93static int max_events = IBMVSCSI_MAX_REQUESTS_DEFAULT + 2; 94static int fast_fail = 1; 95static int client_reserve = 1; 96static char partition_name[97] = "UNKNOWN"; 97static unsigned int partition_number = -1; 98 99static struct scsi_transport_template *ibmvscsi_transport_template; 100 101#define IBMVSCSI_VERSION "1.5.9" 102 103MODULE_DESCRIPTION("IBM Virtual SCSI"); 104MODULE_AUTHOR("Dave Boutcher"); 105MODULE_LICENSE("GPL"); 106MODULE_VERSION(IBMVSCSI_VERSION); 107 108module_param_named(max_id, max_id, int, S_IRUGO | S_IWUSR); 109MODULE_PARM_DESC(max_id, "Largest ID value for each channel"); 110module_param_named(max_channel, max_channel, int, S_IRUGO | S_IWUSR); 111MODULE_PARM_DESC(max_channel, "Largest channel value"); 112module_param_named(init_timeout, init_timeout, int, S_IRUGO | S_IWUSR); 113MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds"); 114module_param_named(max_requests, max_requests, int, S_IRUGO); 115MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter"); 116module_param_named(fast_fail, fast_fail, int, S_IRUGO | S_IWUSR); 117MODULE_PARM_DESC(fast_fail, "Enable fast fail. [Default=1]"); 118module_param_named(client_reserve, client_reserve, int, S_IRUGO ); 119MODULE_PARM_DESC(client_reserve, "Attempt client managed reserve/release"); 120 121static void ibmvscsi_handle_crq(struct viosrp_crq *crq, 122 struct ibmvscsi_host_data *hostdata); 123 124/* ------------------------------------------------------------ 125 * Routines for managing the command/response queue 126 */ 127/** 128 * ibmvscsi_handle_event: - Interrupt handler for crq events 129 * @irq: number of irq to handle, not used 130 * @dev_instance: ibmvscsi_host_data of host that received interrupt 131 * 132 * Disables interrupts and schedules srp_task 133 * Always returns IRQ_HANDLED 134 */ 135static irqreturn_t ibmvscsi_handle_event(int irq, void *dev_instance) 136{ 137 struct ibmvscsi_host_data *hostdata = 138 (struct ibmvscsi_host_data *)dev_instance; 139 vio_disable_interrupts(to_vio_dev(hostdata->dev)); 140 tasklet_schedule(&hostdata->srp_task); 141 return IRQ_HANDLED; 142} 143 144/** 145 * release_crq_queue: - Deallocates data and unregisters CRQ 146 * @queue: crq_queue to initialize and register 147 * @host_data: ibmvscsi_host_data of host 148 * 149 * Frees irq, deallocates a page for messages, unmaps dma, and unregisters 150 * the crq with the hypervisor. 151 */ 152static void ibmvscsi_release_crq_queue(struct crq_queue *queue, 153 struct ibmvscsi_host_data *hostdata, 154 int max_requests) 155{ 156 long rc = 0; 157 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 158 free_irq(vdev->irq, (void *)hostdata); 159 tasklet_kill(&hostdata->srp_task); 160 do { 161 if (rc) 162 msleep(100); 163 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 164 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 165 dma_unmap_single(hostdata->dev, 166 queue->msg_token, 167 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); 168 free_page((unsigned long)queue->msgs); 169} 170 171/** 172 * crq_queue_next_crq: - Returns the next entry in message queue 173 * @queue: crq_queue to use 174 * 175 * Returns pointer to next entry in queue, or NULL if there are no new 176 * entried in the CRQ. 177 */ 178static struct viosrp_crq *crq_queue_next_crq(struct crq_queue *queue) 179{ 180 struct viosrp_crq *crq; 181 unsigned long flags; 182 183 spin_lock_irqsave(&queue->lock, flags); 184 crq = &queue->msgs[queue->cur]; 185 if (crq->valid & 0x80) { 186 if (++queue->cur == queue->size) 187 queue->cur = 0; 188 189 /* Ensure the read of the valid bit occurs before reading any 190 * other bits of the CRQ entry 191 */ 192 rmb(); 193 } else 194 crq = NULL; 195 spin_unlock_irqrestore(&queue->lock, flags); 196 197 return crq; 198} 199 200/** 201 * ibmvscsi_send_crq: - Send a CRQ 202 * @hostdata: the adapter 203 * @word1: the first 64 bits of the data 204 * @word2: the second 64 bits of the data 205 */ 206static int ibmvscsi_send_crq(struct ibmvscsi_host_data *hostdata, 207 u64 word1, u64 word2) 208{ 209 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 210 211 /* 212 * Ensure the command buffer is flushed to memory before handing it 213 * over to the VIOS to prevent it from fetching any stale data. 214 */ 215 mb(); 216 return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2); 217} 218 219/** 220 * ibmvscsi_task: - Process srps asynchronously 221 * @data: ibmvscsi_host_data of host 222 */ 223static void ibmvscsi_task(void *data) 224{ 225 struct ibmvscsi_host_data *hostdata = (struct ibmvscsi_host_data *)data; 226 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 227 struct viosrp_crq *crq; 228 int done = 0; 229 230 while (!done) { 231 /* Pull all the valid messages off the CRQ */ 232 while ((crq = crq_queue_next_crq(&hostdata->queue)) != NULL) { 233 ibmvscsi_handle_crq(crq, hostdata); 234 crq->valid = 0x00; 235 } 236 237 vio_enable_interrupts(vdev); 238 crq = crq_queue_next_crq(&hostdata->queue); 239 if (crq != NULL) { 240 vio_disable_interrupts(vdev); 241 ibmvscsi_handle_crq(crq, hostdata); 242 crq->valid = 0x00; 243 } else { 244 done = 1; 245 } 246 } 247} 248 249static void gather_partition_info(void) 250{ 251 struct device_node *rootdn; 252 253 const char *ppartition_name; 254 const __be32 *p_number_ptr; 255 256 /* Retrieve information about this partition */ 257 rootdn = of_find_node_by_path("/"); 258 if (!rootdn) { 259 return; 260 } 261 262 ppartition_name = of_get_property(rootdn, "ibm,partition-name", NULL); 263 if (ppartition_name) 264 strncpy(partition_name, ppartition_name, 265 sizeof(partition_name)); 266 p_number_ptr = of_get_property(rootdn, "ibm,partition-no", NULL); 267 if (p_number_ptr) 268 partition_number = of_read_number(p_number_ptr, 1); 269 of_node_put(rootdn); 270} 271 272static void set_adapter_info(struct ibmvscsi_host_data *hostdata) 273{ 274 memset(&hostdata->madapter_info, 0x00, 275 sizeof(hostdata->madapter_info)); 276 277 dev_info(hostdata->dev, "SRP_VERSION: %s\n", SRP_VERSION); 278 strcpy(hostdata->madapter_info.srp_version, SRP_VERSION); 279 280 strncpy(hostdata->madapter_info.partition_name, partition_name, 281 sizeof(hostdata->madapter_info.partition_name)); 282 283 hostdata->madapter_info.partition_number = 284 cpu_to_be32(partition_number); 285 286 hostdata->madapter_info.mad_version = cpu_to_be32(1); 287 hostdata->madapter_info.os_type = cpu_to_be32(2); 288} 289 290/** 291 * reset_crq_queue: - resets a crq after a failure 292 * @queue: crq_queue to initialize and register 293 * @hostdata: ibmvscsi_host_data of host 294 * 295 */ 296static int ibmvscsi_reset_crq_queue(struct crq_queue *queue, 297 struct ibmvscsi_host_data *hostdata) 298{ 299 int rc = 0; 300 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 301 302 /* Close the CRQ */ 303 do { 304 if (rc) 305 msleep(100); 306 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 307 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 308 309 /* Clean out the queue */ 310 memset(queue->msgs, 0x00, PAGE_SIZE); 311 queue->cur = 0; 312 313 set_adapter_info(hostdata); 314 315 /* And re-open it again */ 316 rc = plpar_hcall_norets(H_REG_CRQ, 317 vdev->unit_address, 318 queue->msg_token, PAGE_SIZE); 319 if (rc == 2) { 320 /* Adapter is good, but other end is not ready */ 321 dev_warn(hostdata->dev, "Partner adapter not ready\n"); 322 } else if (rc != 0) { 323 dev_warn(hostdata->dev, "couldn't register crq--rc 0x%x\n", rc); 324 } 325 return rc; 326} 327 328/** 329 * initialize_crq_queue: - Initializes and registers CRQ with hypervisor 330 * @queue: crq_queue to initialize and register 331 * @hostdata: ibmvscsi_host_data of host 332 * 333 * Allocates a page for messages, maps it for dma, and registers 334 * the crq with the hypervisor. 335 * Returns zero on success. 336 */ 337static int ibmvscsi_init_crq_queue(struct crq_queue *queue, 338 struct ibmvscsi_host_data *hostdata, 339 int max_requests) 340{ 341 int rc; 342 int retrc; 343 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 344 345 queue->msgs = (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL); 346 347 if (!queue->msgs) 348 goto malloc_failed; 349 queue->size = PAGE_SIZE / sizeof(*queue->msgs); 350 351 queue->msg_token = dma_map_single(hostdata->dev, queue->msgs, 352 queue->size * sizeof(*queue->msgs), 353 DMA_BIDIRECTIONAL); 354 355 if (dma_mapping_error(hostdata->dev, queue->msg_token)) 356 goto map_failed; 357 358 gather_partition_info(); 359 set_adapter_info(hostdata); 360 361 retrc = rc = plpar_hcall_norets(H_REG_CRQ, 362 vdev->unit_address, 363 queue->msg_token, PAGE_SIZE); 364 if (rc == H_RESOURCE) 365 /* maybe kexecing and resource is busy. try a reset */ 366 rc = ibmvscsi_reset_crq_queue(queue, 367 hostdata); 368 369 if (rc == 2) { 370 /* Adapter is good, but other end is not ready */ 371 dev_warn(hostdata->dev, "Partner adapter not ready\n"); 372 retrc = 0; 373 } else if (rc != 0) { 374 dev_warn(hostdata->dev, "Error %d opening adapter\n", rc); 375 goto reg_crq_failed; 376 } 377 378 queue->cur = 0; 379 spin_lock_init(&queue->lock); 380 381 tasklet_init(&hostdata->srp_task, (void *)ibmvscsi_task, 382 (unsigned long)hostdata); 383 384 if (request_irq(vdev->irq, 385 ibmvscsi_handle_event, 386 0, "ibmvscsi", (void *)hostdata) != 0) { 387 dev_err(hostdata->dev, "couldn't register irq 0x%x\n", 388 vdev->irq); 389 goto req_irq_failed; 390 } 391 392 rc = vio_enable_interrupts(vdev); 393 if (rc != 0) { 394 dev_err(hostdata->dev, "Error %d enabling interrupts!!!\n", rc); 395 goto req_irq_failed; 396 } 397 398 return retrc; 399 400 req_irq_failed: 401 tasklet_kill(&hostdata->srp_task); 402 rc = 0; 403 do { 404 if (rc) 405 msleep(100); 406 rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address); 407 } while ((rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 408 reg_crq_failed: 409 dma_unmap_single(hostdata->dev, 410 queue->msg_token, 411 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); 412 map_failed: 413 free_page((unsigned long)queue->msgs); 414 malloc_failed: 415 return -1; 416} 417 418/** 419 * reenable_crq_queue: - reenables a crq after 420 * @queue: crq_queue to initialize and register 421 * @hostdata: ibmvscsi_host_data of host 422 * 423 */ 424static int ibmvscsi_reenable_crq_queue(struct crq_queue *queue, 425 struct ibmvscsi_host_data *hostdata) 426{ 427 int rc = 0; 428 struct vio_dev *vdev = to_vio_dev(hostdata->dev); 429 430 /* Re-enable the CRQ */ 431 do { 432 if (rc) 433 msleep(100); 434 rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address); 435 } while ((rc == H_IN_PROGRESS) || (rc == H_BUSY) || (H_IS_LONG_BUSY(rc))); 436 437 if (rc) 438 dev_err(hostdata->dev, "Error %d enabling adapter\n", rc); 439 return rc; 440} 441 442/* ------------------------------------------------------------ 443 * Routines for the event pool and event structs 444 */ 445/** 446 * initialize_event_pool: - Allocates and initializes the event pool for a host 447 * @pool: event_pool to be initialized 448 * @size: Number of events in pool 449 * @hostdata: ibmvscsi_host_data who owns the event pool 450 * 451 * Returns zero on success. 452*/ 453static int initialize_event_pool(struct event_pool *pool, 454 int size, struct ibmvscsi_host_data *hostdata) 455{ 456 int i; 457 458 pool->size = size; 459 pool->next = 0; 460 pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL); 461 if (!pool->events) 462 return -ENOMEM; 463 464 pool->iu_storage = 465 dma_alloc_coherent(hostdata->dev, 466 pool->size * sizeof(*pool->iu_storage), 467 &pool->iu_token, 0); 468 if (!pool->iu_storage) { 469 kfree(pool->events); 470 return -ENOMEM; 471 } 472 473 for (i = 0; i < pool->size; ++i) { 474 struct srp_event_struct *evt = &pool->events[i]; 475 memset(&evt->crq, 0x00, sizeof(evt->crq)); 476 atomic_set(&evt->free, 1); 477 evt->crq.valid = 0x80; 478 evt->crq.IU_length = cpu_to_be16(sizeof(*evt->xfer_iu)); 479 evt->crq.IU_data_ptr = cpu_to_be64(pool->iu_token + 480 sizeof(*evt->xfer_iu) * i); 481 evt->xfer_iu = pool->iu_storage + i; 482 evt->hostdata = hostdata; 483 evt->ext_list = NULL; 484 evt->ext_list_token = 0; 485 } 486 487 return 0; 488} 489 490/** 491 * release_event_pool: - Frees memory of an event pool of a host 492 * @pool: event_pool to be released 493 * @hostdata: ibmvscsi_host_data who owns the even pool 494 * 495 * Returns zero on success. 496*/ 497static void release_event_pool(struct event_pool *pool, 498 struct ibmvscsi_host_data *hostdata) 499{ 500 int i, in_use = 0; 501 for (i = 0; i < pool->size; ++i) { 502 if (atomic_read(&pool->events[i].free) != 1) 503 ++in_use; 504 if (pool->events[i].ext_list) { 505 dma_free_coherent(hostdata->dev, 506 SG_ALL * sizeof(struct srp_direct_buf), 507 pool->events[i].ext_list, 508 pool->events[i].ext_list_token); 509 } 510 } 511 if (in_use) 512 dev_warn(hostdata->dev, "releasing event pool with %d " 513 "events still in use?\n", in_use); 514 kfree(pool->events); 515 dma_free_coherent(hostdata->dev, 516 pool->size * sizeof(*pool->iu_storage), 517 pool->iu_storage, pool->iu_token); 518} 519 520/** 521 * valid_event_struct: - Determines if event is valid. 522 * @pool: event_pool that contains the event 523 * @evt: srp_event_struct to be checked for validity 524 * 525 * Returns zero if event is invalid, one otherwise. 526*/ 527static int valid_event_struct(struct event_pool *pool, 528 struct srp_event_struct *evt) 529{ 530 int index = evt - pool->events; 531 if (index < 0 || index >= pool->size) /* outside of bounds */ 532 return 0; 533 if (evt != pool->events + index) /* unaligned */ 534 return 0; 535 return 1; 536} 537 538/** 539 * ibmvscsi_free-event_struct: - Changes status of event to "free" 540 * @pool: event_pool that contains the event 541 * @evt: srp_event_struct to be modified 542 * 543*/ 544static void free_event_struct(struct event_pool *pool, 545 struct srp_event_struct *evt) 546{ 547 if (!valid_event_struct(pool, evt)) { 548 dev_err(evt->hostdata->dev, "Freeing invalid event_struct %p " 549 "(not in pool %p)\n", evt, pool->events); 550 return; 551 } 552 if (atomic_inc_return(&evt->free) != 1) { 553 dev_err(evt->hostdata->dev, "Freeing event_struct %p " 554 "which is not in use!\n", evt); 555 return; 556 } 557} 558 559/** 560 * get_evt_struct: - Gets the next free event in pool 561 * @pool: event_pool that contains the events to be searched 562 * 563 * Returns the next event in "free" state, and NULL if none are free. 564 * Note that no synchronization is done here, we assume the host_lock 565 * will syncrhonze things. 566*/ 567static struct srp_event_struct *get_event_struct(struct event_pool *pool) 568{ 569 int i; 570 int poolsize = pool->size; 571 int offset = pool->next; 572 573 for (i = 0; i < poolsize; i++) { 574 offset = (offset + 1) % poolsize; 575 if (!atomic_dec_if_positive(&pool->events[offset].free)) { 576 pool->next = offset; 577 return &pool->events[offset]; 578 } 579 } 580 581 printk(KERN_ERR "ibmvscsi: found no event struct in pool!\n"); 582 return NULL; 583} 584 585/** 586 * init_event_struct: Initialize fields in an event struct that are always 587 * required. 588 * @evt: The event 589 * @done: Routine to call when the event is responded to 590 * @format: SRP or MAD format 591 * @timeout: timeout value set in the CRQ 592 */ 593static void init_event_struct(struct srp_event_struct *evt_struct, 594 void (*done) (struct srp_event_struct *), 595 u8 format, 596 int timeout) 597{ 598 evt_struct->cmnd = NULL; 599 evt_struct->cmnd_done = NULL; 600 evt_struct->sync_srp = NULL; 601 evt_struct->crq.format = format; 602 evt_struct->crq.timeout = cpu_to_be16(timeout); 603 evt_struct->done = done; 604} 605 606/* ------------------------------------------------------------ 607 * Routines for receiving SCSI responses from the hosting partition 608 */ 609 610/** 611 * set_srp_direction: Set the fields in the srp related to data 612 * direction and number of buffers based on the direction in 613 * the scsi_cmnd and the number of buffers 614 */ 615static void set_srp_direction(struct scsi_cmnd *cmd, 616 struct srp_cmd *srp_cmd, 617 int numbuf) 618{ 619 u8 fmt; 620 621 if (numbuf == 0) 622 return; 623 624 if (numbuf == 1) 625 fmt = SRP_DATA_DESC_DIRECT; 626 else { 627 fmt = SRP_DATA_DESC_INDIRECT; 628 numbuf = min(numbuf, MAX_INDIRECT_BUFS); 629 630 if (cmd->sc_data_direction == DMA_TO_DEVICE) 631 srp_cmd->data_out_desc_cnt = numbuf; 632 else 633 srp_cmd->data_in_desc_cnt = numbuf; 634 } 635 636 if (cmd->sc_data_direction == DMA_TO_DEVICE) 637 srp_cmd->buf_fmt = fmt << 4; 638 else 639 srp_cmd->buf_fmt = fmt; 640} 641 642/** 643 * unmap_cmd_data: - Unmap data pointed in srp_cmd based on the format 644 * @cmd: srp_cmd whose additional_data member will be unmapped 645 * @dev: device for which the memory is mapped 646 * 647*/ 648static void unmap_cmd_data(struct srp_cmd *cmd, 649 struct srp_event_struct *evt_struct, 650 struct device *dev) 651{ 652 u8 out_fmt, in_fmt; 653 654 out_fmt = cmd->buf_fmt >> 4; 655 in_fmt = cmd->buf_fmt & ((1U << 4) - 1); 656 657 if (out_fmt == SRP_NO_DATA_DESC && in_fmt == SRP_NO_DATA_DESC) 658 return; 659 660 if (evt_struct->cmnd) 661 scsi_dma_unmap(evt_struct->cmnd); 662} 663 664static int map_sg_list(struct scsi_cmnd *cmd, int nseg, 665 struct srp_direct_buf *md) 666{ 667 int i; 668 struct scatterlist *sg; 669 u64 total_length = 0; 670 671 scsi_for_each_sg(cmd, sg, nseg, i) { 672 struct srp_direct_buf *descr = md + i; 673 descr->va = cpu_to_be64(sg_dma_address(sg)); 674 descr->len = cpu_to_be32(sg_dma_len(sg)); 675 descr->key = 0; 676 total_length += sg_dma_len(sg); 677 } 678 return total_length; 679} 680 681/** 682 * map_sg_data: - Maps dma for a scatterlist and initializes decriptor fields 683 * @cmd: Scsi_Cmnd with the scatterlist 684 * @srp_cmd: srp_cmd that contains the memory descriptor 685 * @dev: device for which to map dma memory 686 * 687 * Called by map_data_for_srp_cmd() when building srp cmd from scsi cmd. 688 * Returns 1 on success. 689*/ 690static int map_sg_data(struct scsi_cmnd *cmd, 691 struct srp_event_struct *evt_struct, 692 struct srp_cmd *srp_cmd, struct device *dev) 693{ 694 695 int sg_mapped; 696 u64 total_length = 0; 697 struct srp_direct_buf *data = 698 (struct srp_direct_buf *) srp_cmd->add_data; 699 struct srp_indirect_buf *indirect = 700 (struct srp_indirect_buf *) data; 701 702 sg_mapped = scsi_dma_map(cmd); 703 if (!sg_mapped) 704 return 1; 705 else if (sg_mapped < 0) 706 return 0; 707 708 set_srp_direction(cmd, srp_cmd, sg_mapped); 709 710 /* special case; we can use a single direct descriptor */ 711 if (sg_mapped == 1) { 712 map_sg_list(cmd, sg_mapped, data); 713 return 1; 714 } 715 716 indirect->table_desc.va = 0; 717 indirect->table_desc.len = cpu_to_be32(sg_mapped * 718 sizeof(struct srp_direct_buf)); 719 indirect->table_desc.key = 0; 720 721 if (sg_mapped <= MAX_INDIRECT_BUFS) { 722 total_length = map_sg_list(cmd, sg_mapped, 723 &indirect->desc_list[0]); 724 indirect->len = cpu_to_be32(total_length); 725 return 1; 726 } 727 728 /* get indirect table */ 729 if (!evt_struct->ext_list) { 730 evt_struct->ext_list = (struct srp_direct_buf *) 731 dma_alloc_coherent(dev, 732 SG_ALL * sizeof(struct srp_direct_buf), 733 &evt_struct->ext_list_token, 0); 734 if (!evt_struct->ext_list) { 735 if (!firmware_has_feature(FW_FEATURE_CMO)) 736 sdev_printk(KERN_ERR, cmd->device, 737 "Can't allocate memory " 738 "for indirect table\n"); 739 scsi_dma_unmap(cmd); 740 return 0; 741 } 742 } 743 744 total_length = map_sg_list(cmd, sg_mapped, evt_struct->ext_list); 745 746 indirect->len = cpu_to_be32(total_length); 747 indirect->table_desc.va = cpu_to_be64(evt_struct->ext_list_token); 748 indirect->table_desc.len = cpu_to_be32(sg_mapped * 749 sizeof(indirect->desc_list[0])); 750 memcpy(indirect->desc_list, evt_struct->ext_list, 751 MAX_INDIRECT_BUFS * sizeof(struct srp_direct_buf)); 752 return 1; 753} 754 755/** 756 * map_data_for_srp_cmd: - Calls functions to map data for srp cmds 757 * @cmd: struct scsi_cmnd with the memory to be mapped 758 * @srp_cmd: srp_cmd that contains the memory descriptor 759 * @dev: dma device for which to map dma memory 760 * 761 * Called by scsi_cmd_to_srp_cmd() when converting scsi cmds to srp cmds 762 * Returns 1 on success. 763*/ 764static int map_data_for_srp_cmd(struct scsi_cmnd *cmd, 765 struct srp_event_struct *evt_struct, 766 struct srp_cmd *srp_cmd, struct device *dev) 767{ 768 switch (cmd->sc_data_direction) { 769 case DMA_FROM_DEVICE: 770 case DMA_TO_DEVICE: 771 break; 772 case DMA_NONE: 773 return 1; 774 case DMA_BIDIRECTIONAL: 775 sdev_printk(KERN_ERR, cmd->device, 776 "Can't map DMA_BIDIRECTIONAL to read/write\n"); 777 return 0; 778 default: 779 sdev_printk(KERN_ERR, cmd->device, 780 "Unknown data direction 0x%02x; can't map!\n", 781 cmd->sc_data_direction); 782 return 0; 783 } 784 785 return map_sg_data(cmd, evt_struct, srp_cmd, dev); 786} 787 788/** 789 * purge_requests: Our virtual adapter just shut down. purge any sent requests 790 * @hostdata: the adapter 791 */ 792static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code) 793{ 794 struct srp_event_struct *evt; 795 unsigned long flags; 796 797 spin_lock_irqsave(hostdata->host->host_lock, flags); 798 while (!list_empty(&hostdata->sent)) { 799 evt = list_first_entry(&hostdata->sent, struct srp_event_struct, list); 800 list_del(&evt->list); 801 del_timer(&evt->timer); 802 803 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 804 if (evt->cmnd) { 805 evt->cmnd->result = (error_code << 16); 806 unmap_cmd_data(&evt->iu.srp.cmd, evt, 807 evt->hostdata->dev); 808 if (evt->cmnd_done) 809 evt->cmnd_done(evt->cmnd); 810 } else if (evt->done && evt->crq.format != VIOSRP_MAD_FORMAT && 811 evt->iu.srp.login_req.opcode != SRP_LOGIN_REQ) 812 evt->done(evt); 813 free_event_struct(&evt->hostdata->pool, evt); 814 spin_lock_irqsave(hostdata->host->host_lock, flags); 815 } 816 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 817} 818 819/** 820 * ibmvscsi_reset_host - Reset the connection to the server 821 * @hostdata: struct ibmvscsi_host_data to reset 822*/ 823static void ibmvscsi_reset_host(struct ibmvscsi_host_data *hostdata) 824{ 825 scsi_block_requests(hostdata->host); 826 atomic_set(&hostdata->request_limit, 0); 827 828 purge_requests(hostdata, DID_ERROR); 829 hostdata->reset_crq = 1; 830 wake_up(&hostdata->work_wait_q); 831} 832 833/** 834 * ibmvscsi_timeout - Internal command timeout handler 835 * @evt_struct: struct srp_event_struct that timed out 836 * 837 * Called when an internally generated command times out 838*/ 839static void ibmvscsi_timeout(struct srp_event_struct *evt_struct) 840{ 841 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 842 843 dev_err(hostdata->dev, "Command timed out (%x). Resetting connection\n", 844 evt_struct->iu.srp.cmd.opcode); 845 846 ibmvscsi_reset_host(hostdata); 847} 848 849 850/* ------------------------------------------------------------ 851 * Routines for sending and receiving SRPs 852 */ 853/** 854 * ibmvscsi_send_srp_event: - Transforms event to u64 array and calls send_crq() 855 * @evt_struct: evt_struct to be sent 856 * @hostdata: ibmvscsi_host_data of host 857 * @timeout: timeout in seconds - 0 means do not time command 858 * 859 * Returns the value returned from ibmvscsi_send_crq(). (Zero for success) 860 * Note that this routine assumes that host_lock is held for synchronization 861*/ 862static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct, 863 struct ibmvscsi_host_data *hostdata, 864 unsigned long timeout) 865{ 866 __be64 *crq_as_u64 = (__be64 *)&evt_struct->crq; 867 int request_status = 0; 868 int rc; 869 int srp_req = 0; 870 871 /* If we have exhausted our request limit, just fail this request, 872 * unless it is for a reset or abort. 873 * Note that there are rare cases involving driver generated requests 874 * (such as task management requests) that the mid layer may think we 875 * can handle more requests (can_queue) when we actually can't 876 */ 877 if (evt_struct->crq.format == VIOSRP_SRP_FORMAT) { 878 srp_req = 1; 879 request_status = 880 atomic_dec_if_positive(&hostdata->request_limit); 881 /* If request limit was -1 when we started, it is now even 882 * less than that 883 */ 884 if (request_status < -1) 885 goto send_error; 886 /* Otherwise, we may have run out of requests. */ 887 /* If request limit was 0 when we started the adapter is in the 888 * process of performing a login with the server adapter, or 889 * we may have run out of requests. 890 */ 891 else if (request_status == -1 && 892 evt_struct->iu.srp.login_req.opcode != SRP_LOGIN_REQ) 893 goto send_busy; 894 /* Abort and reset calls should make it through. 895 * Nothing except abort and reset should use the last two 896 * slots unless we had two or less to begin with. 897 */ 898 else if (request_status < 2 && 899 evt_struct->iu.srp.cmd.opcode != SRP_TSK_MGMT) { 900 /* In the case that we have less than two requests 901 * available, check the server limit as a combination 902 * of the request limit and the number of requests 903 * in-flight (the size of the send list). If the 904 * server limit is greater than 2, return busy so 905 * that the last two are reserved for reset and abort. 906 */ 907 int server_limit = request_status; 908 struct srp_event_struct *tmp_evt; 909 910 list_for_each_entry(tmp_evt, &hostdata->sent, list) { 911 server_limit++; 912 } 913 914 if (server_limit > 2) 915 goto send_busy; 916 } 917 } 918 919 /* Copy the IU into the transfer area */ 920 *evt_struct->xfer_iu = evt_struct->iu; 921 evt_struct->xfer_iu->srp.rsp.tag = (u64)evt_struct; 922 923 /* Add this to the sent list. We need to do this 924 * before we actually send 925 * in case it comes back REALLY fast 926 */ 927 list_add_tail(&evt_struct->list, &hostdata->sent); 928 929 init_timer(&evt_struct->timer); 930 if (timeout) { 931 evt_struct->timer.data = (unsigned long) evt_struct; 932 evt_struct->timer.expires = jiffies + (timeout * HZ); 933 evt_struct->timer.function = (void (*)(unsigned long))ibmvscsi_timeout; 934 add_timer(&evt_struct->timer); 935 } 936 937 rc = ibmvscsi_send_crq(hostdata, be64_to_cpu(crq_as_u64[0]), 938 be64_to_cpu(crq_as_u64[1])); 939 if (rc != 0) { 940 list_del(&evt_struct->list); 941 del_timer(&evt_struct->timer); 942 943 /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY. 944 * Firmware will send a CRQ with a transport event (0xFF) to 945 * tell this client what has happened to the transport. This 946 * will be handled in ibmvscsi_handle_crq() 947 */ 948 if (rc == H_CLOSED) { 949 dev_warn(hostdata->dev, "send warning. " 950 "Receive queue closed, will retry.\n"); 951 goto send_busy; 952 } 953 dev_err(hostdata->dev, "send error %d\n", rc); 954 if (srp_req) 955 atomic_inc(&hostdata->request_limit); 956 goto send_error; 957 } 958 959 return 0; 960 961 send_busy: 962 unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev); 963 964 free_event_struct(&hostdata->pool, evt_struct); 965 if (srp_req && request_status != -1) 966 atomic_inc(&hostdata->request_limit); 967 return SCSI_MLQUEUE_HOST_BUSY; 968 969 send_error: 970 unmap_cmd_data(&evt_struct->iu.srp.cmd, evt_struct, hostdata->dev); 971 972 if (evt_struct->cmnd != NULL) { 973 evt_struct->cmnd->result = DID_ERROR << 16; 974 evt_struct->cmnd_done(evt_struct->cmnd); 975 } else if (evt_struct->done) 976 evt_struct->done(evt_struct); 977 978 free_event_struct(&hostdata->pool, evt_struct); 979 return 0; 980} 981 982/** 983 * handle_cmd_rsp: - Handle responses from commands 984 * @evt_struct: srp_event_struct to be handled 985 * 986 * Used as a callback by when sending scsi cmds. 987 * Gets called by ibmvscsi_handle_crq() 988*/ 989static void handle_cmd_rsp(struct srp_event_struct *evt_struct) 990{ 991 struct srp_rsp *rsp = &evt_struct->xfer_iu->srp.rsp; 992 struct scsi_cmnd *cmnd = evt_struct->cmnd; 993 994 if (unlikely(rsp->opcode != SRP_RSP)) { 995 if (printk_ratelimit()) 996 dev_warn(evt_struct->hostdata->dev, 997 "bad SRP RSP type %d\n", rsp->opcode); 998 } 999 1000 if (cmnd) { 1001 cmnd->result |= rsp->status; 1002 if (((cmnd->result >> 1) & 0x1f) == CHECK_CONDITION) 1003 memcpy(cmnd->sense_buffer, 1004 rsp->data, 1005 be32_to_cpu(rsp->sense_data_len)); 1006 unmap_cmd_data(&evt_struct->iu.srp.cmd, 1007 evt_struct, 1008 evt_struct->hostdata->dev); 1009 1010 if (rsp->flags & SRP_RSP_FLAG_DOOVER) 1011 scsi_set_resid(cmnd, 1012 be32_to_cpu(rsp->data_out_res_cnt)); 1013 else if (rsp->flags & SRP_RSP_FLAG_DIOVER) 1014 scsi_set_resid(cmnd, be32_to_cpu(rsp->data_in_res_cnt)); 1015 } 1016 1017 if (evt_struct->cmnd_done) 1018 evt_struct->cmnd_done(cmnd); 1019} 1020 1021/** 1022 * lun_from_dev: - Returns the lun of the scsi device 1023 * @dev: struct scsi_device 1024 * 1025*/ 1026static inline u16 lun_from_dev(struct scsi_device *dev) 1027{ 1028 return (0x2 << 14) | (dev->id << 8) | (dev->channel << 5) | dev->lun; 1029} 1030 1031/** 1032 * ibmvscsi_queue: - The queuecommand function of the scsi template 1033 * @cmd: struct scsi_cmnd to be executed 1034 * @done: Callback function to be called when cmd is completed 1035*/ 1036static int ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd, 1037 void (*done) (struct scsi_cmnd *)) 1038{ 1039 struct srp_cmd *srp_cmd; 1040 struct srp_event_struct *evt_struct; 1041 struct srp_indirect_buf *indirect; 1042 struct ibmvscsi_host_data *hostdata = shost_priv(cmnd->device->host); 1043 u16 lun = lun_from_dev(cmnd->device); 1044 u8 out_fmt, in_fmt; 1045 1046 cmnd->result = (DID_OK << 16); 1047 evt_struct = get_event_struct(&hostdata->pool); 1048 if (!evt_struct) 1049 return SCSI_MLQUEUE_HOST_BUSY; 1050 1051 /* Set up the actual SRP IU */ 1052 srp_cmd = &evt_struct->iu.srp.cmd; 1053 memset(srp_cmd, 0x00, SRP_MAX_IU_LEN); 1054 srp_cmd->opcode = SRP_CMD; 1055 memcpy(srp_cmd->cdb, cmnd->cmnd, sizeof(srp_cmd->cdb)); 1056 srp_cmd->lun = cpu_to_be64(((u64)lun) << 48); 1057 1058 if (!map_data_for_srp_cmd(cmnd, evt_struct, srp_cmd, hostdata->dev)) { 1059 if (!firmware_has_feature(FW_FEATURE_CMO)) 1060 sdev_printk(KERN_ERR, cmnd->device, 1061 "couldn't convert cmd to srp_cmd\n"); 1062 free_event_struct(&hostdata->pool, evt_struct); 1063 return SCSI_MLQUEUE_HOST_BUSY; 1064 } 1065 1066 init_event_struct(evt_struct, 1067 handle_cmd_rsp, 1068 VIOSRP_SRP_FORMAT, 1069 cmnd->request->timeout/HZ); 1070 1071 evt_struct->cmnd = cmnd; 1072 evt_struct->cmnd_done = done; 1073 1074 /* Fix up dma address of the buffer itself */ 1075 indirect = (struct srp_indirect_buf *) srp_cmd->add_data; 1076 out_fmt = srp_cmd->buf_fmt >> 4; 1077 in_fmt = srp_cmd->buf_fmt & ((1U << 4) - 1); 1078 if ((in_fmt == SRP_DATA_DESC_INDIRECT || 1079 out_fmt == SRP_DATA_DESC_INDIRECT) && 1080 indirect->table_desc.va == 0) { 1081 indirect->table_desc.va = 1082 cpu_to_be64(be64_to_cpu(evt_struct->crq.IU_data_ptr) + 1083 offsetof(struct srp_cmd, add_data) + 1084 offsetof(struct srp_indirect_buf, desc_list)); 1085 } 1086 1087 return ibmvscsi_send_srp_event(evt_struct, hostdata, 0); 1088} 1089 1090static DEF_SCSI_QCMD(ibmvscsi_queuecommand) 1091 1092/* ------------------------------------------------------------ 1093 * Routines for driver initialization 1094 */ 1095 1096/** 1097 * map_persist_bufs: - Pre-map persistent data for adapter logins 1098 * @hostdata: ibmvscsi_host_data of host 1099 * 1100 * Map the capabilities and adapter info DMA buffers to avoid runtime failures. 1101 * Return 1 on error, 0 on success. 1102 */ 1103static int map_persist_bufs(struct ibmvscsi_host_data *hostdata) 1104{ 1105 1106 hostdata->caps_addr = dma_map_single(hostdata->dev, &hostdata->caps, 1107 sizeof(hostdata->caps), DMA_BIDIRECTIONAL); 1108 1109 if (dma_mapping_error(hostdata->dev, hostdata->caps_addr)) { 1110 dev_err(hostdata->dev, "Unable to map capabilities buffer!\n"); 1111 return 1; 1112 } 1113 1114 hostdata->adapter_info_addr = dma_map_single(hostdata->dev, 1115 &hostdata->madapter_info, 1116 sizeof(hostdata->madapter_info), 1117 DMA_BIDIRECTIONAL); 1118 if (dma_mapping_error(hostdata->dev, hostdata->adapter_info_addr)) { 1119 dev_err(hostdata->dev, "Unable to map adapter info buffer!\n"); 1120 dma_unmap_single(hostdata->dev, hostdata->caps_addr, 1121 sizeof(hostdata->caps), DMA_BIDIRECTIONAL); 1122 return 1; 1123 } 1124 1125 return 0; 1126} 1127 1128/** 1129 * unmap_persist_bufs: - Unmap persistent data needed for adapter logins 1130 * @hostdata: ibmvscsi_host_data of host 1131 * 1132 * Unmap the capabilities and adapter info DMA buffers 1133 */ 1134static void unmap_persist_bufs(struct ibmvscsi_host_data *hostdata) 1135{ 1136 dma_unmap_single(hostdata->dev, hostdata->caps_addr, 1137 sizeof(hostdata->caps), DMA_BIDIRECTIONAL); 1138 1139 dma_unmap_single(hostdata->dev, hostdata->adapter_info_addr, 1140 sizeof(hostdata->madapter_info), DMA_BIDIRECTIONAL); 1141} 1142 1143/** 1144 * login_rsp: - Handle response to SRP login request 1145 * @evt_struct: srp_event_struct with the response 1146 * 1147 * Used as a "done" callback by when sending srp_login. Gets called 1148 * by ibmvscsi_handle_crq() 1149*/ 1150static void login_rsp(struct srp_event_struct *evt_struct) 1151{ 1152 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 1153 switch (evt_struct->xfer_iu->srp.login_rsp.opcode) { 1154 case SRP_LOGIN_RSP: /* it worked! */ 1155 break; 1156 case SRP_LOGIN_REJ: /* refused! */ 1157 dev_info(hostdata->dev, "SRP_LOGIN_REJ reason %u\n", 1158 evt_struct->xfer_iu->srp.login_rej.reason); 1159 /* Login failed. */ 1160 atomic_set(&hostdata->request_limit, -1); 1161 return; 1162 default: 1163 dev_err(hostdata->dev, "Invalid login response typecode 0x%02x!\n", 1164 evt_struct->xfer_iu->srp.login_rsp.opcode); 1165 /* Login failed. */ 1166 atomic_set(&hostdata->request_limit, -1); 1167 return; 1168 } 1169 1170 dev_info(hostdata->dev, "SRP_LOGIN succeeded\n"); 1171 hostdata->client_migrated = 0; 1172 1173 /* Now we know what the real request-limit is. 1174 * This value is set rather than added to request_limit because 1175 * request_limit could have been set to -1 by this client. 1176 */ 1177 atomic_set(&hostdata->request_limit, 1178 be32_to_cpu(evt_struct->xfer_iu->srp.login_rsp.req_lim_delta)); 1179 1180 /* If we had any pending I/Os, kick them */ 1181 scsi_unblock_requests(hostdata->host); 1182} 1183 1184/** 1185 * send_srp_login: - Sends the srp login 1186 * @hostdata: ibmvscsi_host_data of host 1187 * 1188 * Returns zero if successful. 1189*/ 1190static int send_srp_login(struct ibmvscsi_host_data *hostdata) 1191{ 1192 int rc; 1193 unsigned long flags; 1194 struct srp_login_req *login; 1195 struct srp_event_struct *evt_struct = get_event_struct(&hostdata->pool); 1196 1197 BUG_ON(!evt_struct); 1198 init_event_struct(evt_struct, login_rsp, 1199 VIOSRP_SRP_FORMAT, login_timeout); 1200 1201 login = &evt_struct->iu.srp.login_req; 1202 memset(login, 0, sizeof(*login)); 1203 login->opcode = SRP_LOGIN_REQ; 1204 login->req_it_iu_len = cpu_to_be32(sizeof(union srp_iu)); 1205 login->req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | 1206 SRP_BUF_FORMAT_INDIRECT); 1207 1208 spin_lock_irqsave(hostdata->host->host_lock, flags); 1209 /* Start out with a request limit of 0, since this is negotiated in 1210 * the login request we are just sending and login requests always 1211 * get sent by the driver regardless of request_limit. 1212 */ 1213 atomic_set(&hostdata->request_limit, 0); 1214 1215 rc = ibmvscsi_send_srp_event(evt_struct, hostdata, login_timeout * 2); 1216 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1217 dev_info(hostdata->dev, "sent SRP login\n"); 1218 return rc; 1219}; 1220 1221/** 1222 * capabilities_rsp: - Handle response to MAD adapter capabilities request 1223 * @evt_struct: srp_event_struct with the response 1224 * 1225 * Used as a "done" callback by when sending adapter_info. 1226 */ 1227static void capabilities_rsp(struct srp_event_struct *evt_struct) 1228{ 1229 struct ibmvscsi_host_data *hostdata = evt_struct->hostdata; 1230 1231 if (evt_struct->xfer_iu->mad.capabilities.common.status) { 1232 dev_err(hostdata->dev, "error 0x%X getting capabilities info\n", 1233 evt_struct->xfer_iu->mad.capabilities.common.status); 1234 } else { 1235 if (hostdata->caps.migration.common.server_support != 1236 cpu_to_be16(SERVER_SUPPORTS_CAP)) 1237 dev_info(hostdata->dev, "Partition migration not supported\n"); 1238 1239 if (client_reserve) { 1240 if (hostdata->caps.reserve.common.server_support == 1241 cpu_to_be16(SERVER_SUPPORTS_CAP)) 1242 dev_info(hostdata->dev, "Client reserve enabled\n"); 1243 else 1244 dev_info(hostdata->dev, "Client reserve not supported\n"); 1245 } 1246 } 1247 1248 send_srp_login(hostdata); 1249} 1250 1251/** 1252 * send_mad_capabilities: - Sends the mad capabilities request 1253 * and stores the result so it can be retrieved with 1254 * @hostdata: ibmvscsi_host_data of host 1255 */ 1256static void send_mad_capabilities(struct ibmvscsi_host_data *hostdata) 1257{ 1258 struct viosrp_capabilities *req; 1259 struct srp_event_struct *evt_struct; 1260 unsigned long flags; 1261 struct device_node *of_node = hostdata->dev->of_node; 1262 const char *location; 1263 1264 evt_struct = get_event_struct(&hostdata->pool); 1265 BUG_ON(!evt_struct); 1266 1267 init_event_struct(evt_struct, capabilities_rsp, 1268 VIOSRP_MAD_FORMAT, info_timeout); 1269 1270 req = &evt_struct->iu.mad.capabilities; 1271 memset(req, 0, sizeof(*req)); 1272 1273 hostdata->caps.flags = cpu_to_be32(CAP_LIST_SUPPORTED); 1274 if (hostdata->client_migrated) 1275 hostdata->caps.flags |= cpu_to_be32(CLIENT_MIGRATED); 1276 1277 strncpy(hostdata->caps.name, dev_name(&hostdata->host->shost_gendev), 1278 sizeof(hostdata->caps.name)); 1279 hostdata->caps.name[sizeof(hostdata->caps.name) - 1] = '\0'; 1280 1281 location = of_get_property(of_node, "ibm,loc-code", NULL); 1282 location = location ? location : dev_name(hostdata->dev); 1283 strncpy(hostdata->caps.loc, location, sizeof(hostdata->caps.loc)); 1284 hostdata->caps.loc[sizeof(hostdata->caps.loc) - 1] = '\0'; 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 */ 1325static 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 */ 1346static 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*/ 1381static 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) == 3 && 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) == 3) { 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*/ 1428static 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 */ 1459static 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 */ 1470static 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 */ 1483static 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 tsk_mgmt->lun = cpu_to_be64(((u64) lun) << 48); 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 */ 1622static 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 tsk_mgmt->lun = cpu_to_be64(((u64) lun) << 48); 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*/ 1733static 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*/ 1761static 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 0xC0: /* initialization */ 1771 switch (crq->format) { 1772 case 0x01: /* 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 0x02: /* 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 0xFF: /* 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->reenable_crq = 1; 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 0x80: /* 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_get_host_config: Send the command to the server to get host 1859 * configuration data. The data is opaque to us. 1860 */ 1861static int ibmvscsi_do_host_config(struct ibmvscsi_host_data *hostdata, 1862 unsigned char *buffer, int length) 1863{ 1864 struct viosrp_host_config *host_config; 1865 struct srp_event_struct *evt_struct; 1866 unsigned long flags; 1867 dma_addr_t addr; 1868 int rc; 1869 1870 evt_struct = get_event_struct(&hostdata->pool); 1871 if (!evt_struct) { 1872 dev_err(hostdata->dev, "couldn't allocate event for HOST_CONFIG!\n"); 1873 return -1; 1874 } 1875 1876 init_event_struct(evt_struct, 1877 sync_completion, 1878 VIOSRP_MAD_FORMAT, 1879 info_timeout); 1880 1881 host_config = &evt_struct->iu.mad.host_config; 1882 1883 /* The transport length field is only 16-bit */ 1884 length = min(0xffff, length); 1885 1886 /* Set up a lun reset SRP command */ 1887 memset(host_config, 0x00, sizeof(*host_config)); 1888 host_config->common.type = cpu_to_be32(VIOSRP_HOST_CONFIG_TYPE); 1889 host_config->common.length = cpu_to_be16(length); 1890 addr = dma_map_single(hostdata->dev, buffer, length, DMA_BIDIRECTIONAL); 1891 1892 if (dma_mapping_error(hostdata->dev, addr)) { 1893 if (!firmware_has_feature(FW_FEATURE_CMO)) 1894 dev_err(hostdata->dev, 1895 "dma_mapping error getting host config\n"); 1896 free_event_struct(&hostdata->pool, evt_struct); 1897 return -1; 1898 } 1899 1900 host_config->buffer = cpu_to_be64(addr); 1901 1902 init_completion(&evt_struct->comp); 1903 spin_lock_irqsave(hostdata->host->host_lock, flags); 1904 rc = ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2); 1905 spin_unlock_irqrestore(hostdata->host->host_lock, flags); 1906 if (rc == 0) 1907 wait_for_completion(&evt_struct->comp); 1908 dma_unmap_single(hostdata->dev, addr, length, DMA_BIDIRECTIONAL); 1909 1910 return rc; 1911} 1912 1913/** 1914 * ibmvscsi_slave_configure: Set the "allow_restart" flag for each disk. 1915 * @sdev: struct scsi_device device to configure 1916 * 1917 * Enable allow_restart for a device if it is a disk. Adjust the 1918 * queue_depth here also as is required by the documentation for 1919 * struct scsi_host_template. 1920 */ 1921static int ibmvscsi_slave_configure(struct scsi_device *sdev) 1922{ 1923 struct Scsi_Host *shost = sdev->host; 1924 unsigned long lock_flags = 0; 1925 1926 spin_lock_irqsave(shost->host_lock, lock_flags); 1927 if (sdev->type == TYPE_DISK) { 1928 sdev->allow_restart = 1; 1929 blk_queue_rq_timeout(sdev->request_queue, 120 * HZ); 1930 } 1931 spin_unlock_irqrestore(shost->host_lock, lock_flags); 1932 return 0; 1933} 1934 1935/** 1936 * ibmvscsi_change_queue_depth - Change the device's queue depth 1937 * @sdev: scsi device struct 1938 * @qdepth: depth to set 1939 * @reason: calling context 1940 * 1941 * Return value: 1942 * actual depth set 1943 **/ 1944static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth) 1945{ 1946 if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN) 1947 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN; 1948 return scsi_change_queue_depth(sdev, qdepth); 1949} 1950 1951/* ------------------------------------------------------------ 1952 * sysfs attributes 1953 */ 1954static ssize_t show_host_vhost_loc(struct device *dev, 1955 struct device_attribute *attr, char *buf) 1956{ 1957 struct Scsi_Host *shost = class_to_shost(dev); 1958 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1959 int len; 1960 1961 len = snprintf(buf, sizeof(hostdata->caps.loc), "%s\n", 1962 hostdata->caps.loc); 1963 return len; 1964} 1965 1966static struct device_attribute ibmvscsi_host_vhost_loc = { 1967 .attr = { 1968 .name = "vhost_loc", 1969 .mode = S_IRUGO, 1970 }, 1971 .show = show_host_vhost_loc, 1972}; 1973 1974static ssize_t show_host_vhost_name(struct device *dev, 1975 struct device_attribute *attr, char *buf) 1976{ 1977 struct Scsi_Host *shost = class_to_shost(dev); 1978 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1979 int len; 1980 1981 len = snprintf(buf, sizeof(hostdata->caps.name), "%s\n", 1982 hostdata->caps.name); 1983 return len; 1984} 1985 1986static struct device_attribute ibmvscsi_host_vhost_name = { 1987 .attr = { 1988 .name = "vhost_name", 1989 .mode = S_IRUGO, 1990 }, 1991 .show = show_host_vhost_name, 1992}; 1993 1994static ssize_t show_host_srp_version(struct device *dev, 1995 struct device_attribute *attr, char *buf) 1996{ 1997 struct Scsi_Host *shost = class_to_shost(dev); 1998 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 1999 int len; 2000 2001 len = snprintf(buf, PAGE_SIZE, "%s\n", 2002 hostdata->madapter_info.srp_version); 2003 return len; 2004} 2005 2006static struct device_attribute ibmvscsi_host_srp_version = { 2007 .attr = { 2008 .name = "srp_version", 2009 .mode = S_IRUGO, 2010 }, 2011 .show = show_host_srp_version, 2012}; 2013 2014static ssize_t show_host_partition_name(struct device *dev, 2015 struct device_attribute *attr, 2016 char *buf) 2017{ 2018 struct Scsi_Host *shost = class_to_shost(dev); 2019 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2020 int len; 2021 2022 len = snprintf(buf, PAGE_SIZE, "%s\n", 2023 hostdata->madapter_info.partition_name); 2024 return len; 2025} 2026 2027static struct device_attribute ibmvscsi_host_partition_name = { 2028 .attr = { 2029 .name = "partition_name", 2030 .mode = S_IRUGO, 2031 }, 2032 .show = show_host_partition_name, 2033}; 2034 2035static ssize_t show_host_partition_number(struct device *dev, 2036 struct device_attribute *attr, 2037 char *buf) 2038{ 2039 struct Scsi_Host *shost = class_to_shost(dev); 2040 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2041 int len; 2042 2043 len = snprintf(buf, PAGE_SIZE, "%d\n", 2044 hostdata->madapter_info.partition_number); 2045 return len; 2046} 2047 2048static struct device_attribute ibmvscsi_host_partition_number = { 2049 .attr = { 2050 .name = "partition_number", 2051 .mode = S_IRUGO, 2052 }, 2053 .show = show_host_partition_number, 2054}; 2055 2056static ssize_t show_host_mad_version(struct device *dev, 2057 struct device_attribute *attr, char *buf) 2058{ 2059 struct Scsi_Host *shost = class_to_shost(dev); 2060 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2061 int len; 2062 2063 len = snprintf(buf, PAGE_SIZE, "%d\n", 2064 hostdata->madapter_info.mad_version); 2065 return len; 2066} 2067 2068static struct device_attribute ibmvscsi_host_mad_version = { 2069 .attr = { 2070 .name = "mad_version", 2071 .mode = S_IRUGO, 2072 }, 2073 .show = show_host_mad_version, 2074}; 2075 2076static ssize_t show_host_os_type(struct device *dev, 2077 struct device_attribute *attr, char *buf) 2078{ 2079 struct Scsi_Host *shost = class_to_shost(dev); 2080 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2081 int len; 2082 2083 len = snprintf(buf, PAGE_SIZE, "%d\n", hostdata->madapter_info.os_type); 2084 return len; 2085} 2086 2087static struct device_attribute ibmvscsi_host_os_type = { 2088 .attr = { 2089 .name = "os_type", 2090 .mode = S_IRUGO, 2091 }, 2092 .show = show_host_os_type, 2093}; 2094 2095static ssize_t show_host_config(struct device *dev, 2096 struct device_attribute *attr, char *buf) 2097{ 2098 struct Scsi_Host *shost = class_to_shost(dev); 2099 struct ibmvscsi_host_data *hostdata = shost_priv(shost); 2100 2101 /* returns null-terminated host config data */ 2102 if (ibmvscsi_do_host_config(hostdata, buf, PAGE_SIZE) == 0) 2103 return strlen(buf); 2104 else 2105 return 0; 2106} 2107 2108static struct device_attribute ibmvscsi_host_config = { 2109 .attr = { 2110 .name = "config", 2111 .mode = S_IRUGO, 2112 }, 2113 .show = show_host_config, 2114}; 2115 2116static struct device_attribute *ibmvscsi_attrs[] = { 2117 &ibmvscsi_host_vhost_loc, 2118 &ibmvscsi_host_vhost_name, 2119 &ibmvscsi_host_srp_version, 2120 &ibmvscsi_host_partition_name, 2121 &ibmvscsi_host_partition_number, 2122 &ibmvscsi_host_mad_version, 2123 &ibmvscsi_host_os_type, 2124 &ibmvscsi_host_config, 2125 NULL 2126}; 2127 2128/* ------------------------------------------------------------ 2129 * SCSI driver registration 2130 */ 2131static struct scsi_host_template driver_template = { 2132 .module = THIS_MODULE, 2133 .name = "IBM POWER Virtual SCSI Adapter " IBMVSCSI_VERSION, 2134 .proc_name = "ibmvscsi", 2135 .queuecommand = ibmvscsi_queuecommand, 2136 .eh_abort_handler = ibmvscsi_eh_abort_handler, 2137 .eh_device_reset_handler = ibmvscsi_eh_device_reset_handler, 2138 .eh_host_reset_handler = ibmvscsi_eh_host_reset_handler, 2139 .slave_configure = ibmvscsi_slave_configure, 2140 .change_queue_depth = ibmvscsi_change_queue_depth, 2141 .cmd_per_lun = IBMVSCSI_CMDS_PER_LUN_DEFAULT, 2142 .can_queue = IBMVSCSI_MAX_REQUESTS_DEFAULT, 2143 .this_id = -1, 2144 .sg_tablesize = SG_ALL, 2145 .use_clustering = ENABLE_CLUSTERING, 2146 .shost_attrs = ibmvscsi_attrs, 2147}; 2148 2149/** 2150 * ibmvscsi_get_desired_dma - Calculate IO memory desired by the driver 2151 * 2152 * @vdev: struct vio_dev for the device whose desired IO mem is to be returned 2153 * 2154 * Return value: 2155 * Number of bytes of IO data the driver will need to perform well. 2156 */ 2157static unsigned long ibmvscsi_get_desired_dma(struct vio_dev *vdev) 2158{ 2159 /* iu_storage data allocated in initialize_event_pool */ 2160 unsigned long desired_io = max_events * sizeof(union viosrp_iu); 2161 2162 /* add io space for sg data */ 2163 desired_io += (IBMVSCSI_MAX_SECTORS_DEFAULT * 512 * 2164 IBMVSCSI_CMDS_PER_LUN_DEFAULT); 2165 2166 return desired_io; 2167} 2168 2169static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata) 2170{ 2171 int rc; 2172 char *action = "reset"; 2173 2174 if (hostdata->reset_crq) { 2175 smp_rmb(); 2176 hostdata->reset_crq = 0; 2177 2178 rc = ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata); 2179 if (!rc) 2180 rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0); 2181 vio_enable_interrupts(to_vio_dev(hostdata->dev)); 2182 } else if (hostdata->reenable_crq) { 2183 smp_rmb(); 2184 action = "enable"; 2185 rc = ibmvscsi_reenable_crq_queue(&hostdata->queue, hostdata); 2186 hostdata->reenable_crq = 0; 2187 if (!rc) 2188 rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0); 2189 } else 2190 return; 2191 2192 if (rc) { 2193 atomic_set(&hostdata->request_limit, -1); 2194 dev_err(hostdata->dev, "error after %s\n", action); 2195 } 2196 2197 scsi_unblock_requests(hostdata->host); 2198} 2199 2200static int ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata) 2201{ 2202 if (kthread_should_stop()) 2203 return 1; 2204 else if (hostdata->reset_crq) { 2205 smp_rmb(); 2206 return 1; 2207 } else if (hostdata->reenable_crq) { 2208 smp_rmb(); 2209 return 1; 2210 } 2211 2212 return 0; 2213} 2214 2215static int ibmvscsi_work(void *data) 2216{ 2217 struct ibmvscsi_host_data *hostdata = data; 2218 int rc; 2219 2220 set_user_nice(current, MIN_NICE); 2221 2222 while (1) { 2223 rc = wait_event_interruptible(hostdata->work_wait_q, 2224 ibmvscsi_work_to_do(hostdata)); 2225 2226 BUG_ON(rc); 2227 2228 if (kthread_should_stop()) 2229 break; 2230 2231 ibmvscsi_do_work(hostdata); 2232 } 2233 2234 return 0; 2235} 2236 2237/** 2238 * Called by bus code for each adapter 2239 */ 2240static int ibmvscsi_probe(struct vio_dev *vdev, const struct vio_device_id *id) 2241{ 2242 struct ibmvscsi_host_data *hostdata; 2243 struct Scsi_Host *host; 2244 struct device *dev = &vdev->dev; 2245 struct srp_rport_identifiers ids; 2246 struct srp_rport *rport; 2247 unsigned long wait_switch = 0; 2248 int rc; 2249 2250 dev_set_drvdata(&vdev->dev, NULL); 2251 2252 host = scsi_host_alloc(&driver_template, sizeof(*hostdata)); 2253 if (!host) { 2254 dev_err(&vdev->dev, "couldn't allocate host data\n"); 2255 goto scsi_host_alloc_failed; 2256 } 2257 2258 host->transportt = ibmvscsi_transport_template; 2259 hostdata = shost_priv(host); 2260 memset(hostdata, 0x00, sizeof(*hostdata)); 2261 INIT_LIST_HEAD(&hostdata->sent); 2262 init_waitqueue_head(&hostdata->work_wait_q); 2263 hostdata->host = host; 2264 hostdata->dev = dev; 2265 atomic_set(&hostdata->request_limit, -1); 2266 hostdata->host->max_sectors = IBMVSCSI_MAX_SECTORS_DEFAULT; 2267 2268 if (map_persist_bufs(hostdata)) { 2269 dev_err(&vdev->dev, "couldn't map persistent buffers\n"); 2270 goto persist_bufs_failed; 2271 } 2272 2273 hostdata->work_thread = kthread_run(ibmvscsi_work, hostdata, "%s_%d", 2274 "ibmvscsi", host->host_no); 2275 2276 if (IS_ERR(hostdata->work_thread)) { 2277 dev_err(&vdev->dev, "couldn't initialize kthread. rc=%ld\n", 2278 PTR_ERR(hostdata->work_thread)); 2279 goto init_crq_failed; 2280 } 2281 2282 rc = ibmvscsi_init_crq_queue(&hostdata->queue, hostdata, max_events); 2283 if (rc != 0 && rc != H_RESOURCE) { 2284 dev_err(&vdev->dev, "couldn't initialize crq. rc=%d\n", rc); 2285 goto kill_kthread; 2286 } 2287 if (initialize_event_pool(&hostdata->pool, max_events, hostdata) != 0) { 2288 dev_err(&vdev->dev, "couldn't initialize event pool\n"); 2289 goto init_pool_failed; 2290 } 2291 2292 host->max_lun = 8; 2293 host->max_id = max_id; 2294 host->max_channel = max_channel; 2295 host->max_cmd_len = 16; 2296 2297 if (scsi_add_host(hostdata->host, hostdata->dev)) 2298 goto add_host_failed; 2299 2300 /* we don't have a proper target_port_id so let's use the fake one */ 2301 memcpy(ids.port_id, hostdata->madapter_info.partition_name, 2302 sizeof(ids.port_id)); 2303 ids.roles = SRP_RPORT_ROLE_TARGET; 2304 rport = srp_rport_add(host, &ids); 2305 if (IS_ERR(rport)) 2306 goto add_srp_port_failed; 2307 2308 /* Try to send an initialization message. Note that this is allowed 2309 * to fail if the other end is not acive. In that case we don't 2310 * want to scan 2311 */ 2312 if (ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0) == 0 2313 || rc == H_RESOURCE) { 2314 /* 2315 * Wait around max init_timeout secs for the adapter to finish 2316 * initializing. When we are done initializing, we will have a 2317 * valid request_limit. We don't want Linux scanning before 2318 * we are ready. 2319 */ 2320 for (wait_switch = jiffies + (init_timeout * HZ); 2321 time_before(jiffies, wait_switch) && 2322 atomic_read(&hostdata->request_limit) < 2;) { 2323 2324 msleep(10); 2325 } 2326 2327 /* if we now have a valid request_limit, initiate a scan */ 2328 if (atomic_read(&hostdata->request_limit) > 0) 2329 scsi_scan_host(host); 2330 } 2331 2332 dev_set_drvdata(&vdev->dev, hostdata); 2333 return 0; 2334 2335 add_srp_port_failed: 2336 scsi_remove_host(hostdata->host); 2337 add_host_failed: 2338 release_event_pool(&hostdata->pool, hostdata); 2339 init_pool_failed: 2340 ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, max_events); 2341 kill_kthread: 2342 kthread_stop(hostdata->work_thread); 2343 init_crq_failed: 2344 unmap_persist_bufs(hostdata); 2345 persist_bufs_failed: 2346 scsi_host_put(host); 2347 scsi_host_alloc_failed: 2348 return -1; 2349} 2350 2351static int ibmvscsi_remove(struct vio_dev *vdev) 2352{ 2353 struct ibmvscsi_host_data *hostdata = dev_get_drvdata(&vdev->dev); 2354 unmap_persist_bufs(hostdata); 2355 release_event_pool(&hostdata->pool, hostdata); 2356 ibmvscsi_release_crq_queue(&hostdata->queue, hostdata, 2357 max_events); 2358 2359 kthread_stop(hostdata->work_thread); 2360 srp_remove_host(hostdata->host); 2361 scsi_remove_host(hostdata->host); 2362 scsi_host_put(hostdata->host); 2363 2364 return 0; 2365} 2366 2367/** 2368 * ibmvscsi_resume: Resume from suspend 2369 * @dev: device struct 2370 * 2371 * We may have lost an interrupt across suspend/resume, so kick the 2372 * interrupt handler 2373 */ 2374static int ibmvscsi_resume(struct device *dev) 2375{ 2376 struct ibmvscsi_host_data *hostdata = dev_get_drvdata(dev); 2377 vio_disable_interrupts(to_vio_dev(hostdata->dev)); 2378 tasklet_schedule(&hostdata->srp_task); 2379 2380 return 0; 2381} 2382 2383/** 2384 * ibmvscsi_device_table: Used by vio.c to match devices in the device tree we 2385 * support. 2386 */ 2387static struct vio_device_id ibmvscsi_device_table[] = { 2388 {"vscsi", "IBM,v-scsi"}, 2389 { "", "" } 2390}; 2391MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table); 2392 2393static struct dev_pm_ops ibmvscsi_pm_ops = { 2394 .resume = ibmvscsi_resume 2395}; 2396 2397static struct vio_driver ibmvscsi_driver = { 2398 .id_table = ibmvscsi_device_table, 2399 .probe = ibmvscsi_probe, 2400 .remove = ibmvscsi_remove, 2401 .get_desired_dma = ibmvscsi_get_desired_dma, 2402 .name = "ibmvscsi", 2403 .pm = &ibmvscsi_pm_ops, 2404}; 2405 2406static struct srp_function_template ibmvscsi_transport_functions = { 2407}; 2408 2409int __init ibmvscsi_module_init(void) 2410{ 2411 int ret; 2412 2413 /* Ensure we have two requests to do error recovery */ 2414 driver_template.can_queue = max_requests; 2415 max_events = max_requests + 2; 2416 2417 if (!firmware_has_feature(FW_FEATURE_VIO)) 2418 return -ENODEV; 2419 2420 ibmvscsi_transport_template = 2421 srp_attach_transport(&ibmvscsi_transport_functions); 2422 if (!ibmvscsi_transport_template) 2423 return -ENOMEM; 2424 2425 ret = vio_register_driver(&ibmvscsi_driver); 2426 if (ret) 2427 srp_release_transport(ibmvscsi_transport_template); 2428 return ret; 2429} 2430 2431void __exit ibmvscsi_module_exit(void) 2432{ 2433 vio_unregister_driver(&ibmvscsi_driver); 2434 srp_release_transport(ibmvscsi_transport_template); 2435} 2436 2437module_init(ibmvscsi_module_init); 2438module_exit(ibmvscsi_module_exit); 2439