drivers/scsi/sun_esp.c

   1 /* sun_esp.c: ESP front-end for Sparc SBUS systems.
   2  *
   3  * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/types.h>
   8 #include <linux/delay.h>
   9 #include <linux/module.h>
  10 #include <linux/mm.h>
  11 #include <linux/init.h>
  12
  13 #include <asm/irq.h>
  14 #include <asm/io.h>
  15 #include <asm/dma.h>
  16
  17 #include <asm/sbus.h>
  18
  19 #include <scsi/scsi_host.h>
  20
  21 #include "esp_scsi.h"
  22
  23 #define DRV_MODULE_NAME         "sun_esp"
  24 #define PFX DRV_MODULE_NAME     ": "
  25 #define DRV_VERSION             "1.000"
  26 #define DRV_MODULE_RELDATE      "April 19, 2007"
  27
  28 #define dma_read32(REG) \
  29         sbus_readl(esp->dma_regs + (REG))
  30 #define dma_write32(VAL, REG) \
  31         sbus_writel((VAL), esp->dma_regs + (REG))
  32
  33 static int __devinit esp_sbus_find_dma(struct esp *esp, struct sbus_dev *dma_sdev)
  34 {
  35         struct sbus_dev *sdev = esp->dev;
  36         struct sbus_dma *dma;
  37
  38         if (dma_sdev != NULL) {
  39                 for_each_dvma(dma) {
  40                         if (dma->sdev == dma_sdev)
  41                                 break;
  42                 }
  43         } else {
  44                 for_each_dvma(dma) {
  45                         if (dma->sdev == NULL)
  46                                 break;
  47
  48                         /* If bus + slot are the same and it has the
  49                          * correct OBP name, it's ours.
  50                          */
  51                         if (sdev->bus == dma->sdev->bus &&
  52                             sdev->slot == dma->sdev->slot &&
  53                             (!strcmp(dma->sdev->prom_name, "dma") ||
  54                              !strcmp(dma->sdev->prom_name, "espdma")))
  55                                 break;
  56                 }
  57         }
  58
  59         if (dma == NULL) {
  60                 printk(KERN_ERR PFX "[%s] Cannot find dma.\n",
  61                        sdev->ofdev.node->full_name);
  62                 return -ENODEV;
  63         }
  64         esp->dma = dma;
  65         esp->dma_regs = dma->regs;
  66
  67         return 0;
  68
  69 }
  70
  71 static int __devinit esp_sbus_map_regs(struct esp *esp, int hme)
  72 {
  73         struct sbus_dev *sdev = esp->dev;
  74         struct resource *res;
  75
  76         /* On HME, two reg sets exist, first is DVMA,
  77          * second is ESP registers.
  78          */
  79         if (hme)
  80                 res = &sdev->resource[1];
  81         else
  82                 res = &sdev->resource[0];
  83
  84         esp->regs = sbus_ioremap(res, 0, SBUS_ESP_REG_SIZE, "ESP");
  85         if (!esp->regs)
  86                 return -ENOMEM;
  87
  88         return 0;
  89 }
  90
  91 static int __devinit esp_sbus_map_command_block(struct esp *esp)
  92 {
  93         struct sbus_dev *sdev = esp->dev;
  94
  95         esp->command_block = sbus_alloc_consistent(sdev, 16,
  96                                                    &esp->command_block_dma);
  97         if (!esp->command_block)
  98                 return -ENOMEM;
  99         return 0;
 100 }
 101
 102 static int __devinit esp_sbus_register_irq(struct esp *esp)
 103 {
 104         struct Scsi_Host *host = esp->host;
 105         struct sbus_dev *sdev = esp->dev;
 106
 107         host->irq = sdev->irqs[0];
 108         return request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "ESP", esp);
 109 }
 110
 111 static void __devinit esp_get_scsi_id(struct esp *esp)
 112 {
 113         struct sbus_dev *sdev = esp->dev;
 114         struct device_node *dp = sdev->ofdev.node;
 115
 116         esp->scsi_id = of_getintprop_default(dp, "initiator-id", 0xff);
 117         if (esp->scsi_id != 0xff)
 118                 goto done;
 119
 120         esp->scsi_id = of_getintprop_default(dp, "scsi-initiator-id", 0xff);
 121         if (esp->scsi_id != 0xff)
 122                 goto done;
 123
 124         if (!sdev->bus) {
 125                 /* SUN4 */
 126                 esp->scsi_id = 7;
 127                 goto done;
 128         }
 129
 130         esp->scsi_id = of_getintprop_default(sdev->bus->ofdev.node,
 131                                              "scsi-initiator-id", 7);
 132
 133 done:
 134         esp->host->this_id = esp->scsi_id;
 135         esp->scsi_id_mask = (1 << esp->scsi_id);
 136 }
 137
 138 static void __devinit esp_get_differential(struct esp *esp)
 139 {
 140         struct sbus_dev *sdev = esp->dev;
 141         struct device_node *dp = sdev->ofdev.node;
 142
 143         if (of_find_property(dp, "differential", NULL))
 144                 esp->flags |= ESP_FLAG_DIFFERENTIAL;
 145         else
 146                 esp->flags &= ~ESP_FLAG_DIFFERENTIAL;
 147 }
 148
 149 static void __devinit esp_get_clock_params(struct esp *esp)
 150 {
 151         struct sbus_dev *sdev = esp->dev;
 152         struct device_node *dp = sdev->ofdev.node;
 153         struct device_node *bus_dp;
 154         int fmhz;
 155
 156         bus_dp = NULL;
 157         if (sdev != NULL && sdev->bus != NULL)
 158                 bus_dp = sdev->bus->ofdev.node;
 159
 160         fmhz = of_getintprop_default(dp, "clock-frequency", 0);
 161         if (fmhz == 0)
 162                 fmhz = (!bus_dp) ? 0 :
 163                         of_getintprop_default(bus_dp, "clock-frequency", 0);
 164
 165         esp->cfreq = fmhz;
 166 }
 167
 168 static void __devinit esp_get_bursts(struct esp *esp, struct sbus_dev *dma)
 169 {
 170         struct sbus_dev *sdev = esp->dev;
 171         struct device_node *dp = sdev->ofdev.node;
 172         u8 bursts;
 173
 174         bursts = of_getintprop_default(dp, "burst-sizes", 0xff);
 175         if (dma) {
 176                 struct device_node *dma_dp = dma->ofdev.node;
 177                 u8 val = of_getintprop_default(dma_dp, "burst-sizes", 0xff);
 178                 if (val != 0xff)
 179                         bursts &= val;
 180         }
 181
 182         if (sdev->bus) {
 183                 u8 val = of_getintprop_default(sdev->bus->ofdev.node,
 184                                                "burst-sizes", 0xff);
 185                 if (val != 0xff)
 186                         bursts &= val;
 187         }
 188
 189         if (bursts == 0xff ||
 190             (bursts & DMA_BURST16) == 0 ||
 191             (bursts & DMA_BURST32) == 0)
 192                 bursts = (DMA_BURST32 - 1);
 193
 194         esp->bursts = bursts;
 195 }
 196
 197 static void __devinit esp_sbus_get_props(struct esp *esp, struct sbus_dev *espdma)
 198 {
 199         esp_get_scsi_id(esp);
 200         esp_get_differential(esp);
 201         esp_get_clock_params(esp);
 202         esp_get_bursts(esp, espdma);
 203 }
 204
 205 static void sbus_esp_write8(struct esp *esp, u8 val, unsigned long reg)
 206 {
 207         sbus_writeb(val, esp->regs + (reg * 4UL));
 208 }
 209
 210 static u8 sbus_esp_read8(struct esp *esp, unsigned long reg)
 211 {
 212         return sbus_readb(esp->regs + (reg * 4UL));
 213 }
 214
 215 static dma_addr_t sbus_esp_map_single(struct esp *esp, void *buf,
 216                                       size_t sz, int dir)
 217 {
 218         return sbus_map_single(esp->dev, buf, sz, dir);
 219 }
 220
 221 static int sbus_esp_map_sg(struct esp *esp, struct scatterlist *sg,
 222                                   int num_sg, int dir)
 223 {
 224         return sbus_map_sg(esp->dev, sg, num_sg, dir);
 225 }
 226
 227 static void sbus_esp_unmap_single(struct esp *esp, dma_addr_t addr,
 228                                   size_t sz, int dir)
 229 {
 230         sbus_unmap_single(esp->dev, addr, sz, dir);
 231 }
 232
 233 static void sbus_esp_unmap_sg(struct esp *esp, struct scatterlist *sg,
 234                               int num_sg, int dir)
 235 {
 236         sbus_unmap_sg(esp->dev, sg, num_sg, dir);
 237 }
 238
 239 static int sbus_esp_irq_pending(struct esp *esp)
 240 {
 241         if (dma_read32(DMA_CSR) & (DMA_HNDL_INTR | DMA_HNDL_ERROR))
 242                 return 1;
 243         return 0;
 244 }
 245
 246 static void sbus_esp_reset_dma(struct esp *esp)
 247 {
 248         int can_do_burst16, can_do_burst32, can_do_burst64;
 249         int can_do_sbus64, lim;
 250         u32 val;
 251
 252         can_do_burst16 = (esp->bursts & DMA_BURST16) != 0;
 253         can_do_burst32 = (esp->bursts & DMA_BURST32) != 0;
 254         can_do_burst64 = 0;
 255         can_do_sbus64 = 0;
 256         if (sbus_can_dma_64bit(esp->dev))
 257                 can_do_sbus64 = 1;
 258         if (sbus_can_burst64(esp->sdev))
 259                 can_do_burst64 = (esp->bursts & DMA_BURST64) != 0;
 260
 261         /* Put the DVMA into a known state. */
 262         if (esp->dma->revision != dvmahme) {
 263                 val = dma_read32(DMA_CSR);
 264                 dma_write32(val | DMA_RST_SCSI, DMA_CSR);
 265                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
 266         }
 267         switch (esp->dma->revision) {
 268         case dvmahme:
 269                 dma_write32(DMA_RESET_FAS366, DMA_CSR);
 270                 dma_write32(DMA_RST_SCSI, DMA_CSR);
 271
 272                 esp->prev_hme_dmacsr = (DMA_PARITY_OFF | DMA_2CLKS |
 273                                         DMA_SCSI_DISAB | DMA_INT_ENAB);
 274
 275                 esp->prev_hme_dmacsr &= ~(DMA_ENABLE | DMA_ST_WRITE |
 276                                           DMA_BRST_SZ);
 277
 278                 if (can_do_burst64)
 279                         esp->prev_hme_dmacsr |= DMA_BRST64;
 280                 else if (can_do_burst32)
 281                         esp->prev_hme_dmacsr |= DMA_BRST32;
 282
 283                 if (can_do_sbus64) {
 284                         esp->prev_hme_dmacsr |= DMA_SCSI_SBUS64;
 285                         sbus_set_sbus64(esp->dev, esp->bursts);
 286                 }
 287
 288                 lim = 1000;
 289                 while (dma_read32(DMA_CSR) & DMA_PEND_READ) {
 290                         if (--lim == 0) {
 291                                 printk(KERN_ALERT PFX "esp%d: DMA_PEND_READ "
 292                                        "will not clear!\n",
 293                                        esp->host->unique_id);
 294                                 break;
 295                         }
 296                         udelay(1);
 297                 }
 298
 299                 dma_write32(0, DMA_CSR);
 300                 dma_write32(esp->prev_hme_dmacsr, DMA_CSR);
 301
 302                 dma_write32(0, DMA_ADDR);
 303                 break;
 304
 305         case dvmarev2:
 306                 if (esp->rev != ESP100) {
 307                         val = dma_read32(DMA_CSR);
 308                         dma_write32(val | DMA_3CLKS, DMA_CSR);
 309                 }
 310                 break;
 311
 312         case dvmarev3:
 313                 val = dma_read32(DMA_CSR);
 314                 val &= ~DMA_3CLKS;
 315                 val |= DMA_2CLKS;
 316                 if (can_do_burst32) {
 317                         val &= ~DMA_BRST_SZ;
 318                         val |= DMA_BRST32;
 319                 }
 320                 dma_write32(val, DMA_CSR);
 321                 break;
 322
 323         case dvmaesc1:
 324                 val = dma_read32(DMA_CSR);
 325                 val |= DMA_ADD_ENABLE;
 326                 val &= ~DMA_BCNT_ENAB;
 327                 if (!can_do_burst32 && can_do_burst16) {
 328                         val |= DMA_ESC_BURST;
 329                 } else {
 330                         val &= ~(DMA_ESC_BURST);
 331                 }
 332                 dma_write32(val, DMA_CSR);
 333                 break;
 334
 335         default:
 336                 break;
 337         }
 338
 339         /* Enable interrupts.  */
 340         val = dma_read32(DMA_CSR);
 341         dma_write32(val | DMA_INT_ENAB, DMA_CSR);
 342 }
 343
 344 static void sbus_esp_dma_drain(struct esp *esp)
 345 {
 346         u32 csr;
 347         int lim;
 348
 349         if (esp->dma->revision == dvmahme)
 350                 return;
 351
 352         csr = dma_read32(DMA_CSR);
 353         if (!(csr & DMA_FIFO_ISDRAIN))
 354                 return;
 355
 356         if (esp->dma->revision != dvmarev3 && esp->dma->revision != dvmaesc1)
 357                 dma_write32(csr | DMA_FIFO_STDRAIN, DMA_CSR);
 358
 359         lim = 1000;
 360         while (dma_read32(DMA_CSR) & DMA_FIFO_ISDRAIN) {
 361                 if (--lim == 0) {
 362                         printk(KERN_ALERT PFX "esp%d: DMA will not drain!\n",
 363                                esp->host->unique_id);
 364                         break;
 365                 }
 366                 udelay(1);
 367         }
 368 }
 369
 370 static void sbus_esp_dma_invalidate(struct esp *esp)
 371 {
 372         if (esp->dma->revision == dvmahme) {
 373                 dma_write32(DMA_RST_SCSI, DMA_CSR);
 374
 375                 esp->prev_hme_dmacsr = ((esp->prev_hme_dmacsr |
 376                                          (DMA_PARITY_OFF | DMA_2CLKS |
 377                                           DMA_SCSI_DISAB | DMA_INT_ENAB)) &
 378                                         ~(DMA_ST_WRITE | DMA_ENABLE));
 379
 380                 dma_write32(0, DMA_CSR);
 381                 dma_write32(esp->prev_hme_dmacsr, DMA_CSR);
 382
 383                 /* This is necessary to avoid having the SCSI channel
 384                  * engine lock up on us.
 385                  */
 386                 dma_write32(0, DMA_ADDR);
 387         } else {
 388                 u32 val;
 389                 int lim;
 390
 391                 lim = 1000;
 392                 while ((val = dma_read32(DMA_CSR)) & DMA_PEND_READ) {
 393                         if (--lim == 0) {
 394                                 printk(KERN_ALERT PFX "esp%d: DMA will not "
 395                                        "invalidate!\n", esp->host->unique_id);
 396                                 break;
 397                         }
 398                         udelay(1);
 399                 }
 400
 401                 val &= ~(DMA_ENABLE | DMA_ST_WRITE | DMA_BCNT_ENAB);
 402                 val |= DMA_FIFO_INV;
 403                 dma_write32(val, DMA_CSR);
 404                 val &= ~DMA_FIFO_INV;
 405                 dma_write32(val, DMA_CSR);
 406         }
 407 }
 408
 409 static void sbus_esp_send_dma_cmd(struct esp *esp, u32 addr, u32 esp_count,
 410                                   u32 dma_count, int write, u8 cmd)
 411 {
 412         u32 csr;
 413
 414         BUG_ON(!(cmd & ESP_CMD_DMA));
 415
 416         sbus_esp_write8(esp, (esp_count >> 0) & 0xff, ESP_TCLOW);
 417         sbus_esp_write8(esp, (esp_count >> 8) & 0xff, ESP_TCMED);
 418         if (esp->rev == FASHME) {
 419                 sbus_esp_write8(esp, (esp_count >> 16) & 0xff, FAS_RLO);
 420                 sbus_esp_write8(esp, 0, FAS_RHI);
 421
 422                 scsi_esp_cmd(esp, cmd);
 423
 424                 csr = esp->prev_hme_dmacsr;
 425                 csr |= DMA_SCSI_DISAB | DMA_ENABLE;
 426                 if (write)
 427                         csr |= DMA_ST_WRITE;
 428                 else
 429                         csr &= ~DMA_ST_WRITE;
 430                 esp->prev_hme_dmacsr = csr;
 431
 432                 dma_write32(dma_count, DMA_COUNT);
 433                 dma_write32(addr, DMA_ADDR);
 434                 dma_write32(csr, DMA_CSR);
 435         } else {
 436                 csr = dma_read32(DMA_CSR);
 437                 csr |= DMA_ENABLE;
 438                 if (write)
 439                         csr |= DMA_ST_WRITE;
 440                 else
 441                         csr &= ~DMA_ST_WRITE;
 442                 dma_write32(csr, DMA_CSR);
 443                 if (esp->dma->revision == dvmaesc1) {
 444                         u32 end = PAGE_ALIGN(addr + dma_count + 16U);
 445                         dma_write32(end - addr, DMA_COUNT);
 446                 }
 447                 dma_write32(addr, DMA_ADDR);
 448
 449                 scsi_esp_cmd(esp, cmd);
 450         }
 451
 452 }
 453
 454 static int sbus_esp_dma_error(struct esp *esp)
 455 {
 456         u32 csr = dma_read32(DMA_CSR);
 457
 458         if (csr & DMA_HNDL_ERROR)
 459                 return 1;
 460
 461         return 0;
 462 }
 463
 464 static const struct esp_driver_ops sbus_esp_ops = {
 465         .esp_write8     =       sbus_esp_write8,
 466         .esp_read8      =       sbus_esp_read8,
 467         .map_single     =       sbus_esp_map_single,
 468         .map_sg         =       sbus_esp_map_sg,
 469         .unmap_single   =       sbus_esp_unmap_single,
 470         .unmap_sg       =       sbus_esp_unmap_sg,
 471         .irq_pending    =       sbus_esp_irq_pending,
 472         .reset_dma      =       sbus_esp_reset_dma,
 473         .dma_drain      =       sbus_esp_dma_drain,
 474         .dma_invalidate =       sbus_esp_dma_invalidate,
 475         .send_dma_cmd   =       sbus_esp_send_dma_cmd,
 476         .dma_error      =       sbus_esp_dma_error,
 477 };
 478
 479 static int __devinit esp_sbus_probe_one(struct device *dev,
 480                                         struct sbus_dev *esp_dev,
 481                                         struct sbus_dev *espdma,
 482                                         struct sbus_bus *sbus,
 483                                         int hme)
 484 {
 485         struct scsi_host_template *tpnt = &scsi_esp_template;
 486         struct Scsi_Host *host;
 487         struct esp *esp;
 488         int err;
 489
 490         host = scsi_host_alloc(tpnt, sizeof(struct esp));
 491
 492         err = -ENOMEM;
 493         if (!host)
 494                 goto fail;
 495
 496         host->max_id = (hme ? 16 : 8);
 497         esp = shost_priv(host);
 498
 499         esp->host = host;
 500         esp->dev = esp_dev;
 501         esp->ops = &sbus_esp_ops;
 502
 503         if (hme)
 504                 esp->flags |= ESP_FLAG_WIDE_CAPABLE;
 505
 506         err = esp_sbus_find_dma(esp, espdma);
 507         if (err < 0)
 508                 goto fail_unlink;
 509
 510         err = esp_sbus_map_regs(esp, hme);
 511         if (err < 0)
 512                 goto fail_unlink;
 513
 514         err = esp_sbus_map_command_block(esp);
 515         if (err < 0)
 516                 goto fail_unmap_regs;
 517
 518         err = esp_sbus_register_irq(esp);
 519         if (err < 0)
 520                 goto fail_unmap_command_block;
 521
 522         esp_sbus_get_props(esp, espdma);
 523
 524         /* Before we try to touch the ESP chip, ESC1 dma can
 525          * come up with the reset bit set, so make sure that
 526          * is clear first.
 527          */
 528         if (esp->dma->revision == dvmaesc1) {
 529                 u32 val = dma_read32(DMA_CSR);
 530
 531                 dma_write32(val & ~DMA_RST_SCSI, DMA_CSR);
 532         }
 533
 534         dev_set_drvdata(&esp_dev->ofdev.dev, esp);
 535
 536         err = scsi_esp_register(esp, dev);
 537         if (err)
 538                 goto fail_free_irq;
 539
 540         return 0;
 541
 542 fail_free_irq:
 543         free_irq(host->irq, esp);
 544 fail_unmap_command_block:
 545         sbus_free_consistent(esp->dev, 16,
 546                              esp->command_block,
 547                              esp->command_block_dma);
 548 fail_unmap_regs:
 549         sbus_iounmap(esp->regs, SBUS_ESP_REG_SIZE);
 550 fail_unlink:
 551         scsi_host_put(host);
 552 fail:
 553         return err;
 554 }
 555
 556 static int __devinit esp_sbus_probe(struct of_device *dev, const struct of_device_id *match)
 557 {
 558         struct sbus_dev *sdev = to_sbus_device(&dev->dev);
 559         struct device_node *dp = dev->node;
 560         struct sbus_dev *dma_sdev = NULL;
 561         int hme = 0;
 562
 563         if (dp->parent &&
 564             (!strcmp(dp->parent->name, "espdma") ||
 565              !strcmp(dp->parent->name, "dma")))
 566                 dma_sdev = sdev->parent;
 567         else if (!strcmp(dp->name, "SUNW,fas")) {
 568                 dma_sdev = sdev;
 569                 hme = 1;
 570         }
 571
 572         return esp_sbus_probe_one(&dev->dev, sdev, dma_sdev,
 573                                   sdev->bus, hme);
 574 }
 575
 576 static int __devexit esp_sbus_remove(struct of_device *dev)
 577 {
 578         struct esp *esp = dev_get_drvdata(&dev->dev);
 579         unsigned int irq = esp->host->irq;
 580         u32 val;
 581
 582         scsi_esp_unregister(esp);
 583
 584         /* Disable interrupts.  */
 585         val = dma_read32(DMA_CSR);
 586         dma_write32(val & ~DMA_INT_ENAB, DMA_CSR);
 587
 588         free_irq(irq, esp);
 589         sbus_free_consistent(esp->dev, 16,
 590                              esp->command_block,
 591                              esp->command_block_dma);
 592         sbus_iounmap(esp->regs, SBUS_ESP_REG_SIZE);
 593
 594         scsi_host_put(esp->host);
 595
 596         return 0;
 597 }
 598
 599 static struct of_device_id esp_match[] = {
 600         {
 601                 .name = "SUNW,esp",
 602         },
 603         {
 604                 .name = "SUNW,fas",
 605         },
 606         {
 607                 .name = "esp",
 608         },
 609         {},
 610 };
 611 MODULE_DEVICE_TABLE(of, esp_match);
 612
 613 static struct of_platform_driver esp_sbus_driver = {
 614         .name           = "esp",
 615         .match_table    = esp_match,
 616         .probe          = esp_sbus_probe,
 617         .remove         = __devexit_p(esp_sbus_remove),
 618 };
 619
 620 static int __init sunesp_init(void)
 621 {
 622         return of_register_driver(&esp_sbus_driver, &sbus_bus_type);
 623 }
 624
 625 static void __exit sunesp_exit(void)
 626 {
 627         of_unregister_driver(&esp_sbus_driver);
 628 }
 629
 630 MODULE_DESCRIPTION("Sun ESP SCSI driver");
 631 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
 632 MODULE_LICENSE("GPL");
 633 MODULE_VERSION(DRV_VERSION);
 634
 635 module_init(sunesp_init);
 636 module_exit(sunesp_exit);