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