arch/ia64/drivers/simscsi.c

   1 /*
   2  * Simulated SCSI driver.
   3  *
   4  * Copyright (C) 1999, 2001-2003 Hewlett-Packard Co
   5  *      David Mosberger-Tang <davidm@hpl.hp.com>
   6  *      Stephane Eranian <eranian@hpl.hp.com>
   7  *
   8  * 02/01/15 David Mosberger     Updated for v2.5.1
   9  * 99/12/18 David Mosberger     Added support for READ10/WRITE10 needed by linux v2.3.33
  10  */
  11 #include <linux/config.h>
  12 #include <linux/blk.h>
  13 #include <linux/init.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/kernel.h>
  16 #include <linux/timer.h>
  17
  18 #include <scsi/scsi.h>
  19
  20 #include <asm/irq.h>
  21
  22 #include "../drivers/scsi/scsi.h"
  23 #include "../drivers/scsi/sd.h"
  24 #include "../drivers/scsi/hosts.h"
  25 #include "simscsi.h"
  26
  27 #define DEBUG_SIMSCSI   1
  28
  29 /* Simulator system calls: */
  30
  31 #define SSC_OPEN                        50
  32 #define SSC_CLOSE                       51
  33 #define SSC_READ                        52
  34 #define SSC_WRITE                       53
  35 #define SSC_GET_COMPLETION              54
  36 #define SSC_WAIT_COMPLETION             55
  37
  38 #define SSC_WRITE_ACCESS                2
  39 #define SSC_READ_ACCESS                 1
  40
  41 #if DEBUG_SIMSCSI
  42   int simscsi_debug;
  43 # define DBG    simscsi_debug
  44 #else
  45 # define DBG    0
  46 #endif
  47
  48 static void simscsi_interrupt (unsigned long val);
  49 DECLARE_TASKLET(simscsi_tasklet, simscsi_interrupt, 0);
  50
  51 struct disk_req {
  52         unsigned long addr;
  53         unsigned len;
  54 };
  55
  56 struct disk_stat {
  57         int fd;
  58         unsigned count;
  59 };
  60
  61 extern long ia64_ssc (long arg0, long arg1, long arg2, long arg3, int nr);
  62
  63 static int desc[16] = {
  64         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
  65 };
  66
  67 static struct queue_entry {
  68         Scsi_Cmnd *sc;
  69 } queue[SIMSCSI_REQ_QUEUE_LEN];
  70
  71 static int rd, wr;
  72 static atomic_t num_reqs = ATOMIC_INIT(0);
  73
  74 /* base name for default disks */
  75 static char *simscsi_root = DEFAULT_SIMSCSI_ROOT;
  76
  77 #define MAX_ROOT_LEN    128
  78
  79 /*
  80  * used to setup a new base for disk images
  81  * to use /foo/bar/disk[a-z] as disk images
  82  * you have to specify simscsi=/foo/bar/disk on the command line
  83  */
  84 static int __init
  85 simscsi_setup (char *s)
  86 {
  87         /* XXX Fix me we may need to strcpy() ? */
  88         if (strlen(s) > MAX_ROOT_LEN) {
  89                 printk(KERN_ERR "simscsi_setup: prefix too long---using default %s\n",
  90                        simscsi_root);
  91         }
  92         simscsi_root = s;
  93         return 1;
  94 }
  95
  96 __setup("simscsi=", simscsi_setup);
  97
  98 static void
  99 simscsi_interrupt (unsigned long val)
 100 {
 101         unsigned long flags;
 102         Scsi_Cmnd *sc;
 103
 104         spin_lock_irqsave(&io_request_lock, flags);
 105         {
 106                 while ((sc = queue[rd].sc) != 0) {
 107                         atomic_dec(&num_reqs);
 108                         queue[rd].sc = 0;
 109                         if (DBG)
 110                                 printk("simscsi_interrupt: done with %ld\n", sc->serial_number);
 111                         (*sc->scsi_done)(sc);
 112                         rd = (rd + 1) % SIMSCSI_REQ_QUEUE_LEN;
 113                 }
 114         }
 115         spin_unlock_irqrestore(&io_request_lock, flags);
 116 }
 117
 118 int
 119 simscsi_detect (Scsi_Host_Template *templ)
 120 {
 121         templ->proc_name = "simscsi";
 122         return 1;       /* fake one SCSI host adapter */
 123 }
 124
 125 int
 126 simscsi_release (struct Scsi_Host *host)
 127 {
 128         return 0;       /* this is easy...  */
 129 }
 130
 131 const char *
 132 simscsi_info (struct Scsi_Host *host)
 133 {
 134         return "simulated SCSI host adapter";
 135 }
 136
 137 int
 138 simscsi_biosparam (Disk *disk, kdev_t n, int ip[])
 139 {
 140         unsigned capacity = disk->capacity;
 141
 142         ip[0] = 64;             /* heads */
 143         ip[1] = 32;             /* sectors */
 144         ip[2] = capacity >> 11; /* cylinders */
 145         return 0;
 146 }
 147
 148 static void
 149 simscsi_readwrite (Scsi_Cmnd *sc, int mode, unsigned long offset, unsigned long len)
 150 {
 151         struct disk_stat stat;
 152         struct disk_req req;
 153
 154         req.addr = __pa(sc->request_buffer);
 155         req.len  = len;                 /* # of bytes to transfer */
 156
 157         if (sc->request_bufflen < req.len)
 158                 return;
 159
 160         stat.fd = desc[sc->target];
 161         if (DBG)
 162                 printk("simscsi_%s @ %lx (off %lx)\n",
 163                        mode == SSC_READ ? "read":"write", req.addr, offset);
 164         ia64_ssc(stat.fd, 1, __pa(&req), offset, mode);
 165         ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
 166
 167         if (stat.count == req.len) {
 168                 sc->result = GOOD;
 169         } else {
 170                 sc->result = DID_ERROR << 16;
 171         }
 172 }
 173
 174 static void
 175 simscsi_sg_readwrite (Scsi_Cmnd *sc, int mode, unsigned long offset)
 176 {
 177         int list_len = sc->use_sg;
 178         struct scatterlist *sl = (struct scatterlist *)sc->buffer;
 179         struct disk_stat stat;
 180         struct disk_req req;
 181
 182         stat.fd = desc[sc->target];
 183
 184         while (list_len) {
 185                 req.addr = __pa(sl->address);
 186                 req.len  = sl->length;
 187                 if (DBG)
 188                         printk("simscsi_sg_%s @ %lx (off %lx) use_sg=%d len=%d\n",
 189                                mode == SSC_READ ? "read":"write", req.addr, offset,
 190                                list_len, sl->length);
 191                 ia64_ssc(stat.fd, 1, __pa(&req), offset, mode);
 192                 ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
 193
 194                 /* should not happen in our case */
 195                 if (stat.count != req.len) {
 196                         sc->result = DID_ERROR << 16;
 197                         return;
 198                 }
 199                 offset +=  sl->length;
 200                 sl++;
 201                 list_len--;
 202         }
 203         sc->result = GOOD;
 204 }
 205
 206 /*
 207  * function handling both READ_6/WRITE_6 (non-scatter/gather mode)
 208  * commands.
 209  * Added 02/26/99 S.Eranian
 210  */
 211 static void
 212 simscsi_readwrite6 (Scsi_Cmnd *sc, int mode)
 213 {
 214         unsigned long offset;
 215
 216         offset = (((sc->cmnd[1] & 0x1f) << 16) | (sc->cmnd[2] << 8) | sc->cmnd[3])*512;
 217         if (sc->use_sg > 0)
 218                 simscsi_sg_readwrite(sc, mode, offset);
 219         else
 220                 simscsi_readwrite(sc, mode, offset, sc->cmnd[4]*512);
 221 }
 222
 223 static size_t
 224 simscsi_get_disk_size (int fd)
 225 {
 226         struct disk_stat stat;
 227         size_t bit, sectors = 0;
 228         struct disk_req req;
 229         char buf[512];
 230
 231         /*
 232          * This is a bit kludgey: the simulator doesn't provide a direct way of determining
 233          * the disk size, so we do a binary search, assuming a maximum disk size of 4GB.
 234          */
 235         for (bit = (4UL << 30)/512; bit != 0; bit >>= 1) {
 236                 req.addr = __pa(&buf);
 237                 req.len = sizeof(buf);
 238                 ia64_ssc(fd, 1, __pa(&req), ((sectors | bit) - 1)*512, SSC_READ);
 239                 stat.fd = fd;
 240                 ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
 241                 if (stat.count == sizeof(buf))
 242                         sectors |= bit;
 243         }
 244         return sectors - 1;     /* return last valid sector number */
 245 }
 246
 247 static void
 248 simscsi_readwrite10 (Scsi_Cmnd *sc, int mode)
 249 {
 250         unsigned long offset;
 251
 252         offset = (  (sc->cmnd[2] << 24) | (sc->cmnd[3] << 16)
 253                   | (sc->cmnd[4] <<  8) | (sc->cmnd[5] <<  0))*512;
 254         if (sc->use_sg > 0)
 255                 simscsi_sg_readwrite(sc, mode, offset);
 256         else
 257                 simscsi_readwrite(sc, mode, offset, ((sc->cmnd[7] << 8) | sc->cmnd[8])*512);
 258 }
 259
 260 int
 261 simscsi_queuecommand (Scsi_Cmnd *sc, void (*done)(Scsi_Cmnd *))
 262 {
 263         char fname[MAX_ROOT_LEN+16];
 264         size_t disk_size;
 265         char *buf;
 266 #if DEBUG_SIMSCSI
 267         register long sp asm ("sp");
 268
 269         if (DBG)
 270                 printk("simscsi_queuecommand: target=%d,cmnd=%u,sc=%lu,sp=%lx,done=%p\n",
 271                        sc->target, sc->cmnd[0], sc->serial_number, sp, done);
 272 #endif
 273
 274         sc->result = DID_BAD_TARGET << 16;
 275         sc->scsi_done = done;
 276         if (sc->target <= 15 && sc->lun == 0) {
 277                 switch (sc->cmnd[0]) {
 278                       case INQUIRY:
 279                         if (sc->request_bufflen < 35) {
 280                                 break;
 281                         }
 282                         sprintf (fname, "%s%c", simscsi_root, 'a' + sc->target);
 283                         desc[sc->target] = ia64_ssc(__pa(fname), SSC_READ_ACCESS|SSC_WRITE_ACCESS,
 284                                                     0, 0, SSC_OPEN);
 285                         if (desc[sc->target] < 0) {
 286                                 /* disk doesn't exist... */
 287                                 break;
 288                         }
 289                         buf = sc->request_buffer;
 290                         buf[0] = 0;     /* magnetic disk */
 291                         buf[1] = 0;     /* not a removable medium */
 292                         buf[2] = 2;     /* SCSI-2 compliant device */
 293                         buf[3] = 2;     /* SCSI-2 response data format */
 294                         buf[4] = 31;    /* additional length (bytes) */
 295                         buf[5] = 0;     /* reserved */
 296                         buf[6] = 0;     /* reserved */
 297                         buf[7] = 0;     /* various flags */
 298                         memcpy(buf + 8, "HP      SIMULATED DISK  0.00",  28);
 299                         sc->result = GOOD;
 300                         break;
 301
 302                       case TEST_UNIT_READY:
 303                         sc->result = GOOD;
 304                         break;
 305
 306                       case READ_6:
 307                         if (desc[sc->target] < 0 )
 308                                 break;
 309                         simscsi_readwrite6(sc, SSC_READ);
 310                         break;
 311
 312                       case READ_10:
 313                         if (desc[sc->target] < 0 )
 314                                 break;
 315                         simscsi_readwrite10(sc, SSC_READ);
 316                         break;
 317
 318                       case WRITE_6:
 319                         if (desc[sc->target] < 0)
 320                                 break;
 321                         simscsi_readwrite6(sc, SSC_WRITE);
 322                         break;
 323
 324                       case WRITE_10:
 325                         if (desc[sc->target] < 0)
 326                                 break;
 327                         simscsi_readwrite10(sc, SSC_WRITE);
 328                         break;
 329
 330
 331                       case READ_CAPACITY:
 332                         if (desc[sc->target] < 0 || sc->request_bufflen < 8) {
 333                                 break;
 334                         }
 335                         buf = sc->request_buffer;
 336
 337                         disk_size = simscsi_get_disk_size(desc[sc->target]);
 338                         buf[0] = (disk_size >> 24) & 0xff;
 339                         buf[1] = (disk_size >> 16) & 0xff;
 340                         buf[2] = (disk_size >>  8) & 0xff;
 341                         buf[3] = (disk_size >>  0) & 0xff;
 342                         /* set block size of 512 bytes: */
 343                         buf[4] = 0;
 344                         buf[5] = 0;
 345                         buf[6] = 2;
 346                         buf[7] = 0;
 347                         sc->result = GOOD;
 348                         break;
 349
 350                       case MODE_SENSE:
 351                         /* sd.c uses this to determine whether disk does write-caching. */
 352                         memset(sc->request_buffer, 0, 128);
 353                         sc->result = GOOD;
 354                         break;
 355
 356                       case START_STOP:
 357                         printk(KERN_ERR "START_STOP\n");
 358                         break;
 359
 360                       default:
 361                         panic("simscsi: unknown SCSI command %u\n", sc->cmnd[0]);
 362                 }
 363         }
 364         if (sc->result == DID_BAD_TARGET) {
 365                 sc->result |= DRIVER_SENSE << 24;
 366                 sc->sense_buffer[0] = 0x70;
 367                 sc->sense_buffer[2] = 0x00;
 368         }
 369         if (atomic_read(&num_reqs) >= SIMSCSI_REQ_QUEUE_LEN) {
 370                 panic("Attempt to queue command while command is pending!!");
 371         }
 372         atomic_inc(&num_reqs);
 373         queue[wr].sc = sc;
 374         wr = (wr + 1) % SIMSCSI_REQ_QUEUE_LEN;
 375
 376         tasklet_schedule(&simscsi_tasklet);
 377         return 0;
 378 }
 379
 380 int
 381 simscsi_reset (Scsi_Cmnd *cmd, unsigned int reset_flags)
 382 {
 383         printk(KERN_ERR "simscsi_reset: unimplemented\n");
 384         return SCSI_RESET_SUCCESS;
 385 }
 386
 387 int
 388 simscsi_abort (Scsi_Cmnd *cmd)
 389 {
 390         printk(KERN_ERR "simscsi_abort: unimplemented\n");
 391         return SCSI_ABORT_SUCCESS;
 392 }
 393
 394 static Scsi_Host_Template driver_template = SIMSCSI;
 395
 396 #include "../drivers/scsi/scsi_module.c"