7661bb065fa570a4a61036acf551d5feacda94ef
[linux-2.6.git] / 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);