]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
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> | |
7b3166db | 18 | #include "hpsim_ssc.h" |
1da177e4 LT |
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 | ||
1da177e4 LT |
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); | |
69cbc046 CG |
92 | } else |
93 | simscsi_root = s; | |
1da177e4 LT |
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 | ||
1e4dcd22 | 104 | while ((sc = queue[rd].sc) != NULL) { |
1da177e4 | 105 | atomic_dec(&num_reqs); |
cfa7fd72 | 106 | queue[rd].sc = NULL; |
1da177e4 LT |
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 | ||
1da177e4 LT |
124 | static void |
125 | simscsi_sg_readwrite (struct scsi_cmnd *sc, int mode, unsigned long offset) | |
126 | { | |
fd3adb2a FT |
127 | int i; |
128 | struct scatterlist *sl; | |
1da177e4 LT |
129 | struct disk_stat stat; |
130 | struct disk_req req; | |
131 | ||
132 | stat.fd = desc[sc->device->id]; | |
133 | ||
fd3adb2a | 134 | scsi_for_each_sg(sc, sl, scsi_sg_count(sc), i) { |
58b053e4 | 135 | req.addr = __pa(sg_virt(sl)); |
1da177e4 LT |
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, | |
fd3adb2a | 140 | scsi_sg_count(sc) - i, sl->length); |
1da177e4 LT |
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; | |
1da177e4 LT |
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; | |
fd3adb2a | 165 | simscsi_sg_readwrite(sc, mode, offset); |
1da177e4 LT |
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 | /* | |
b6a7e1ec PC |
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. | |
1da177e4 | 180 | */ |
b6a7e1ec | 181 | for (bit = (128UL << 30)/512; bit != 0; bit >>= 1) { |
1da177e4 LT |
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 | ||
b6a7e1ec PC |
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; | |
fd3adb2a | 202 | simscsi_sg_readwrite(sc, mode, offset); |
1da177e4 LT |
203 | } |
204 | ||
205 | static int | |
f281233d | 206 | simscsi_queuecommand_lck (struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) |
1da177e4 LT |
207 | { |
208 | unsigned int target_id = sc->device->id; | |
209 | char fname[MAX_ROOT_LEN+16]; | |
210 | size_t disk_size; | |
211 | char *buf; | |
83a78d9b | 212 | char localbuf[36]; |
1da177e4 LT |
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: | |
fd3adb2a | 226 | if (scsi_bufflen(sc) < 35) { |
1da177e4 LT |
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 | } | |
83a78d9b | 236 | buf = localbuf; |
1da177e4 LT |
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); | |
1a7a2e1a | 246 | scsi_sg_copy_from_buffer(sc, buf, 36); |
1da177e4 LT |
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 | ||
1da177e4 | 278 | case READ_CAPACITY: |
fd3adb2a | 279 | if (desc[target_id] < 0 || scsi_bufflen(sc) < 8) { |
1da177e4 LT |
280 | break; |
281 | } | |
83a78d9b | 282 | buf = localbuf; |
1da177e4 LT |
283 | disk_size = simscsi_get_disk_size(desc[target_id]); |
284 | ||
1da177e4 LT |
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; | |
1a7a2e1a | 294 | scsi_sg_copy_from_buffer(sc, buf, 8); |
1da177e4 LT |
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. */ | |
1a7a2e1a FT |
301 | scsi_sg_copy_from_buffer(sc, (char *)empty_zero_page, |
302 | PAGE_SIZE); | |
1da177e4 LT |
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 | ||
f281233d JG |
330 | static DEF_SCSI_QCMD(simscsi_queuecommand) |
331 | ||
1da177e4 LT |
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); | |
a60ebc52 MW |
363 | if (error) |
364 | goto free_host; | |
365 | scsi_scan_host(host); | |
366 | return 0; | |
367 | ||
368 | free_host: | |
369 | scsi_host_put(host); | |
1da177e4 LT |
370 | return error; |
371 | } | |
2a177fd1 | 372 | device_initcall(simscsi_init); |