arch/ia64/hp/sim/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/blkdev.h>
  12 #include <linux/init.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/kernel.h>
  15 #include <linux/timer.h>
  16 #include <asm/irq.h>
  17 #include "hpsim_ssc.h"
  18
  19 #include <scsi/scsi.h>
  20 #include <scsi/scsi_cmnd.h>
  21 #include <scsi/scsi_device.h>
  22 #include <scsi/scsi_host.h>
  23
  24 #define DEBUG_SIMSCSI   0
  25
  26 #define SIMSCSI_REQ_QUEUE_LEN   64
  27 #define DEFAULT_SIMSCSI_ROOT    "/var/ski-disks/sd"
  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 struct Scsi_Host *host;
  49
  50 static void simscsi_interrupt (unsigned long val);
  51 static DECLARE_TASKLET(simscsi_tasklet, simscsi_interrupt, 0);
  52
  53 struct disk_req {
  54         unsigned long addr;
  55         unsigned len;
  56 };
  57
  58 struct disk_stat {
  59         int fd;
  60         unsigned count;
  61 };
  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         struct 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         struct scsi_cmnd *sc;
 102
 103         while ((sc = queue[rd].sc) != NULL) {
 104                 atomic_dec(&num_reqs);
 105                 queue[rd].sc = NULL;
 106                 if (DBG)
 107                         printk("simscsi_interrupt: done with %ld\n", sc->serial_number);
 108                 (*sc->scsi_done)(sc);
 109                 rd = (rd + 1) % SIMSCSI_REQ_QUEUE_LEN;
 110         }
 111 }
 112
 113 static int
 114 simscsi_biosparam (struct scsi_device *sdev, struct block_device *n,
 115                 sector_t capacity, int ip[])
 116 {
 117         ip[0] = 64;             /* heads */
 118         ip[1] = 32;             /* sectors */
 119         ip[2] = capacity >> 11; /* cylinders */
 120         return 0;
 121 }
 122
 123 static void
 124 simscsi_sg_readwrite (struct scsi_cmnd *sc, int mode, unsigned long offset)
 125 {
 126         int i;
 127         struct scatterlist *sl;
 128         struct disk_stat stat;
 129         struct disk_req req;
 130
 131         stat.fd = desc[sc->device->id];
 132
 133         scsi_for_each_sg(sc, sl, scsi_sg_count(sc), i) {
 134                 req.addr = __pa(sg_virt(sl));
 135                 req.len  = sl->length;
 136                 if (DBG)
 137                         printk("simscsi_sg_%s @ %lx (off %lx) use_sg=%d len=%d\n",
 138                                mode == SSC_READ ? "read":"write", req.addr, offset,
 139                                scsi_sg_count(sc) - i, sl->length);
 140                 ia64_ssc(stat.fd, 1, __pa(&req), offset, mode);
 141                 ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
 142
 143                 /* should not happen in our case */
 144                 if (stat.count != req.len) {
 145                         sc->result = DID_ERROR << 16;
 146                         return;
 147                 }
 148                 offset +=  sl->length;
 149         }
 150         sc->result = GOOD;
 151 }
 152
 153 /*
 154  * function handling both READ_6/WRITE_6 (non-scatter/gather mode)
 155  * commands.
 156  * Added 02/26/99 S.Eranian
 157  */
 158 static void
 159 simscsi_readwrite6 (struct scsi_cmnd *sc, int mode)
 160 {
 161         unsigned long offset;
 162
 163         offset = (((sc->cmnd[1] & 0x1f) << 16) | (sc->cmnd[2] << 8) | sc->cmnd[3])*512;
 164         simscsi_sg_readwrite(sc, mode, offset);
 165 }
 166
 167 static size_t
 168 simscsi_get_disk_size (int fd)
 169 {
 170         struct disk_stat stat;
 171         size_t bit, sectors = 0;
 172         struct disk_req req;
 173         char buf[512];
 174
 175         /*
 176          * This is a bit kludgey: the simulator doesn't provide a
 177          * direct way of determining the disk size, so we do a binary
 178          * search, assuming a maximum disk size of 128GB.
 179          */
 180         for (bit = (128UL << 30)/512; bit != 0; bit >>= 1) {
 181                 req.addr = __pa(&buf);
 182                 req.len = sizeof(buf);
 183                 ia64_ssc(fd, 1, __pa(&req), ((sectors | bit) - 1)*512, SSC_READ);
 184                 stat.fd = fd;
 185                 ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
 186                 if (stat.count == sizeof(buf))
 187                         sectors |= bit;
 188         }
 189         return sectors - 1;     /* return last valid sector number */
 190 }
 191
 192 static void
 193 simscsi_readwrite10 (struct scsi_cmnd *sc, int mode)
 194 {
 195         unsigned long offset;
 196
 197         offset = (((unsigned long)sc->cmnd[2] << 24)
 198                 | ((unsigned long)sc->cmnd[3] << 16)
 199                 | ((unsigned long)sc->cmnd[4] <<  8)
 200                 | ((unsigned long)sc->cmnd[5] <<  0))*512UL;
 201         simscsi_sg_readwrite(sc, mode, offset);
 202 }
 203
 204 static void simscsi_fillresult(struct scsi_cmnd *sc, char *buf, unsigned len)
 205 {
 206
 207         int i;
 208         unsigned thislen;
 209         struct scatterlist *slp;
 210
 211         scsi_for_each_sg(sc, slp, scsi_sg_count(sc), i) {
 212                 if (!len)
 213                         break;
 214                 thislen = min(len, slp->length);
 215                 memcpy(sg_virt(slp), buf, thislen);
 216                 len -= thislen;
 217         }
 218 }
 219
 220 static int
 221 simscsi_queuecommand (struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
 222 {
 223         unsigned int target_id = sc->device->id;
 224         char fname[MAX_ROOT_LEN+16];
 225         size_t disk_size;
 226         char *buf;
 227         char localbuf[36];
 228 #if DEBUG_SIMSCSI
 229         register long sp asm ("sp");
 230
 231         if (DBG)
 232                 printk("simscsi_queuecommand: target=%d,cmnd=%u,sc=%lu,sp=%lx,done=%p\n",
 233                        target_id, sc->cmnd[0], sc->serial_number, sp, done);
 234 #endif
 235
 236         sc->result = DID_BAD_TARGET << 16;
 237         sc->scsi_done = done;
 238         if (target_id <= 15 && sc->device->lun == 0) {
 239                 switch (sc->cmnd[0]) {
 240                       case INQUIRY:
 241                         if (scsi_bufflen(sc) < 35) {
 242                                 break;
 243                         }
 244                         sprintf (fname, "%s%c", simscsi_root, 'a' + target_id);
 245                         desc[target_id] = ia64_ssc(__pa(fname), SSC_READ_ACCESS|SSC_WRITE_ACCESS,
 246                                                    0, 0, SSC_OPEN);
 247                         if (desc[target_id] < 0) {
 248                                 /* disk doesn't exist... */
 249                                 break;
 250                         }
 251                         buf = localbuf;
 252                         buf[0] = 0;     /* magnetic disk */
 253                         buf[1] = 0;     /* not a removable medium */
 254                         buf[2] = 2;     /* SCSI-2 compliant device */
 255                         buf[3] = 2;     /* SCSI-2 response data format */
 256                         buf[4] = 31;    /* additional length (bytes) */
 257                         buf[5] = 0;     /* reserved */
 258                         buf[6] = 0;     /* reserved */
 259                         buf[7] = 0;     /* various flags */
 260                         memcpy(buf + 8, "HP      SIMULATED DISK  0.00",  28);
 261                         simscsi_fillresult(sc, buf, 36);
 262                         sc->result = GOOD;
 263                         break;
 264
 265                       case TEST_UNIT_READY:
 266                         sc->result = GOOD;
 267                         break;
 268
 269                       case READ_6:
 270                         if (desc[target_id] < 0 )
 271                                 break;
 272                         simscsi_readwrite6(sc, SSC_READ);
 273                         break;
 274
 275                       case READ_10:
 276                         if (desc[target_id] < 0 )
 277                                 break;
 278                         simscsi_readwrite10(sc, SSC_READ);
 279                         break;
 280
 281                       case WRITE_6:
 282                         if (desc[target_id] < 0)
 283                                 break;
 284                         simscsi_readwrite6(sc, SSC_WRITE);
 285                         break;
 286
 287                       case WRITE_10:
 288                         if (desc[target_id] < 0)
 289                                 break;
 290                         simscsi_readwrite10(sc, SSC_WRITE);
 291                         break;
 292
 293                       case READ_CAPACITY:
 294                         if (desc[target_id] < 0 || scsi_bufflen(sc) < 8) {
 295                                 break;
 296                         }
 297                         buf = localbuf;
 298                         disk_size = simscsi_get_disk_size(desc[target_id]);
 299
 300                         buf[0] = (disk_size >> 24) & 0xff;
 301                         buf[1] = (disk_size >> 16) & 0xff;
 302                         buf[2] = (disk_size >>  8) & 0xff;
 303                         buf[3] = (disk_size >>  0) & 0xff;
 304                         /* set block size of 512 bytes: */
 305                         buf[4] = 0;
 306                         buf[5] = 0;
 307                         buf[6] = 2;
 308                         buf[7] = 0;
 309                         simscsi_fillresult(sc, buf, 8);
 310                         sc->result = GOOD;
 311                         break;
 312
 313                       case MODE_SENSE:
 314                       case MODE_SENSE_10:
 315                         /* sd.c uses this to determine whether disk does write-caching. */
 316                         simscsi_fillresult(sc, (char *)empty_zero_page, scsi_bufflen(sc));
 317                         sc->result = GOOD;
 318                         break;
 319
 320                       case START_STOP:
 321                         printk(KERN_ERR "START_STOP\n");
 322                         break;
 323
 324                       default:
 325                         panic("simscsi: unknown SCSI command %u\n", sc->cmnd[0]);
 326                 }
 327         }
 328         if (sc->result == DID_BAD_TARGET) {
 329                 sc->result |= DRIVER_SENSE << 24;
 330                 sc->sense_buffer[0] = 0x70;
 331                 sc->sense_buffer[2] = 0x00;
 332         }
 333         if (atomic_read(&num_reqs) >= SIMSCSI_REQ_QUEUE_LEN) {
 334                 panic("Attempt to queue command while command is pending!!");
 335         }
 336         atomic_inc(&num_reqs);
 337         queue[wr].sc = sc;
 338         wr = (wr + 1) % SIMSCSI_REQ_QUEUE_LEN;
 339
 340         tasklet_schedule(&simscsi_tasklet);
 341         return 0;
 342 }
 343
 344 static int
 345 simscsi_host_reset (struct scsi_cmnd *sc)
 346 {
 347         printk(KERN_ERR "simscsi_host_reset: not implemented\n");
 348         return 0;
 349 }
 350
 351 static struct scsi_host_template driver_template = {
 352         .name                   = "simulated SCSI host adapter",
 353         .proc_name              = "simscsi",
 354         .queuecommand           = simscsi_queuecommand,
 355         .eh_host_reset_handler  = simscsi_host_reset,
 356         .bios_param             = simscsi_biosparam,
 357         .can_queue              = SIMSCSI_REQ_QUEUE_LEN,
 358         .this_id                = -1,
 359         .sg_tablesize           = SG_ALL,
 360         .max_sectors            = 1024,
 361         .cmd_per_lun            = SIMSCSI_REQ_QUEUE_LEN,
 362         .use_clustering         = DISABLE_CLUSTERING,
 363 };
 364
 365 static int __init
 366 simscsi_init(void)
 367 {
 368         int error;
 369
 370         host = scsi_host_alloc(&driver_template, 0);
 371         if (!host)
 372                 return -ENOMEM;
 373
 374         error = scsi_add_host(host, NULL);
 375         if (error)
 376                 goto free_host;
 377         scsi_scan_host(host);
 378         return 0;
 379
 380  free_host:
 381         scsi_host_put(host);
 382         return error;
 383 }
 384
 385 static void __exit
 386 simscsi_exit(void)
 387 {
 388         scsi_remove_host(host);
 389         scsi_host_put(host);
 390 }
 391
 392 module_init(simscsi_init);
 393 module_exit(simscsi_exit);