Commit | Line | Data |
---|---|---|
c906108c SS |
1 | /* This file is part of the program psim. |
2 | ||
3 | Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au> | |
4 | ||
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 2 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 | ||
19 | */ | |
20 | ||
21 | ||
22 | #ifndef _HW_DISK_C_ | |
23 | #define _HW_DISK_C_ | |
24 | ||
25 | #include "device_table.h" | |
26 | ||
27 | #include "pk.h" | |
28 | ||
29 | #include <stdio.h> | |
30 | ||
31 | #ifdef HAVE_UNISTD_H | |
32 | #include <unistd.h> | |
33 | #endif | |
34 | ||
35 | #ifndef SEEK_SET | |
36 | #define SEEK_SET 0 | |
37 | #endif | |
38 | ||
39 | /* DEVICE | |
40 | ||
41 | ||
42 | cdrom - read-only removable mass storage device | |
43 | ||
44 | disk - mass storage device | |
45 | ||
46 | floppy - removable mass storage device | |
47 | ||
48 | ||
49 | DESCRIPTION | |
50 | ||
51 | ||
52 | Mass storage devices such as a hard-disk or cdrom-drive are not | |
53 | normally directly connected to the processor. Instead, these | |
54 | devices are attached to a logical bus, such as SCSI or IDE, and | |
55 | then a controller of that bus is made accessible to the processor. | |
56 | ||
57 | Reflecting this, within a device tree, mass storage devices such as | |
58 | a <<cdrom>>, <<disk>> or <<floppy>> are created as children of of a | |
59 | logical bus controller node (such as a SCSI or IDE interface). | |
60 | That controller, in turn, would be made the child of a physical bus | |
61 | node that is directly accessible to the processor. | |
62 | ||
63 | The above mass storage devices provide two interfaces - a logical | |
64 | and a physical. | |
65 | ||
66 | At the physical level the <<device_io_...>> functions can be used | |
67 | perform reads and writes of the raw media. The address being | |
68 | interpreted as an offset from the start of the disk. | |
69 | ||
70 | At the logical level, it is possible to create an instance of the | |
71 | disk that provides access to any of the physical media, a disk | |
72 | partition, or even a file within a partition. The <<disk-label>> | |
73 | package, which implements this functionality, is described | |
74 | elsewhere. Both the Open Firmware and Moto BUG rom emulations | |
75 | support this interface. | |
76 | ||
77 | Block devices such as the <<floppy>> and <<cdrom>> have removable | |
78 | media. At the programmer level, the media can be changed using the | |
79 | <<change_media>> ioctl. From within GDB, a <<change-media>> | |
80 | operation can be initated by using the command. | |
81 | ||
82 | | (gdb) sim | |
83 | ||
84 | ||
85 | PROPERTIES | |
86 | ||
87 | ||
88 | file = <file-name> (required) | |
89 | ||
90 | The name of the file that contains an image of the disk. For | |
91 | <<disk>> and <<floppy>> devices, the image will be opened for both | |
92 | reading and writing. Multiple image files may be specified, the | |
93 | second and later files being opened when <<change-media>> (with a | |
94 | NULL file name) being specified. | |
95 | ||
96 | ||
97 | block-size = <nr-bytes> (optional) | |
98 | ||
99 | The value is returned by the block-size method. The default value | |
100 | is 512 bytes. | |
101 | ||
102 | ||
103 | max-transfer = <nr-bytes> (optional) | |
104 | ||
105 | The value is returned by the max-transfer method. The default value | |
106 | is 512 bytes. | |
107 | ||
108 | ||
109 | #blocks = <nr-blocks> (optional) | |
110 | ||
111 | The value is returned by the #blocks method. If no value is | |
112 | present then -1 is returned. | |
113 | ||
114 | ||
115 | read-only = <anything> (optional) | |
116 | ||
117 | If this property is present, the disk file image is always opened | |
118 | read-only. | |
119 | ||
120 | EXAMPLES | |
121 | ||
122 | ||
123 | Enable tracing | |
124 | ||
125 | | $ psim -t 'disk-device' \ | |
126 | ||
127 | ||
128 | Add a CDROM and disk to an IDE bus. Specify the host operating | |
129 | system's cd drive as the CD-ROM image. | |
130 | ||
131 | | -o '/pci/ide/disk@0/file "disk-image' \ | |
132 | | -o '/pci/ide/cdrom@1/file "/dev/cd0a' \ | |
133 | ||
134 | ||
135 | As part of the code implementing a logical bus device (for instance | |
136 | the IDE controller), locate the CDROM device and then read block | |
137 | 47. | |
138 | ||
139 | | device *cdrom = device_tree_find_device(me, "cdrom"); | |
140 | | char block[512]; | |
141 | | device_io_read_buffer(cdrom, buf, 0, | |
142 | 0, 47 * sizeof(block), // space, address | |
143 | sizeof(block), NULL, 0); | |
144 | ||
145 | ||
146 | Use the device instance interface to read block 47 of the file | |
147 | called <<netbsd.elf>> on the disks default partition. Similar code | |
148 | would be used in an operating systems pre-boot loader. | |
149 | ||
150 | | device_instance *netbsd = | |
151 | | device_create_instance(root, "/pci/ide/disk:,\netbsd.elf"); | |
152 | | char block[512]; | |
153 | | device_instance_seek(netbsd, 0, 47 * sizeof(block)); | |
154 | | device_instance_read(netbsd, block, sizeof(block)); | |
155 | ||
156 | ||
157 | BUGS | |
158 | ||
159 | ||
160 | The block device specification includes mechanisms for determining | |
161 | the physical device characteristics - such as the disks size. | |
162 | Currently this mechanism is not implemented. | |
163 | ||
164 | The functionality of this device (in particular the device instance | |
165 | interface) depends on the implementation of <<disk-label>> package. | |
166 | That package may not be fully implemented. | |
167 | ||
168 | The disk does not know its size. Hence it relies on the failure of | |
169 | fread(), fwrite() and fseek() calls to detect errors. | |
170 | ||
171 | The disk size is limited by the addressable range covered by | |
172 | unsigned_word (addr). An extension would be to instead use the | |
173 | concatenated value space:addr. | |
174 | ||
175 | The method #blocks should `stat' the disk to determine the number | |
176 | of blocks if there is no #blocks property. | |
177 | ||
178 | It would appear that OpenFirmware does not define a client call for | |
179 | changing (ejecting) the media of a device. | |
180 | ||
181 | */ | |
182 | ||
183 | typedef struct _hw_disk_device { | |
184 | int name_index; | |
185 | int nr_names; | |
186 | char *name; | |
187 | int read_only; | |
188 | /* unsigned_word size; */ | |
189 | FILE *image; | |
190 | } hw_disk_device; | |
191 | ||
192 | typedef struct _hw_disk_instance { | |
193 | unsigned_word pos; | |
194 | hw_disk_device *disk; | |
195 | } hw_disk_instance; | |
196 | ||
197 | ||
198 | static void | |
199 | open_disk_image(device *me, | |
200 | hw_disk_device *disk, | |
201 | const char *name) | |
202 | { | |
203 | if (disk->image != NULL) | |
204 | fclose(disk->image); | |
205 | if (disk->name != NULL) | |
206 | zfree(disk->name); | |
207 | disk->name = strdup(name); | |
208 | disk->image = fopen(disk->name, disk->read_only ? "r" : "r+"); | |
209 | if (disk->image == NULL) { | |
210 | perror(device_name(me)); | |
211 | device_error(me, "open %s failed\n", disk->name); | |
212 | } | |
213 | ||
214 | DTRACE(disk, ("image %s (%s)\n", | |
215 | disk->name, | |
216 | (disk->read_only ? "read-only" : "read-write"))); | |
217 | } | |
218 | ||
219 | static void | |
220 | hw_disk_init_address(device *me) | |
221 | { | |
222 | hw_disk_device *disk = device_data(me); | |
223 | unsigned_word address; | |
224 | int space; | |
225 | const char *name; | |
226 | ||
227 | /* attach to the parent. Since the bus is logical, attach using just | |
228 | the unit-address (size must be zero) */ | |
229 | device_address_to_attach_address(device_parent(me), device_unit_address(me), | |
230 | &space, &address, me); | |
231 | device_attach_address(device_parent(me), attach_callback, | |
232 | space, address, 0/*size*/, access_read_write_exec, | |
233 | me); | |
234 | ||
23c7880c DB |
235 | /* Tell the world we are a disk. */ |
236 | device_add_string_property(me, "device_type", "disk"); | |
237 | ||
c906108c SS |
238 | /* get the name of the file specifying the disk image */ |
239 | disk->name_index = 0; | |
240 | disk->nr_names = device_find_string_array_property(me, "file", | |
241 | disk->name_index, &name); | |
242 | if (!disk->nr_names) | |
243 | device_error(me, "invalid file property"); | |
244 | ||
245 | /* is it a RO device? */ | |
246 | disk->read_only = | |
247 | (strcmp(device_name(me), "disk") != 0 | |
248 | && strcmp(device_name(me), "floppy") != 0 | |
249 | && device_find_property(me, "read-only") == NULL); | |
250 | ||
251 | /* now open it */ | |
252 | open_disk_image(me, disk, name); | |
253 | } | |
254 | ||
255 | static int | |
256 | hw_disk_ioctl(device *me, | |
257 | cpu *processor, | |
258 | unsigned_word cia, | |
259 | device_ioctl_request request, | |
260 | va_list ap) | |
261 | { | |
262 | switch (request) { | |
263 | case device_ioctl_change_media: | |
264 | { | |
265 | hw_disk_device *disk = device_data(me); | |
266 | const char *name = va_arg(ap, const char *); | |
267 | if (name != NULL) { | |
268 | disk->name_index = -1; | |
269 | } | |
270 | else { | |
271 | disk->name_index = (disk->name_index + 1) % disk->nr_names; | |
272 | if (!device_find_string_array_property(me, "file", | |
273 | disk->name_index, &name)) | |
274 | device_error(me, "invalid file property"); | |
275 | } | |
276 | open_disk_image(me, disk, name); | |
277 | } | |
278 | break; | |
279 | default: | |
280 | device_error(me, "insupported ioctl request"); | |
281 | break; | |
282 | } | |
283 | return 0; | |
284 | } | |
285 | ||
286 | ||
287 | ||
288 | ||
289 | ||
290 | static unsigned | |
291 | hw_disk_io_read_buffer(device *me, | |
292 | void *dest, | |
293 | int space, | |
294 | unsigned_word addr, | |
295 | unsigned nr_bytes, | |
296 | cpu *processor, | |
297 | unsigned_word cia) | |
298 | { | |
299 | hw_disk_device *disk = device_data(me); | |
300 | unsigned nr_bytes_read; | |
301 | if (space != 0) | |
302 | device_error(me, "read - extended disk addressing unimplemented"); | |
303 | if (nr_bytes == 0) | |
304 | nr_bytes_read = 0; | |
305 | else if (fseek(disk->image, addr, SEEK_SET) < 0) | |
306 | nr_bytes_read = 0; | |
307 | else if (fread(dest, nr_bytes, 1, disk->image) != 1) | |
308 | nr_bytes_read = 0; | |
309 | else | |
310 | nr_bytes_read = nr_bytes; | |
311 | DTRACE(disk, ("io-read - address 0x%lx, nr-bytes-read %d, requested %d\n", | |
312 | (unsigned long) addr, (int)nr_bytes_read, (int)nr_bytes)); | |
313 | return nr_bytes_read; | |
314 | } | |
315 | ||
316 | ||
317 | static unsigned | |
318 | hw_disk_io_write_buffer(device *me, | |
319 | const void *source, | |
320 | int space, | |
321 | unsigned_word addr, | |
322 | unsigned nr_bytes, | |
323 | cpu *processor, | |
324 | unsigned_word cia) | |
325 | { | |
326 | hw_disk_device *disk = device_data(me); | |
327 | unsigned nr_bytes_written; | |
328 | if (space != 0) | |
329 | device_error(me, "write - extended disk addressing unimplemented"); | |
330 | if (disk->read_only) | |
331 | nr_bytes_written = 0; | |
332 | else if (nr_bytes == 0) | |
333 | nr_bytes_written = 0; | |
334 | else if (fseek(disk->image, addr, SEEK_SET) < 0) | |
335 | nr_bytes_written = 0; | |
336 | else if (fwrite(source, nr_bytes, 1, disk->image) != 1) | |
337 | nr_bytes_written = 0; | |
338 | else | |
339 | nr_bytes_written = nr_bytes; | |
340 | DTRACE(disk, ("io-write - address 0x%lx, nr-bytes-written %d, requested %d\n", | |
341 | (unsigned long) addr, (int)nr_bytes_written, (int)nr_bytes)); | |
342 | return nr_bytes_written; | |
343 | } | |
344 | ||
345 | ||
346 | /* instances of the hw_disk device */ | |
347 | ||
348 | static void | |
349 | hw_disk_instance_delete(device_instance *instance) | |
350 | { | |
351 | hw_disk_instance *data = device_instance_data(instance); | |
352 | DITRACE(disk, ("delete - instance=%ld\n", | |
353 | (unsigned long)device_instance_to_external(instance))); | |
354 | zfree(data); | |
355 | } | |
356 | ||
357 | static int | |
358 | hw_disk_instance_read(device_instance *instance, | |
359 | void *buf, | |
360 | unsigned_word len) | |
361 | { | |
362 | hw_disk_instance *data = device_instance_data(instance); | |
363 | DITRACE(disk, ("read - instance=%ld len=%ld\n", | |
364 | (unsigned long)device_instance_to_external(instance), | |
365 | (long)len)); | |
366 | if ((data->pos + len) < data->pos) | |
367 | return -1; /* overflow */ | |
368 | if (fseek(data->disk->image, data->pos, SEEK_SET) < 0) | |
369 | return -1; | |
370 | if (fread(buf, len, 1, data->disk->image) != 1) | |
371 | return -1; | |
372 | data->pos = ftell(data->disk->image); | |
373 | return len; | |
374 | } | |
375 | ||
376 | static int | |
377 | hw_disk_instance_write(device_instance *instance, | |
378 | const void *buf, | |
379 | unsigned_word len) | |
380 | { | |
381 | hw_disk_instance *data = device_instance_data(instance); | |
382 | DITRACE(disk, ("write - instance=%ld len=%ld\n", | |
383 | (unsigned long)device_instance_to_external(instance), | |
384 | (long)len)); | |
385 | if ((data->pos + len) < data->pos) | |
386 | return -1; /* overflow */ | |
387 | if (data->disk->read_only) | |
388 | return -1; | |
389 | if (fseek(data->disk->image, data->pos, SEEK_SET) < 0) | |
390 | return -1; | |
391 | if (fwrite(buf, len, 1, data->disk->image) != 1) | |
392 | return -1; | |
393 | data->pos = ftell(data->disk->image); | |
394 | return len; | |
395 | } | |
396 | ||
397 | static int | |
398 | hw_disk_instance_seek(device_instance *instance, | |
399 | unsigned_word pos_hi, | |
400 | unsigned_word pos_lo) | |
401 | { | |
402 | hw_disk_instance *data = device_instance_data(instance); | |
403 | if (pos_hi != 0) | |
404 | device_error(device_instance_device(instance), | |
405 | "seek - extended addressing unimplemented"); | |
406 | DITRACE(disk, ("seek - instance=%ld pos_hi=%ld pos_lo=%ld\n", | |
407 | (unsigned long)device_instance_to_external(instance), | |
408 | (long)pos_hi, (long)pos_lo)); | |
409 | data->pos = pos_lo; | |
410 | return 0; | |
411 | } | |
412 | ||
413 | static int | |
414 | hw_disk_max_transfer(device_instance *instance, | |
415 | int n_stack_args, | |
416 | unsigned32 stack_args[/*n_stack_args*/], | |
417 | int n_stack_returns, | |
418 | unsigned32 stack_returns[/*n_stack_returns*/]) | |
419 | { | |
420 | device *me = device_instance_device(instance); | |
421 | if ((n_stack_args != 0) | |
422 | || (n_stack_returns != 1)) { | |
423 | device_error(me, "Incorrect number of arguments for max-transfer method\n"); | |
424 | return -1; | |
425 | } | |
426 | else { | |
427 | unsigned_cell max_transfer; | |
428 | if (device_find_property(me, "max-transfer")) | |
429 | max_transfer = device_find_integer_property(me, "max-transfer"); | |
430 | else | |
431 | max_transfer = 512; | |
432 | DITRACE(disk, ("max-transfer - instance=%ld max-transfer=%ld\n", | |
433 | (unsigned long)device_instance_to_external(instance), | |
434 | (long int)max_transfer)); | |
435 | stack_returns[0] = max_transfer; | |
436 | return 0; | |
437 | } | |
438 | } | |
439 | ||
440 | static int | |
441 | hw_disk_block_size(device_instance *instance, | |
442 | int n_stack_args, | |
443 | unsigned32 stack_args[/*n_stack_args*/], | |
444 | int n_stack_returns, | |
445 | unsigned32 stack_returns[/*n_stack_returns*/]) | |
446 | { | |
447 | device *me = device_instance_device(instance); | |
448 | if ((n_stack_args != 0) | |
449 | || (n_stack_returns != 1)) { | |
450 | device_error(me, "Incorrect number of arguments for block-size method\n"); | |
451 | return -1; | |
452 | } | |
453 | else { | |
454 | unsigned_cell block_size; | |
455 | if (device_find_property(me, "block-size")) | |
456 | block_size = device_find_integer_property(me, "block-size"); | |
457 | else | |
458 | block_size = 512; | |
459 | DITRACE(disk, ("block-size - instance=%ld block-size=%ld\n", | |
460 | (unsigned long)device_instance_to_external(instance), | |
461 | (long int)block_size)); | |
462 | stack_returns[0] = block_size; | |
463 | return 0; | |
464 | } | |
465 | } | |
466 | ||
467 | static int | |
468 | hw_disk_nr_blocks(device_instance *instance, | |
469 | int n_stack_args, | |
470 | unsigned32 stack_args[/*n_stack_args*/], | |
471 | int n_stack_returns, | |
472 | unsigned32 stack_returns[/*n_stack_returns*/]) | |
473 | { | |
474 | device *me = device_instance_device(instance); | |
475 | if ((n_stack_args != 0) | |
476 | || (n_stack_returns != 1)) { | |
477 | device_error(me, "Incorrect number of arguments for block-size method\n"); | |
478 | return -1; | |
479 | } | |
480 | else { | |
481 | unsigned_word nr_blocks; | |
482 | if (device_find_property(me, "#blocks")) | |
483 | nr_blocks = device_find_integer_property(me, "#blocks"); | |
484 | else | |
485 | nr_blocks = -1; | |
486 | DITRACE(disk, ("#blocks - instance=%ld #blocks=%ld\n", | |
487 | (unsigned long)device_instance_to_external(instance), | |
488 | (long int)nr_blocks)); | |
489 | stack_returns[0] = nr_blocks; | |
490 | return 0; | |
491 | } | |
492 | } | |
493 | ||
494 | static device_instance_methods hw_disk_instance_methods[] = { | |
495 | { "max-transfer", hw_disk_max_transfer }, | |
496 | { "block-size", hw_disk_block_size }, | |
497 | { "#blocks", hw_disk_nr_blocks }, | |
498 | { NULL, }, | |
499 | }; | |
500 | ||
501 | static const device_instance_callbacks hw_disk_instance_callbacks = { | |
502 | hw_disk_instance_delete, | |
503 | hw_disk_instance_read, | |
504 | hw_disk_instance_write, | |
505 | hw_disk_instance_seek, | |
506 | hw_disk_instance_methods, | |
507 | }; | |
508 | ||
509 | static device_instance * | |
510 | hw_disk_create_instance(device *me, | |
511 | const char *path, | |
512 | const char *args) | |
513 | { | |
514 | device_instance *instance; | |
515 | hw_disk_device *disk = device_data(me); | |
516 | hw_disk_instance *data = ZALLOC(hw_disk_instance); | |
517 | data->disk = disk; | |
518 | data->pos = 0; | |
519 | instance = device_create_instance_from(me, NULL, | |
520 | data, | |
521 | path, args, | |
522 | &hw_disk_instance_callbacks); | |
523 | DITRACE(disk, ("create - path=%s(%s) instance=%ld\n", | |
524 | path, args, | |
525 | (unsigned long)device_instance_to_external(instance))); | |
526 | return pk_disklabel_create_instance(instance, args); | |
527 | } | |
528 | ||
529 | static device_callbacks const hw_disk_callbacks = { | |
530 | { hw_disk_init_address, NULL }, | |
531 | { NULL, }, /* address */ | |
532 | { hw_disk_io_read_buffer, | |
533 | hw_disk_io_write_buffer, }, | |
534 | { NULL, }, /* DMA */ | |
535 | { NULL, }, /* interrupt */ | |
536 | { NULL, }, /* unit */ | |
537 | hw_disk_create_instance, | |
538 | hw_disk_ioctl, | |
539 | }; | |
540 | ||
541 | ||
542 | static void * | |
543 | hw_disk_create(const char *name, | |
544 | const device_unit *unit_address, | |
545 | const char *args) | |
546 | { | |
547 | /* create the descriptor */ | |
548 | hw_disk_device *hw_disk = ZALLOC(hw_disk_device); | |
549 | return hw_disk; | |
550 | } | |
551 | ||
552 | ||
553 | const device_descriptor hw_disk_device_descriptor[] = { | |
554 | { "disk", hw_disk_create, &hw_disk_callbacks }, | |
555 | { "cdrom", hw_disk_create, &hw_disk_callbacks }, | |
556 | { "floppy", hw_disk_create, &hw_disk_callbacks }, | |
557 | { NULL }, | |
558 | }; | |
559 | ||
560 | #endif /* _HW_DISK_C_ */ |