~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/ia64/hp/sim/simscsi.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp