blob: 7661bb065fa570a4a61036acf551d5feacda94ef [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Peter Chubb7b3166d2007-08-21 13:57:01 +100017#include "hpsim_ssc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
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
48static struct Scsi_Host *host;
49
50static void simscsi_interrupt (unsigned long val);
51static DECLARE_TASKLET(simscsi_tasklet, simscsi_interrupt, 0);
52
53struct disk_req {
54 unsigned long addr;
55 unsigned len;
56};
57
58struct disk_stat {
59 int fd;
60 unsigned count;
61};
62
Linus Torvalds1da177e2005-04-16 15:20:36 -070063static int desc[16] = {
64 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
65};
66
67static struct queue_entry {
68 struct scsi_cmnd *sc;
69} queue[SIMSCSI_REQ_QUEUE_LEN];
70
71static int rd, wr;
72static atomic_t num_reqs = ATOMIC_INIT(0);
73
74/* base name for default disks */
75static 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 */
84static int __init
85simscsi_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
98static void
99simscsi_interrupt (unsigned long val)
100{
101 struct scsi_cmnd *sc;
102
Yoann Padioleau1e4dcd22007-07-27 11:44:42 +0200103 while ((sc = queue[rd].sc) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 atomic_dec(&num_reqs);
Al Virocfa7fd72006-10-10 22:46:17 +0100105 queue[rd].sc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 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
113static int
114simscsi_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
123static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124simscsi_sg_readwrite (struct scsi_cmnd *sc, int mode, unsigned long offset)
125{
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900126 int i;
127 struct scatterlist *sl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 struct disk_stat stat;
129 struct disk_req req;
130
131 stat.fd = desc[sc->device->id];
132
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900133 scsi_for_each_sg(sc, sl, scsi_sg_count(sc), i) {
Jens Axboe58b053e2007-10-22 20:02:46 +0200134 req.addr = __pa(sg_virt(sl));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 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,
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900139 scsi_sg_count(sc) - i, sl->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
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 */
158static void
159simscsi_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;
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900164 simscsi_sg_readwrite(sc, mode, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165}
166
167static size_t
168simscsi_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 /*
Peter Chubbb6a7e1e2005-10-20 12:31:19 +1000176 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 */
Peter Chubbb6a7e1e2005-10-20 12:31:19 +1000180 for (bit = (128UL << 30)/512; bit != 0; bit >>= 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 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
192static void
193simscsi_readwrite10 (struct scsi_cmnd *sc, int mode)
194{
195 unsigned long offset;
196
Peter Chubbb6a7e1e2005-10-20 12:31:19 +1000197 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;
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900201 simscsi_sg_readwrite(sc, mode, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
Peter Chubb83a78d92005-09-19 09:36:12 +1000204static void simscsi_fillresult(struct scsi_cmnd *sc, char *buf, unsigned len)
205{
206
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900207 int i;
208 unsigned thislen;
Peter Chubb83a78d92005-09-19 09:36:12 +1000209 struct scatterlist *slp;
210
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900211 scsi_for_each_sg(sc, slp, scsi_sg_count(sc), i) {
212 if (!len)
213 break;
214 thislen = min(len, slp->length);
Jens Axboe58b053e2007-10-22 20:02:46 +0200215 memcpy(sg_virt(slp), buf, thislen);
Peter Chubb83a78d92005-09-19 09:36:12 +1000216 len -= thislen;
217 }
218}
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220static int
221simscsi_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;
Peter Chubb83a78d92005-09-19 09:36:12 +1000227 char localbuf[36];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228#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:
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900241 if (scsi_bufflen(sc) < 35) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 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 }
Peter Chubb83a78d92005-09-19 09:36:12 +1000251 buf = localbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 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);
Peter Chubb83a78d92005-09-19 09:36:12 +1000261 simscsi_fillresult(sc, buf, 36);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 case READ_CAPACITY:
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900294 if (desc[target_id] < 0 || scsi_bufflen(sc) < 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 break;
296 }
Peter Chubb83a78d92005-09-19 09:36:12 +1000297 buf = localbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 disk_size = simscsi_get_disk_size(desc[target_id]);
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 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;
Peter Chubb83a78d92005-09-19 09:36:12 +1000309 simscsi_fillresult(sc, buf, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 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. */
FUJITA Tomonorifd3adb22007-07-23 09:40:54 +0900316 simscsi_fillresult(sc, (char *)empty_zero_page, scsi_bufflen(sc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 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
344static int
345simscsi_host_reset (struct scsi_cmnd *sc)
346{
347 printk(KERN_ERR "simscsi_host_reset: not implemented\n");
348 return 0;
349}
350
351static 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
365static int __init
366simscsi_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);
Matthew Wilcoxa60ebc52007-08-15 12:56:54 -0600375 if (error)
376 goto free_host;
377 scsi_scan_host(host);
378 return 0;
379
380 free_host:
381 scsi_host_put(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 return error;
383}
384
385static void __exit
386simscsi_exit(void)
387{
388 scsi_remove_host(host);
389 scsi_host_put(host);
390}
391
392module_init(simscsi_init);
393module_exit(simscsi_exit);