1/* 2 * IBM eServer i/pSeries Virtual SCSI Target Driver 3 * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp. 4 * Santiago Leon (santil@us.ibm.com) IBM Corp. 5 * Linda Xie (lxie@us.ibm.com) IBM Corp. 6 * 7 * Copyright (C) 2005-2006 FUJITA Tomonori <tomof@acm.org> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 22 * USA 23 */ 24#include <linux/interrupt.h> 25#include <linux/module.h> 26#include <scsi/scsi.h> 27#include <scsi/scsi_host.h> 28#include <scsi/scsi_tgt.h> 29#include <scsi/libsrp.h> 30#include <asm/hvcall.h> 31#include <asm/iommu.h> 32#include <asm/prom.h> 33#include <asm/vio.h> 34 35#include "ibmvscsi.h" 36 37#define INITIAL_SRP_LIMIT 16 38#define DEFAULT_MAX_SECTORS 256 39 40#define TGT_NAME "ibmvstgt" 41 42/* 43 * Hypervisor calls. 44 */ 45#define h_copy_rdma(l, sa, sb, da, db) \ 46 plpar_hcall_norets(H_COPY_RDMA, l, sa, sb, da, db) 47#define h_send_crq(ua, l, h) \ 48 plpar_hcall_norets(H_SEND_CRQ, ua, l, h) 49#define h_reg_crq(ua, tok, sz)\ 50 plpar_hcall_norets(H_REG_CRQ, ua, tok, sz); 51#define h_free_crq(ua) \ 52 plpar_hcall_norets(H_FREE_CRQ, ua); 53 54/* tmp - will replace with SCSI logging stuff */ 55#define eprintk(fmt, args...) \ 56do { \ 57 printk("%s(%d) " fmt, __FUNCTION__, __LINE__, ##args); \ 58} while (0) 59/* #define dprintk eprintk */ 60#define dprintk(fmt, args...) 61 62struct vio_port { 63 struct vio_dev *dma_dev; 64 65 struct crq_queue crq_queue; 66 struct work_struct crq_work; 67 68 unsigned long liobn; 69 unsigned long riobn; 70 struct srp_target *target; 71}; 72 73static struct workqueue_struct *vtgtd; 74 75/* 76 * These are fixed for the system and come from the Open Firmware device tree. 77 * We just store them here to save getting them every time. 78 */ 79static char system_id[64] = ""; 80static char partition_name[97] = "UNKNOWN"; 81static unsigned int partition_number = -1; 82 83static struct vio_port *target_to_port(struct srp_target *target) 84{ 85 return (struct vio_port *) target->ldata; 86} 87 88static inline union viosrp_iu *vio_iu(struct iu_entry *iue) 89{ 90 return (union viosrp_iu *) (iue->sbuf->buf); 91} 92 93static int send_iu(struct iu_entry *iue, uint64_t length, uint8_t format) 94{ 95 struct srp_target *target = iue->target; 96 struct vio_port *vport = target_to_port(target); 97 long rc, rc1; 98 union { 99 struct viosrp_crq cooked; 100 uint64_t raw[2]; 101 } crq; 102 103 /* First copy the SRP */ 104 rc = h_copy_rdma(length, vport->liobn, iue->sbuf->dma, 105 vport->riobn, iue->remote_token); 106 107 if (rc) 108 eprintk("Error %ld transferring data\n", rc); 109 110 crq.cooked.valid = 0x80; 111 crq.cooked.format = format; 112 crq.cooked.reserved = 0x00; 113 crq.cooked.timeout = 0x00; 114 crq.cooked.IU_length = length; 115 crq.cooked.IU_data_ptr = vio_iu(iue)->srp.rsp.tag; 116 117 if (rc == 0) 118 crq.cooked.status = 0x99; /* Just needs to be non-zero */ 119 else 120 crq.cooked.status = 0x00; 121 122 rc1 = h_send_crq(vport->dma_dev->unit_address, crq.raw[0], crq.raw[1]); 123 124 if (rc1) { 125 eprintk("%ld sending response\n", rc1); 126 return rc1; 127 } 128 129 return rc; 130} 131 132#define SRP_RSP_SENSE_DATA_LEN 18 133 134static int send_rsp(struct iu_entry *iue, struct scsi_cmnd *sc, 135 unsigned char status, unsigned char asc) 136{ 137 union viosrp_iu *iu = vio_iu(iue); 138 uint64_t tag = iu->srp.rsp.tag; 139 140 /* If the linked bit is on and status is good */ 141 if (test_bit(V_LINKED, &iue->flags) && (status == NO_SENSE)) 142 status = 0x10; 143 144 memset(iu, 0, sizeof(struct srp_rsp)); 145 iu->srp.rsp.opcode = SRP_RSP; 146 iu->srp.rsp.req_lim_delta = 1; 147 iu->srp.rsp.tag = tag; 148 149 if (test_bit(V_DIOVER, &iue->flags)) 150 iu->srp.rsp.flags |= SRP_RSP_FLAG_DIOVER; 151 152 iu->srp.rsp.data_in_res_cnt = 0; 153 iu->srp.rsp.data_out_res_cnt = 0; 154 155 iu->srp.rsp.flags &= ~SRP_RSP_FLAG_RSPVALID; 156 157 iu->srp.rsp.resp_data_len = 0; 158 iu->srp.rsp.status = status; 159 if (status) { 160 uint8_t *sense = iu->srp.rsp.data; 161 162 if (sc) { 163 iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID; 164 iu->srp.rsp.sense_data_len = SCSI_SENSE_BUFFERSIZE; 165 memcpy(sense, sc->sense_buffer, SCSI_SENSE_BUFFERSIZE); 166 } else { 167 iu->srp.rsp.status = SAM_STAT_CHECK_CONDITION; 168 iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID; 169 iu->srp.rsp.sense_data_len = SRP_RSP_SENSE_DATA_LEN; 170 171 /* Valid bit and 'current errors' */ 172 sense[0] = (0x1 << 7 | 0x70); 173 /* Sense key */ 174 sense[2] = status; 175 /* Additional sense length */ 176 sense[7] = 0xa; /* 10 bytes */ 177 /* Additional sense code */ 178 sense[12] = asc; 179 } 180 } 181 182 send_iu(iue, sizeof(iu->srp.rsp) + SRP_RSP_SENSE_DATA_LEN, 183 VIOSRP_SRP_FORMAT); 184 185 return 0; 186} 187 188static void handle_cmd_queue(struct srp_target *target) 189{ 190 struct Scsi_Host *shost = target->shost; 191 struct iu_entry *iue; 192 struct srp_cmd *cmd; 193 unsigned long flags; 194 int err; 195 196retry: 197 spin_lock_irqsave(&target->lock, flags); 198 199 list_for_each_entry(iue, &target->cmd_queue, ilist) { 200 if (!test_and_set_bit(V_FLYING, &iue->flags)) { 201 spin_unlock_irqrestore(&target->lock, flags); 202 cmd = iue->sbuf->buf; 203 err = srp_cmd_queue(shost, cmd, iue, 0); 204 if (err) { 205 eprintk("cannot queue cmd %p %d\n", cmd, err); 206 srp_iu_put(iue); 207 } 208 goto retry; 209 } 210 } 211 212 spin_unlock_irqrestore(&target->lock, flags); 213} 214 215static int ibmvstgt_rdma(struct scsi_cmnd *sc, struct scatterlist *sg, int nsg, 216 struct srp_direct_buf *md, int nmd, 217 enum dma_data_direction dir, unsigned int rest) 218{ 219 struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr; 220 struct srp_target *target = iue->target; 221 struct vio_port *vport = target_to_port(target); 222 dma_addr_t token; 223 long err; 224 unsigned int done = 0; 225 int i, sidx, soff; 226 227 sidx = soff = 0; 228 token = sg_dma_address(sg + sidx); 229 230 for (i = 0; i < nmd && rest; i++) { 231 unsigned int mdone, mlen; 232 233 mlen = min(rest, md[i].len); 234 for (mdone = 0; mlen;) { 235 int slen = min(sg_dma_len(sg + sidx) - soff, mlen); 236 237 if (dir == DMA_TO_DEVICE) 238 err = h_copy_rdma(slen, 239 vport->riobn, 240 md[i].va + mdone, 241 vport->liobn, 242 token + soff); 243 else 244 err = h_copy_rdma(slen, 245 vport->liobn, 246 token + soff, 247 vport->riobn, 248 md[i].va + mdone); 249 250 if (err != H_SUCCESS) { 251 eprintk("rdma error %d %d %ld\n", dir, slen, err); 252 return -EIO; 253 } 254 255 mlen -= slen; 256 mdone += slen; 257 soff += slen; 258 done += slen; 259 260 if (soff == sg_dma_len(sg + sidx)) { 261 sidx++; 262 soff = 0; 263 token = sg_dma_address(sg + sidx); 264 265 if (sidx > nsg) { 266 eprintk("out of sg %p %d %d\n", 267 iue, sidx, nsg); 268 return -EIO; 269 } 270 } 271 }; 272 273 rest -= mlen; 274 } 275 return 0; 276} 277 278static int ibmvstgt_cmd_done(struct scsi_cmnd *sc, 279 void (*done)(struct scsi_cmnd *)) 280{ 281 unsigned long flags; 282 struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr; 283 struct srp_target *target = iue->target; 284 int err = 0; 285 286 dprintk("%p %p %x %u\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0], 287 cmd->usg_sg); 288 289 if (sc->use_sg) 290 err = srp_transfer_data(sc, &vio_iu(iue)->srp.cmd, ibmvstgt_rdma, 1, 1); 291 292 spin_lock_irqsave(&target->lock, flags); 293 list_del(&iue->ilist); 294 spin_unlock_irqrestore(&target->lock, flags); 295 296 if (err|| sc->result != SAM_STAT_GOOD) { 297 eprintk("operation failed %p %d %x\n", 298 iue, sc->result, vio_iu(iue)->srp.cmd.cdb[0]); 299 send_rsp(iue, sc, HARDWARE_ERROR, 0x00); 300 } else 301 send_rsp(iue, sc, NO_SENSE, 0x00); 302 303 done(sc); 304 srp_iu_put(iue); 305 return 0; 306} 307 308int send_adapter_info(struct iu_entry *iue, 309 dma_addr_t remote_buffer, uint16_t length) 310{ 311 struct srp_target *target = iue->target; 312 struct vio_port *vport = target_to_port(target); 313 struct Scsi_Host *shost = target->shost; 314 dma_addr_t data_token; 315 struct mad_adapter_info_data *info; 316 int err; 317 318 info = dma_alloc_coherent(target->dev, sizeof(*info), &data_token, 319 GFP_KERNEL); 320 if (!info) { 321 eprintk("bad dma_alloc_coherent %p\n", target); 322 return 1; 323 } 324 325 /* Get remote info */ 326 err = h_copy_rdma(sizeof(*info), vport->riobn, remote_buffer, 327 vport->liobn, data_token); 328 if (err == H_SUCCESS) { 329 dprintk("Client connect: %s (%d)\n", 330 info->partition_name, info->partition_number); 331 } 332 333 memset(info, 0, sizeof(*info)); 334 335 strcpy(info->srp_version, "16.a"); 336 strncpy(info->partition_name, partition_name, 337 sizeof(info->partition_name)); 338 info->partition_number = partition_number; 339 info->mad_version = 1; 340 info->os_type = 2; 341 info->port_max_txu[0] = shost->hostt->max_sectors << 9; 342 343 /* Send our info to remote */ 344 err = h_copy_rdma(sizeof(*info), vport->liobn, data_token, 345 vport->riobn, remote_buffer); 346 347 dma_free_coherent(target->dev, sizeof(*info), info, data_token); 348 349 if (err != H_SUCCESS) { 350 eprintk("Error sending adapter info %d\n", err); 351 return 1; 352 } 353 354 return 0; 355} 356 357static void process_login(struct iu_entry *iue) 358{ 359 union viosrp_iu *iu = vio_iu(iue); 360 struct srp_login_rsp *rsp = &iu->srp.login_rsp; 361 uint64_t tag = iu->srp.rsp.tag; 362 363 /* TODO handle case that requested size is wrong and 364 * buffer format is wrong 365 */ 366 memset(iu, 0, sizeof(struct srp_login_rsp)); 367 rsp->opcode = SRP_LOGIN_RSP; 368 rsp->req_lim_delta = INITIAL_SRP_LIMIT; 369 rsp->tag = tag; 370 rsp->max_it_iu_len = sizeof(union srp_iu); 371 rsp->max_ti_iu_len = sizeof(union srp_iu); 372 /* direct and indirect */ 373 rsp->buf_fmt = SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT; 374 375 send_iu(iue, sizeof(*rsp), VIOSRP_SRP_FORMAT); 376} 377 378static inline void queue_cmd(struct iu_entry *iue) 379{ 380 struct srp_target *target = iue->target; 381 unsigned long flags; 382 383 spin_lock_irqsave(&target->lock, flags); 384 list_add_tail(&iue->ilist, &target->cmd_queue); 385 spin_unlock_irqrestore(&target->lock, flags); 386} 387 388static int process_tsk_mgmt(struct iu_entry *iue) 389{ 390 union viosrp_iu *iu = vio_iu(iue); 391 int fn; 392 393 dprintk("%p %u\n", iue, iu->srp.tsk_mgmt.tsk_mgmt_func); 394 395 switch (iu->srp.tsk_mgmt.tsk_mgmt_func) { 396 case SRP_TSK_ABORT_TASK: 397 fn = ABORT_TASK; 398 break; 399 case SRP_TSK_ABORT_TASK_SET: 400 fn = ABORT_TASK_SET; 401 break; 402 case SRP_TSK_CLEAR_TASK_SET: 403 fn = CLEAR_TASK_SET; 404 break; 405 case SRP_TSK_LUN_RESET: 406 fn = LOGICAL_UNIT_RESET; 407 break; 408 case SRP_TSK_CLEAR_ACA: 409 fn = CLEAR_ACA; 410 break; 411 default: 412 fn = 0; 413 } 414 if (fn) 415 scsi_tgt_tsk_mgmt_request(iue->target->shost, fn, 416 iu->srp.tsk_mgmt.task_tag, 417 (struct scsi_lun *) &iu->srp.tsk_mgmt.lun, 418 iue); 419 else 420 send_rsp(iue, NULL, ILLEGAL_REQUEST, 0x20); 421 422 return !fn; 423} 424 425static int process_mad_iu(struct iu_entry *iue) 426{ 427 union viosrp_iu *iu = vio_iu(iue); 428 struct viosrp_adapter_info *info; 429 struct viosrp_host_config *conf; 430 431 switch (iu->mad.empty_iu.common.type) { 432 case VIOSRP_EMPTY_IU_TYPE: 433 eprintk("%s\n", "Unsupported EMPTY MAD IU"); 434 break; 435 case VIOSRP_ERROR_LOG_TYPE: 436 eprintk("%s\n", "Unsupported ERROR LOG MAD IU"); 437 iu->mad.error_log.common.status = 1; 438 send_iu(iue, sizeof(iu->mad.error_log), VIOSRP_MAD_FORMAT); 439 break; 440 case VIOSRP_ADAPTER_INFO_TYPE: 441 info = &iu->mad.adapter_info; 442 info->common.status = send_adapter_info(iue, info->buffer, 443 info->common.length); 444 send_iu(iue, sizeof(*info), VIOSRP_MAD_FORMAT); 445 break; 446 case VIOSRP_HOST_CONFIG_TYPE: 447 conf = &iu->mad.host_config; 448 conf->common.status = 1; 449 send_iu(iue, sizeof(*conf), VIOSRP_MAD_FORMAT); 450 break; 451 default: 452 eprintk("Unknown type %u\n", iu->srp.rsp.opcode); 453 } 454 455 return 1; 456} 457 458static int process_srp_iu(struct iu_entry *iue) 459{ 460 union viosrp_iu *iu = vio_iu(iue); 461 int done = 1; 462 u8 opcode = iu->srp.rsp.opcode; 463 464 switch (opcode) { 465 case SRP_LOGIN_REQ: 466 process_login(iue); 467 break; 468 case SRP_TSK_MGMT: 469 done = process_tsk_mgmt(iue); 470 break; 471 case SRP_CMD: 472 queue_cmd(iue); 473 done = 0; 474 break; 475 case SRP_LOGIN_RSP: 476 case SRP_I_LOGOUT: 477 case SRP_T_LOGOUT: 478 case SRP_RSP: 479 case SRP_CRED_REQ: 480 case SRP_CRED_RSP: 481 case SRP_AER_REQ: 482 case SRP_AER_RSP: 483 eprintk("Unsupported type %u\n", opcode); 484 break; 485 default: 486 eprintk("Unknown type %u\n", opcode); 487 } 488 489 return done; 490} 491 492static void process_iu(struct viosrp_crq *crq, struct srp_target *target) 493{ 494 struct vio_port *vport = target_to_port(target); 495 struct iu_entry *iue; 496 long err; 497 int done = 1; 498 499 iue = srp_iu_get(target); 500 if (!iue) { 501 eprintk("Error getting IU from pool, %p\n", target); 502 return; 503 } 504 505 iue->remote_token = crq->IU_data_ptr; 506 507 err = h_copy_rdma(crq->IU_length, vport->riobn, 508 iue->remote_token, vport->liobn, iue->sbuf->dma); 509 510 if (err != H_SUCCESS) { 511 eprintk("%ld transferring data error %p\n", err, iue); 512 goto out; 513 } 514 515 if (crq->format == VIOSRP_MAD_FORMAT) 516 done = process_mad_iu(iue); 517 else 518 done = process_srp_iu(iue); 519out: 520 if (done) 521 srp_iu_put(iue); 522} 523 524static irqreturn_t ibmvstgt_interrupt(int irq, void *data) 525{ 526 struct srp_target *target = (struct srp_target *) data; 527 struct vio_port *vport = target_to_port(target); 528 529 vio_disable_interrupts(vport->dma_dev); 530 queue_work(vtgtd, &vport->crq_work); 531 532 return IRQ_HANDLED; 533} 534 535static int crq_queue_create(struct crq_queue *queue, struct srp_target *target) 536{ 537 int err; 538 struct vio_port *vport = target_to_port(target); 539 540 queue->msgs = (struct viosrp_crq *) get_zeroed_page(GFP_KERNEL); 541 if (!queue->msgs) 542 goto malloc_failed; 543 queue->size = PAGE_SIZE / sizeof(*queue->msgs); 544 545 queue->msg_token = dma_map_single(target->dev, queue->msgs, 546 queue->size * sizeof(*queue->msgs), 547 DMA_BIDIRECTIONAL); 548 549 if (dma_mapping_error(queue->msg_token)) 550 goto map_failed; 551 552 err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token, 553 PAGE_SIZE); 554 555 /* If the adapter was left active for some reason (like kexec) 556 * try freeing and re-registering 557 */ 558 if (err == H_RESOURCE) { 559 do { 560 err = h_free_crq(vport->dma_dev->unit_address); 561 } while (err == H_BUSY || H_IS_LONG_BUSY(err)); 562 563 err = h_reg_crq(vport->dma_dev->unit_address, queue->msg_token, 564 PAGE_SIZE); 565 } 566 567 if (err != H_SUCCESS && err != 2) { 568 eprintk("Error 0x%x opening virtual adapter\n", err); 569 goto reg_crq_failed; 570 } 571 572 err = request_irq(vport->dma_dev->irq, &ibmvstgt_interrupt, 573 IRQF_DISABLED, "ibmvstgt", target); 574 if (err) 575 goto req_irq_failed; 576 577 vio_enable_interrupts(vport->dma_dev); 578 579 h_send_crq(vport->dma_dev->unit_address, 0xC001000000000000, 0); 580 581 queue->cur = 0; 582 spin_lock_init(&queue->lock); 583 584 return 0; 585 586req_irq_failed: 587 do { 588 err = h_free_crq(vport->dma_dev->unit_address); 589 } while (err == H_BUSY || H_IS_LONG_BUSY(err)); 590 591reg_crq_failed: 592 dma_unmap_single(target->dev, queue->msg_token, 593 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); 594map_failed: 595 free_page((unsigned long) queue->msgs); 596 597malloc_failed: 598 return -ENOMEM; 599} 600 601static void crq_queue_destroy(struct srp_target *target) 602{ 603 struct vio_port *vport = target_to_port(target); 604 struct crq_queue *queue = &vport->crq_queue; 605 int err; 606 607 free_irq(vport->dma_dev->irq, target); 608 do { 609 err = h_free_crq(vport->dma_dev->unit_address); 610 } while (err == H_BUSY || H_IS_LONG_BUSY(err)); 611 612 dma_unmap_single(target->dev, queue->msg_token, 613 queue->size * sizeof(*queue->msgs), DMA_BIDIRECTIONAL); 614 615 free_page((unsigned long) queue->msgs); 616} 617 618static void process_crq(struct viosrp_crq *crq, struct srp_target *target) 619{ 620 struct vio_port *vport = target_to_port(target); 621 dprintk("%x %x\n", crq->valid, crq->format); 622 623 switch (crq->valid) { 624 case 0xC0: 625 /* initialization */ 626 switch (crq->format) { 627 case 0x01: 628 h_send_crq(vport->dma_dev->unit_address, 629 0xC002000000000000, 0); 630 break; 631 case 0x02: 632 break; 633 default: 634 eprintk("Unknown format %u\n", crq->format); 635 } 636 break; 637 case 0xFF: 638 /* transport event */ 639 break; 640 case 0x80: 641 /* real payload */ 642 switch (crq->format) { 643 case VIOSRP_SRP_FORMAT: 644 case VIOSRP_MAD_FORMAT: 645 process_iu(crq, target); 646 break; 647 case VIOSRP_OS400_FORMAT: 648 case VIOSRP_AIX_FORMAT: 649 case VIOSRP_LINUX_FORMAT: 650 case VIOSRP_INLINE_FORMAT: 651 eprintk("Unsupported format %u\n", crq->format); 652 break; 653 default: 654 eprintk("Unknown format %u\n", crq->format); 655 } 656 break; 657 default: 658 eprintk("unknown message type 0x%02x!?\n", crq->valid); 659 } 660} 661 662static inline struct viosrp_crq *next_crq(struct crq_queue *queue) 663{ 664 struct viosrp_crq *crq; 665 unsigned long flags; 666 667 spin_lock_irqsave(&queue->lock, flags); 668 crq = &queue->msgs[queue->cur]; 669 if (crq->valid & 0x80) { 670 if (++queue->cur == queue->size) 671 queue->cur = 0; 672 } else 673 crq = NULL; 674 spin_unlock_irqrestore(&queue->lock, flags); 675 676 return crq; 677} 678 679static void handle_crq(struct work_struct *work) 680{ 681 struct vio_port *vport = container_of(work, struct vio_port, crq_work); 682 struct srp_target *target = vport->target; 683 struct viosrp_crq *crq; 684 int done = 0; 685 686 while (!done) { 687 while ((crq = next_crq(&vport->crq_queue)) != NULL) { 688 process_crq(crq, target); 689 crq->valid = 0x00; 690 } 691 692 vio_enable_interrupts(vport->dma_dev); 693 694 crq = next_crq(&vport->crq_queue); 695 if (crq) { 696 vio_disable_interrupts(vport->dma_dev); 697 process_crq(crq, target); 698 crq->valid = 0x00; 699 } else 700 done = 1; 701 } 702 703 handle_cmd_queue(target); 704} 705 706 707static int ibmvstgt_eh_abort_handler(struct scsi_cmnd *sc) 708{ 709 unsigned long flags; 710 struct iu_entry *iue = (struct iu_entry *) sc->SCp.ptr; 711 struct srp_target *target = iue->target; 712 713 dprintk("%p %p %x\n", iue, target, vio_iu(iue)->srp.cmd.cdb[0]); 714 715 spin_lock_irqsave(&target->lock, flags); 716 list_del(&iue->ilist); 717 spin_unlock_irqrestore(&target->lock, flags); 718 719 srp_iu_put(iue); 720 721 return 0; 722} 723 724static int ibmvstgt_tsk_mgmt_response(u64 mid, int result) 725{ 726 struct iu_entry *iue = (struct iu_entry *) ((void *) mid); 727 union viosrp_iu *iu = vio_iu(iue); 728 unsigned char status, asc; 729 730 eprintk("%p %d\n", iue, result); 731 status = NO_SENSE; 732 asc = 0; 733 734 switch (iu->srp.tsk_mgmt.tsk_mgmt_func) { 735 case SRP_TSK_ABORT_TASK: 736 asc = 0x14; 737 if (result) 738 status = ABORTED_COMMAND; 739 break; 740 default: 741 break; 742 } 743 744 send_rsp(iue, NULL, status, asc); 745 srp_iu_put(iue); 746 747 return 0; 748} 749 750static ssize_t system_id_show(struct class_device *cdev, char *buf) 751{ 752 return snprintf(buf, PAGE_SIZE, "%s\n", system_id); 753} 754 755static ssize_t partition_number_show(struct class_device *cdev, char *buf) 756{ 757 return snprintf(buf, PAGE_SIZE, "%x\n", partition_number); 758} 759 760static ssize_t unit_address_show(struct class_device *cdev, char *buf) 761{ 762 struct Scsi_Host *shost = class_to_shost(cdev); 763 struct srp_target *target = host_to_srp_target(shost); 764 struct vio_port *vport = target_to_port(target); 765 return snprintf(buf, PAGE_SIZE, "%x\n", vport->dma_dev->unit_address); 766} 767 768static CLASS_DEVICE_ATTR(system_id, S_IRUGO, system_id_show, NULL); 769static CLASS_DEVICE_ATTR(partition_number, S_IRUGO, partition_number_show, NULL); 770static CLASS_DEVICE_ATTR(unit_address, S_IRUGO, unit_address_show, NULL); 771 772static struct class_device_attribute *ibmvstgt_attrs[] = { 773 &class_device_attr_system_id, 774 &class_device_attr_partition_number, 775 &class_device_attr_unit_address, 776 NULL, 777}; 778 779static struct scsi_host_template ibmvstgt_sht = { 780 .name = TGT_NAME, 781 .module = THIS_MODULE, 782 .can_queue = INITIAL_SRP_LIMIT, 783 .sg_tablesize = SG_ALL, 784 .use_clustering = DISABLE_CLUSTERING, 785 .max_sectors = DEFAULT_MAX_SECTORS, 786 .transfer_response = ibmvstgt_cmd_done, 787 .eh_abort_handler = ibmvstgt_eh_abort_handler, 788 .tsk_mgmt_response = ibmvstgt_tsk_mgmt_response, 789 .shost_attrs = ibmvstgt_attrs, 790 .proc_name = TGT_NAME, 791}; 792 793static int ibmvstgt_probe(struct vio_dev *dev, const struct vio_device_id *id) 794{ 795 struct Scsi_Host *shost; 796 struct srp_target *target; 797 struct vio_port *vport; 798 unsigned int *dma, dma_size; 799 int err = -ENOMEM; 800 801 vport = kzalloc(sizeof(struct vio_port), GFP_KERNEL); 802 if (!vport) 803 return err; 804 shost = scsi_host_alloc(&ibmvstgt_sht, sizeof(struct srp_target)); 805 if (!shost) 806 goto free_vport; 807 err = scsi_tgt_alloc_queue(shost); 808 if (err) 809 goto put_host; 810 811 target = host_to_srp_target(shost); 812 target->shost = shost; 813 vport->dma_dev = dev; 814 target->ldata = vport; 815 vport->target = target; 816 err = srp_target_alloc(target, &dev->dev, INITIAL_SRP_LIMIT, 817 SRP_MAX_IU_LEN); 818 if (err) 819 goto put_host; 820 821 dma = (unsigned int *) vio_get_attribute(dev, "ibm,my-dma-window", 822 &dma_size); 823 if (!dma || dma_size != 40) { 824 eprintk("Couldn't get window property %d\n", dma_size); 825 err = -EIO; 826 goto free_srp_target; 827 } 828 vport->liobn = dma[0]; 829 vport->riobn = dma[5]; 830 831 INIT_WORK(&vport->crq_work, handle_crq); 832 833 err = crq_queue_create(&vport->crq_queue, target); 834 if (err) 835 goto free_srp_target; 836 837 err = scsi_add_host(shost, target->dev); 838 if (err) 839 goto destroy_queue; 840 return 0; 841 842destroy_queue: 843 crq_queue_destroy(target); 844free_srp_target: 845 srp_target_free(target); 846put_host: 847 scsi_host_put(shost); 848free_vport: 849 kfree(vport); 850 return err; 851} 852 853static int ibmvstgt_remove(struct vio_dev *dev) 854{ 855 struct srp_target *target = (struct srp_target *) dev->dev.driver_data; 856 struct Scsi_Host *shost = target->shost; 857 struct vio_port *vport = target->ldata; 858 859 crq_queue_destroy(target); 860 scsi_remove_host(shost); 861 scsi_tgt_free_queue(shost); 862 srp_target_free(target); 863 kfree(vport); 864 scsi_host_put(shost); 865 return 0; 866} 867 868static struct vio_device_id ibmvstgt_device_table[] __devinitdata = { 869 {"v-scsi-host", "IBM,v-scsi-host"}, 870 {"",""} 871}; 872 873MODULE_DEVICE_TABLE(vio, ibmvstgt_device_table); 874 875static struct vio_driver ibmvstgt_driver = { 876 .id_table = ibmvstgt_device_table, 877 .probe = ibmvstgt_probe, 878 .remove = ibmvstgt_remove, 879 .driver = { 880 .name = "ibmvscsis", 881 .owner = THIS_MODULE, 882 } 883}; 884 885static int get_system_info(void) 886{ 887 struct device_node *rootdn; 888 const char *id, *model, *name; 889 const unsigned int *num; 890 891 rootdn = of_find_node_by_path("/"); 892 if (!rootdn) 893 return -ENOENT; 894 895 model = of_get_property(rootdn, "model", NULL); 896 id = of_get_property(rootdn, "system-id", NULL); 897 if (model && id) 898 snprintf(system_id, sizeof(system_id), "%s-%s", model, id); 899 900 name = of_get_property(rootdn, "ibm,partition-name", NULL); 901 if (name) 902 strncpy(partition_name, name, sizeof(partition_name)); 903 904 num = of_get_property(rootdn, "ibm,partition-no", NULL); 905 if (num) 906 partition_number = *num; 907 908 of_node_put(rootdn); 909 return 0; 910} 911 912static int ibmvstgt_init(void) 913{ 914 int err = -ENOMEM; 915 916 printk("IBM eServer i/pSeries Virtual SCSI Target Driver\n"); 917 918 vtgtd = create_workqueue("ibmvtgtd"); 919 if (!vtgtd) 920 return err; 921 922 err = get_system_info(); 923 if (err) 924 goto destroy_wq; 925 926 err = vio_register_driver(&ibmvstgt_driver); 927 if (err) 928 goto destroy_wq; 929 930 return 0; 931 932destroy_wq: 933 destroy_workqueue(vtgtd); 934 return err; 935} 936 937static void ibmvstgt_exit(void) 938{ 939 printk("Unregister IBM virtual SCSI driver\n"); 940 941 destroy_workqueue(vtgtd); 942 vio_unregister_driver(&ibmvstgt_driver); 943} 944 945MODULE_DESCRIPTION("IBM Virtual SCSI Target"); 946MODULE_AUTHOR("Santiago Leon"); 947MODULE_LICENSE("GPL"); 948 949module_init(ibmvstgt_init); 950module_exit(ibmvstgt_exit); 951