1 /* 2 * HighPoint RR3xxx controller driver for Linux 3 * Copyright (C) 2006 HighPoint Technologies, Inc. All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; version 2 of the License. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * Please report bugs/comments/suggestions to linux@highpoint-tech.com 15 * 16 * For more information, visit http://www.highpoint-tech.com 17 */ 18 #include <linux/config.h> 19 #include <linux/module.h> 20 #include <linux/types.h> 21 #include <linux/string.h> 22 #include <linux/kernel.h> 23 #include <linux/pci.h> 24 #include <linux/interrupt.h> 25 #include <linux/errno.h> 26 #include <linux/delay.h> 27 #include <linux/timer.h> 28 #include <linux/spinlock.h> 29 #include <linux/hdreg.h> 30 #include <asm/uaccess.h> 31 #include <asm/io.h> 32 #include <asm/div64.h> 33 #include <scsi/scsi_cmnd.h> 34 #include <scsi/scsi_device.h> 35 #include <scsi/scsi.h> 36 #include <scsi/scsi_tcq.h> 37 #include <scsi/scsi_host.h> 38 39 #include "hptiop.h" 40 41 MODULE_AUTHOR("HighPoint Technologies, Inc."); 42 MODULE_DESCRIPTION("HighPoint RocketRAID 3xxx SATA Controller Driver"); 43 44 static char driver_name[] = "hptiop"; 45 static const char driver_name_long[] = "RocketRAID 3xxx SATA Controller driver"; 46 static const char driver_ver[] = "v1.0 (060426)"; 47 48 static DEFINE_SPINLOCK(hptiop_hba_list_lock); 49 static LIST_HEAD(hptiop_hba_list); 50 static int hptiop_cdev_major = -1; 51 52 static void hptiop_host_request_callback(struct hptiop_hba *hba, u32 tag); 53 static void hptiop_iop_request_callback(struct hptiop_hba *hba, u32 tag); 54 static void hptiop_message_callback(struct hptiop_hba *hba, u32 msg); 55 56 static inline void hptiop_pci_posting_flush(struct hpt_iopmu __iomem *iop) 57 { 58 readl(&iop->outbound_intstatus); 59 } 60 61 static int iop_wait_ready(struct hpt_iopmu __iomem *iop, u32 millisec) 62 { 63 u32 req = 0; 64 int i; 65 66 for (i = 0; i < millisec; i++) { 67 req = readl(&iop->inbound_queue); 68 if (req != IOPMU_QUEUE_EMPTY) 69 break; 70 msleep(1); 71 } 72 73 if (req != IOPMU_QUEUE_EMPTY) { 74 writel(req, &iop->outbound_queue); 75 hptiop_pci_posting_flush(iop); 76 return 0; 77 } 78 79 return -1; 80 } 81 82 static void hptiop_request_callback(struct hptiop_hba *hba, u32 tag) 83 { 84 if ((tag & IOPMU_QUEUE_MASK_HOST_BITS) == IOPMU_QUEUE_ADDR_HOST_BIT) 85 return hptiop_host_request_callback(hba, 86 tag & ~IOPMU_QUEUE_ADDR_HOST_BIT); 87 else 88 return hptiop_iop_request_callback(hba, tag); 89 } 90 91 static inline void hptiop_drain_outbound_queue(struct hptiop_hba *hba) 92 { 93 u32 req; 94 95 while ((req = readl(&hba->iop->outbound_queue)) != IOPMU_QUEUE_EMPTY) { 96 97 if (req & IOPMU_QUEUE_MASK_HOST_BITS) 98 hptiop_request_callback(hba, req); 99 else { 100 struct hpt_iop_request_header __iomem * p; 101 102 p = (struct hpt_iop_request_header __iomem *) 103 ((char __iomem *)hba->iop + req); 104 105 if (readl(&p->flags) & IOP_REQUEST_FLAG_SYNC_REQUEST) { 106 if (readl(&p->context)) 107 hptiop_request_callback(hba, req); 108 else 109 writel(1, &p->context); 110 } 111 else 112 hptiop_request_callback(hba, req); 113 } 114 } 115 } 116 117 static int __iop_intr(struct hptiop_hba *hba) 118 { 119 struct hpt_iopmu __iomem *iop = hba->iop; 120 u32 status; 121 int ret = 0; 122 123 status = readl(&iop->outbound_intstatus); 124 125 if (status & IOPMU_OUTBOUND_INT_MSG0) { 126 u32 msg = readl(&iop->outbound_msgaddr0); 127 dprintk("received outbound msg %x\n", msg); 128 writel(IOPMU_OUTBOUND_INT_MSG0, &iop->outbound_intstatus); 129 hptiop_message_callback(hba, msg); 130 ret = 1; 131 } 132 133 if (status & IOPMU_OUTBOUND_INT_POSTQUEUE) { 134 hptiop_drain_outbound_queue(hba); 135 ret = 1; 136 } 137 138 return ret; 139 } 140 141 static int iop_send_sync_request(struct hptiop_hba *hba, 142 void __iomem *_req, u32 millisec) 143 { 144 struct hpt_iop_request_header __iomem *req = _req; 145 u32 i; 146 147 writel(readl(&req->flags) | IOP_REQUEST_FLAG_SYNC_REQUEST, 148 &req->flags); 149 150 writel(0, &req->context); 151 152 writel((unsigned long)req - (unsigned long)hba->iop, 153 &hba->iop->inbound_queue); 154 155 hptiop_pci_posting_flush(hba->iop); 156 157 for (i = 0; i < millisec; i++) { 158 __iop_intr(hba); 159 if (readl(&req->context)) 160 return 0; 161 msleep(1); 162 } 163 164 return -1; 165 } 166 167 static int iop_send_sync_msg(struct hptiop_hba *hba, u32 msg, u32 millisec) 168 { 169 u32 i; 170 171 hba->msg_done = 0; 172 173 writel(msg, &hba->iop->inbound_msgaddr0); 174 175 hptiop_pci_posting_flush(hba->iop); 176 177 for (i = 0; i < millisec; i++) { 178 spin_lock_irq(hba->host->host_lock); 179 __iop_intr(hba); 180 spin_unlock_irq(hba->host->host_lock); 181 if (hba->msg_done) 182 break; 183 msleep(1); 184 } 185 186 return hba->msg_done? 0 : -1; 187 } 188 189 static int iop_get_config(struct hptiop_hba *hba, 190 struct hpt_iop_request_get_config *config) 191 { 192 u32 req32; 193 struct hpt_iop_request_get_config __iomem *req; 194 195 req32 = readl(&hba->iop->inbound_queue); 196 if (req32 == IOPMU_QUEUE_EMPTY) 197 return -1; 198 199 req = (struct hpt_iop_request_get_config __iomem *) 200 ((unsigned long)hba->iop + req32); 201 202 writel(0, &req->header.flags); 203 writel(IOP_REQUEST_TYPE_GET_CONFIG, &req->header.type); 204 writel(sizeof(struct hpt_iop_request_get_config), &req->header.size); 205 writel(IOP_RESULT_PENDING, &req->header.result); 206 207 if (iop_send_sync_request(hba, req, 20000)) { 208 dprintk("Get config send cmd failed\n"); 209 return -1; 210 } 211 212 memcpy_fromio(config, req, sizeof(*config)); 213 writel(req32, &hba->iop->outbound_queue); 214 return 0; 215 } 216 217 static int iop_set_config(struct hptiop_hba *hba, 218 struct hpt_iop_request_set_config *config) 219 { 220 u32 req32; 221 struct hpt_iop_request_set_config __iomem *req; 222 223 req32 = readl(&hba->iop->inbound_queue); 224 if (req32 == IOPMU_QUEUE_EMPTY) 225 return -1; 226 227 req = (struct hpt_iop_request_set_config __iomem *) 228 ((unsigned long)hba->iop + req32); 229 230 memcpy_toio((u8 __iomem *)req + sizeof(struct hpt_iop_request_header), 231 (u8 *)config + sizeof(struct hpt_iop_request_header), 232 sizeof(struct hpt_iop_request_set_config) - 233 sizeof(struct hpt_iop_request_header)); 234 235 writel(0, &req->header.flags); 236 writel(IOP_REQUEST_TYPE_SET_CONFIG, &req->header.type); 237 writel(sizeof(struct hpt_iop_request_set_config), &req->header.size); 238 writel(IOP_RESULT_PENDING, &req->header.result); 239 240 if (iop_send_sync_request(hba, req, 20000)) { 241 dprintk("Set config send cmd failed\n"); 242 return -1; 243 } 244 245 writel(req32, &hba->iop->outbound_queue); 246 return 0; 247 } 248 249 static int hptiop_initialize_iop(struct hptiop_hba *hba) 250 { 251 struct hpt_iopmu __iomem *iop = hba->iop; 252 253 /* enable interrupts */ 254 writel(~(IOPMU_OUTBOUND_INT_POSTQUEUE | IOPMU_OUTBOUND_INT_MSG0), 255 &iop->outbound_intmask); 256 257 hba->initialized = 1; 258 259 /* start background tasks */ 260 if (iop_send_sync_msg(hba, 261 IOPMU_INBOUND_MSG0_START_BACKGROUND_TASK, 5000)) { 262 printk(KERN_ERR "scsi%d: fail to start background task\n", 263 hba->host->host_no); 264 return -1; 265 } 266 return 0; 267 } 268 269 static int hptiop_map_pci_bar(struct hptiop_hba *hba) 270 { 271 u32 mem_base_phy, length; 272 void __iomem *mem_base_virt; 273 struct pci_dev *pcidev = hba->pcidev; 274 275 if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) { 276 printk(KERN_ERR "scsi%d: pci resource invalid\n", 277 hba->host->host_no); 278 return -1; 279 } 280 281 mem_base_phy = pci_resource_start(pcidev, 0); 282 length = pci_resource_len(pcidev, 0); 283 mem_base_virt = ioremap(mem_base_phy, length); 284 285 if (!mem_base_virt) { 286 printk(KERN_ERR "scsi%d: Fail to ioremap memory space\n", 287 hba->host->host_no); 288 return -1; 289 } 290 291 hba->iop = mem_base_virt; 292 dprintk("hptiop_map_pci_bar: iop=%p\n", hba->iop); 293 return 0; 294 } 295 296 static void hptiop_message_callback(struct hptiop_hba *hba, u32 msg) 297 { 298 dprintk("iop message 0x%x\n", msg); 299 300 if (!hba->initialized) 301 return; 302 303 if (msg == IOPMU_INBOUND_MSG0_RESET) { 304 atomic_set(&hba->resetting, 0); 305 wake_up(&hba->reset_wq); 306 } 307 else if (msg <= IOPMU_INBOUND_MSG0_MAX) 308 hba->msg_done = 1; 309 } 310 311 static inline struct hptiop_request *get_req(struct hptiop_hba *hba) 312 { 313 struct hptiop_request *ret; 314 315 dprintk("get_req : req=%p\n", hba->req_list); 316 317 ret = hba->req_list; 318 if (ret) 319 hba->req_list = ret->next; 320 321 return ret; 322 } 323 324 static inline void free_req(struct hptiop_hba *hba, struct hptiop_request *req) 325 { 326 dprintk("free_req(%d, %p)\n", req->index, req); 327 req->next = hba->req_list; 328 hba->req_list = req; 329 } 330 331 static void hptiop_host_request_callback(struct hptiop_hba *hba, u32 tag) 332 { 333 struct hpt_iop_request_scsi_command *req; 334 struct scsi_cmnd *scp; 335 336 req = (struct hpt_iop_request_scsi_command *)hba->reqs[tag].req_virt; 337 dprintk("hptiop_host_request_callback: req=%p, type=%d, " 338 "result=%d, context=0x%x tag=%d\n", 339 req, req->header.type, req->header.result, 340 req->header.context, tag); 341 342 BUG_ON(!req->header.result); 343 BUG_ON(req->header.type != cpu_to_le32(IOP_REQUEST_TYPE_SCSI_COMMAND)); 344 345 scp = hba->reqs[tag].scp; 346 347 if (HPT_SCP(scp)->mapped) { 348 if (scp->use_sg) 349 pci_unmap_sg(hba->pcidev, 350 (struct scatterlist *)scp->request_buffer, 351 scp->use_sg, 352 scp->sc_data_direction 353 ); 354 else 355 pci_unmap_single(hba->pcidev, 356 HPT_SCP(scp)->dma_handle, 357 scp->request_bufflen, 358 scp->sc_data_direction 359 ); 360 } 361 362 switch (le32_to_cpu(req->header.result)) { 363 case IOP_RESULT_SUCCESS: 364 scp->result = (DID_OK<<16); 365 break; 366 case IOP_RESULT_BAD_TARGET: 367 scp->result = (DID_BAD_TARGET<<16); 368 break; 369 case IOP_RESULT_BUSY: 370 scp->result = (DID_BUS_BUSY<<16); 371 break; 372 case IOP_RESULT_RESET: 373 scp->result = (DID_RESET<<16); 374 break; 375 case IOP_RESULT_FAIL: 376 scp->result = (DID_ERROR<<16); 377 break; 378 case IOP_RESULT_INVALID_REQUEST: 379 scp->result = (DID_ABORT<<16); 380 break; 381 case IOP_RESULT_MODE_SENSE_CHECK_CONDITION: 382 scp->result = SAM_STAT_CHECK_CONDITION; 383 memset(&scp->sense_buffer, 384 0, sizeof(scp->sense_buffer)); 385 memcpy(&scp->sense_buffer, 386 &req->sg_list, le32_to_cpu(req->dataxfer_length)); 387 break; 388 389 default: 390 scp->result = ((DRIVER_INVALID|SUGGEST_ABORT)<<24) | 391 (DID_ABORT<<16); 392 break; 393 } 394 395 dprintk("scsi_done(%p)\n", scp); 396 scp->scsi_done(scp); 397 free_req(hba, &hba->reqs[tag]); 398 } 399 400 void hptiop_iop_request_callback(struct hptiop_hba *hba, u32 tag) 401 { 402 struct hpt_iop_request_header __iomem *req; 403 struct hpt_iop_request_ioctl_command __iomem *p; 404 struct hpt_ioctl_k *arg; 405 406 req = (struct hpt_iop_request_header __iomem *) 407 ((unsigned long)hba->iop + tag); 408 dprintk("hptiop_iop_request_callback: req=%p, type=%d, " 409 "result=%d, context=0x%x tag=%d\n", 410 req, readl(&req->type), readl(&req->result), 411 readl(&req->context), tag); 412 413 BUG_ON(!readl(&req->result)); 414 BUG_ON(readl(&req->type) != IOP_REQUEST_TYPE_IOCTL_COMMAND); 415 416 p = (struct hpt_iop_request_ioctl_command __iomem *)req; 417 arg = (struct hpt_ioctl_k *)(unsigned long) 418 (readl(&req->context) | 419 ((u64)readl(&req->context_hi32)<<32)); 420 421 if (readl(&req->result) == IOP_RESULT_SUCCESS) { 422 arg->result = HPT_IOCTL_RESULT_OK; 423 424 if (arg->outbuf_size) 425 memcpy_fromio(arg->outbuf, 426 &p->buf[(readl(&p->inbuf_size) + 3)& ~3], 427 arg->outbuf_size); 428 429 if (arg->bytes_returned) 430 *arg->bytes_returned = arg->outbuf_size; 431 } 432 else 433 arg->result = HPT_IOCTL_RESULT_FAILED; 434 435 arg->done(arg); 436 writel(tag, &hba->iop->outbound_queue); 437 } 438 439 static irqreturn_t hptiop_intr(int irq, void *dev_id, struct pt_regs *regs) 440 { 441 struct hptiop_hba *hba = dev_id; 442 int handled; 443 unsigned long flags; 444 445 spin_lock_irqsave(hba->host->host_lock, flags); 446 handled = __iop_intr(hba); 447 spin_unlock_irqrestore(hba->host->host_lock, flags); 448 449 return handled; 450 } 451 452 static int hptiop_buildsgl(struct scsi_cmnd *scp, struct hpt_iopsg *psg) 453 { 454 struct Scsi_Host *host = scp->device->host; 455 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 456 struct scatterlist *sglist = (struct scatterlist *)scp->request_buffer; 457 458 /* 459 * though we'll not get non-use_sg fields anymore, 460 * keep use_sg checking anyway 461 */ 462 if (scp->use_sg) { 463 int idx; 464 465 HPT_SCP(scp)->sgcnt = pci_map_sg(hba->pcidev, 466 sglist, scp->use_sg, 467 scp->sc_data_direction); 468 HPT_SCP(scp)->mapped = 1; 469 BUG_ON(HPT_SCP(scp)->sgcnt > hba->max_sg_descriptors); 470 471 for (idx = 0; idx < HPT_SCP(scp)->sgcnt; idx++) { 472 psg[idx].pci_address = 473 cpu_to_le64(sg_dma_address(&sglist[idx])); 474 psg[idx].size = cpu_to_le32(sg_dma_len(&sglist[idx])); 475 psg[idx].eot = (idx == HPT_SCP(scp)->sgcnt - 1) ? 476 cpu_to_le32(1) : 0; 477 } 478 479 return HPT_SCP(scp)->sgcnt; 480 } else { 481 HPT_SCP(scp)->dma_handle = pci_map_single( 482 hba->pcidev, 483 scp->request_buffer, 484 scp->request_bufflen, 485 scp->sc_data_direction 486 ); 487 HPT_SCP(scp)->mapped = 1; 488 psg->pci_address = cpu_to_le64(HPT_SCP(scp)->dma_handle); 489 psg->size = cpu_to_le32(scp->request_bufflen); 490 psg->eot = cpu_to_le32(1); 491 return 1; 492 } 493 } 494 495 static int hptiop_queuecommand(struct scsi_cmnd *scp, 496 void (*done)(struct scsi_cmnd *)) 497 { 498 struct Scsi_Host *host = scp->device->host; 499 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 500 struct hpt_iop_request_scsi_command *req; 501 int sg_count = 0; 502 struct hptiop_request *_req; 503 504 BUG_ON(!done); 505 scp->scsi_done = done; 506 507 _req = get_req(hba); 508 if (_req == NULL) { 509 dprintk("hptiop_queuecmd : no free req\n"); 510 return SCSI_MLQUEUE_HOST_BUSY; 511 } 512 513 _req->scp = scp; 514 515 dprintk("hptiop_queuecmd(scp=%p) %d/%d/%d/%d cdb=(%x-%x-%x) " 516 "req_index=%d, req=%p\n", 517 scp, 518 host->host_no, scp->device->channel, 519 scp->device->id, scp->device->lun, 520 *((u32 *)&scp->cmnd), 521 *((u32 *)&scp->cmnd + 1), 522 *((u32 *)&scp->cmnd + 2), 523 _req->index, _req->req_virt); 524 525 scp->result = 0; 526 527 if (scp->device->channel || scp->device->lun || 528 scp->device->id > hba->max_devices) { 529 scp->result = DID_BAD_TARGET << 16; 530 free_req(hba, _req); 531 goto cmd_done; 532 } 533 534 req = (struct hpt_iop_request_scsi_command *)_req->req_virt; 535 536 /* build S/G table */ 537 if (scp->request_bufflen) 538 sg_count = hptiop_buildsgl(scp, req->sg_list); 539 else 540 HPT_SCP(scp)->mapped = 0; 541 542 req->header.flags = cpu_to_le32(IOP_REQUEST_FLAG_OUTPUT_CONTEXT); 543 req->header.type = cpu_to_le32(IOP_REQUEST_TYPE_SCSI_COMMAND); 544 req->header.result = cpu_to_le32(IOP_RESULT_PENDING); 545 req->header.context = cpu_to_le32(IOPMU_QUEUE_ADDR_HOST_BIT | 546 (u32)_req->index); 547 req->header.context_hi32 = 0; 548 req->dataxfer_length = cpu_to_le32(scp->request_bufflen); 549 req->channel = scp->device->channel; 550 req->target = scp->device->id; 551 req->lun = scp->device->lun; 552 req->header.size = cpu_to_le32( 553 sizeof(struct hpt_iop_request_scsi_command) 554 - sizeof(struct hpt_iopsg) 555 + sg_count * sizeof(struct hpt_iopsg)); 556 557 memcpy(req->cdb, scp->cmnd, sizeof(req->cdb)); 558 559 writel(IOPMU_QUEUE_ADDR_HOST_BIT | _req->req_shifted_phy, 560 &hba->iop->inbound_queue); 561 562 return 0; 563 564 cmd_done: 565 dprintk("scsi_done(scp=%p)\n", scp); 566 scp->scsi_done(scp); 567 return 0; 568 } 569 570 static const char *hptiop_info(struct Scsi_Host *host) 571 { 572 return driver_name_long; 573 } 574 575 static int hptiop_reset_hba(struct hptiop_hba *hba) 576 { 577 if (atomic_xchg(&hba->resetting, 1) == 0) { 578 atomic_inc(&hba->reset_count); 579 writel(IOPMU_INBOUND_MSG0_RESET, 580 &hba->iop->outbound_msgaddr0); 581 hptiop_pci_posting_flush(hba->iop); 582 } 583 584 wait_event_timeout(hba->reset_wq, 585 atomic_read(&hba->resetting) == 0, 60 * HZ); 586 587 if (atomic_read(&hba->resetting)) { 588 /* IOP is in unkown state, abort reset */ 589 printk(KERN_ERR "scsi%d: reset failed\n", hba->host->host_no); 590 return -1; 591 } 592 593 if (iop_send_sync_msg(hba, 594 IOPMU_INBOUND_MSG0_START_BACKGROUND_TASK, 5000)) { 595 dprintk("scsi%d: fail to start background task\n", 596 hba->host->host_no); 597 } 598 599 return 0; 600 } 601 602 static int hptiop_reset(struct scsi_cmnd *scp) 603 { 604 struct Scsi_Host * host = scp->device->host; 605 struct hptiop_hba * hba = (struct hptiop_hba *)host->hostdata; 606 607 printk(KERN_WARNING "hptiop_reset(%d/%d/%d) scp=%p\n", 608 scp->device->host->host_no, scp->device->channel, 609 scp->device->id, scp); 610 611 return hptiop_reset_hba(hba)? FAILED : SUCCESS; 612 } 613 614 static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev, 615 int queue_depth) 616 { 617 if(queue_depth > 256) 618 queue_depth = 256; 619 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth); 620 return queue_depth; 621 } 622 623 struct hptiop_getinfo { 624 char __user *buffer; 625 loff_t buflength; 626 loff_t bufoffset; 627 loff_t buffillen; 628 loff_t filpos; 629 }; 630 631 static void hptiop_copy_mem_info(struct hptiop_getinfo *pinfo, 632 char *data, int datalen) 633 { 634 if (pinfo->filpos < pinfo->bufoffset) { 635 if (pinfo->filpos + datalen <= pinfo->bufoffset) { 636 pinfo->filpos += datalen; 637 return; 638 } else { 639 data += (pinfo->bufoffset - pinfo->filpos); 640 datalen -= (pinfo->bufoffset - pinfo->filpos); 641 pinfo->filpos = pinfo->bufoffset; 642 } 643 } 644 645 pinfo->filpos += datalen; 646 if (pinfo->buffillen == pinfo->buflength) 647 return; 648 649 if (pinfo->buflength - pinfo->buffillen < datalen) 650 datalen = pinfo->buflength - pinfo->buffillen; 651 652 if (copy_to_user(pinfo->buffer + pinfo->buffillen, data, datalen)) 653 return; 654 655 pinfo->buffillen += datalen; 656 } 657 658 static int hptiop_copy_info(struct hptiop_getinfo *pinfo, char *fmt, ...) 659 { 660 va_list args; 661 char buf[128]; 662 int len; 663 664 va_start(args, fmt); 665 len = vsnprintf(buf, sizeof(buf), fmt, args); 666 va_end(args); 667 hptiop_copy_mem_info(pinfo, buf, len); 668 return len; 669 } 670 671 static void hptiop_ioctl_done(struct hpt_ioctl_k *arg) 672 { 673 arg->done = NULL; 674 wake_up(&arg->hba->ioctl_wq); 675 } 676 677 static void hptiop_do_ioctl(struct hpt_ioctl_k *arg) 678 { 679 struct hptiop_hba *hba = arg->hba; 680 u32 val; 681 struct hpt_iop_request_ioctl_command __iomem *req; 682 int ioctl_retry = 0; 683 684 dprintk("scsi%d: hptiop_do_ioctl\n", hba->host->host_no); 685 686 /* 687 * check (in + out) buff size from application. 688 * outbuf must be dword aligned. 689 */ 690 if (((arg->inbuf_size + 3) & ~3) + arg->outbuf_size > 691 hba->max_request_size 692 - sizeof(struct hpt_iop_request_header) 693 - 4 * sizeof(u32)) { 694 dprintk("scsi%d: ioctl buf size (%d/%d) is too large\n", 695 hba->host->host_no, 696 arg->inbuf_size, arg->outbuf_size); 697 arg->result = HPT_IOCTL_RESULT_FAILED; 698 return; 699 } 700 701 retry: 702 spin_lock_irq(hba->host->host_lock); 703 704 val = readl(&hba->iop->inbound_queue); 705 if (val == IOPMU_QUEUE_EMPTY) { 706 spin_unlock_irq(hba->host->host_lock); 707 dprintk("scsi%d: no free req for ioctl\n", hba->host->host_no); 708 arg->result = -1; 709 return; 710 } 711 712 req = (struct hpt_iop_request_ioctl_command __iomem *) 713 ((unsigned long)hba->iop + val); 714 715 writel(HPT_CTL_CODE_LINUX_TO_IOP(arg->ioctl_code), 716 &req->ioctl_code); 717 writel(arg->inbuf_size, &req->inbuf_size); 718 writel(arg->outbuf_size, &req->outbuf_size); 719 720 /* 721 * use the buffer on the IOP local memory first, then copy it 722 * back to host. 723 * the caller's request buffer shoudl be little-endian. 724 */ 725 if (arg->inbuf_size) 726 memcpy_toio(req->buf, arg->inbuf, arg->inbuf_size); 727 728 /* correct the controller ID for IOP */ 729 if ((arg->ioctl_code == HPT_IOCTL_GET_CHANNEL_INFO || 730 arg->ioctl_code == HPT_IOCTL_GET_CONTROLLER_INFO_V2 || 731 arg->ioctl_code == HPT_IOCTL_GET_CONTROLLER_INFO) 732 && arg->inbuf_size >= sizeof(u32)) 733 writel(0, req->buf); 734 735 writel(IOP_REQUEST_TYPE_IOCTL_COMMAND, &req->header.type); 736 writel(0, &req->header.flags); 737 writel(offsetof(struct hpt_iop_request_ioctl_command, buf) 738 + arg->inbuf_size, &req->header.size); 739 writel((u32)(unsigned long)arg, &req->header.context); 740 writel(BITS_PER_LONG > 32 ? (u32)((unsigned long)arg>>32) : 0, 741 &req->header.context_hi32); 742 writel(IOP_RESULT_PENDING, &req->header.result); 743 744 arg->result = HPT_IOCTL_RESULT_FAILED; 745 arg->done = hptiop_ioctl_done; 746 747 writel(val, &hba->iop->inbound_queue); 748 hptiop_pci_posting_flush(hba->iop); 749 750 spin_unlock_irq(hba->host->host_lock); 751 752 wait_event_timeout(hba->ioctl_wq, arg->done == NULL, 60 * HZ); 753 754 if (arg->done != NULL) { 755 hptiop_reset_hba(hba); 756 if (ioctl_retry++ < 3) 757 goto retry; 758 } 759 760 dprintk("hpt_iop_ioctl %x result %d\n", 761 arg->ioctl_code, arg->result); 762 } 763 764 static int __hpt_do_ioctl(struct hptiop_hba *hba, u32 code, void *inbuf, 765 u32 insize, void *outbuf, u32 outsize) 766 { 767 struct hpt_ioctl_k arg; 768 arg.hba = hba; 769 arg.ioctl_code = code; 770 arg.inbuf = inbuf; 771 arg.outbuf = outbuf; 772 arg.inbuf_size = insize; 773 arg.outbuf_size = outsize; 774 arg.bytes_returned = NULL; 775 hptiop_do_ioctl(&arg); 776 return arg.result; 777 } 778 779 static inline int hpt_id_valid(__le32 id) 780 { 781 return id != 0 && id != cpu_to_le32(0xffffffff); 782 } 783 784 static int hptiop_get_controller_info(struct hptiop_hba *hba, 785 struct hpt_controller_info *pinfo) 786 { 787 int id = 0; 788 789 return __hpt_do_ioctl(hba, HPT_IOCTL_GET_CONTROLLER_INFO, 790 &id, sizeof(int), pinfo, sizeof(*pinfo)); 791 } 792 793 794 static int hptiop_get_channel_info(struct hptiop_hba *hba, int bus, 795 struct hpt_channel_info *pinfo) 796 { 797 u32 ids[2]; 798 799 ids[0] = 0; 800 ids[1] = bus; 801 return __hpt_do_ioctl(hba, HPT_IOCTL_GET_CHANNEL_INFO, 802 ids, sizeof(ids), pinfo, sizeof(*pinfo)); 803 804 } 805 806 static int hptiop_get_logical_devices(struct hptiop_hba *hba, 807 __le32 *pids, int maxcount) 808 { 809 int i; 810 u32 count = maxcount - 1; 811 812 if (__hpt_do_ioctl(hba, HPT_IOCTL_GET_LOGICAL_DEVICES, 813 &count, sizeof(u32), 814 pids, sizeof(u32) * maxcount)) 815 return -1; 816 817 maxcount = le32_to_cpu(pids[0]); 818 for (i = 0; i < maxcount; i++) 819 pids[i] = pids[i+1]; 820 821 return maxcount; 822 } 823 824 static int hptiop_get_device_info_v3(struct hptiop_hba *hba, __le32 id, 825 struct hpt_logical_device_info_v3 *pinfo) 826 { 827 return __hpt_do_ioctl(hba, HPT_IOCTL_GET_DEVICE_INFO_V3, 828 &id, sizeof(u32), 829 pinfo, sizeof(*pinfo)); 830 } 831 832 static const char *get_array_status(struct hpt_logical_device_info_v3 *devinfo) 833 { 834 static char s[64]; 835 u32 flags = le32_to_cpu(devinfo->u.array.flags); 836 u32 trans_prog = le32_to_cpu(devinfo->u.array.transforming_progress); 837 u32 reb_prog = le32_to_cpu(devinfo->u.array.rebuilding_progress); 838 839 if (flags & ARRAY_FLAG_DISABLED) 840 return "Disabled"; 841 else if (flags & ARRAY_FLAG_TRANSFORMING) 842 sprintf(s, "Expanding/Migrating %d.%d%%%s%s", 843 trans_prog / 100, 844 trans_prog % 100, 845 (flags & (ARRAY_FLAG_NEEDBUILDING|ARRAY_FLAG_BROKEN))? 846 ", Critical" : "", 847 ((flags & ARRAY_FLAG_NEEDINITIALIZING) && 848 !(flags & ARRAY_FLAG_REBUILDING) && 849 !(flags & ARRAY_FLAG_INITIALIZING))? 850 ", Unintialized" : ""); 851 else if ((flags & ARRAY_FLAG_BROKEN) && 852 devinfo->u.array.array_type != AT_RAID6) 853 return "Critical"; 854 else if (flags & ARRAY_FLAG_REBUILDING) 855 sprintf(s, 856 (flags & ARRAY_FLAG_NEEDINITIALIZING)? 857 "%sBackground initializing %d.%d%%" : 858 "%sRebuilding %d.%d%%", 859 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "", 860 reb_prog / 100, 861 reb_prog % 100); 862 else if (flags & ARRAY_FLAG_VERIFYING) 863 sprintf(s, "%sVerifying %d.%d%%", 864 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "", 865 reb_prog / 100, 866 reb_prog % 100); 867 else if (flags & ARRAY_FLAG_INITIALIZING) 868 sprintf(s, "%sForground initializing %d.%d%%", 869 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "", 870 reb_prog / 100, 871 reb_prog % 100); 872 else if (flags & ARRAY_FLAG_NEEDTRANSFORM) 873 sprintf(s,"%s%s%s", "Need Expanding/Migrating", 874 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : "", 875 ((flags & ARRAY_FLAG_NEEDINITIALIZING) && 876 !(flags & ARRAY_FLAG_REBUILDING) && 877 !(flags & ARRAY_FLAG_INITIALIZING))? 878 ", Unintialized" : ""); 879 else if (flags & ARRAY_FLAG_NEEDINITIALIZING && 880 !(flags & ARRAY_FLAG_REBUILDING) && 881 !(flags & ARRAY_FLAG_INITIALIZING)) 882 sprintf(s,"%sUninitialized", 883 (flags & ARRAY_FLAG_BROKEN)? "Critical, " : ""); 884 else if ((flags & ARRAY_FLAG_NEEDBUILDING) || 885 (flags & ARRAY_FLAG_BROKEN)) 886 return "Critical"; 887 else 888 return "Normal"; 889 return s; 890 } 891 892 static void hptiop_dump_devinfo(struct hptiop_hba *hba, 893 struct hptiop_getinfo *pinfo, __le32 id, int indent) 894 { 895 struct hpt_logical_device_info_v3 devinfo; 896 int i; 897 u64 capacity; 898 899 for (i = 0; i < indent; i++) 900 hptiop_copy_info(pinfo, "\t"); 901 902 if (hptiop_get_device_info_v3(hba, id, &devinfo)) { 903 hptiop_copy_info(pinfo, "unknown\n"); 904 return; 905 } 906 907 switch (devinfo.type) { 908 909 case LDT_DEVICE: { 910 struct hd_driveid *driveid; 911 u32 flags = le32_to_cpu(devinfo.u.device.flags); 912 913 driveid = (struct hd_driveid *)devinfo.u.device.ident; 914 /* model[] is 40 chars long, but we just want 20 chars here */ 915 driveid->model[20] = 0; 916 917 if (indent) 918 if (flags & DEVICE_FLAG_DISABLED) 919 hptiop_copy_info(pinfo,"Missing\n"); 920 else 921 hptiop_copy_info(pinfo, "CH%d %s\n", 922 devinfo.u.device.path_id + 1, 923 driveid->model); 924 else { 925 capacity = le64_to_cpu(devinfo.capacity) * 512; 926 do_div(capacity, 1000000); 927 hptiop_copy_info(pinfo, 928 "CH%d %s, %lluMB, %s %s%s%s%s\n", 929 devinfo.u.device.path_id + 1, 930 driveid->model, 931 capacity, 932 (flags & DEVICE_FLAG_DISABLED)? 933 "Disabled" : "Normal", 934 devinfo.u.device.read_ahead_enabled? 935 "[RA]" : "", 936 devinfo.u.device.write_cache_enabled? 937 "[WC]" : "", 938 devinfo.u.device.TCQ_enabled? 939 "[TCQ]" : "", 940 devinfo.u.device.NCQ_enabled? 941 "[NCQ]" : "" 942 ); 943 } 944 break; 945 } 946 947 case LDT_ARRAY: 948 if (devinfo.target_id != INVALID_TARGET_ID) 949 hptiop_copy_info(pinfo, "[DISK %d_%d] ", 950 devinfo.vbus_id, devinfo.target_id); 951 952 capacity = le64_to_cpu(devinfo.capacity) * 512; 953 do_div(capacity, 1000000); 954 hptiop_copy_info(pinfo, "%s (%s), %lluMB, %s\n", 955 devinfo.u.array.name, 956 devinfo.u.array.array_type==AT_RAID0? "RAID0" : 957 devinfo.u.array.array_type==AT_RAID1? "RAID1" : 958 devinfo.u.array.array_type==AT_RAID5? "RAID5" : 959 devinfo.u.array.array_type==AT_RAID6? "RAID6" : 960 devinfo.u.array.array_type==AT_JBOD? "JBOD" : 961 "unknown", 962 capacity, 963 get_array_status(&devinfo)); 964 for (i = 0; i < devinfo.u.array.ndisk; i++) { 965 if (hpt_id_valid(devinfo.u.array.members[i])) { 966 if (cpu_to_le16(1<<i) & 967 devinfo.u.array.critical_members) 968 hptiop_copy_info(pinfo, "\t*"); 969 hptiop_dump_devinfo(hba, pinfo, 970 devinfo.u.array.members[i], indent+1); 971 } 972 else 973 hptiop_copy_info(pinfo, "\tMissing\n"); 974 } 975 if (id == devinfo.u.array.transform_source) { 976 hptiop_copy_info(pinfo, "\tExpanding/Migrating to:\n"); 977 hptiop_dump_devinfo(hba, pinfo, 978 devinfo.u.array.transform_target, indent+1); 979 } 980 break; 981 } 982 } 983 984 static ssize_t hptiop_show_version(struct class_device *class_dev, char *buf) 985 { 986 return snprintf(buf, PAGE_SIZE, "%s\n", driver_ver); 987 } 988 989 static ssize_t hptiop_cdev_read(struct file *filp, char __user *buf, 990 size_t count, loff_t *ppos) 991 { 992 struct hptiop_hba *hba = filp->private_data; 993 struct hptiop_getinfo info; 994 int i, j, ndev; 995 struct hpt_controller_info con_info; 996 struct hpt_channel_info chan_info; 997 __le32 ids[32]; 998 999 info.buffer = buf; 1000 info.buflength = count; 1001 info.bufoffset = ppos ? *ppos : 0; 1002 info.filpos = 0; 1003 info.buffillen = 0; 1004 1005 if (hptiop_get_controller_info(hba, &con_info)) 1006 return -EIO; 1007 1008 for (i = 0; i < con_info.num_buses; i++) { 1009 if (hptiop_get_channel_info(hba, i, &chan_info) == 0) { 1010 if (hpt_id_valid(chan_info.devices[0])) 1011 hptiop_dump_devinfo(hba, &info, 1012 chan_info.devices[0], 0); 1013 if (hpt_id_valid(chan_info.devices[1])) 1014 hptiop_dump_devinfo(hba, &info, 1015 chan_info.devices[1], 0); 1016 } 1017 } 1018 1019 ndev = hptiop_get_logical_devices(hba, ids, 1020 sizeof(ids) / sizeof(ids[0])); 1021 1022 /* 1023 * if hptiop_get_logical_devices fails, ndev==-1 and it just 1024 * output nothing here 1025 */ 1026 for (j = 0; j < ndev; j++) 1027 hptiop_dump_devinfo(hba, &info, ids[j], 0); 1028 1029 if (ppos) 1030 *ppos += info.buffillen; 1031 1032 return info.buffillen; 1033 } 1034 1035 static int hptiop_cdev_ioctl(struct inode *inode, struct file *file, 1036 unsigned int cmd, unsigned long arg) 1037 { 1038 struct hptiop_hba *hba = file->private_data; 1039 struct hpt_ioctl_u ioctl_u; 1040 struct hpt_ioctl_k ioctl_k; 1041 u32 bytes_returned; 1042 int err = -EINVAL; 1043 1044 if (copy_from_user(&ioctl_u, 1045 (void __user *)arg, sizeof(struct hpt_ioctl_u))) 1046 return -EINVAL; 1047 1048 if (ioctl_u.magic != HPT_IOCTL_MAGIC) 1049 return -EINVAL; 1050 1051 ioctl_k.ioctl_code = ioctl_u.ioctl_code; 1052 ioctl_k.inbuf = NULL; 1053 ioctl_k.inbuf_size = ioctl_u.inbuf_size; 1054 ioctl_k.outbuf = NULL; 1055 ioctl_k.outbuf_size = ioctl_u.outbuf_size; 1056 ioctl_k.hba = hba; 1057 ioctl_k.bytes_returned = &bytes_returned; 1058 1059 /* verify user buffer */ 1060 if ((ioctl_k.inbuf_size && !access_ok(VERIFY_READ, 1061 ioctl_u.inbuf, ioctl_k.inbuf_size)) || 1062 (ioctl_k.outbuf_size && !access_ok(VERIFY_WRITE, 1063 ioctl_u.outbuf, ioctl_k.outbuf_size)) || 1064 (ioctl_u.bytes_returned && !access_ok(VERIFY_WRITE, 1065 ioctl_u.bytes_returned, sizeof(u32))) || 1066 ioctl_k.inbuf_size + ioctl_k.outbuf_size > 0x10000) { 1067 1068 dprintk("scsi%d: got bad user address\n", hba->host->host_no); 1069 return -EINVAL; 1070 } 1071 1072 /* map buffer to kernel. */ 1073 if (ioctl_k.inbuf_size) { 1074 ioctl_k.inbuf = kmalloc(ioctl_k.inbuf_size, GFP_KERNEL); 1075 if (!ioctl_k.inbuf) { 1076 dprintk("scsi%d: fail to alloc inbuf\n", 1077 hba->host->host_no); 1078 err = -ENOMEM; 1079 goto err_exit; 1080 } 1081 1082 if (copy_from_user(ioctl_k.inbuf, 1083 ioctl_u.inbuf, ioctl_k.inbuf_size)) { 1084 goto err_exit; 1085 } 1086 } 1087 1088 if (ioctl_k.outbuf_size) { 1089 ioctl_k.outbuf = kmalloc(ioctl_k.outbuf_size, GFP_KERNEL); 1090 if (!ioctl_k.outbuf) { 1091 dprintk("scsi%d: fail to alloc outbuf\n", 1092 hba->host->host_no); 1093 err = -ENOMEM; 1094 goto err_exit; 1095 } 1096 } 1097 1098 hptiop_do_ioctl(&ioctl_k); 1099 1100 if (ioctl_k.result == HPT_IOCTL_RESULT_OK) { 1101 if (ioctl_k.outbuf_size && 1102 copy_to_user(ioctl_u.outbuf, 1103 ioctl_k.outbuf, ioctl_k.outbuf_size)) 1104 goto err_exit; 1105 1106 if (ioctl_u.bytes_returned && 1107 copy_to_user(ioctl_u.bytes_returned, 1108 &bytes_returned, sizeof(u32))) 1109 goto err_exit; 1110 1111 err = 0; 1112 } 1113 1114 err_exit: 1115 kfree(ioctl_k.inbuf); 1116 kfree(ioctl_k.outbuf); 1117 1118 return err; 1119 } 1120 1121 static int hptiop_cdev_open(struct inode *inode, struct file *file) 1122 { 1123 struct hptiop_hba *hba; 1124 unsigned i = 0, minor = iminor(inode); 1125 int ret = -ENODEV; 1126 1127 spin_lock(&hptiop_hba_list_lock); 1128 list_for_each_entry(hba, &hptiop_hba_list, link) { 1129 if (i == minor) { 1130 file->private_data = hba; 1131 ret = 0; 1132 goto out; 1133 } 1134 i++; 1135 } 1136 1137 out: 1138 spin_unlock(&hptiop_hba_list_lock); 1139 return ret; 1140 } 1141 1142 static struct file_operations hptiop_cdev_fops = { 1143 .owner = THIS_MODULE, 1144 .read = hptiop_cdev_read, 1145 .ioctl = hptiop_cdev_ioctl, 1146 .open = hptiop_cdev_open, 1147 }; 1148 1149 static ssize_t hptiop_show_fw_version(struct class_device *class_dev, char *buf) 1150 { 1151 struct Scsi_Host *host = class_to_shost(class_dev); 1152 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 1153 1154 return snprintf(buf, PAGE_SIZE, "%d.%d.%d.%d\n", 1155 hba->firmware_version >> 24, 1156 (hba->firmware_version >> 16) & 0xff, 1157 (hba->firmware_version >> 8) & 0xff, 1158 hba->firmware_version & 0xff); 1159 } 1160 1161 static struct class_device_attribute hptiop_attr_version = { 1162 .attr = { 1163 .name = "driver-version", 1164 .mode = S_IRUGO, 1165 }, 1166 .show = hptiop_show_version, 1167 }; 1168 1169 static struct class_device_attribute hptiop_attr_fw_version = { 1170 .attr = { 1171 .name = "firmware-version", 1172 .mode = S_IRUGO, 1173 }, 1174 .show = hptiop_show_fw_version, 1175 }; 1176 1177 static struct class_device_attribute *hptiop_attrs[] = { 1178 &hptiop_attr_version, 1179 &hptiop_attr_fw_version, 1180 NULL 1181 }; 1182 1183 static struct scsi_host_template driver_template = { 1184 .module = THIS_MODULE, 1185 .name = driver_name, 1186 .queuecommand = hptiop_queuecommand, 1187 .eh_device_reset_handler = hptiop_reset, 1188 .eh_bus_reset_handler = hptiop_reset, 1189 .info = hptiop_info, 1190 .unchecked_isa_dma = 0, 1191 .emulated = 0, 1192 .use_clustering = ENABLE_CLUSTERING, 1193 .proc_name = driver_name, 1194 .shost_attrs = hptiop_attrs, 1195 .this_id = -1, 1196 .change_queue_depth = hptiop_adjust_disk_queue_depth, 1197 }; 1198 1199 static int __devinit hptiop_probe(struct pci_dev *pcidev, 1200 const struct pci_device_id *id) 1201 { 1202 struct Scsi_Host *host = NULL; 1203 struct hptiop_hba *hba; 1204 struct hpt_iop_request_get_config iop_config; 1205 struct hpt_iop_request_set_config set_config; 1206 dma_addr_t start_phy; 1207 void *start_virt; 1208 u32 offset, i, req_size; 1209 1210 dprintk("hptiop_probe(%p)\n", pcidev); 1211 1212 if (pci_enable_device(pcidev)) { 1213 printk(KERN_ERR "hptiop: fail to enable pci device\n"); 1214 return -ENODEV; 1215 } 1216 1217 printk(KERN_INFO "adapter at PCI %d:%d:%d, IRQ %d\n", 1218 pcidev->bus->number, pcidev->devfn >> 3, pcidev->devfn & 7, 1219 pcidev->irq); 1220 1221 pci_set_master(pcidev); 1222 1223 /* Enable 64bit DMA if possible */ 1224 if (pci_set_dma_mask(pcidev, DMA_64BIT_MASK)) { 1225 if (pci_set_dma_mask(pcidev, DMA_32BIT_MASK)) { 1226 printk(KERN_ERR "hptiop: fail to set dma_mask\n"); 1227 goto disable_pci_device; 1228 } 1229 } 1230 1231 if (pci_request_regions(pcidev, driver_name)) { 1232 printk(KERN_ERR "hptiop: pci_request_regions failed\n"); 1233 goto disable_pci_device; 1234 } 1235 1236 host = scsi_host_alloc(&driver_template, sizeof(struct hptiop_hba)); 1237 if (!host) { 1238 printk(KERN_ERR "hptiop: fail to alloc scsi host\n"); 1239 goto free_pci_regions; 1240 } 1241 1242 hba = (struct hptiop_hba *)host->hostdata; 1243 1244 hba->pcidev = pcidev; 1245 hba->host = host; 1246 hba->initialized = 0; 1247 1248 atomic_set(&hba->resetting, 0); 1249 atomic_set(&hba->reset_count, 0); 1250 1251 init_waitqueue_head(&hba->reset_wq); 1252 init_waitqueue_head(&hba->ioctl_wq); 1253 1254 host->max_lun = 1; 1255 host->max_channel = 0; 1256 host->io_port = 0; 1257 host->n_io_port = 0; 1258 host->irq = pcidev->irq; 1259 1260 if (hptiop_map_pci_bar(hba)) 1261 goto free_scsi_host; 1262 1263 if (iop_wait_ready(hba->iop, 20000)) { 1264 printk(KERN_ERR "scsi%d: firmware not ready\n", 1265 hba->host->host_no); 1266 goto unmap_pci_bar; 1267 } 1268 1269 if (iop_get_config(hba, &iop_config)) { 1270 printk(KERN_ERR "scsi%d: get config failed\n", 1271 hba->host->host_no); 1272 goto unmap_pci_bar; 1273 } 1274 1275 hba->max_requests = min(le32_to_cpu(iop_config.max_requests), 1276 HPTIOP_MAX_REQUESTS); 1277 hba->max_devices = le32_to_cpu(iop_config.max_devices); 1278 hba->max_request_size = le32_to_cpu(iop_config.request_size); 1279 hba->max_sg_descriptors = le32_to_cpu(iop_config.max_sg_count); 1280 hba->firmware_version = le32_to_cpu(iop_config.firmware_version); 1281 hba->sdram_size = le32_to_cpu(iop_config.sdram_size); 1282 1283 host->max_sectors = le32_to_cpu(iop_config.data_transfer_length) >> 9; 1284 host->max_id = le32_to_cpu(iop_config.max_devices); 1285 host->sg_tablesize = le32_to_cpu(iop_config.max_sg_count); 1286 host->can_queue = le32_to_cpu(iop_config.max_requests); 1287 host->cmd_per_lun = le32_to_cpu(iop_config.max_requests); 1288 host->max_cmd_len = 16; 1289 1290 set_config.vbus_id = cpu_to_le32(host->host_no); 1291 set_config.iop_id = cpu_to_le32(host->host_no); 1292 1293 if (iop_set_config(hba, &set_config)) { 1294 printk(KERN_ERR "scsi%d: set config failed\n", 1295 hba->host->host_no); 1296 goto unmap_pci_bar; 1297 } 1298 1299 if (scsi_add_host(host, &pcidev->dev)) { 1300 printk(KERN_ERR "scsi%d: scsi_add_host failed\n", 1301 hba->host->host_no); 1302 goto unmap_pci_bar; 1303 } 1304 1305 pci_set_drvdata(pcidev, host); 1306 1307 if (request_irq(pcidev->irq, hptiop_intr, IRQF_SHARED, 1308 driver_name, hba)) { 1309 printk(KERN_ERR "scsi%d: request irq %d failed\n", 1310 hba->host->host_no, pcidev->irq); 1311 goto remove_scsi_host; 1312 } 1313 1314 /* Allocate request mem */ 1315 req_size = sizeof(struct hpt_iop_request_scsi_command) 1316 + sizeof(struct hpt_iopsg) * (hba->max_sg_descriptors - 1); 1317 if ((req_size& 0x1f) != 0) 1318 req_size = (req_size + 0x1f) & ~0x1f; 1319 1320 dprintk("req_size=%d, max_requests=%d\n", req_size, hba->max_requests); 1321 1322 hba->req_size = req_size; 1323 start_virt = dma_alloc_coherent(&pcidev->dev, 1324 hba->req_size*hba->max_requests + 0x20, 1325 &start_phy, GFP_KERNEL); 1326 1327 if (!start_virt) { 1328 printk(KERN_ERR "scsi%d: fail to alloc request mem\n", 1329 hba->host->host_no); 1330 goto free_request_irq; 1331 } 1332 1333 hba->dma_coherent = start_virt; 1334 hba->dma_coherent_handle = start_phy; 1335 1336 if ((start_phy & 0x1f) != 0) 1337 { 1338 offset = ((start_phy + 0x1f) & ~0x1f) - start_phy; 1339 start_phy += offset; 1340 start_virt += offset; 1341 } 1342 1343 hba->req_list = start_virt; 1344 for (i = 0; i < hba->max_requests; i++) { 1345 hba->reqs[i].next = NULL; 1346 hba->reqs[i].req_virt = start_virt; 1347 hba->reqs[i].req_shifted_phy = start_phy >> 5; 1348 hba->reqs[i].index = i; 1349 free_req(hba, &hba->reqs[i]); 1350 start_virt = (char *)start_virt + hba->req_size; 1351 start_phy = start_phy + hba->req_size; 1352 } 1353 1354 /* Enable Interrupt and start background task */ 1355 if (hptiop_initialize_iop(hba)) 1356 goto free_request_mem; 1357 1358 spin_lock(&hptiop_hba_list_lock); 1359 list_add_tail(&hba->link, &hptiop_hba_list); 1360 spin_unlock(&hptiop_hba_list_lock); 1361 1362 scsi_scan_host(host); 1363 1364 dprintk("scsi%d: hptiop_probe successfully\n", hba->host->host_no); 1365 return 0; 1366 1367 free_request_mem: 1368 dma_free_coherent(&hba->pcidev->dev, 1369 hba->req_size*hba->max_requests + 0x20, 1370 hba->dma_coherent, hba->dma_coherent_handle); 1371 1372 free_request_irq: 1373 free_irq(hba->pcidev->irq, hba); 1374 1375 remove_scsi_host: 1376 scsi_remove_host(host); 1377 1378 unmap_pci_bar: 1379 iounmap(hba->iop); 1380 1381 free_pci_regions: 1382 pci_release_regions(pcidev) ; 1383 1384 free_scsi_host: 1385 scsi_host_put(host); 1386 1387 disable_pci_device: 1388 pci_disable_device(pcidev); 1389 1390 dprintk("scsi%d: hptiop_probe fail\n", host->host_no); 1391 return -ENODEV; 1392 } 1393 1394 static void hptiop_shutdown(struct pci_dev *pcidev) 1395 { 1396 struct Scsi_Host *host = pci_get_drvdata(pcidev); 1397 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 1398 struct hpt_iopmu __iomem *iop = hba->iop; 1399 u32 int_mask; 1400 1401 dprintk("hptiop_shutdown(%p)\n", hba); 1402 1403 /* stop the iop */ 1404 if (iop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_SHUTDOWN, 60000)) 1405 printk(KERN_ERR "scsi%d: shutdown the iop timeout\n", 1406 hba->host->host_no); 1407 1408 /* disable all outbound interrupts */ 1409 int_mask = readl(&iop->outbound_intmask); 1410 writel(int_mask | 1411 IOPMU_OUTBOUND_INT_MSG0 | IOPMU_OUTBOUND_INT_POSTQUEUE, 1412 &iop->outbound_intmask); 1413 hptiop_pci_posting_flush(iop); 1414 } 1415 1416 static void hptiop_remove(struct pci_dev *pcidev) 1417 { 1418 struct Scsi_Host *host = pci_get_drvdata(pcidev); 1419 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 1420 1421 dprintk("scsi%d: hptiop_remove\n", hba->host->host_no); 1422 1423 scsi_remove_host(host); 1424 1425 spin_lock(&hptiop_hba_list_lock); 1426 list_del_init(&hba->link); 1427 spin_unlock(&hptiop_hba_list_lock); 1428 1429 hptiop_shutdown(pcidev); 1430 1431 free_irq(hba->pcidev->irq, hba); 1432 1433 dma_free_coherent(&hba->pcidev->dev, 1434 hba->req_size * hba->max_requests + 0x20, 1435 hba->dma_coherent, 1436 hba->dma_coherent_handle); 1437 1438 iounmap(hba->iop); 1439 1440 pci_release_regions(hba->pcidev); 1441 pci_set_drvdata(hba->pcidev, NULL); 1442 pci_disable_device(hba->pcidev); 1443 1444 scsi_host_put(host); 1445 } 1446 1447 static struct pci_device_id hptiop_id_table[] = { 1448 { PCI_DEVICE(0x1103, 0x3220) }, 1449 { PCI_DEVICE(0x1103, 0x3320) }, 1450 {}, 1451 }; 1452 1453 MODULE_DEVICE_TABLE(pci, hptiop_id_table); 1454 1455 static struct pci_driver hptiop_pci_driver = { 1456 .name = driver_name, 1457 .id_table = hptiop_id_table, 1458 .probe = hptiop_probe, 1459 .remove = hptiop_remove, 1460 .shutdown = hptiop_shutdown, 1461 }; 1462 1463 static int __init hptiop_module_init(void) 1464 { 1465 int error; 1466 1467 printk(KERN_INFO "%s %s\n", driver_name_long, driver_ver); 1468 1469 error = pci_register_driver(&hptiop_pci_driver); 1470 if (error < 0) 1471 return error; 1472 1473 hptiop_cdev_major = register_chrdev(0, "hptiop", &hptiop_cdev_fops); 1474 if (hptiop_cdev_major < 0) { 1475 printk(KERN_WARNING "unable to register hptiop device.\n"); 1476 return hptiop_cdev_major; 1477 } 1478 1479 return 0; 1480 } 1481 1482 static void __exit hptiop_module_exit(void) 1483 { 1484 dprintk("hptiop_module_exit\n"); 1485 unregister_chrdev(hptiop_cdev_major, "hptiop"); 1486 pci_unregister_driver(&hptiop_pci_driver); 1487 } 1488 1489 1490 module_init(hptiop_module_init); 1491 module_exit(hptiop_module_exit); 1492 1493 MODULE_LICENSE("GPL"); 1494