Remove obsolete #include <linux/config.h>
[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
18 #include <scsi/scsi.h>
19 #include <scsi/scsi_cmnd.h>
20 #include <scsi/scsi_device.h>
21 #include <scsi/scsi_host.h>
22
23 #define DEBUG_SIMSCSI   0
24
25 #define SIMSCSI_REQ_QUEUE_LEN   64
26 #define DEFAULT_SIMSCSI_ROOT    "/var/ski-disks/sd"
27
28 /* Simulator system calls: */
29
30 #define SSC_OPEN                        50
31 #define SSC_CLOSE                       51
32 #define SSC_READ                        52
33 #define SSC_WRITE                       53
34 #define SSC_GET_COMPLETION              54
35 #define SSC_WAIT_COMPLETION             55
36
37 #define SSC_WRITE_ACCESS                2
38 #define SSC_READ_ACCESS                 1
39
40 #if DEBUG_SIMSCSI
41   int simscsi_debug;
42 # define DBG    simscsi_debug
43 #else
44 # define DBG    0
45 #endif
46
47 static struct Scsi_Host *host;
48
49 static void simscsi_interrupt (unsigned long val);
50 static DECLARE_TASKLET(simscsi_tasklet, simscsi_interrupt, 0);
51
52 struct disk_req {
53         unsigned long addr;
54         unsigned len;
55 };
56
57 struct disk_stat {
58         int fd;
59         unsigned count;
60 };
61
62 extern long ia64_ssc (long arg0, long arg1, long arg2, long arg3, int nr);
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         }
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) != 0) {
105                 atomic_dec(&num_reqs);
106                 queue[rd].sc = 0;
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_readwrite (struct scsi_cmnd *sc, int mode, unsigned long offset, unsigned long len)
126 {
127         struct disk_stat stat;
128         struct disk_req req;
129
130         req.addr = __pa(sc->request_buffer);
131         req.len  = len;                 /* # of bytes to transfer */
132
133         if (sc->request_bufflen < req.len)
134                 return;
135
136         stat.fd = desc[sc->device->id];
137         if (DBG)
138                 printk("simscsi_%s @ %lx (off %lx)\n",
139                        mode == SSC_READ ? "read":"write", req.addr, offset);
140         ia64_ssc(stat.fd, 1, __pa(&req), offset, mode);
141         ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
142
143         if (stat.count == req.len) {
144                 sc->result = GOOD;
145         } else {
146                 sc->result = DID_ERROR << 16;
147         }
148 }
149
150 static void
151 simscsi_sg_readwrite (struct scsi_cmnd *sc, int mode, unsigned long offset)
152 {
153         int list_len = sc->use_sg;
154         struct scatterlist *sl = (struct scatterlist *)sc->buffer;
155         struct disk_stat stat;
156         struct disk_req req;
157
158         stat.fd = desc[sc->device->id];
159
160         while (list_len) {
161                 req.addr = __pa(page_address(sl->page) + sl->offset);
162                 req.len  = sl->length;
163                 if (DBG)
164                         printk("simscsi_sg_%s @ %lx (off %lx) use_sg=%d len=%d\n",
165                                mode == SSC_READ ? "read":"write", req.addr, offset,
166                                list_len, sl->length);
167                 ia64_ssc(stat.fd, 1, __pa(&req), offset, mode);
168                 ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
169
170                 /* should not happen in our case */
171                 if (stat.count != req.len) {
172                         sc->result = DID_ERROR << 16;
173                         return;
174                 }
175                 offset +=  sl->length;
176                 sl++;
177                 list_len--;
178         }
179         sc->result = GOOD;
180 }
181
182 /*
183  * function handling both READ_6/WRITE_6 (non-scatter/gather mode)
184  * commands.
185  * Added 02/26/99 S.Eranian
186  */
187 static void
188 simscsi_readwrite6 (struct scsi_cmnd *sc, int mode)
189 {
190         unsigned long offset;
191
192         offset = (((sc->cmnd[1] & 0x1f) << 16) | (sc->cmnd[2] << 8) | sc->cmnd[3])*512;
193         if (sc->use_sg > 0)
194                 simscsi_sg_readwrite(sc, mode, offset);
195         else
196                 simscsi_readwrite(sc, mode, offset, sc->cmnd[4]*512);
197 }
198
199 static size_t
200 simscsi_get_disk_size (int fd)
201 {
202         struct disk_stat stat;
203         size_t bit, sectors = 0;
204         struct disk_req req;
205         char buf[512];
206
207         /*
208          * This is a bit kludgey: the simulator doesn't provide a
209          * direct way of determining the disk size, so we do a binary
210          * search, assuming a maximum disk size of 128GB.
211          */
212         for (bit = (128UL << 30)/512; bit != 0; bit >>= 1) {
213                 req.addr = __pa(&buf);
214                 req.len = sizeof(buf);
215                 ia64_ssc(fd, 1, __pa(&req), ((sectors | bit) - 1)*512, SSC_READ);
216                 stat.fd = fd;
217                 ia64_ssc(__pa(&stat), 0, 0, 0, SSC_WAIT_COMPLETION);
218                 if (stat.count == sizeof(buf))
219                         sectors |= bit;
220         }
221         return sectors - 1;     /* return last valid sector number */
222 }
223
224 static void
225 simscsi_readwrite10 (struct scsi_cmnd *sc, int mode)
226 {
227         unsigned long offset;
228
229         offset = (((unsigned long)sc->cmnd[2] << 24) 
230                 | ((unsigned long)sc->cmnd[3] << 16)
231                 | ((unsigned long)sc->cmnd[4] <<  8) 
232                 | ((unsigned long)sc->cmnd[5] <<  0))*512UL;
233         if (sc->use_sg > 0)
234                 simscsi_sg_readwrite(sc, mode, offset);
235         else
236                 simscsi_readwrite(sc, mode, offset, ((sc->cmnd[7] << 8) | sc->cmnd[8])*512);
237 }
238
239 static void simscsi_fillresult(struct scsi_cmnd *sc, char *buf, unsigned len)
240 {
241
242         int scatterlen = sc->use_sg;
243         struct scatterlist *slp;
244
245         if (scatterlen == 0)
246                 memcpy(sc->request_buffer, buf, len);
247         else for (slp = (struct scatterlist *)sc->buffer; scatterlen-- > 0 && len > 0; slp++) {
248                 unsigned thislen = min(len, slp->length);
249
250                 memcpy(page_address(slp->page) + slp->offset, buf, thislen);
251                 slp++;
252                 len -= thislen;
253         }
254 }
255
256 static int
257 simscsi_queuecommand (struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
258 {
259         unsigned int target_id = sc->device->id;
260         char fname[MAX_ROOT_LEN+16];
261         size_t disk_size;
262         char *buf;
263         char localbuf[36];
264 #if DEBUG_SIMSCSI
265         register long sp asm ("sp");
266
267         if (DBG)
268                 printk("simscsi_queuecommand: target=%d,cmnd=%u,sc=%lu,sp=%lx,done=%p\n",
269                        target_id, sc->cmnd[0], sc->serial_number, sp, done);
270 #endif
271
272         sc->result = DID_BAD_TARGET << 16;
273         sc->scsi_done = done;
274         if (target_id <= 15 && sc->device->lun == 0) {
275                 switch (sc->cmnd[0]) {
276                       case INQUIRY:
277                         if (sc->request_bufflen < 35) {
278                                 break;
279                         }
280                         sprintf (fname, "%s%c", simscsi_root, 'a' + target_id);
281                         desc[target_id] = ia64_ssc(__pa(fname), SSC_READ_ACCESS|SSC_WRITE_ACCESS,
282                                                    0, 0, SSC_OPEN);
283                         if (desc[target_id] < 0) {
284                                 /* disk doesn't exist... */
285                                 break;
286                         }
287                         buf = localbuf;
288                         buf[0] = 0;     /* magnetic disk */
289                         buf[1] = 0;     /* not a removable medium */
290                         buf[2] = 2;     /* SCSI-2 compliant device */
291                         buf[3] = 2;     /* SCSI-2 response data format */
292                         buf[4] = 31;    /* additional length (bytes) */
293                         buf[5] = 0;     /* reserved */
294                         buf[6] = 0;     /* reserved */
295                         buf[7] = 0;     /* various flags */
296                         memcpy(buf + 8, "HP      SIMULATED DISK  0.00",  28);
297                         simscsi_fillresult(sc, buf, 36);
298                         sc->result = GOOD;
299                         break;
300
301                       case TEST_UNIT_READY:
302                         sc->result = GOOD;
303                         break;
304
305                       case READ_6:
306                         if (desc[target_id] < 0 )
307                                 break;
308                         simscsi_readwrite6(sc, SSC_READ);
309                         break;
310
311                       case READ_10:
312                         if (desc[target_id] < 0 )
313                                 break;
314                         simscsi_readwrite10(sc, SSC_READ);
315                         break;
316
317                       case WRITE_6:
318                         if (desc[target_id] < 0)
319                                 break;
320                         simscsi_readwrite6(sc, SSC_WRITE);
321                         break;
322
323                       case WRITE_10:
324                         if (desc[target_id] < 0)
325                                 break;
326                         simscsi_readwrite10(sc, SSC_WRITE);
327                         break;
328
329                       case READ_CAPACITY:
330                         if (desc[target_id] < 0 || sc->request_bufflen < 8) {
331                                 break;
332                         }
333                         buf = localbuf;
334                         disk_size = simscsi_get_disk_size(desc[target_id]);
335
336                         buf[0] = (disk_size >> 24) & 0xff;
337                         buf[1] = (disk_size >> 16) & 0xff;
338                         buf[2] = (disk_size >>  8) & 0xff;
339                         buf[3] = (disk_size >>  0) & 0xff;
340                         /* set block size of 512 bytes: */
341                         buf[4] = 0;
342                         buf[5] = 0;
343                         buf[6] = 2;
344                         buf[7] = 0;
345                         simscsi_fillresult(sc, buf, 8);
346                         sc->result = GOOD;
347                         break;
348
349                       case MODE_SENSE:
350                       case MODE_SENSE_10:
351                         /* sd.c uses this to determine whether disk does write-caching. */
352                         simscsi_fillresult(sc, (char *)empty_zero_page, sc->request_bufflen);
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 static int
381 simscsi_host_reset (struct scsi_cmnd *sc)
382 {
383         printk(KERN_ERR "simscsi_host_reset: not implemented\n");
384         return 0;
385 }
386
387 static struct scsi_host_template driver_template = {
388         .name                   = "simulated SCSI host adapter",
389         .proc_name              = "simscsi",
390         .queuecommand           = simscsi_queuecommand,
391         .eh_host_reset_handler  = simscsi_host_reset,
392         .bios_param             = simscsi_biosparam,
393         .can_queue              = SIMSCSI_REQ_QUEUE_LEN,
394         .this_id                = -1,
395         .sg_tablesize           = SG_ALL,
396         .max_sectors            = 1024,
397         .cmd_per_lun            = SIMSCSI_REQ_QUEUE_LEN,
398         .use_clustering         = DISABLE_CLUSTERING,
399 };
400
401 static int __init
402 simscsi_init(void)
403 {
404         int error;
405
406         host = scsi_host_alloc(&driver_template, 0);
407         if (!host)
408                 return -ENOMEM;
409
410         error = scsi_add_host(host, NULL);
411         if (!error)
412                 scsi_scan_host(host);
413         return error;
414 }
415
416 static void __exit
417 simscsi_exit(void)
418 {
419         scsi_remove_host(host);
420         scsi_host_put(host);
421 }
422
423 module_init(simscsi_init);
424 module_exit(simscsi_exit);