1 /* 2 * HighPoint RR3xxx/4xxx controller driver for Linux 3 * Copyright (C) 2006-2009 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/module.h> 19 #include <linux/types.h> 20 #include <linux/string.h> 21 #include <linux/kernel.h> 22 #include <linux/pci.h> 23 #include <linux/interrupt.h> 24 #include <linux/errno.h> 25 #include <linux/delay.h> 26 #include <linux/timer.h> 27 #include <linux/spinlock.h> 28 #include <linux/gfp.h> 29 #include <asm/uaccess.h> 30 #include <asm/io.h> 31 #include <asm/div64.h> 32 #include <scsi/scsi_cmnd.h> 33 #include <scsi/scsi_device.h> 34 #include <scsi/scsi.h> 35 #include <scsi/scsi_tcq.h> 36 #include <scsi/scsi_host.h> 37 38 #include "hptiop.h" 39 40 MODULE_AUTHOR("HighPoint Technologies, Inc."); 41 MODULE_DESCRIPTION("HighPoint RocketRAID 3xxx/4xxx Controller Driver"); 42 43 static char driver_name[] = "hptiop"; 44 static const char driver_name_long[] = "RocketRAID 3xxx/4xxx Controller driver"; 45 static const char driver_ver[] = "v1.6 (090910)"; 46 47 static int iop_send_sync_msg(struct hptiop_hba *hba, u32 msg, u32 millisec); 48 static void hptiop_finish_scsi_req(struct hptiop_hba *hba, u32 tag, 49 struct hpt_iop_request_scsi_command *req); 50 static void hptiop_host_request_callback_itl(struct hptiop_hba *hba, u32 tag); 51 static void hptiop_iop_request_callback_itl(struct hptiop_hba *hba, u32 tag); 52 static void hptiop_message_callback(struct hptiop_hba *hba, u32 msg); 53 54 static int iop_wait_ready_itl(struct hptiop_hba *hba, u32 millisec) 55 { 56 u32 req = 0; 57 int i; 58 59 for (i = 0; i < millisec; i++) { 60 req = readl(&hba->u.itl.iop->inbound_queue); 61 if (req != IOPMU_QUEUE_EMPTY) 62 break; 63 msleep(1); 64 } 65 66 if (req != IOPMU_QUEUE_EMPTY) { 67 writel(req, &hba->u.itl.iop->outbound_queue); 68 readl(&hba->u.itl.iop->outbound_intstatus); 69 return 0; 70 } 71 72 return -1; 73 } 74 75 static int iop_wait_ready_mv(struct hptiop_hba *hba, u32 millisec) 76 { 77 return iop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_NOP, millisec); 78 } 79 80 static void hptiop_request_callback_itl(struct hptiop_hba *hba, u32 tag) 81 { 82 if (tag & IOPMU_QUEUE_ADDR_HOST_BIT) 83 hptiop_host_request_callback_itl(hba, 84 tag & ~IOPMU_QUEUE_ADDR_HOST_BIT); 85 else 86 hptiop_iop_request_callback_itl(hba, tag); 87 } 88 89 static void hptiop_drain_outbound_queue_itl(struct hptiop_hba *hba) 90 { 91 u32 req; 92 93 while ((req = readl(&hba->u.itl.iop->outbound_queue)) != 94 IOPMU_QUEUE_EMPTY) { 95 96 if (req & IOPMU_QUEUE_MASK_HOST_BITS) 97 hptiop_request_callback_itl(hba, req); 98 else { 99 struct hpt_iop_request_header __iomem * p; 100 101 p = (struct hpt_iop_request_header __iomem *) 102 ((char __iomem *)hba->u.itl.iop + req); 103 104 if (readl(&p->flags) & IOP_REQUEST_FLAG_SYNC_REQUEST) { 105 if (readl(&p->context)) 106 hptiop_request_callback_itl(hba, req); 107 else 108 writel(1, &p->context); 109 } 110 else 111 hptiop_request_callback_itl(hba, req); 112 } 113 } 114 } 115 116 static int iop_intr_itl(struct hptiop_hba *hba) 117 { 118 struct hpt_iopmu_itl __iomem *iop = hba->u.itl.iop; 119 void __iomem *plx = hba->u.itl.plx; 120 u32 status; 121 int ret = 0; 122 123 if (plx && readl(plx + 0x11C5C) & 0xf) 124 writel(1, plx + 0x11C60); 125 126 status = readl(&iop->outbound_intstatus); 127 128 if (status & IOPMU_OUTBOUND_INT_MSG0) { 129 u32 msg = readl(&iop->outbound_msgaddr0); 130 131 dprintk("received outbound msg %x\n", msg); 132 writel(IOPMU_OUTBOUND_INT_MSG0, &iop->outbound_intstatus); 133 hptiop_message_callback(hba, msg); 134 ret = 1; 135 } 136 137 if (status & IOPMU_OUTBOUND_INT_POSTQUEUE) { 138 hptiop_drain_outbound_queue_itl(hba); 139 ret = 1; 140 } 141 142 return ret; 143 } 144 145 static u64 mv_outbound_read(struct hpt_iopmu_mv __iomem *mu) 146 { 147 u32 outbound_tail = readl(&mu->outbound_tail); 148 u32 outbound_head = readl(&mu->outbound_head); 149 150 if (outbound_tail != outbound_head) { 151 u64 p; 152 153 memcpy_fromio(&p, &mu->outbound_q[mu->outbound_tail], 8); 154 outbound_tail++; 155 156 if (outbound_tail == MVIOP_QUEUE_LEN) 157 outbound_tail = 0; 158 writel(outbound_tail, &mu->outbound_tail); 159 return p; 160 } else 161 return 0; 162 } 163 164 static void mv_inbound_write(u64 p, struct hptiop_hba *hba) 165 { 166 u32 inbound_head = readl(&hba->u.mv.mu->inbound_head); 167 u32 head = inbound_head + 1; 168 169 if (head == MVIOP_QUEUE_LEN) 170 head = 0; 171 172 memcpy_toio(&hba->u.mv.mu->inbound_q[inbound_head], &p, 8); 173 writel(head, &hba->u.mv.mu->inbound_head); 174 writel(MVIOP_MU_INBOUND_INT_POSTQUEUE, 175 &hba->u.mv.regs->inbound_doorbell); 176 } 177 178 static void hptiop_request_callback_mv(struct hptiop_hba *hba, u64 tag) 179 { 180 u32 req_type = (tag >> 5) & 0x7; 181 struct hpt_iop_request_scsi_command *req; 182 183 dprintk("hptiop_request_callback_mv: tag=%llx\n", tag); 184 185 BUG_ON((tag & MVIOP_MU_QUEUE_REQUEST_RETURN_CONTEXT) == 0); 186 187 switch (req_type) { 188 case IOP_REQUEST_TYPE_GET_CONFIG: 189 case IOP_REQUEST_TYPE_SET_CONFIG: 190 hba->msg_done = 1; 191 break; 192 193 case IOP_REQUEST_TYPE_SCSI_COMMAND: 194 req = hba->reqs[tag >> 8].req_virt; 195 if (likely(tag & MVIOP_MU_QUEUE_REQUEST_RESULT_BIT)) 196 req->header.result = cpu_to_le32(IOP_RESULT_SUCCESS); 197 198 hptiop_finish_scsi_req(hba, tag>>8, req); 199 break; 200 201 default: 202 break; 203 } 204 } 205 206 static int iop_intr_mv(struct hptiop_hba *hba) 207 { 208 u32 status; 209 int ret = 0; 210 211 status = readl(&hba->u.mv.regs->outbound_doorbell); 212 writel(~status, &hba->u.mv.regs->outbound_doorbell); 213 214 if (status & MVIOP_MU_OUTBOUND_INT_MSG) { 215 u32 msg; 216 msg = readl(&hba->u.mv.mu->outbound_msg); 217 dprintk("received outbound msg %x\n", msg); 218 hptiop_message_callback(hba, msg); 219 ret = 1; 220 } 221 222 if (status & MVIOP_MU_OUTBOUND_INT_POSTQUEUE) { 223 u64 tag; 224 225 while ((tag = mv_outbound_read(hba->u.mv.mu))) 226 hptiop_request_callback_mv(hba, tag); 227 ret = 1; 228 } 229 230 return ret; 231 } 232 233 static int iop_send_sync_request_itl(struct hptiop_hba *hba, 234 void __iomem *_req, u32 millisec) 235 { 236 struct hpt_iop_request_header __iomem *req = _req; 237 u32 i; 238 239 writel(readl(&req->flags) | IOP_REQUEST_FLAG_SYNC_REQUEST, &req->flags); 240 writel(0, &req->context); 241 writel((unsigned long)req - (unsigned long)hba->u.itl.iop, 242 &hba->u.itl.iop->inbound_queue); 243 readl(&hba->u.itl.iop->outbound_intstatus); 244 245 for (i = 0; i < millisec; i++) { 246 iop_intr_itl(hba); 247 if (readl(&req->context)) 248 return 0; 249 msleep(1); 250 } 251 252 return -1; 253 } 254 255 static int iop_send_sync_request_mv(struct hptiop_hba *hba, 256 u32 size_bits, u32 millisec) 257 { 258 struct hpt_iop_request_header *reqhdr = hba->u.mv.internal_req; 259 u32 i; 260 261 hba->msg_done = 0; 262 reqhdr->flags |= cpu_to_le32(IOP_REQUEST_FLAG_SYNC_REQUEST); 263 mv_inbound_write(hba->u.mv.internal_req_phy | 264 MVIOP_MU_QUEUE_ADDR_HOST_BIT | size_bits, hba); 265 266 for (i = 0; i < millisec; i++) { 267 iop_intr_mv(hba); 268 if (hba->msg_done) 269 return 0; 270 msleep(1); 271 } 272 return -1; 273 } 274 275 static void hptiop_post_msg_itl(struct hptiop_hba *hba, u32 msg) 276 { 277 writel(msg, &hba->u.itl.iop->inbound_msgaddr0); 278 readl(&hba->u.itl.iop->outbound_intstatus); 279 } 280 281 static void hptiop_post_msg_mv(struct hptiop_hba *hba, u32 msg) 282 { 283 writel(msg, &hba->u.mv.mu->inbound_msg); 284 writel(MVIOP_MU_INBOUND_INT_MSG, &hba->u.mv.regs->inbound_doorbell); 285 readl(&hba->u.mv.regs->inbound_doorbell); 286 } 287 288 static int iop_send_sync_msg(struct hptiop_hba *hba, u32 msg, u32 millisec) 289 { 290 u32 i; 291 292 hba->msg_done = 0; 293 hba->ops->post_msg(hba, msg); 294 295 for (i = 0; i < millisec; i++) { 296 spin_lock_irq(hba->host->host_lock); 297 hba->ops->iop_intr(hba); 298 spin_unlock_irq(hba->host->host_lock); 299 if (hba->msg_done) 300 break; 301 msleep(1); 302 } 303 304 return hba->msg_done? 0 : -1; 305 } 306 307 static int iop_get_config_itl(struct hptiop_hba *hba, 308 struct hpt_iop_request_get_config *config) 309 { 310 u32 req32; 311 struct hpt_iop_request_get_config __iomem *req; 312 313 req32 = readl(&hba->u.itl.iop->inbound_queue); 314 if (req32 == IOPMU_QUEUE_EMPTY) 315 return -1; 316 317 req = (struct hpt_iop_request_get_config __iomem *) 318 ((unsigned long)hba->u.itl.iop + req32); 319 320 writel(0, &req->header.flags); 321 writel(IOP_REQUEST_TYPE_GET_CONFIG, &req->header.type); 322 writel(sizeof(struct hpt_iop_request_get_config), &req->header.size); 323 writel(IOP_RESULT_PENDING, &req->header.result); 324 325 if (iop_send_sync_request_itl(hba, req, 20000)) { 326 dprintk("Get config send cmd failed\n"); 327 return -1; 328 } 329 330 memcpy_fromio(config, req, sizeof(*config)); 331 writel(req32, &hba->u.itl.iop->outbound_queue); 332 return 0; 333 } 334 335 static int iop_get_config_mv(struct hptiop_hba *hba, 336 struct hpt_iop_request_get_config *config) 337 { 338 struct hpt_iop_request_get_config *req = hba->u.mv.internal_req; 339 340 req->header.flags = cpu_to_le32(IOP_REQUEST_FLAG_OUTPUT_CONTEXT); 341 req->header.type = cpu_to_le32(IOP_REQUEST_TYPE_GET_CONFIG); 342 req->header.size = 343 cpu_to_le32(sizeof(struct hpt_iop_request_get_config)); 344 req->header.result = cpu_to_le32(IOP_RESULT_PENDING); 345 req->header.context = cpu_to_le32(IOP_REQUEST_TYPE_GET_CONFIG<<5); 346 req->header.context_hi32 = 0; 347 348 if (iop_send_sync_request_mv(hba, 0, 20000)) { 349 dprintk("Get config send cmd failed\n"); 350 return -1; 351 } 352 353 memcpy(config, req, sizeof(struct hpt_iop_request_get_config)); 354 return 0; 355 } 356 357 static int iop_set_config_itl(struct hptiop_hba *hba, 358 struct hpt_iop_request_set_config *config) 359 { 360 u32 req32; 361 struct hpt_iop_request_set_config __iomem *req; 362 363 req32 = readl(&hba->u.itl.iop->inbound_queue); 364 if (req32 == IOPMU_QUEUE_EMPTY) 365 return -1; 366 367 req = (struct hpt_iop_request_set_config __iomem *) 368 ((unsigned long)hba->u.itl.iop + req32); 369 370 memcpy_toio((u8 __iomem *)req + sizeof(struct hpt_iop_request_header), 371 (u8 *)config + sizeof(struct hpt_iop_request_header), 372 sizeof(struct hpt_iop_request_set_config) - 373 sizeof(struct hpt_iop_request_header)); 374 375 writel(0, &req->header.flags); 376 writel(IOP_REQUEST_TYPE_SET_CONFIG, &req->header.type); 377 writel(sizeof(struct hpt_iop_request_set_config), &req->header.size); 378 writel(IOP_RESULT_PENDING, &req->header.result); 379 380 if (iop_send_sync_request_itl(hba, req, 20000)) { 381 dprintk("Set config send cmd failed\n"); 382 return -1; 383 } 384 385 writel(req32, &hba->u.itl.iop->outbound_queue); 386 return 0; 387 } 388 389 static int iop_set_config_mv(struct hptiop_hba *hba, 390 struct hpt_iop_request_set_config *config) 391 { 392 struct hpt_iop_request_set_config *req = hba->u.mv.internal_req; 393 394 memcpy(req, config, sizeof(struct hpt_iop_request_set_config)); 395 req->header.flags = cpu_to_le32(IOP_REQUEST_FLAG_OUTPUT_CONTEXT); 396 req->header.type = cpu_to_le32(IOP_REQUEST_TYPE_SET_CONFIG); 397 req->header.size = 398 cpu_to_le32(sizeof(struct hpt_iop_request_set_config)); 399 req->header.result = cpu_to_le32(IOP_RESULT_PENDING); 400 req->header.context = cpu_to_le32(IOP_REQUEST_TYPE_SET_CONFIG<<5); 401 req->header.context_hi32 = 0; 402 403 if (iop_send_sync_request_mv(hba, 0, 20000)) { 404 dprintk("Set config send cmd failed\n"); 405 return -1; 406 } 407 408 return 0; 409 } 410 411 static void hptiop_enable_intr_itl(struct hptiop_hba *hba) 412 { 413 writel(~(IOPMU_OUTBOUND_INT_POSTQUEUE | IOPMU_OUTBOUND_INT_MSG0), 414 &hba->u.itl.iop->outbound_intmask); 415 } 416 417 static void hptiop_enable_intr_mv(struct hptiop_hba *hba) 418 { 419 writel(MVIOP_MU_OUTBOUND_INT_POSTQUEUE | MVIOP_MU_OUTBOUND_INT_MSG, 420 &hba->u.mv.regs->outbound_intmask); 421 } 422 423 static int hptiop_initialize_iop(struct hptiop_hba *hba) 424 { 425 /* enable interrupts */ 426 hba->ops->enable_intr(hba); 427 428 hba->initialized = 1; 429 430 /* start background tasks */ 431 if (iop_send_sync_msg(hba, 432 IOPMU_INBOUND_MSG0_START_BACKGROUND_TASK, 5000)) { 433 printk(KERN_ERR "scsi%d: fail to start background task\n", 434 hba->host->host_no); 435 return -1; 436 } 437 return 0; 438 } 439 440 static void __iomem *hptiop_map_pci_bar(struct hptiop_hba *hba, int index) 441 { 442 u32 mem_base_phy, length; 443 void __iomem *mem_base_virt; 444 445 struct pci_dev *pcidev = hba->pcidev; 446 447 448 if (!(pci_resource_flags(pcidev, index) & IORESOURCE_MEM)) { 449 printk(KERN_ERR "scsi%d: pci resource invalid\n", 450 hba->host->host_no); 451 return NULL; 452 } 453 454 mem_base_phy = pci_resource_start(pcidev, index); 455 length = pci_resource_len(pcidev, index); 456 mem_base_virt = ioremap(mem_base_phy, length); 457 458 if (!mem_base_virt) { 459 printk(KERN_ERR "scsi%d: Fail to ioremap memory space\n", 460 hba->host->host_no); 461 return NULL; 462 } 463 return mem_base_virt; 464 } 465 466 static int hptiop_map_pci_bar_itl(struct hptiop_hba *hba) 467 { 468 struct pci_dev *pcidev = hba->pcidev; 469 hba->u.itl.iop = hptiop_map_pci_bar(hba, 0); 470 if (hba->u.itl.iop == NULL) 471 return -1; 472 if ((pcidev->device & 0xff00) == 0x4400) { 473 hba->u.itl.plx = hba->u.itl.iop; 474 hba->u.itl.iop = hptiop_map_pci_bar(hba, 2); 475 if (hba->u.itl.iop == NULL) { 476 iounmap(hba->u.itl.plx); 477 return -1; 478 } 479 } 480 return 0; 481 } 482 483 static void hptiop_unmap_pci_bar_itl(struct hptiop_hba *hba) 484 { 485 if (hba->u.itl.plx) 486 iounmap(hba->u.itl.plx); 487 iounmap(hba->u.itl.iop); 488 } 489 490 static int hptiop_map_pci_bar_mv(struct hptiop_hba *hba) 491 { 492 hba->u.mv.regs = hptiop_map_pci_bar(hba, 0); 493 if (hba->u.mv.regs == NULL) 494 return -1; 495 496 hba->u.mv.mu = hptiop_map_pci_bar(hba, 2); 497 if (hba->u.mv.mu == NULL) { 498 iounmap(hba->u.mv.regs); 499 return -1; 500 } 501 502 return 0; 503 } 504 505 static void hptiop_unmap_pci_bar_mv(struct hptiop_hba *hba) 506 { 507 iounmap(hba->u.mv.regs); 508 iounmap(hba->u.mv.mu); 509 } 510 511 static void hptiop_message_callback(struct hptiop_hba *hba, u32 msg) 512 { 513 dprintk("iop message 0x%x\n", msg); 514 515 if (msg == IOPMU_INBOUND_MSG0_NOP) 516 hba->msg_done = 1; 517 518 if (!hba->initialized) 519 return; 520 521 if (msg == IOPMU_INBOUND_MSG0_RESET) { 522 atomic_set(&hba->resetting, 0); 523 wake_up(&hba->reset_wq); 524 } 525 else if (msg <= IOPMU_INBOUND_MSG0_MAX) 526 hba->msg_done = 1; 527 } 528 529 static struct hptiop_request *get_req(struct hptiop_hba *hba) 530 { 531 struct hptiop_request *ret; 532 533 dprintk("get_req : req=%p\n", hba->req_list); 534 535 ret = hba->req_list; 536 if (ret) 537 hba->req_list = ret->next; 538 539 return ret; 540 } 541 542 static void free_req(struct hptiop_hba *hba, struct hptiop_request *req) 543 { 544 dprintk("free_req(%d, %p)\n", req->index, req); 545 req->next = hba->req_list; 546 hba->req_list = req; 547 } 548 549 static void hptiop_finish_scsi_req(struct hptiop_hba *hba, u32 tag, 550 struct hpt_iop_request_scsi_command *req) 551 { 552 struct scsi_cmnd *scp; 553 554 dprintk("hptiop_finish_scsi_req: req=%p, type=%d, " 555 "result=%d, context=0x%x tag=%d\n", 556 req, req->header.type, req->header.result, 557 req->header.context, tag); 558 559 BUG_ON(!req->header.result); 560 BUG_ON(req->header.type != cpu_to_le32(IOP_REQUEST_TYPE_SCSI_COMMAND)); 561 562 scp = hba->reqs[tag].scp; 563 564 if (HPT_SCP(scp)->mapped) 565 scsi_dma_unmap(scp); 566 567 switch (le32_to_cpu(req->header.result)) { 568 case IOP_RESULT_SUCCESS: 569 scsi_set_resid(scp, 570 scsi_bufflen(scp) - le32_to_cpu(req->dataxfer_length)); 571 scp->result = (DID_OK<<16); 572 break; 573 case IOP_RESULT_BAD_TARGET: 574 scp->result = (DID_BAD_TARGET<<16); 575 break; 576 case IOP_RESULT_BUSY: 577 scp->result = (DID_BUS_BUSY<<16); 578 break; 579 case IOP_RESULT_RESET: 580 scp->result = (DID_RESET<<16); 581 break; 582 case IOP_RESULT_FAIL: 583 scp->result = (DID_ERROR<<16); 584 break; 585 case IOP_RESULT_INVALID_REQUEST: 586 scp->result = (DID_ABORT<<16); 587 break; 588 case IOP_RESULT_CHECK_CONDITION: 589 scsi_set_resid(scp, 590 scsi_bufflen(scp) - le32_to_cpu(req->dataxfer_length)); 591 scp->result = SAM_STAT_CHECK_CONDITION; 592 memcpy(scp->sense_buffer, &req->sg_list, 593 min_t(size_t, SCSI_SENSE_BUFFERSIZE, 594 le32_to_cpu(req->dataxfer_length))); 595 break; 596 597 default: 598 scp->result = DRIVER_INVALID << 24 | DID_ABORT << 16; 599 break; 600 } 601 602 dprintk("scsi_done(%p)\n", scp); 603 scp->scsi_done(scp); 604 free_req(hba, &hba->reqs[tag]); 605 } 606 607 static void hptiop_host_request_callback_itl(struct hptiop_hba *hba, u32 _tag) 608 { 609 struct hpt_iop_request_scsi_command *req; 610 u32 tag; 611 612 if (hba->iopintf_v2) { 613 tag = _tag & ~IOPMU_QUEUE_REQUEST_RESULT_BIT; 614 req = hba->reqs[tag].req_virt; 615 if (likely(_tag & IOPMU_QUEUE_REQUEST_RESULT_BIT)) 616 req->header.result = cpu_to_le32(IOP_RESULT_SUCCESS); 617 } else { 618 tag = _tag; 619 req = hba->reqs[tag].req_virt; 620 } 621 622 hptiop_finish_scsi_req(hba, tag, req); 623 } 624 625 void hptiop_iop_request_callback_itl(struct hptiop_hba *hba, u32 tag) 626 { 627 struct hpt_iop_request_header __iomem *req; 628 struct hpt_iop_request_ioctl_command __iomem *p; 629 struct hpt_ioctl_k *arg; 630 631 req = (struct hpt_iop_request_header __iomem *) 632 ((unsigned long)hba->u.itl.iop + tag); 633 dprintk("hptiop_iop_request_callback_itl: req=%p, type=%d, " 634 "result=%d, context=0x%x tag=%d\n", 635 req, readl(&req->type), readl(&req->result), 636 readl(&req->context), tag); 637 638 BUG_ON(!readl(&req->result)); 639 BUG_ON(readl(&req->type) != IOP_REQUEST_TYPE_IOCTL_COMMAND); 640 641 p = (struct hpt_iop_request_ioctl_command __iomem *)req; 642 arg = (struct hpt_ioctl_k *)(unsigned long) 643 (readl(&req->context) | 644 ((u64)readl(&req->context_hi32)<<32)); 645 646 if (readl(&req->result) == IOP_RESULT_SUCCESS) { 647 arg->result = HPT_IOCTL_RESULT_OK; 648 649 if (arg->outbuf_size) 650 memcpy_fromio(arg->outbuf, 651 &p->buf[(readl(&p->inbuf_size) + 3)& ~3], 652 arg->outbuf_size); 653 654 if (arg->bytes_returned) 655 *arg->bytes_returned = arg->outbuf_size; 656 } 657 else 658 arg->result = HPT_IOCTL_RESULT_FAILED; 659 660 arg->done(arg); 661 writel(tag, &hba->u.itl.iop->outbound_queue); 662 } 663 664 static irqreturn_t hptiop_intr(int irq, void *dev_id) 665 { 666 struct hptiop_hba *hba = dev_id; 667 int handled; 668 unsigned long flags; 669 670 spin_lock_irqsave(hba->host->host_lock, flags); 671 handled = hba->ops->iop_intr(hba); 672 spin_unlock_irqrestore(hba->host->host_lock, flags); 673 674 return handled; 675 } 676 677 static int hptiop_buildsgl(struct scsi_cmnd *scp, struct hpt_iopsg *psg) 678 { 679 struct Scsi_Host *host = scp->device->host; 680 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 681 struct scatterlist *sg; 682 int idx, nseg; 683 684 nseg = scsi_dma_map(scp); 685 BUG_ON(nseg < 0); 686 if (!nseg) 687 return 0; 688 689 HPT_SCP(scp)->sgcnt = nseg; 690 HPT_SCP(scp)->mapped = 1; 691 692 BUG_ON(HPT_SCP(scp)->sgcnt > hba->max_sg_descriptors); 693 694 scsi_for_each_sg(scp, sg, HPT_SCP(scp)->sgcnt, idx) { 695 psg[idx].pci_address = cpu_to_le64(sg_dma_address(sg)); 696 psg[idx].size = cpu_to_le32(sg_dma_len(sg)); 697 psg[idx].eot = (idx == HPT_SCP(scp)->sgcnt - 1) ? 698 cpu_to_le32(1) : 0; 699 } 700 return HPT_SCP(scp)->sgcnt; 701 } 702 703 static void hptiop_post_req_itl(struct hptiop_hba *hba, 704 struct hptiop_request *_req) 705 { 706 struct hpt_iop_request_header *reqhdr = _req->req_virt; 707 708 reqhdr->context = cpu_to_le32(IOPMU_QUEUE_ADDR_HOST_BIT | 709 (u32)_req->index); 710 reqhdr->context_hi32 = 0; 711 712 if (hba->iopintf_v2) { 713 u32 size, size_bits; 714 715 size = le32_to_cpu(reqhdr->size); 716 if (size < 256) 717 size_bits = IOPMU_QUEUE_REQUEST_SIZE_BIT; 718 else if (size < 512) 719 size_bits = IOPMU_QUEUE_ADDR_HOST_BIT; 720 else 721 size_bits = IOPMU_QUEUE_REQUEST_SIZE_BIT | 722 IOPMU_QUEUE_ADDR_HOST_BIT; 723 writel(_req->req_shifted_phy | size_bits, 724 &hba->u.itl.iop->inbound_queue); 725 } else 726 writel(_req->req_shifted_phy | IOPMU_QUEUE_ADDR_HOST_BIT, 727 &hba->u.itl.iop->inbound_queue); 728 } 729 730 static void hptiop_post_req_mv(struct hptiop_hba *hba, 731 struct hptiop_request *_req) 732 { 733 struct hpt_iop_request_header *reqhdr = _req->req_virt; 734 u32 size, size_bit; 735 736 reqhdr->context = cpu_to_le32(_req->index<<8 | 737 IOP_REQUEST_TYPE_SCSI_COMMAND<<5); 738 reqhdr->context_hi32 = 0; 739 size = le32_to_cpu(reqhdr->size); 740 741 if (size <= 256) 742 size_bit = 0; 743 else if (size <= 256*2) 744 size_bit = 1; 745 else if (size <= 256*3) 746 size_bit = 2; 747 else 748 size_bit = 3; 749 750 mv_inbound_write((_req->req_shifted_phy << 5) | 751 MVIOP_MU_QUEUE_ADDR_HOST_BIT | size_bit, hba); 752 } 753 754 static int hptiop_queuecommand_lck(struct scsi_cmnd *scp, 755 void (*done)(struct scsi_cmnd *)) 756 { 757 struct Scsi_Host *host = scp->device->host; 758 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 759 struct hpt_iop_request_scsi_command *req; 760 int sg_count = 0; 761 struct hptiop_request *_req; 762 763 BUG_ON(!done); 764 scp->scsi_done = done; 765 766 _req = get_req(hba); 767 if (_req == NULL) { 768 dprintk("hptiop_queuecmd : no free req\n"); 769 return SCSI_MLQUEUE_HOST_BUSY; 770 } 771 772 _req->scp = scp; 773 774 dprintk("hptiop_queuecmd(scp=%p) %d/%d/%d/%d cdb=(%x-%x-%x) " 775 "req_index=%d, req=%p\n", 776 scp, 777 host->host_no, scp->device->channel, 778 scp->device->id, scp->device->lun, 779 ((u32 *)scp->cmnd)[0], 780 ((u32 *)scp->cmnd)[1], 781 ((u32 *)scp->cmnd)[2], 782 _req->index, _req->req_virt); 783 784 scp->result = 0; 785 786 if (scp->device->channel || scp->device->lun || 787 scp->device->id > hba->max_devices) { 788 scp->result = DID_BAD_TARGET << 16; 789 free_req(hba, _req); 790 goto cmd_done; 791 } 792 793 req = _req->req_virt; 794 795 /* build S/G table */ 796 sg_count = hptiop_buildsgl(scp, req->sg_list); 797 if (!sg_count) 798 HPT_SCP(scp)->mapped = 0; 799 800 req->header.flags = cpu_to_le32(IOP_REQUEST_FLAG_OUTPUT_CONTEXT); 801 req->header.type = cpu_to_le32(IOP_REQUEST_TYPE_SCSI_COMMAND); 802 req->header.result = cpu_to_le32(IOP_RESULT_PENDING); 803 req->dataxfer_length = cpu_to_le32(scsi_bufflen(scp)); 804 req->channel = scp->device->channel; 805 req->target = scp->device->id; 806 req->lun = scp->device->lun; 807 req->header.size = cpu_to_le32( 808 sizeof(struct hpt_iop_request_scsi_command) 809 - sizeof(struct hpt_iopsg) 810 + sg_count * sizeof(struct hpt_iopsg)); 811 812 memcpy(req->cdb, scp->cmnd, sizeof(req->cdb)); 813 hba->ops->post_req(hba, _req); 814 return 0; 815 816 cmd_done: 817 dprintk("scsi_done(scp=%p)\n", scp); 818 scp->scsi_done(scp); 819 return 0; 820 } 821 822 static DEF_SCSI_QCMD(hptiop_queuecommand) 823 824 static const char *hptiop_info(struct Scsi_Host *host) 825 { 826 return driver_name_long; 827 } 828 829 static int hptiop_reset_hba(struct hptiop_hba *hba) 830 { 831 if (atomic_xchg(&hba->resetting, 1) == 0) { 832 atomic_inc(&hba->reset_count); 833 hba->ops->post_msg(hba, IOPMU_INBOUND_MSG0_RESET); 834 } 835 836 wait_event_timeout(hba->reset_wq, 837 atomic_read(&hba->resetting) == 0, 60 * HZ); 838 839 if (atomic_read(&hba->resetting)) { 840 /* IOP is in unknown state, abort reset */ 841 printk(KERN_ERR "scsi%d: reset failed\n", hba->host->host_no); 842 return -1; 843 } 844 845 if (iop_send_sync_msg(hba, 846 IOPMU_INBOUND_MSG0_START_BACKGROUND_TASK, 5000)) { 847 dprintk("scsi%d: fail to start background task\n", 848 hba->host->host_no); 849 } 850 851 return 0; 852 } 853 854 static int hptiop_reset(struct scsi_cmnd *scp) 855 { 856 struct Scsi_Host * host = scp->device->host; 857 struct hptiop_hba * hba = (struct hptiop_hba *)host->hostdata; 858 859 printk(KERN_WARNING "hptiop_reset(%d/%d/%d) scp=%p\n", 860 scp->device->host->host_no, scp->device->channel, 861 scp->device->id, scp); 862 863 return hptiop_reset_hba(hba)? FAILED : SUCCESS; 864 } 865 866 static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev, 867 int queue_depth, int reason) 868 { 869 struct hptiop_hba *hba = (struct hptiop_hba *)sdev->host->hostdata; 870 871 if (reason != SCSI_QDEPTH_DEFAULT) 872 return -EOPNOTSUPP; 873 874 if (queue_depth > hba->max_requests) 875 queue_depth = hba->max_requests; 876 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth); 877 return queue_depth; 878 } 879 880 static ssize_t hptiop_show_version(struct device *dev, 881 struct device_attribute *attr, char *buf) 882 { 883 return snprintf(buf, PAGE_SIZE, "%s\n", driver_ver); 884 } 885 886 static ssize_t hptiop_show_fw_version(struct device *dev, 887 struct device_attribute *attr, char *buf) 888 { 889 struct Scsi_Host *host = class_to_shost(dev); 890 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 891 892 return snprintf(buf, PAGE_SIZE, "%d.%d.%d.%d\n", 893 hba->firmware_version >> 24, 894 (hba->firmware_version >> 16) & 0xff, 895 (hba->firmware_version >> 8) & 0xff, 896 hba->firmware_version & 0xff); 897 } 898 899 static struct device_attribute hptiop_attr_version = { 900 .attr = { 901 .name = "driver-version", 902 .mode = S_IRUGO, 903 }, 904 .show = hptiop_show_version, 905 }; 906 907 static struct device_attribute hptiop_attr_fw_version = { 908 .attr = { 909 .name = "firmware-version", 910 .mode = S_IRUGO, 911 }, 912 .show = hptiop_show_fw_version, 913 }; 914 915 static struct device_attribute *hptiop_attrs[] = { 916 &hptiop_attr_version, 917 &hptiop_attr_fw_version, 918 NULL 919 }; 920 921 static struct scsi_host_template driver_template = { 922 .module = THIS_MODULE, 923 .name = driver_name, 924 .queuecommand = hptiop_queuecommand, 925 .eh_device_reset_handler = hptiop_reset, 926 .eh_bus_reset_handler = hptiop_reset, 927 .info = hptiop_info, 928 .emulated = 0, 929 .use_clustering = ENABLE_CLUSTERING, 930 .proc_name = driver_name, 931 .shost_attrs = hptiop_attrs, 932 .this_id = -1, 933 .change_queue_depth = hptiop_adjust_disk_queue_depth, 934 }; 935 936 static int hptiop_internal_memalloc_mv(struct hptiop_hba *hba) 937 { 938 hba->u.mv.internal_req = dma_alloc_coherent(&hba->pcidev->dev, 939 0x800, &hba->u.mv.internal_req_phy, GFP_KERNEL); 940 if (hba->u.mv.internal_req) 941 return 0; 942 else 943 return -1; 944 } 945 946 static int hptiop_internal_memfree_mv(struct hptiop_hba *hba) 947 { 948 if (hba->u.mv.internal_req) { 949 dma_free_coherent(&hba->pcidev->dev, 0x800, 950 hba->u.mv.internal_req, hba->u.mv.internal_req_phy); 951 return 0; 952 } else 953 return -1; 954 } 955 956 static int __devinit hptiop_probe(struct pci_dev *pcidev, 957 const struct pci_device_id *id) 958 { 959 struct Scsi_Host *host = NULL; 960 struct hptiop_hba *hba; 961 struct hpt_iop_request_get_config iop_config; 962 struct hpt_iop_request_set_config set_config; 963 dma_addr_t start_phy; 964 void *start_virt; 965 u32 offset, i, req_size; 966 967 dprintk("hptiop_probe(%p)\n", pcidev); 968 969 if (pci_enable_device(pcidev)) { 970 printk(KERN_ERR "hptiop: fail to enable pci device\n"); 971 return -ENODEV; 972 } 973 974 printk(KERN_INFO "adapter at PCI %d:%d:%d, IRQ %d\n", 975 pcidev->bus->number, pcidev->devfn >> 3, pcidev->devfn & 7, 976 pcidev->irq); 977 978 pci_set_master(pcidev); 979 980 /* Enable 64bit DMA if possible */ 981 if (pci_set_dma_mask(pcidev, DMA_BIT_MASK(64))) { 982 if (pci_set_dma_mask(pcidev, DMA_BIT_MASK(32))) { 983 printk(KERN_ERR "hptiop: fail to set dma_mask\n"); 984 goto disable_pci_device; 985 } 986 } 987 988 if (pci_request_regions(pcidev, driver_name)) { 989 printk(KERN_ERR "hptiop: pci_request_regions failed\n"); 990 goto disable_pci_device; 991 } 992 993 host = scsi_host_alloc(&driver_template, sizeof(struct hptiop_hba)); 994 if (!host) { 995 printk(KERN_ERR "hptiop: fail to alloc scsi host\n"); 996 goto free_pci_regions; 997 } 998 999 hba = (struct hptiop_hba *)host->hostdata; 1000 1001 hba->ops = (struct hptiop_adapter_ops *)id->driver_data; 1002 hba->pcidev = pcidev; 1003 hba->host = host; 1004 hba->initialized = 0; 1005 hba->iopintf_v2 = 0; 1006 1007 atomic_set(&hba->resetting, 0); 1008 atomic_set(&hba->reset_count, 0); 1009 1010 init_waitqueue_head(&hba->reset_wq); 1011 init_waitqueue_head(&hba->ioctl_wq); 1012 1013 host->max_lun = 1; 1014 host->max_channel = 0; 1015 host->io_port = 0; 1016 host->n_io_port = 0; 1017 host->irq = pcidev->irq; 1018 1019 if (hba->ops->map_pci_bar(hba)) 1020 goto free_scsi_host; 1021 1022 if (hba->ops->iop_wait_ready(hba, 20000)) { 1023 printk(KERN_ERR "scsi%d: firmware not ready\n", 1024 hba->host->host_no); 1025 goto unmap_pci_bar; 1026 } 1027 1028 if (hba->ops->internal_memalloc) { 1029 if (hba->ops->internal_memalloc(hba)) { 1030 printk(KERN_ERR "scsi%d: internal_memalloc failed\n", 1031 hba->host->host_no); 1032 goto unmap_pci_bar; 1033 } 1034 } 1035 1036 if (hba->ops->get_config(hba, &iop_config)) { 1037 printk(KERN_ERR "scsi%d: get config failed\n", 1038 hba->host->host_no); 1039 goto unmap_pci_bar; 1040 } 1041 1042 hba->max_requests = min(le32_to_cpu(iop_config.max_requests), 1043 HPTIOP_MAX_REQUESTS); 1044 hba->max_devices = le32_to_cpu(iop_config.max_devices); 1045 hba->max_request_size = le32_to_cpu(iop_config.request_size); 1046 hba->max_sg_descriptors = le32_to_cpu(iop_config.max_sg_count); 1047 hba->firmware_version = le32_to_cpu(iop_config.firmware_version); 1048 hba->interface_version = le32_to_cpu(iop_config.interface_version); 1049 hba->sdram_size = le32_to_cpu(iop_config.sdram_size); 1050 1051 if (hba->firmware_version > 0x01020000 || 1052 hba->interface_version > 0x01020000) 1053 hba->iopintf_v2 = 1; 1054 1055 host->max_sectors = le32_to_cpu(iop_config.data_transfer_length) >> 9; 1056 host->max_id = le32_to_cpu(iop_config.max_devices); 1057 host->sg_tablesize = le32_to_cpu(iop_config.max_sg_count); 1058 host->can_queue = le32_to_cpu(iop_config.max_requests); 1059 host->cmd_per_lun = le32_to_cpu(iop_config.max_requests); 1060 host->max_cmd_len = 16; 1061 1062 req_size = sizeof(struct hpt_iop_request_scsi_command) 1063 + sizeof(struct hpt_iopsg) * (hba->max_sg_descriptors - 1); 1064 if ((req_size & 0x1f) != 0) 1065 req_size = (req_size + 0x1f) & ~0x1f; 1066 1067 memset(&set_config, 0, sizeof(struct hpt_iop_request_set_config)); 1068 set_config.iop_id = cpu_to_le32(host->host_no); 1069 set_config.vbus_id = cpu_to_le16(host->host_no); 1070 set_config.max_host_request_size = cpu_to_le16(req_size); 1071 1072 if (hba->ops->set_config(hba, &set_config)) { 1073 printk(KERN_ERR "scsi%d: set config failed\n", 1074 hba->host->host_no); 1075 goto unmap_pci_bar; 1076 } 1077 1078 pci_set_drvdata(pcidev, host); 1079 1080 if (request_irq(pcidev->irq, hptiop_intr, IRQF_SHARED, 1081 driver_name, hba)) { 1082 printk(KERN_ERR "scsi%d: request irq %d failed\n", 1083 hba->host->host_no, pcidev->irq); 1084 goto unmap_pci_bar; 1085 } 1086 1087 /* Allocate request mem */ 1088 1089 dprintk("req_size=%d, max_requests=%d\n", req_size, hba->max_requests); 1090 1091 hba->req_size = req_size; 1092 start_virt = dma_alloc_coherent(&pcidev->dev, 1093 hba->req_size*hba->max_requests + 0x20, 1094 &start_phy, GFP_KERNEL); 1095 1096 if (!start_virt) { 1097 printk(KERN_ERR "scsi%d: fail to alloc request mem\n", 1098 hba->host->host_no); 1099 goto free_request_irq; 1100 } 1101 1102 hba->dma_coherent = start_virt; 1103 hba->dma_coherent_handle = start_phy; 1104 1105 if ((start_phy & 0x1f) != 0) 1106 { 1107 offset = ((start_phy + 0x1f) & ~0x1f) - start_phy; 1108 start_phy += offset; 1109 start_virt += offset; 1110 } 1111 1112 hba->req_list = start_virt; 1113 for (i = 0; i < hba->max_requests; i++) { 1114 hba->reqs[i].next = NULL; 1115 hba->reqs[i].req_virt = start_virt; 1116 hba->reqs[i].req_shifted_phy = start_phy >> 5; 1117 hba->reqs[i].index = i; 1118 free_req(hba, &hba->reqs[i]); 1119 start_virt = (char *)start_virt + hba->req_size; 1120 start_phy = start_phy + hba->req_size; 1121 } 1122 1123 /* Enable Interrupt and start background task */ 1124 if (hptiop_initialize_iop(hba)) 1125 goto free_request_mem; 1126 1127 if (scsi_add_host(host, &pcidev->dev)) { 1128 printk(KERN_ERR "scsi%d: scsi_add_host failed\n", 1129 hba->host->host_no); 1130 goto free_request_mem; 1131 } 1132 1133 1134 scsi_scan_host(host); 1135 1136 dprintk("scsi%d: hptiop_probe successfully\n", hba->host->host_no); 1137 return 0; 1138 1139 free_request_mem: 1140 dma_free_coherent(&hba->pcidev->dev, 1141 hba->req_size * hba->max_requests + 0x20, 1142 hba->dma_coherent, hba->dma_coherent_handle); 1143 1144 free_request_irq: 1145 free_irq(hba->pcidev->irq, hba); 1146 1147 unmap_pci_bar: 1148 if (hba->ops->internal_memfree) 1149 hba->ops->internal_memfree(hba); 1150 1151 hba->ops->unmap_pci_bar(hba); 1152 1153 free_scsi_host: 1154 scsi_host_put(host); 1155 1156 free_pci_regions: 1157 pci_release_regions(pcidev); 1158 1159 disable_pci_device: 1160 pci_disable_device(pcidev); 1161 1162 dprintk("scsi%d: hptiop_probe fail\n", host ? host->host_no : 0); 1163 return -ENODEV; 1164 } 1165 1166 static void hptiop_shutdown(struct pci_dev *pcidev) 1167 { 1168 struct Scsi_Host *host = pci_get_drvdata(pcidev); 1169 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 1170 1171 dprintk("hptiop_shutdown(%p)\n", hba); 1172 1173 /* stop the iop */ 1174 if (iop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_SHUTDOWN, 60000)) 1175 printk(KERN_ERR "scsi%d: shutdown the iop timeout\n", 1176 hba->host->host_no); 1177 1178 /* disable all outbound interrupts */ 1179 hba->ops->disable_intr(hba); 1180 } 1181 1182 static void hptiop_disable_intr_itl(struct hptiop_hba *hba) 1183 { 1184 u32 int_mask; 1185 1186 int_mask = readl(&hba->u.itl.iop->outbound_intmask); 1187 writel(int_mask | 1188 IOPMU_OUTBOUND_INT_MSG0 | IOPMU_OUTBOUND_INT_POSTQUEUE, 1189 &hba->u.itl.iop->outbound_intmask); 1190 readl(&hba->u.itl.iop->outbound_intmask); 1191 } 1192 1193 static void hptiop_disable_intr_mv(struct hptiop_hba *hba) 1194 { 1195 writel(0, &hba->u.mv.regs->outbound_intmask); 1196 readl(&hba->u.mv.regs->outbound_intmask); 1197 } 1198 1199 static void hptiop_remove(struct pci_dev *pcidev) 1200 { 1201 struct Scsi_Host *host = pci_get_drvdata(pcidev); 1202 struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata; 1203 1204 dprintk("scsi%d: hptiop_remove\n", hba->host->host_no); 1205 1206 scsi_remove_host(host); 1207 1208 hptiop_shutdown(pcidev); 1209 1210 free_irq(hba->pcidev->irq, hba); 1211 1212 dma_free_coherent(&hba->pcidev->dev, 1213 hba->req_size * hba->max_requests + 0x20, 1214 hba->dma_coherent, 1215 hba->dma_coherent_handle); 1216 1217 if (hba->ops->internal_memfree) 1218 hba->ops->internal_memfree(hba); 1219 1220 hba->ops->unmap_pci_bar(hba); 1221 1222 pci_release_regions(hba->pcidev); 1223 pci_set_drvdata(hba->pcidev, NULL); 1224 pci_disable_device(hba->pcidev); 1225 1226 scsi_host_put(host); 1227 } 1228 1229 static struct hptiop_adapter_ops hptiop_itl_ops = { 1230 .iop_wait_ready = iop_wait_ready_itl, 1231 .internal_memalloc = NULL, 1232 .internal_memfree = NULL, 1233 .map_pci_bar = hptiop_map_pci_bar_itl, 1234 .unmap_pci_bar = hptiop_unmap_pci_bar_itl, 1235 .enable_intr = hptiop_enable_intr_itl, 1236 .disable_intr = hptiop_disable_intr_itl, 1237 .get_config = iop_get_config_itl, 1238 .set_config = iop_set_config_itl, 1239 .iop_intr = iop_intr_itl, 1240 .post_msg = hptiop_post_msg_itl, 1241 .post_req = hptiop_post_req_itl, 1242 }; 1243 1244 static struct hptiop_adapter_ops hptiop_mv_ops = { 1245 .iop_wait_ready = iop_wait_ready_mv, 1246 .internal_memalloc = hptiop_internal_memalloc_mv, 1247 .internal_memfree = hptiop_internal_memfree_mv, 1248 .map_pci_bar = hptiop_map_pci_bar_mv, 1249 .unmap_pci_bar = hptiop_unmap_pci_bar_mv, 1250 .enable_intr = hptiop_enable_intr_mv, 1251 .disable_intr = hptiop_disable_intr_mv, 1252 .get_config = iop_get_config_mv, 1253 .set_config = iop_set_config_mv, 1254 .iop_intr = iop_intr_mv, 1255 .post_msg = hptiop_post_msg_mv, 1256 .post_req = hptiop_post_req_mv, 1257 }; 1258 1259 static struct pci_device_id hptiop_id_table[] = { 1260 { PCI_VDEVICE(TTI, 0x3220), (kernel_ulong_t)&hptiop_itl_ops }, 1261 { PCI_VDEVICE(TTI, 0x3320), (kernel_ulong_t)&hptiop_itl_ops }, 1262 { PCI_VDEVICE(TTI, 0x3410), (kernel_ulong_t)&hptiop_itl_ops }, 1263 { PCI_VDEVICE(TTI, 0x3510), (kernel_ulong_t)&hptiop_itl_ops }, 1264 { PCI_VDEVICE(TTI, 0x3511), (kernel_ulong_t)&hptiop_itl_ops }, 1265 { PCI_VDEVICE(TTI, 0x3520), (kernel_ulong_t)&hptiop_itl_ops }, 1266 { PCI_VDEVICE(TTI, 0x3521), (kernel_ulong_t)&hptiop_itl_ops }, 1267 { PCI_VDEVICE(TTI, 0x3522), (kernel_ulong_t)&hptiop_itl_ops }, 1268 { PCI_VDEVICE(TTI, 0x3530), (kernel_ulong_t)&hptiop_itl_ops }, 1269 { PCI_VDEVICE(TTI, 0x3540), (kernel_ulong_t)&hptiop_itl_ops }, 1270 { PCI_VDEVICE(TTI, 0x3560), (kernel_ulong_t)&hptiop_itl_ops }, 1271 { PCI_VDEVICE(TTI, 0x4210), (kernel_ulong_t)&hptiop_itl_ops }, 1272 { PCI_VDEVICE(TTI, 0x4211), (kernel_ulong_t)&hptiop_itl_ops }, 1273 { PCI_VDEVICE(TTI, 0x4310), (kernel_ulong_t)&hptiop_itl_ops }, 1274 { PCI_VDEVICE(TTI, 0x4311), (kernel_ulong_t)&hptiop_itl_ops }, 1275 { PCI_VDEVICE(TTI, 0x4320), (kernel_ulong_t)&hptiop_itl_ops }, 1276 { PCI_VDEVICE(TTI, 0x4321), (kernel_ulong_t)&hptiop_itl_ops }, 1277 { PCI_VDEVICE(TTI, 0x4322), (kernel_ulong_t)&hptiop_itl_ops }, 1278 { PCI_VDEVICE(TTI, 0x4400), (kernel_ulong_t)&hptiop_itl_ops }, 1279 { PCI_VDEVICE(TTI, 0x3120), (kernel_ulong_t)&hptiop_mv_ops }, 1280 { PCI_VDEVICE(TTI, 0x3122), (kernel_ulong_t)&hptiop_mv_ops }, 1281 { PCI_VDEVICE(TTI, 0x3020), (kernel_ulong_t)&hptiop_mv_ops }, 1282 {}, 1283 }; 1284 1285 MODULE_DEVICE_TABLE(pci, hptiop_id_table); 1286 1287 static struct pci_driver hptiop_pci_driver = { 1288 .name = driver_name, 1289 .id_table = hptiop_id_table, 1290 .probe = hptiop_probe, 1291 .remove = hptiop_remove, 1292 .shutdown = hptiop_shutdown, 1293 }; 1294 1295 static int __init hptiop_module_init(void) 1296 { 1297 printk(KERN_INFO "%s %s\n", driver_name_long, driver_ver); 1298 return pci_register_driver(&hptiop_pci_driver); 1299 } 1300 1301 static void __exit hptiop_module_exit(void) 1302 { 1303 pci_unregister_driver(&hptiop_pci_driver); 1304 } 1305 1306 1307 module_init(hptiop_module_init); 1308 module_exit(hptiop_module_exit); 1309 1310 MODULE_LICENSE("GPL"); 1311 1312