1 |
1181 |
sfurman |
/* 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 |
|
|
|
235 |
|
|
/* Tell the world we are a disk. */
|
236 |
|
|
device_add_string_property(me, "device_type", "block");
|
237 |
|
|
|
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_ */
|