linux/drivers/scsi/arm/cumana_2.c
<<
>>
Prefs
   1/*
   2 *  linux/drivers/acorn/scsi/cumana_2.c
   3 *
   4 *  Copyright (C) 1997-2005 Russell King
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License version 2 as
   8 * published by the Free Software Foundation.
   9 *
  10 *  Changelog:
  11 *   30-08-1997 RMK     0.0.0   Created, READONLY version.
  12 *   22-01-1998 RMK     0.0.1   Updated to 2.1.80.
  13 *   15-04-1998 RMK     0.0.1   Only do PIO if FAS216 will allow it.
  14 *   02-05-1998 RMK     0.0.2   Updated & added DMA support.
  15 *   27-06-1998 RMK             Changed asm/delay.h to linux/delay.h
  16 *   18-08-1998 RMK     0.0.3   Fixed synchronous transfer depth.
  17 *   02-04-2000 RMK     0.0.4   Updated for new error handling code.
  18 */
  19#include <linux/module.h>
  20#include <linux/blkdev.h>
  21#include <linux/kernel.h>
  22#include <linux/string.h>
  23#include <linux/ioport.h>
  24#include <linux/proc_fs.h>
  25#include <linux/delay.h>
  26#include <linux/interrupt.h>
  27#include <linux/init.h>
  28#include <linux/dma-mapping.h>
  29
  30#include <asm/dma.h>
  31#include <asm/ecard.h>
  32#include <asm/io.h>
  33#include <asm/pgtable.h>
  34
  35#include "../scsi.h"
  36#include <scsi/scsi_host.h>
  37#include "fas216.h"
  38#include "scsi.h"
  39
  40#include <scsi/scsicam.h>
  41
  42#define CUMANASCSI2_STATUS              (0x0000)
  43#define STATUS_INT                      (1 << 0)
  44#define STATUS_DRQ                      (1 << 1)
  45#define STATUS_LATCHED                  (1 << 3)
  46
  47#define CUMANASCSI2_ALATCH              (0x0014)
  48#define ALATCH_ENA_INT                  (3)
  49#define ALATCH_DIS_INT                  (2)
  50#define ALATCH_ENA_TERM                 (5)
  51#define ALATCH_DIS_TERM                 (4)
  52#define ALATCH_ENA_BIT32                (11)
  53#define ALATCH_DIS_BIT32                (10)
  54#define ALATCH_ENA_DMA                  (13)
  55#define ALATCH_DIS_DMA                  (12)
  56#define ALATCH_DMA_OUT                  (15)
  57#define ALATCH_DMA_IN                   (14)
  58
  59#define CUMANASCSI2_PSEUDODMA           (0x0200)
  60
  61#define CUMANASCSI2_FAS216_OFFSET       (0x0300)
  62#define CUMANASCSI2_FAS216_SHIFT        2
  63
  64/*
  65 * Version
  66 */
  67#define VERSION "1.00 (13/11/2002 2.5.47)"
  68
  69/*
  70 * Use term=0,1,0,0,0 to turn terminators on/off
  71 */
  72static int term[MAX_ECARDS] = { 1, 1, 1, 1, 1, 1, 1, 1 };
  73
  74#define NR_SG   256
  75
  76struct cumanascsi2_info {
  77        FAS216_Info             info;
  78        struct expansion_card   *ec;
  79        void __iomem            *base;
  80        unsigned int            terms;          /* Terminator state     */
  81        struct scatterlist      sg[NR_SG];      /* Scatter DMA list     */
  82};
  83
  84#define CSTATUS_IRQ     (1 << 0)
  85#define CSTATUS_DRQ     (1 << 1)
  86
  87/* Prototype: void cumanascsi_2_irqenable(ec, irqnr)
  88 * Purpose  : Enable interrupts on Cumana SCSI 2 card
  89 * Params   : ec    - expansion card structure
  90 *          : irqnr - interrupt number
  91 */
  92static void
  93cumanascsi_2_irqenable(struct expansion_card *ec, int irqnr)
  94{
  95        struct cumanascsi2_info *info = ec->irq_data;
  96        writeb(ALATCH_ENA_INT, info->base + CUMANASCSI2_ALATCH);
  97}
  98
  99/* Prototype: void cumanascsi_2_irqdisable(ec, irqnr)
 100 * Purpose  : Disable interrupts on Cumana SCSI 2 card
 101 * Params   : ec    - expansion card structure
 102 *          : irqnr - interrupt number
 103 */
 104static void
 105cumanascsi_2_irqdisable(struct expansion_card *ec, int irqnr)
 106{
 107        struct cumanascsi2_info *info = ec->irq_data;
 108        writeb(ALATCH_DIS_INT, info->base + CUMANASCSI2_ALATCH);
 109}
 110
 111static const expansioncard_ops_t cumanascsi_2_ops = {
 112        .irqenable      = cumanascsi_2_irqenable,
 113        .irqdisable     = cumanascsi_2_irqdisable,
 114};
 115
 116/* Prototype: void cumanascsi_2_terminator_ctl(host, on_off)
 117 * Purpose  : Turn the Cumana SCSI 2 terminators on or off
 118 * Params   : host   - card to turn on/off
 119 *          : on_off - !0 to turn on, 0 to turn off
 120 */
 121static void
 122cumanascsi_2_terminator_ctl(struct Scsi_Host *host, int on_off)
 123{
 124        struct cumanascsi2_info *info = (struct cumanascsi2_info *)host->hostdata;
 125
 126        if (on_off) {
 127                info->terms = 1;
 128                writeb(ALATCH_ENA_TERM, info->base + CUMANASCSI2_ALATCH);
 129        } else {
 130                info->terms = 0;
 131                writeb(ALATCH_DIS_TERM, info->base + CUMANASCSI2_ALATCH);
 132        }
 133}
 134
 135/* Prototype: void cumanascsi_2_intr(irq, *dev_id, *regs)
 136 * Purpose  : handle interrupts from Cumana SCSI 2 card
 137 * Params   : irq    - interrupt number
 138 *            dev_id - user-defined (Scsi_Host structure)
 139 */
 140static irqreturn_t
 141cumanascsi_2_intr(int irq, void *dev_id)
 142{
 143        struct cumanascsi2_info *info = dev_id;
 144
 145        return fas216_intr(&info->info);
 146}
 147
 148/* Prototype: fasdmatype_t cumanascsi_2_dma_setup(host, SCpnt, direction, min_type)
 149 * Purpose  : initialises DMA/PIO
 150 * Params   : host      - host
 151 *            SCpnt     - command
 152 *            direction - DMA on to/off of card
 153 *            min_type  - minimum DMA support that we must have for this transfer
 154 * Returns  : type of transfer to be performed
 155 */
 156static fasdmatype_t
 157cumanascsi_2_dma_setup(struct Scsi_Host *host, struct scsi_pointer *SCp,
 158                       fasdmadir_t direction, fasdmatype_t min_type)
 159{
 160        struct cumanascsi2_info *info = (struct cumanascsi2_info *)host->hostdata;
 161        struct device *dev = scsi_get_device(host);
 162        int dmach = info->info.scsi.dma;
 163
 164        writeb(ALATCH_DIS_DMA, info->base + CUMANASCSI2_ALATCH);
 165
 166        if (dmach != NO_DMA &&
 167            (min_type == fasdma_real_all || SCp->this_residual >= 512)) {
 168                int bufs, map_dir, dma_dir, alatch_dir;
 169
 170                bufs = copy_SCp_to_sg(&info->sg[0], SCp, NR_SG);
 171
 172                if (direction == DMA_OUT)
 173                        map_dir = DMA_TO_DEVICE,
 174                        dma_dir = DMA_MODE_WRITE,
 175                        alatch_dir = ALATCH_DMA_OUT;
 176                else
 177                        map_dir = DMA_FROM_DEVICE,
 178                        dma_dir = DMA_MODE_READ,
 179                        alatch_dir = ALATCH_DMA_IN;
 180
 181                dma_map_sg(dev, info->sg, bufs, map_dir);
 182
 183                disable_dma(dmach);
 184                set_dma_sg(dmach, info->sg, bufs);
 185                writeb(alatch_dir, info->base + CUMANASCSI2_ALATCH);
 186                set_dma_mode(dmach, dma_dir);
 187                enable_dma(dmach);
 188                writeb(ALATCH_ENA_DMA, info->base + CUMANASCSI2_ALATCH);
 189                writeb(ALATCH_DIS_BIT32, info->base + CUMANASCSI2_ALATCH);
 190                return fasdma_real_all;
 191        }
 192
 193        /*
 194         * If we're not doing DMA,
 195         *  we'll do pseudo DMA
 196         */
 197        return fasdma_pio;
 198}
 199
 200/*
 201 * Prototype: void cumanascsi_2_dma_pseudo(host, SCpnt, direction, transfer)
 202 * Purpose  : handles pseudo DMA
 203 * Params   : host      - host
 204 *            SCpnt     - command
 205 *            direction - DMA on to/off of card
 206 *            transfer  - minimum number of bytes we expect to transfer
 207 */
 208static void
 209cumanascsi_2_dma_pseudo(struct Scsi_Host *host, struct scsi_pointer *SCp,
 210                        fasdmadir_t direction, int transfer)
 211{
 212        struct cumanascsi2_info *info = (struct cumanascsi2_info *)host->hostdata;
 213        unsigned int length;
 214        unsigned char *addr;
 215
 216        length = SCp->this_residual;
 217        addr = SCp->ptr;
 218
 219        if (direction == DMA_OUT)
 220#if 0
 221                while (length > 1) {
 222                        unsigned long word;
 223                        unsigned int status = readb(info->base + CUMANASCSI2_STATUS);
 224
 225                        if (status & STATUS_INT)
 226                                goto end;
 227
 228                        if (!(status & STATUS_DRQ))
 229                                continue;
 230
 231                        word = *addr | *(addr + 1) << 8;
 232                        writew(word, info->base + CUMANASCSI2_PSEUDODMA);
 233                        addr += 2;
 234                        length -= 2;
 235                }
 236#else
 237                printk ("PSEUDO_OUT???\n");
 238#endif
 239        else {
 240                if (transfer && (transfer & 255)) {
 241                        while (length >= 256) {
 242                                unsigned int status = readb(info->base + CUMANASCSI2_STATUS);
 243
 244                                if (status & STATUS_INT)
 245                                        return;
 246            
 247                                if (!(status & STATUS_DRQ))
 248                                        continue;
 249
 250                                readsw(info->base + CUMANASCSI2_PSEUDODMA,
 251                                       addr, 256 >> 1);
 252                                addr += 256;
 253                                length -= 256;
 254                        }
 255                }
 256
 257                while (length > 0) {
 258                        unsigned long word;
 259                        unsigned int status = readb(info->base + CUMANASCSI2_STATUS);
 260
 261                        if (status & STATUS_INT)
 262                                return;
 263
 264                        if (!(status & STATUS_DRQ))
 265                                continue;
 266
 267                        word = readw(info->base + CUMANASCSI2_PSEUDODMA);
 268                        *addr++ = word;
 269                        if (--length > 0) {
 270                                *addr++ = word >> 8;
 271                                length --;
 272                        }
 273                }
 274        }
 275}
 276
 277/* Prototype: int cumanascsi_2_dma_stop(host, SCpnt)
 278 * Purpose  : stops DMA/PIO
 279 * Params   : host  - host
 280 *            SCpnt - command
 281 */
 282static void
 283cumanascsi_2_dma_stop(struct Scsi_Host *host, struct scsi_pointer *SCp)
 284{
 285        struct cumanascsi2_info *info = (struct cumanascsi2_info *)host->hostdata;
 286        if (info->info.scsi.dma != NO_DMA) {
 287                writeb(ALATCH_DIS_DMA, info->base + CUMANASCSI2_ALATCH);
 288                disable_dma(info->info.scsi.dma);
 289        }
 290}
 291
 292/* Prototype: const char *cumanascsi_2_info(struct Scsi_Host * host)
 293 * Purpose  : returns a descriptive string about this interface,
 294 * Params   : host - driver host structure to return info for.
 295 * Returns  : pointer to a static buffer containing null terminated string.
 296 */
 297const char *cumanascsi_2_info(struct Scsi_Host *host)
 298{
 299        struct cumanascsi2_info *info = (struct cumanascsi2_info *)host->hostdata;
 300        static char string[150];
 301
 302        sprintf(string, "%s (%s) in slot %d v%s terminators o%s",
 303                host->hostt->name, info->info.scsi.type, info->ec->slot_no,
 304                VERSION, info->terms ? "n" : "ff");
 305
 306        return string;
 307}
 308
 309/* Prototype: int cumanascsi_2_set_proc_info(struct Scsi_Host *host, char *buffer, int length)
 310 * Purpose  : Set a driver specific function
 311 * Params   : host   - host to setup
 312 *          : buffer - buffer containing string describing operation
 313 *          : length - length of string
 314 * Returns  : -EINVAL, or 0
 315 */
 316static int
 317cumanascsi_2_set_proc_info(struct Scsi_Host *host, char *buffer, int length)
 318{
 319        int ret = length;
 320
 321        if (length >= 11 && strncmp(buffer, "CUMANASCSI2", 11) == 0) {
 322                buffer += 11;
 323                length -= 11;
 324
 325                if (length >= 5 && strncmp(buffer, "term=", 5) == 0) {
 326                        if (buffer[5] == '1')
 327                                cumanascsi_2_terminator_ctl(host, 1);
 328                        else if (buffer[5] == '0')
 329                                cumanascsi_2_terminator_ctl(host, 0);
 330                        else
 331                                ret = -EINVAL;
 332                } else
 333                        ret = -EINVAL;
 334        } else
 335                ret = -EINVAL;
 336
 337        return ret;
 338}
 339
 340static int cumanascsi_2_show_info(struct seq_file *m, struct Scsi_Host *host)
 341{
 342        struct cumanascsi2_info *info;
 343        info = (struct cumanascsi2_info *)host->hostdata;
 344
 345        seq_printf(m, "Cumana SCSI II driver v%s\n", VERSION);
 346        fas216_print_host(&info->info, m);
 347        seq_printf(m, "Term    : o%s\n",
 348                        info->terms ? "n" : "ff");
 349
 350        fas216_print_stats(&info->info, m);
 351        fas216_print_devices(&info->info, m);
 352        return 0;
 353}
 354
 355static struct scsi_host_template cumanascsi2_template = {
 356        .module                         = THIS_MODULE,
 357        .show_info                      = cumanascsi_2_show_info,
 358        .write_info                     = cumanascsi_2_set_proc_info,
 359        .name                           = "Cumana SCSI II",
 360        .info                           = cumanascsi_2_info,
 361        .queuecommand                   = fas216_queue_command,
 362        .eh_host_reset_handler          = fas216_eh_host_reset,
 363        .eh_bus_reset_handler           = fas216_eh_bus_reset,
 364        .eh_device_reset_handler        = fas216_eh_device_reset,
 365        .eh_abort_handler               = fas216_eh_abort,
 366        .can_queue                      = 1,
 367        .this_id                        = 7,
 368        .sg_tablesize                   = SCSI_MAX_SG_CHAIN_SEGMENTS,
 369        .dma_boundary                   = IOMD_DMA_BOUNDARY,
 370        .cmd_per_lun                    = 1,
 371        .use_clustering                 = DISABLE_CLUSTERING,
 372        .proc_name                      = "cumanascsi2",
 373};
 374
 375static int cumanascsi2_probe(struct expansion_card *ec,
 376                             const struct ecard_id *id)
 377{
 378        struct Scsi_Host *host;
 379        struct cumanascsi2_info *info;
 380        void __iomem *base;
 381        int ret;
 382
 383        ret = ecard_request_resources(ec);
 384        if (ret)
 385                goto out;
 386
 387        base = ecardm_iomap(ec, ECARD_RES_MEMC, 0, 0);
 388        if (!base) {
 389                ret = -ENOMEM;
 390                goto out_region;
 391        }
 392
 393        host = scsi_host_alloc(&cumanascsi2_template,
 394                               sizeof(struct cumanascsi2_info));
 395        if (!host) {
 396                ret = -ENOMEM;
 397                goto out_region;
 398        }
 399
 400        ecard_set_drvdata(ec, host);
 401
 402        info = (struct cumanascsi2_info *)host->hostdata;
 403        info->ec        = ec;
 404        info->base      = base;
 405
 406        cumanascsi_2_terminator_ctl(host, term[ec->slot_no]);
 407
 408        info->info.scsi.io_base         = base + CUMANASCSI2_FAS216_OFFSET;
 409        info->info.scsi.io_shift        = CUMANASCSI2_FAS216_SHIFT;
 410        info->info.scsi.irq             = ec->irq;
 411        info->info.scsi.dma             = ec->dma;
 412        info->info.ifcfg.clockrate      = 40; /* MHz */
 413        info->info.ifcfg.select_timeout = 255;
 414        info->info.ifcfg.asyncperiod    = 200; /* ns */
 415        info->info.ifcfg.sync_max_depth = 7;
 416        info->info.ifcfg.cntl3          = CNTL3_BS8 | CNTL3_FASTSCSI | CNTL3_FASTCLK;
 417        info->info.ifcfg.disconnect_ok  = 1;
 418        info->info.ifcfg.wide_max_size  = 0;
 419        info->info.ifcfg.capabilities   = FASCAP_PSEUDODMA;
 420        info->info.dma.setup            = cumanascsi_2_dma_setup;
 421        info->info.dma.pseudo           = cumanascsi_2_dma_pseudo;
 422        info->info.dma.stop             = cumanascsi_2_dma_stop;
 423
 424        ec->irqaddr     = info->base + CUMANASCSI2_STATUS;
 425        ec->irqmask     = STATUS_INT;
 426
 427        ecard_setirq(ec, &cumanascsi_2_ops, info);
 428
 429        ret = fas216_init(host);
 430        if (ret)
 431                goto out_free;
 432
 433        ret = request_irq(ec->irq, cumanascsi_2_intr,
 434                          0, "cumanascsi2", info);
 435        if (ret) {
 436                printk("scsi%d: IRQ%d not free: %d\n",
 437                       host->host_no, ec->irq, ret);
 438                goto out_release;
 439        }
 440
 441        if (info->info.scsi.dma != NO_DMA) {
 442                if (request_dma(info->info.scsi.dma, "cumanascsi2")) {
 443                        printk("scsi%d: DMA%d not free, using PIO\n",
 444                               host->host_no, info->info.scsi.dma);
 445                        info->info.scsi.dma = NO_DMA;
 446                } else {
 447                        set_dma_speed(info->info.scsi.dma, 180);
 448                        info->info.ifcfg.capabilities |= FASCAP_DMA;
 449                }
 450        }
 451
 452        ret = fas216_add(host, &ec->dev);
 453        if (ret == 0)
 454                goto out;
 455
 456        if (info->info.scsi.dma != NO_DMA)
 457                free_dma(info->info.scsi.dma);
 458        free_irq(ec->irq, host);
 459
 460 out_release:
 461        fas216_release(host);
 462
 463 out_free:
 464        scsi_host_put(host);
 465
 466 out_region:
 467        ecard_release_resources(ec);
 468
 469 out:
 470        return ret;
 471}
 472
 473static void cumanascsi2_remove(struct expansion_card *ec)
 474{
 475        struct Scsi_Host *host = ecard_get_drvdata(ec);
 476        struct cumanascsi2_info *info = (struct cumanascsi2_info *)host->hostdata;
 477
 478        ecard_set_drvdata(ec, NULL);
 479        fas216_remove(host);
 480
 481        if (info->info.scsi.dma != NO_DMA)
 482                free_dma(info->info.scsi.dma);
 483        free_irq(ec->irq, info);
 484
 485        fas216_release(host);
 486        scsi_host_put(host);
 487        ecard_release_resources(ec);
 488}
 489
 490static const struct ecard_id cumanascsi2_cids[] = {
 491        { MANU_CUMANA, PROD_CUMANA_SCSI_2 },
 492        { 0xffff, 0xffff },
 493};
 494
 495static struct ecard_driver cumanascsi2_driver = {
 496        .probe          = cumanascsi2_probe,
 497        .remove         = cumanascsi2_remove,
 498        .id_table       = cumanascsi2_cids,
 499        .drv = {
 500                .name           = "cumanascsi2",
 501        },
 502};
 503
 504static int __init cumanascsi2_init(void)
 505{
 506        return ecard_register_driver(&cumanascsi2_driver);
 507}
 508
 509static void __exit cumanascsi2_exit(void)
 510{
 511        ecard_remove_driver(&cumanascsi2_driver);
 512}
 513
 514module_init(cumanascsi2_init);
 515module_exit(cumanascsi2_exit);
 516
 517MODULE_AUTHOR("Russell King");
 518MODULE_DESCRIPTION("Cumana SCSI-2 driver for Acorn machines");
 519module_param_array(term, int, NULL, 0);
 520MODULE_PARM_DESC(term, "SCSI bus termination");
 521MODULE_LICENSE("GPL");
 522