drivers/scsi/hptiop.c

   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");