drivers/scsi/wd719x.c

   1 /*
   2  * Driver for Western Digital WD7193, WD7197 and WD7296 SCSI cards
   3  * Copyright 2013 Ondrej Zary
   4  *
   5  * Original driver by
   6  * Aaron Dewell <dewell@woods.net>
   7  * Gaerti <Juergen.Gaertner@mbox.si.uni-hannover.de>
   8  *
   9  * HW documentation available in book:
  10  *
  11  * SPIDER Command Protocol
  12  * by Chandru M. Sippy
  13  * SCSI Storage Products (MCP)
  14  * Western Digital Corporation
  15  * 09-15-95
  16  *
  17  * http://web.archive.org/web/20070717175254/http://sun1.rrzn.uni-hannover.de/gaertner.juergen/wd719x/Linux/Docu/Spider/
  18  */
  19
  20 /*
  21  * Driver workflow:
  22  * 1. SCSI command is transformed to SCB (Spider Control Block) by the
  23  *    queuecommand function.
  24  * 2. The address of the SCB is stored in a list to be able to access it, if
  25  *    something goes wrong.
  26  * 3. The address of the SCB is written to the Controller, which loads the SCB
  27  *    via BM-DMA and processes it.
  28  * 4. After it has finished, it generates an interrupt, and sets registers.
  29  *
  30  * flaws:
  31  *  - abort/reset functions
  32  *
  33  * ToDo:
  34  *  - tagged queueing
  35  */
  36
  37 #include <linux/interrupt.h>
  38 #include <linux/module.h>
  39 #include <linux/delay.h>
  40 #include <linux/pci.h>
  41 #include <linux/firmware.h>
  42 #include <linux/eeprom_93cx6.h>
  43 #include <scsi/scsi_cmnd.h>
  44 #include <scsi/scsi_device.h>
  45 #include <scsi/scsi_host.h>
  46 #include "wd719x.h"
  47
  48 /* low-level register access */
  49 static inline u8 wd719x_readb(struct wd719x *wd, u8 reg)
  50 {
  51         return ioread8(wd->base + reg);
  52 }
  53
  54 static inline u32 wd719x_readl(struct wd719x *wd, u8 reg)
  55 {
  56         return ioread32(wd->base + reg);
  57 }
  58
  59 static inline void wd719x_writeb(struct wd719x *wd, u8 reg, u8 val)
  60 {
  61         iowrite8(val, wd->base + reg);
  62 }
  63
  64 static inline void wd719x_writew(struct wd719x *wd, u8 reg, u16 val)
  65 {
  66         iowrite16(val, wd->base + reg);
  67 }
  68
  69 static inline void wd719x_writel(struct wd719x *wd, u8 reg, u32 val)
  70 {
  71         iowrite32(val, wd->base + reg);
  72 }
  73
  74 /* wait until the command register is ready */
  75 static inline int wd719x_wait_ready(struct wd719x *wd)
  76 {
  77         int i = 0;
  78
  79         do {
  80                 if (wd719x_readb(wd, WD719X_AMR_COMMAND) == WD719X_CMD_READY)
  81                         return 0;
  82                 udelay(1);
  83         } while (i++ < WD719X_WAIT_FOR_CMD_READY);
  84
  85         dev_err(&wd->pdev->dev, "command register is not ready: 0x%02x\n",
  86                 wd719x_readb(wd, WD719X_AMR_COMMAND));
  87
  88         return -ETIMEDOUT;
  89 }
  90
  91 /* poll interrupt status register until command finishes */
  92 static inline int wd719x_wait_done(struct wd719x *wd, int timeout)
  93 {
  94         u8 status;
  95
  96         while (timeout > 0) {
  97                 status = wd719x_readb(wd, WD719X_AMR_INT_STATUS);
  98                 if (status)
  99                         break;
 100                 timeout--;
 101                 udelay(1);
 102         }
 103
 104         if (timeout <= 0) {
 105                 dev_err(&wd->pdev->dev, "direct command timed out\n");
 106                 return -ETIMEDOUT;
 107         }
 108
 109         if (status != WD719X_INT_NOERRORS) {
 110                 dev_err(&wd->pdev->dev, "direct command failed, status 0x%02x, SUE 0x%02x\n",
 111                         status, wd719x_readb(wd, WD719X_AMR_SCB_ERROR));
 112                 return -EIO;
 113         }
 114
 115         return 0;
 116 }
 117
 118 static int wd719x_direct_cmd(struct wd719x *wd, u8 opcode, u8 dev, u8 lun,
 119                              u8 tag, dma_addr_t data, int timeout)
 120 {
 121         int ret = 0;
 122
 123         /* clear interrupt status register (allow command register to clear) */
 124         wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
 125
 126         /* Wait for the Command register to become free */
 127         if (wd719x_wait_ready(wd))
 128                 return -ETIMEDOUT;
 129
 130         /* make sure we get NO interrupts */
 131         dev |= WD719X_DISABLE_INT;
 132         wd719x_writeb(wd, WD719X_AMR_CMD_PARAM, dev);
 133         wd719x_writeb(wd, WD719X_AMR_CMD_PARAM_2, lun);
 134         wd719x_writeb(wd, WD719X_AMR_CMD_PARAM_3, tag);
 135         if (data)
 136                 wd719x_writel(wd, WD719X_AMR_SCB_IN, data);
 137
 138         /* clear interrupt status register again */
 139         wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
 140
 141         /* Now, write the command */
 142         wd719x_writeb(wd, WD719X_AMR_COMMAND, opcode);
 143
 144         if (timeout)    /* wait for the command to complete */
 145                 ret = wd719x_wait_done(wd, timeout);
 146
 147         /* clear interrupt status register (clean up) */
 148         if (opcode != WD719X_CMD_READ_FIRMVER)
 149                 wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
 150
 151         return ret;
 152 }
 153
 154 static void wd719x_destroy(struct wd719x *wd)
 155 {
 156         struct wd719x_scb *scb;
 157
 158         /* stop the RISC */
 159         if (wd719x_direct_cmd(wd, WD719X_CMD_SLEEP, 0, 0, 0, 0,
 160                               WD719X_WAIT_FOR_RISC))
 161                 dev_warn(&wd->pdev->dev, "RISC sleep command failed\n");
 162         /* disable RISC */
 163         wd719x_writeb(wd, WD719X_PCI_MODE_SELECT, 0);
 164
 165         WARN_ON_ONCE(!list_empty(&wd->active_scbs));
 166
 167         /* free all SCBs */
 168         list_for_each_entry(scb, &wd->free_scbs, list)
 169                 pci_free_consistent(wd->pdev, sizeof(struct wd719x_scb), scb,
 170                                     scb->phys);
 171         /* free internal buffers */
 172         pci_free_consistent(wd->pdev, wd->fw_size, wd->fw_virt, wd->fw_phys);
 173         wd->fw_virt = NULL;
 174         pci_free_consistent(wd->pdev, WD719X_HASH_TABLE_SIZE, wd->hash_virt,
 175                             wd->hash_phys);
 176         wd->hash_virt = NULL;
 177         pci_free_consistent(wd->pdev, sizeof(struct wd719x_host_param),
 178                             wd->params, wd->params_phys);
 179         wd->params = NULL;
 180         free_irq(wd->pdev->irq, wd);
 181 }
 182
 183 /* finish a SCSI command, mark SCB (if any) as free, unmap buffers */
 184 static void wd719x_finish_cmd(struct scsi_cmnd *cmd, int result)
 185 {
 186         struct wd719x *wd = shost_priv(cmd->device->host);
 187         struct wd719x_scb *scb = (struct wd719x_scb *) cmd->host_scribble;
 188
 189         if (scb) {
 190                 list_move(&scb->list, &wd->free_scbs);
 191                 dma_unmap_single(&wd->pdev->dev, cmd->SCp.dma_handle,
 192                                  SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
 193                 scsi_dma_unmap(cmd);
 194         }
 195         cmd->result = result << 16;
 196         cmd->scsi_done(cmd);
 197 }
 198
 199 /* Build a SCB and send it to the card */
 200 static int wd719x_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
 201 {
 202         int i, count_sg;
 203         unsigned long flags;
 204         struct wd719x_scb *scb;
 205         struct wd719x *wd = shost_priv(sh);
 206         dma_addr_t phys;
 207
 208         cmd->host_scribble = NULL;
 209
 210         /* get a free SCB - either from existing ones or allocate a new one */
 211         spin_lock_irqsave(wd->sh->host_lock, flags);
 212         scb = list_first_entry_or_null(&wd->free_scbs, struct wd719x_scb, list);
 213         if (scb) {
 214                 list_del(&scb->list);
 215                 phys = scb->phys;
 216         } else {
 217                 spin_unlock_irqrestore(wd->sh->host_lock, flags);
 218                 scb = pci_alloc_consistent(wd->pdev, sizeof(struct wd719x_scb),
 219                                            &phys);
 220                 spin_lock_irqsave(wd->sh->host_lock, flags);
 221                 if (!scb) {
 222                         dev_err(&wd->pdev->dev, "unable to allocate SCB\n");
 223                         wd719x_finish_cmd(cmd, DID_ERROR);
 224                         spin_unlock_irqrestore(wd->sh->host_lock, flags);
 225                         return 0;
 226                 }
 227         }
 228         memset(scb, 0, sizeof(struct wd719x_scb));
 229         list_add(&scb->list, &wd->active_scbs);
 230
 231         scb->phys = phys;
 232         scb->cmd = cmd;
 233         cmd->host_scribble = (char *) scb;
 234
 235         scb->CDB_tag = 0;       /* Tagged queueing not supported yet */
 236         scb->devid = cmd->device->id;
 237         scb->lun = cmd->device->lun;
 238
 239         /* copy the command */
 240         memcpy(scb->CDB, cmd->cmnd, cmd->cmd_len);
 241
 242         /* map sense buffer */
 243         scb->sense_buf_length = SCSI_SENSE_BUFFERSIZE;
 244         cmd->SCp.dma_handle = dma_map_single(&wd->pdev->dev, cmd->sense_buffer,
 245                         SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
 246         scb->sense_buf = cpu_to_le32(cmd->SCp.dma_handle);
 247
 248         /* request autosense */
 249         scb->SCB_options |= WD719X_SCB_FLAGS_AUTO_REQUEST_SENSE;
 250
 251         /* check direction */
 252         if (cmd->sc_data_direction == DMA_TO_DEVICE)
 253                 scb->SCB_options |= WD719X_SCB_FLAGS_CHECK_DIRECTION
 254                                  |  WD719X_SCB_FLAGS_PCI_TO_SCSI;
 255         else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
 256                 scb->SCB_options |= WD719X_SCB_FLAGS_CHECK_DIRECTION;
 257
 258         /* Scather/gather */
 259         count_sg = scsi_dma_map(cmd);
 260         if (count_sg < 0) {
 261                 wd719x_finish_cmd(cmd, DID_ERROR);
 262                 spin_unlock_irqrestore(wd->sh->host_lock, flags);
 263                 return 0;
 264         }
 265         BUG_ON(count_sg > WD719X_SG);
 266
 267         if (count_sg) {
 268                 struct scatterlist *sg;
 269
 270                 scb->data_length = cpu_to_le32(count_sg *
 271                                                sizeof(struct wd719x_sglist));
 272                 scb->data_p = cpu_to_le32(scb->phys +
 273                                           offsetof(struct wd719x_scb, sg_list));
 274
 275                 scsi_for_each_sg(cmd, sg, count_sg, i) {
 276                         scb->sg_list[i].ptr = cpu_to_le32(sg_dma_address(sg));
 277                         scb->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
 278                 }
 279                 scb->SCB_options |= WD719X_SCB_FLAGS_DO_SCATTER_GATHER;
 280         } else { /* zero length */
 281                 scb->data_length = 0;
 282                 scb->data_p = 0;
 283         }
 284
 285         /* check if the Command register is free */
 286         if (wd719x_readb(wd, WD719X_AMR_COMMAND) != WD719X_CMD_READY) {
 287                 spin_unlock_irqrestore(wd->sh->host_lock, flags);
 288                 return SCSI_MLQUEUE_HOST_BUSY;
 289         }
 290
 291         /* write pointer to the AMR */
 292         wd719x_writel(wd, WD719X_AMR_SCB_IN, scb->phys);
 293         /* send SCB opcode */
 294         wd719x_writeb(wd, WD719X_AMR_COMMAND, WD719X_CMD_PROCESS_SCB);
 295
 296         spin_unlock_irqrestore(wd->sh->host_lock, flags);
 297
 298         return 0;
 299 }
 300
 301 static int wd719x_chip_init(struct wd719x *wd)
 302 {
 303         int i, ret;
 304         u32 risc_init[3];
 305         const struct firmware *fw_wcs, *fw_risc;
 306         const char fwname_wcs[] = "wd719x-wcs.bin";
 307         const char fwname_risc[] = "wd719x-risc.bin";
 308
 309         memset(wd->hash_virt, 0, WD719X_HASH_TABLE_SIZE);
 310
 311         /* WCS (sequencer) firmware */
 312         ret = request_firmware(&fw_wcs, fwname_wcs, &wd->pdev->dev);
 313         if (ret) {
 314                 dev_err(&wd->pdev->dev, "Unable to load firmware %s: %d\n",
 315                         fwname_wcs, ret);
 316                 return ret;
 317         }
 318         /* RISC firmware */
 319         ret = request_firmware(&fw_risc, fwname_risc, &wd->pdev->dev);
 320         if (ret) {
 321                 dev_err(&wd->pdev->dev, "Unable to load firmware %s: %d\n",
 322                         fwname_risc, ret);
 323                 release_firmware(fw_wcs);
 324                 return ret;
 325         }
 326         wd->fw_size = ALIGN(fw_wcs->size, 4) + fw_risc->size;
 327
 328         if (!wd->fw_virt)
 329                 wd->fw_virt = pci_alloc_consistent(wd->pdev, wd->fw_size,
 330                                                    &wd->fw_phys);
 331         if (!wd->fw_virt) {
 332                 ret = -ENOMEM;
 333                 goto wd719x_init_end;
 334         }
 335
 336         /* make a fresh copy of WCS and RISC code */
 337         memcpy(wd->fw_virt, fw_wcs->data, fw_wcs->size);
 338         memcpy(wd->fw_virt + ALIGN(fw_wcs->size, 4), fw_risc->data,
 339                 fw_risc->size);
 340
 341         /* Reset the Spider Chip and adapter itself */
 342         wd719x_writeb(wd, WD719X_PCI_PORT_RESET, WD719X_PCI_RESET);
 343         udelay(WD719X_WAIT_FOR_RISC);
 344         /* Clear PIO mode bits set by BIOS */
 345         wd719x_writeb(wd, WD719X_AMR_CMD_PARAM, 0);
 346         /* ensure RISC is not running */
 347         wd719x_writeb(wd, WD719X_PCI_MODE_SELECT, 0);
 348         /* ensure command port is ready */
 349         wd719x_writeb(wd, WD719X_AMR_COMMAND, 0);
 350         if (wd719x_wait_ready(wd)) {
 351                 ret = -ETIMEDOUT;
 352                 goto wd719x_init_end;
 353         }
 354
 355         /* Transfer the first 2K words of RISC code to kick start the uP */
 356         risc_init[0] = wd->fw_phys;                             /* WCS FW */
 357         risc_init[1] = wd->fw_phys + ALIGN(fw_wcs->size, 4);    /* RISC FW */
 358         risc_init[2] = wd->hash_phys;                           /* hash table */
 359
 360         /* clear DMA status */
 361         wd719x_writeb(wd, WD719X_PCI_CHANNEL2_3STATUS, 0);
 362
 363         /* address to read firmware from */
 364         wd719x_writel(wd, WD719X_PCI_EXTERNAL_ADDR, risc_init[1]);
 365         /* base address to write firmware to (on card) */
 366         wd719x_writew(wd, WD719X_PCI_INTERNAL_ADDR, WD719X_PRAM_BASE_ADDR);
 367         /* size: first 2K words */
 368         wd719x_writew(wd, WD719X_PCI_DMA_TRANSFER_SIZE, 2048 * 2);
 369         /* start DMA */
 370         wd719x_writeb(wd, WD719X_PCI_CHANNEL2_3CMD, WD719X_START_CHANNEL2_3DMA);
 371
 372         /* wait for DMA to complete */
 373         i = WD719X_WAIT_FOR_RISC;
 374         while (i-- > 0) {
 375                 u8 status = wd719x_readb(wd, WD719X_PCI_CHANNEL2_3STATUS);
 376                 if (status == WD719X_START_CHANNEL2_3DONE)
 377                         break;
 378                 if (status == WD719X_START_CHANNEL2_3ABORT) {
 379                         dev_warn(&wd->pdev->dev, "RISC bootstrap failed: DMA aborted\n");
 380                         ret = -EIO;
 381                         goto wd719x_init_end;
 382                 }
 383                 udelay(1);
 384         }
 385         if (i < 1) {
 386                 dev_warn(&wd->pdev->dev, "RISC bootstrap failed: DMA timeout\n");
 387                 ret = -ETIMEDOUT;
 388                 goto wd719x_init_end;
 389         }
 390
 391         /* firmware is loaded, now initialize and wake up the RISC */
 392         /* write RISC initialization long words to Spider */
 393         wd719x_writel(wd, WD719X_AMR_SCB_IN, risc_init[0]);
 394         wd719x_writel(wd, WD719X_AMR_SCB_IN + 4, risc_init[1]);
 395         wd719x_writel(wd, WD719X_AMR_SCB_IN + 8, risc_init[2]);
 396
 397         /* disable interrupts during initialization of RISC */
 398         wd719x_writeb(wd, WD719X_AMR_CMD_PARAM, WD719X_DISABLE_INT);
 399
 400         /* issue INITIALIZE RISC comand */
 401         wd719x_writeb(wd, WD719X_AMR_COMMAND, WD719X_CMD_INIT_RISC);
 402         /* enable advanced mode (wake up RISC) */
 403         wd719x_writeb(wd, WD719X_PCI_MODE_SELECT, WD719X_ENABLE_ADVANCE_MODE);
 404         udelay(WD719X_WAIT_FOR_RISC);
 405
 406         ret = wd719x_wait_done(wd, WD719X_WAIT_FOR_RISC);
 407         /* clear interrupt status register */
 408         wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
 409         if (ret) {
 410                 dev_warn(&wd->pdev->dev, "Unable to initialize RISC\n");
 411                 goto wd719x_init_end;
 412         }
 413         /* RISC is up and running */
 414
 415         /* Read FW version from RISC */
 416         ret = wd719x_direct_cmd(wd, WD719X_CMD_READ_FIRMVER, 0, 0, 0, 0,
 417                                 WD719X_WAIT_FOR_RISC);
 418         if (ret) {
 419                 dev_warn(&wd->pdev->dev, "Unable to read firmware version\n");
 420                 goto wd719x_init_end;
 421         }
 422         dev_info(&wd->pdev->dev, "RISC initialized with firmware version %.2x.%.2x\n",
 423                         wd719x_readb(wd, WD719X_AMR_SCB_OUT + 1),
 424                         wd719x_readb(wd, WD719X_AMR_SCB_OUT));
 425
 426         /* RESET SCSI bus */
 427         ret = wd719x_direct_cmd(wd, WD719X_CMD_BUSRESET, 0, 0, 0, 0,
 428                                 WD719X_WAIT_FOR_SCSI_RESET);
 429         if (ret) {
 430                 dev_warn(&wd->pdev->dev, "SCSI bus reset failed\n");
 431                 goto wd719x_init_end;
 432         }
 433
 434         /* use HostParameter structure to set Spider's Host Parameter Block */
 435         ret = wd719x_direct_cmd(wd, WD719X_CMD_SET_PARAM, 0,
 436                                 sizeof(struct wd719x_host_param), 0,
 437                                 wd->params_phys, WD719X_WAIT_FOR_RISC);
 438         if (ret) {
 439                 dev_warn(&wd->pdev->dev, "Failed to set HOST PARAMETERS\n");
 440                 goto wd719x_init_end;
 441         }
 442
 443         /* initiate SCAM (does nothing if disabled in BIOS) */
 444         /* bug?: we should pass a mask of static IDs which we don't have */
 445         ret = wd719x_direct_cmd(wd, WD719X_CMD_INIT_SCAM, 0, 0, 0, 0,
 446                                 WD719X_WAIT_FOR_SCSI_RESET);
 447         if (ret) {
 448                 dev_warn(&wd->pdev->dev, "SCAM initialization failed\n");
 449                 goto wd719x_init_end;
 450         }
 451
 452         /* clear AMR_BIOS_SHARE_INT register */
 453         wd719x_writeb(wd, WD719X_AMR_BIOS_SHARE_INT, 0);
 454
 455 wd719x_init_end:
 456         release_firmware(fw_wcs);
 457         release_firmware(fw_risc);
 458
 459         return ret;
 460 }
 461
 462 static int wd719x_abort(struct scsi_cmnd *cmd)
 463 {
 464         int action, result;
 465         unsigned long flags;
 466         struct wd719x_scb *scb = (struct wd719x_scb *)cmd->host_scribble;
 467         struct wd719x *wd = shost_priv(cmd->device->host);
 468
 469         dev_info(&wd->pdev->dev, "abort command, tag: %x\n", cmd->tag);
 470
 471         action = /*cmd->tag ? WD719X_CMD_ABORT_TAG : */WD719X_CMD_ABORT;
 472
 473         spin_lock_irqsave(wd->sh->host_lock, flags);
 474         result = wd719x_direct_cmd(wd, action, cmd->device->id,
 475                                    cmd->device->lun, cmd->tag, scb->phys, 0);
 476         spin_unlock_irqrestore(wd->sh->host_lock, flags);
 477         if (result)
 478                 return FAILED;
 479
 480         return SUCCESS;
 481 }
 482
 483 static int wd719x_reset(struct scsi_cmnd *cmd, u8 opcode, u8 device)
 484 {
 485         int result;
 486         unsigned long flags;
 487         struct wd719x *wd = shost_priv(cmd->device->host);
 488
 489         dev_info(&wd->pdev->dev, "%s reset requested\n",
 490                  (opcode == WD719X_CMD_BUSRESET) ? "bus" : "device");
 491
 492         spin_lock_irqsave(wd->sh->host_lock, flags);
 493         result = wd719x_direct_cmd(wd, opcode, device, 0, 0, 0,
 494                                    WD719X_WAIT_FOR_SCSI_RESET);
 495         spin_unlock_irqrestore(wd->sh->host_lock, flags);
 496         if (result)
 497                 return FAILED;
 498
 499         return SUCCESS;
 500 }
 501
 502 static int wd719x_dev_reset(struct scsi_cmnd *cmd)
 503 {
 504         return wd719x_reset(cmd, WD719X_CMD_RESET, cmd->device->id);
 505 }
 506
 507 static int wd719x_bus_reset(struct scsi_cmnd *cmd)
 508 {
 509         return wd719x_reset(cmd, WD719X_CMD_BUSRESET, 0);
 510 }
 511
 512 static int wd719x_host_reset(struct scsi_cmnd *cmd)
 513 {
 514         struct wd719x *wd = shost_priv(cmd->device->host);
 515         struct wd719x_scb *scb, *tmp;
 516         unsigned long flags;
 517         int result;
 518
 519         dev_info(&wd->pdev->dev, "host reset requested\n");
 520         spin_lock_irqsave(wd->sh->host_lock, flags);
 521         /* Try to reinit the RISC */
 522         if (wd719x_chip_init(wd) == 0)
 523                 result = SUCCESS;
 524         else
 525                 result = FAILED;
 526
 527         /* flush all SCBs */
 528         list_for_each_entry_safe(scb, tmp, &wd->active_scbs, list) {
 529                 struct scsi_cmnd *tmp_cmd = scb->cmd;
 530                 wd719x_finish_cmd(tmp_cmd, result);
 531         }
 532         spin_unlock_irqrestore(wd->sh->host_lock, flags);
 533
 534         return result;
 535 }
 536
 537 static int wd719x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
 538                             sector_t capacity, int geom[])
 539 {
 540         if (capacity >= 0x200000) {
 541                 geom[0] = 255;  /* heads */
 542                 geom[1] = 63;   /* sectors */
 543         } else {
 544                 geom[0] = 64;   /* heads */
 545                 geom[1] = 32;   /* sectors */
 546         }
 547         geom[2] = sector_div(capacity, geom[0] * geom[1]);      /* cylinders */
 548
 549         return 0;
 550 }
 551
 552 /* process a SCB-completion interrupt */
 553 static inline void wd719x_interrupt_SCB(struct wd719x *wd,
 554                                         union wd719x_regs regs,
 555                                         struct wd719x_scb *scb)
 556 {
 557         struct scsi_cmnd *cmd;
 558         int result;
 559
 560         /* now have to find result from card */
 561         switch (regs.bytes.SUE) {
 562         case WD719X_SUE_NOERRORS:
 563                 result = DID_OK;
 564                 break;
 565         case WD719X_SUE_REJECTED:
 566                 dev_err(&wd->pdev->dev, "command rejected\n");
 567                 result = DID_ERROR;
 568                 break;
 569         case WD719X_SUE_SCBQFULL:
 570                 dev_err(&wd->pdev->dev, "SCB queue is full\n");
 571                 result = DID_ERROR;
 572                 break;
 573         case WD719X_SUE_TERM:
 574                 dev_dbg(&wd->pdev->dev, "SCB terminated by direct command\n");
 575                 result = DID_ABORT;     /* or DID_RESET? */
 576                 break;
 577         case WD719X_SUE_CHAN1ABORT:
 578         case WD719X_SUE_CHAN23ABORT:
 579                 result = DID_ABORT;
 580                 dev_err(&wd->pdev->dev, "DMA abort\n");
 581                 break;
 582         case WD719X_SUE_CHAN1PAR:
 583         case WD719X_SUE_CHAN23PAR:
 584                 result = DID_PARITY;
 585                 dev_err(&wd->pdev->dev, "DMA parity error\n");
 586                 break;
 587         case WD719X_SUE_TIMEOUT:
 588                 result = DID_TIME_OUT;
 589                 dev_dbg(&wd->pdev->dev, "selection timeout\n");
 590                 break;
 591         case WD719X_SUE_RESET:
 592                 dev_dbg(&wd->pdev->dev, "bus reset occurred\n");
 593                 result = DID_RESET;
 594                 break;
 595         case WD719X_SUE_BUSERROR:
 596                 dev_dbg(&wd->pdev->dev, "SCSI bus error\n");
 597                 result = DID_ERROR;
 598                 break;
 599         case WD719X_SUE_WRONGWAY:
 600                 dev_err(&wd->pdev->dev, "wrong data transfer direction\n");
 601                 result = DID_ERROR;
 602                 break;
 603         case WD719X_SUE_BADPHASE:
 604                 dev_err(&wd->pdev->dev, "invalid SCSI phase\n");
 605                 result = DID_ERROR;
 606                 break;
 607         case WD719X_SUE_TOOLONG:
 608                 dev_err(&wd->pdev->dev, "record too long\n");
 609                 result = DID_ERROR;
 610                 break;
 611         case WD719X_SUE_BUSFREE:
 612                 dev_err(&wd->pdev->dev, "unexpected bus free\n");
 613                 result = DID_NO_CONNECT; /* or DID_ERROR ???*/
 614                 break;
 615         case WD719X_SUE_ARSDONE:
 616                 dev_dbg(&wd->pdev->dev, "auto request sense\n");
 617                 if (regs.bytes.SCSI == 0)
 618                         result = DID_OK;
 619                 else
 620                         result = DID_PARITY;
 621                 break;
 622         case WD719X_SUE_IGNORED:
 623                 dev_err(&wd->pdev->dev, "target id %d ignored command\n",
 624                         scb->cmd->device->id);
 625                 result = DID_NO_CONNECT;
 626                 break;
 627         case WD719X_SUE_WRONGTAGS:
 628                 dev_err(&wd->pdev->dev, "reversed tags\n");
 629                 result = DID_ERROR;
 630                 break;
 631         case WD719X_SUE_BADTAGS:
 632                 dev_err(&wd->pdev->dev, "tag type not supported by target\n");
 633                 result = DID_ERROR;
 634                 break;
 635         case WD719X_SUE_NOSCAMID:
 636                 dev_err(&wd->pdev->dev, "no SCAM soft ID available\n");
 637                 result = DID_ERROR;
 638                 break;
 639         default:
 640                 dev_warn(&wd->pdev->dev, "unknown SUE error code: 0x%x\n",
 641                          regs.bytes.SUE);
 642                 result = DID_ERROR;
 643                 break;
 644         }
 645         cmd = scb->cmd;
 646
 647         wd719x_finish_cmd(cmd, result);
 648 }
 649
 650 static irqreturn_t wd719x_interrupt(int irq, void *dev_id)
 651 {
 652         struct wd719x *wd = dev_id;
 653         union wd719x_regs regs;
 654         unsigned long flags;
 655         u32 SCB_out;
 656
 657         spin_lock_irqsave(wd->sh->host_lock, flags);
 658         /* read SCB pointer back from card */
 659         SCB_out = wd719x_readl(wd, WD719X_AMR_SCB_OUT);
 660         /* read all status info at once */
 661         regs.all = cpu_to_le32(wd719x_readl(wd, WD719X_AMR_OP_CODE));
 662
 663         switch (regs.bytes.INT) {
 664         case WD719X_INT_NONE:
 665                 spin_unlock_irqrestore(wd->sh->host_lock, flags);
 666                 return IRQ_NONE;
 667         case WD719X_INT_LINKNOSTATUS:
 668                 dev_err(&wd->pdev->dev, "linked command completed with no status\n");
 669                 break;
 670         case WD719X_INT_BADINT:
 671                 dev_err(&wd->pdev->dev, "unsolicited interrupt\n");
 672                 break;
 673         case WD719X_INT_NOERRORS:
 674         case WD719X_INT_LINKNOERRORS:
 675         case WD719X_INT_ERRORSLOGGED:
 676         case WD719X_INT_SPIDERFAILED:
 677                 /* was the cmd completed a direct or SCB command? */
 678                 if (regs.bytes.OPC == WD719X_CMD_PROCESS_SCB) {
 679                         struct wd719x_scb *scb;
 680                         list_for_each_entry(scb, &wd->active_scbs, list)
 681                                 if (SCB_out == scb->phys)
 682                                         break;
 683                         if (SCB_out == scb->phys)
 684                                 wd719x_interrupt_SCB(wd, regs, scb);
 685                         else
 686                                 dev_err(&wd->pdev->dev, "card returned invalid SCB pointer\n");
 687                 } else
 688                         dev_warn(&wd->pdev->dev, "direct command 0x%x completed\n",
 689                                  regs.bytes.OPC);
 690                 break;
 691         case WD719X_INT_PIOREADY:
 692                 dev_err(&wd->pdev->dev, "card indicates PIO data ready but we never use PIO\n");
 693                 /* interrupt will not be cleared until all data is read */
 694                 break;
 695         default:
 696                 dev_err(&wd->pdev->dev, "unknown interrupt reason: %d\n",
 697                         regs.bytes.INT);
 698
 699         }
 700         /* clear interrupt so another can happen */
 701         wd719x_writeb(wd, WD719X_AMR_INT_STATUS, WD719X_INT_NONE);
 702         spin_unlock_irqrestore(wd->sh->host_lock, flags);
 703
 704         return IRQ_HANDLED;
 705 }
 706
 707 static void wd719x_eeprom_reg_read(struct eeprom_93cx6 *eeprom)
 708 {
 709         struct wd719x *wd = eeprom->data;
 710         u8 reg = wd719x_readb(wd, WD719X_PCI_GPIO_DATA);
 711
 712         eeprom->reg_data_out = reg & WD719X_EE_DO;
 713 }
 714
 715 static void wd719x_eeprom_reg_write(struct eeprom_93cx6 *eeprom)
 716 {
 717         struct wd719x *wd = eeprom->data;
 718         u8 reg = 0;
 719
 720         if (eeprom->reg_data_in)
 721                 reg |= WD719X_EE_DI;
 722         if (eeprom->reg_data_clock)
 723                 reg |= WD719X_EE_CLK;
 724         if (eeprom->reg_chip_select)
 725                 reg |= WD719X_EE_CS;
 726
 727         wd719x_writeb(wd, WD719X_PCI_GPIO_DATA, reg);
 728 }
 729
 730 /* read config from EEPROM so it can be downloaded by the RISC on (re-)init */
 731 static void wd719x_read_eeprom(struct wd719x *wd)
 732 {
 733         struct eeprom_93cx6 eeprom;
 734         u8 gpio;
 735         struct wd719x_eeprom_header header;
 736
 737         eeprom.data = wd;
 738         eeprom.register_read = wd719x_eeprom_reg_read;
 739         eeprom.register_write = wd719x_eeprom_reg_write;
 740         eeprom.width = PCI_EEPROM_WIDTH_93C46;
 741
 742         /* set all outputs to low */
 743         wd719x_writeb(wd, WD719X_PCI_GPIO_DATA, 0);
 744         /* configure GPIO pins */
 745         gpio = wd719x_readb(wd, WD719X_PCI_GPIO_CONTROL);
 746         /* GPIO outputs */
 747         gpio &= (~(WD719X_EE_CLK | WD719X_EE_DI | WD719X_EE_CS));
 748         /* GPIO input */
 749         gpio |= WD719X_EE_DO;
 750         wd719x_writeb(wd, WD719X_PCI_GPIO_CONTROL, gpio);
 751
 752         /* read EEPROM header */
 753         eeprom_93cx6_multireadb(&eeprom, 0, (u8 *)&header, sizeof(header));
 754
 755         if (header.sig1 == 'W' && header.sig2 == 'D')
 756                 eeprom_93cx6_multireadb(&eeprom, header.cfg_offset,
 757                                         (u8 *)wd->params,
 758                                         sizeof(struct wd719x_host_param));
 759         else { /* default EEPROM values */
 760                 dev_warn(&wd->pdev->dev, "EEPROM signature is invalid (0x%02x 0x%02x), using default values\n",
 761                          header.sig1, header.sig2);
 762                 wd->params->ch_1_th     = 0x10; /* 16 DWs = 64 B */
 763                 wd->params->scsi_conf   = 0x4c; /* 48ma, spue, parity check */
 764                 wd->params->own_scsi_id = 0x07; /* ID 7, SCAM disabled */
 765                 wd->params->sel_timeout = 0x4d; /* 250 ms */
 766                 wd->params->sleep_timer = 0x01;
 767                 wd->params->cdb_size    = cpu_to_le16(0x5555);  /* all 6 B */
 768                 wd->params->scsi_pad    = 0x1b;
 769                 if (wd->type == WD719X_TYPE_7193) /* narrow card - disable */
 770                         wd->params->wide = cpu_to_le32(0x00000000);
 771                 else    /* initiate & respond to WIDE messages */
 772                         wd->params->wide = cpu_to_le32(0xffffffff);
 773                 wd->params->sync        = cpu_to_le32(0xffffffff);
 774                 wd->params->soft_mask   = 0x00; /* all disabled */
 775                 wd->params->unsol_mask  = 0x00; /* all disabled */
 776         }
 777         /* disable TAGGED messages */
 778         wd->params->tag_en = cpu_to_le16(0x0000);
 779 }
 780
 781 /* Read card type from GPIO bits 1 and 3 */
 782 static enum wd719x_card_type wd719x_detect_type(struct wd719x *wd)
 783 {
 784         u8 card = wd719x_readb(wd, WD719X_PCI_GPIO_CONTROL);
 785
 786         card |= WD719X_GPIO_ID_BITS;
 787         wd719x_writeb(wd, WD719X_PCI_GPIO_CONTROL, card);
 788         card = wd719x_readb(wd, WD719X_PCI_GPIO_DATA) & WD719X_GPIO_ID_BITS;
 789         switch (card) {
 790         case 0x08:
 791                 return WD719X_TYPE_7193;
 792         case 0x02:
 793                 return WD719X_TYPE_7197;
 794         case 0x00:
 795                 return WD719X_TYPE_7296;
 796         default:
 797                 dev_warn(&wd->pdev->dev, "unknown card type 0x%x\n", card);
 798                 return WD719X_TYPE_UNKNOWN;
 799         }
 800 }
 801
 802 static int wd719x_board_found(struct Scsi_Host *sh)
 803 {
 804         struct wd719x *wd = shost_priv(sh);
 805         static const char * const card_types[] = {
 806                 "Unknown card", "WD7193", "WD7197", "WD7296"
 807         };
 808         int ret;
 809
 810         INIT_LIST_HEAD(&wd->active_scbs);
 811         INIT_LIST_HEAD(&wd->free_scbs);
 812
 813         sh->base = pci_resource_start(wd->pdev, 0);
 814
 815         wd->type = wd719x_detect_type(wd);
 816
 817         wd->sh = sh;
 818         sh->irq = wd->pdev->irq;
 819         wd->fw_virt = NULL;
 820
 821         /* memory area for host (EEPROM) parameters */
 822         wd->params = pci_alloc_consistent(wd->pdev,
 823                                           sizeof(struct wd719x_host_param),
 824                                           &wd->params_phys);
 825         if (!wd->params) {
 826                 dev_warn(&wd->pdev->dev, "unable to allocate parameter buffer\n");
 827                 return -ENOMEM;
 828         }
 829
 830         /* memory area for the RISC for hash table of outstanding requests */
 831         wd->hash_virt = pci_alloc_consistent(wd->pdev, WD719X_HASH_TABLE_SIZE,
 832                                              &wd->hash_phys);
 833         if (!wd->hash_virt) {
 834                 dev_warn(&wd->pdev->dev, "unable to allocate hash buffer\n");
 835                 ret = -ENOMEM;
 836                 goto fail_free_params;
 837         }
 838
 839         ret = request_irq(wd->pdev->irq, wd719x_interrupt, IRQF_SHARED,
 840                           "wd719x", wd);
 841         if (ret) {
 842                 dev_warn(&wd->pdev->dev, "unable to assign IRQ %d\n",
 843                          wd->pdev->irq);
 844                 goto fail_free_hash;
 845         }
 846
 847         /* read parameters from EEPROM */
 848         wd719x_read_eeprom(wd);
 849
 850         ret = wd719x_chip_init(wd);
 851         if (ret)
 852                 goto fail_free_irq;
 853
 854         sh->this_id = wd->params->own_scsi_id & WD719X_EE_SCSI_ID_MASK;
 855
 856         dev_info(&wd->pdev->dev, "%s at I/O 0x%lx, IRQ %u, SCSI ID %d\n",
 857                  card_types[wd->type], sh->base, sh->irq, sh->this_id);
 858
 859         return 0;
 860
 861 fail_free_irq:
 862         free_irq(wd->pdev->irq, wd);
 863 fail_free_hash:
 864         pci_free_consistent(wd->pdev, WD719X_HASH_TABLE_SIZE, wd->hash_virt,
 865                             wd->hash_phys);
 866 fail_free_params:
 867         pci_free_consistent(wd->pdev, sizeof(struct wd719x_host_param),
 868                             wd->params, wd->params_phys);
 869
 870         return ret;
 871 }
 872
 873 static struct scsi_host_template wd719x_template = {
 874         .module                         = THIS_MODULE,
 875         .name                           = "Western Digital 719x",
 876         .queuecommand                   = wd719x_queuecommand,
 877         .eh_abort_handler               = wd719x_abort,
 878         .eh_device_reset_handler        = wd719x_dev_reset,
 879         .eh_bus_reset_handler           = wd719x_bus_reset,
 880         .eh_host_reset_handler          = wd719x_host_reset,
 881         .bios_param                     = wd719x_biosparam,
 882         .proc_name                      = "wd719x",
 883         .can_queue                      = 255,
 884         .this_id                        = 7,
 885         .sg_tablesize                   = WD719X_SG,
 886         .use_clustering                 = ENABLE_CLUSTERING,
 887 };
 888
 889 static int wd719x_pci_probe(struct pci_dev *pdev, const struct pci_device_id *d)
 890 {
 891         int err;
 892         struct Scsi_Host *sh;
 893         struct wd719x *wd;
 894
 895         err = pci_enable_device(pdev);
 896         if (err)
 897                 goto fail;
 898
 899         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
 900                 dev_warn(&pdev->dev, "Unable to set 32-bit DMA mask\n");
 901                 goto disable_device;
 902         }
 903
 904         err = pci_request_regions(pdev, "wd719x");
 905         if (err)
 906                 goto disable_device;
 907         pci_set_master(pdev);
 908
 909         err = -ENODEV;
 910         if (pci_resource_len(pdev, 0) == 0)
 911                 goto release_region;
 912
 913         err = -ENOMEM;
 914         sh = scsi_host_alloc(&wd719x_template, sizeof(struct wd719x));
 915         if (!sh)
 916                 goto release_region;
 917
 918         wd = shost_priv(sh);
 919         wd->base = pci_iomap(pdev, 0, 0);
 920         if (!wd->base)
 921                 goto free_host;
 922         wd->pdev = pdev;
 923
 924         err = wd719x_board_found(sh);
 925         if (err)
 926                 goto unmap;
 927
 928         err = scsi_add_host(sh, &wd->pdev->dev);
 929         if (err)
 930                 goto destroy;
 931
 932         scsi_scan_host(sh);
 933
 934         pci_set_drvdata(pdev, sh);
 935         return 0;
 936
 937 destroy:
 938         wd719x_destroy(wd);
 939 unmap:
 940         pci_iounmap(pdev, wd->base);
 941 free_host:
 942         scsi_host_put(sh);
 943 release_region:
 944         pci_release_regions(pdev);
 945 disable_device:
 946         pci_disable_device(pdev);
 947 fail:
 948         return err;
 949 }
 950
 951
 952 static void wd719x_pci_remove(struct pci_dev *pdev)
 953 {
 954         struct Scsi_Host *sh = pci_get_drvdata(pdev);
 955         struct wd719x *wd = shost_priv(sh);
 956
 957         scsi_remove_host(sh);
 958         wd719x_destroy(wd);
 959         pci_iounmap(pdev, wd->base);
 960         pci_release_regions(pdev);
 961         pci_disable_device(pdev);
 962
 963         scsi_host_put(sh);
 964 }
 965
 966 static const struct pci_device_id wd719x_pci_table[] = {
 967         { PCI_DEVICE(PCI_VENDOR_ID_WD, 0x3296) },
 968         {}
 969 };
 970
 971 MODULE_DEVICE_TABLE(pci, wd719x_pci_table);
 972
 973 static struct pci_driver wd719x_pci_driver = {
 974         .name =         "wd719x",
 975         .id_table =     wd719x_pci_table,
 976         .probe =        wd719x_pci_probe,
 977         .remove =       wd719x_pci_remove,
 978 };
 979
 980 module_pci_driver(wd719x_pci_driver);
 981
 982 MODULE_DESCRIPTION("Western Digital WD7193/7197/7296 SCSI driver");
 983 MODULE_AUTHOR("Ondrej Zary, Aaron Dewell, Juergen Gaertner");
 984 MODULE_LICENSE("GPL");
 985 MODULE_FIRMWARE("wd719x-wcs.bin");
 986 MODULE_FIRMWARE("wd719x-risc.bin");