99c8957d381c9885918e3058dd23ea4cd168c120
[people/xl0/gpxe.git] / src / arch / i386 / drivers / bus / bios_disks.c
1 #include "realmode.h"
2 #include "console.h"
3 #include "disk.h"
4 #include "bios_disks.h"
5
6 #warning "This file is obsolete"
7 #if 0
8
9 #define CF ( 1 << 0 )
10 #define BIOS_DISK_NONE 0
11
12 /*
13  * Reset the disk system using INT 13,0.  Forces both hard disks and
14  * floppy disks to seek back to track 0.
15  *
16  */
17 static void bios_disk_init ( void ) {
18         REAL_EXEC ( rm_bios_disk_init,
19                     "sti\n\t"
20                     "xorw %%ax,%%ax\n\t"
21                     "movb $0x80,%%dl\n\t"
22                     "int $0x13\n\t"
23                     "cli\n\t",
24                     0,
25                     OUT_CONSTRAINTS (),
26                     IN_CONSTRAINTS (),
27                     CLOBBER ( "eax", "ebx", "ecx", "edx",
28                               "ebp", "esi", "edi" ) );
29 }
30
31 /*
32  * Read a single sector from a disk using INT 13,2.
33  *
34  * Returns the BIOS status code (%ah) - 0 indicates success.
35  * Automatically retries up to three times to allow time for floppy
36  * disks to spin up, calling bios_disk_init() after each failure.
37  *
38  */
39 static unsigned int bios_disk_read ( struct bios_disk_device *bios_disk,
40                                      unsigned int cylinder,
41                                      unsigned int head,
42                                      unsigned int sector,
43                                      struct bios_disk_sector *buf ) {
44         uint16_t basemem_buf, ax, flags;
45         unsigned int status, discard_c, discard_d;
46         int retry = 3;
47
48         basemem_buf = BASEMEM_PARAMETER_INIT ( *buf );
49         do {
50                 REAL_EXEC ( rm_bios_disk_read,
51                             "sti\n\t"
52                             "movw $0x0201, %%ax\n\t" /* Read a single sector */
53                             "int $0x13\n\t"
54                             "pushfw\n\t"
55                             "popw %%bx\n\t"
56                             "cli\n\t",
57                             4,
58                             OUT_CONSTRAINTS ( "=a" ( ax ), "=b" ( flags ),
59                                               "=c" ( discard_c ),
60                                               "=d" ( discard_d ) ),
61                             IN_CONSTRAINTS ( "c" ( ( (cylinder & 0xff) << 8 ) |
62                                                    ( (cylinder >> 8) & 0x3 ) |
63                                                    sector ),
64                                              "d" ( ( head << 8 ) |
65                                                    bios_disk->drive ),
66                                              "b" ( basemem_buf ) ),
67                             CLOBBER ( "ebp", "esi", "edi" ) );
68                 status = ( flags & CF ) ? ( ax >> 8 ) : 0;
69         } while ( ( status != 0 ) && ( bios_disk_init(), retry-- ) );
70         BASEMEM_PARAMETER_DONE ( *buf );
71
72         return status;
73 }
74
75 /*
76  * Increment a bus_loc structure to the next possible BIOS disk
77  * location.  Leave the structure zeroed and return 0 if there are no
78  * more valid locations.
79  *
80  */
81 static int bios_disk_next_location ( struct bus_loc *bus_loc ) {
82         struct bios_disk_loc *bios_disk_loc
83                 = ( struct bios_disk_loc * ) bus_loc;
84         
85         /*
86          * Ensure that there is sufficient space in the shared bus
87          * structures for a struct bios_disk_loc and a struct
88          * bios_disk_dev, as mandated by bus.h.
89          *
90          */
91         BUS_LOC_CHECK ( struct bios_disk_loc );
92         BUS_DEV_CHECK ( struct bios_disk_device );
93
94         return ( ++bios_disk_loc->drive );
95 }
96
97 /*
98  * Fill in parameters for a BIOS disk device based on drive number
99  *
100  */
101 static int bios_disk_fill_device ( struct bus_dev *bus_dev,
102                                    struct bus_loc *bus_loc ) {
103         struct bios_disk_loc *bios_disk_loc
104                 = ( struct bios_disk_loc * ) bus_loc;
105         struct bios_disk_device *bios_disk
106                 = ( struct bios_disk_device * ) bus_dev;
107         uint16_t flags;
108
109         /* Store drive in struct bios_disk_device */
110         bios_disk->drive = bios_disk_loc->drive;
111        
112         REAL_EXEC ( rm_bios_disk_exists,
113                     "sti\n\t"
114                     "movb $0x15, %%ah\n\t"
115                     "int $0x13\n\t"
116                     "pushfw\n\t"
117                     "popw %%dx\n\t"
118                     "movb %%ah, %%al\n\t"
119                     "cli\n\t",
120                     2,
121                     OUT_CONSTRAINTS ( "=a" ( bios_disk->type ),
122                                       "=d" ( flags ) ),
123                     IN_CONSTRAINTS ( "d" ( bios_disk->drive ) ),
124                     CLOBBER ( "ebx", "ecx", "esi", "edi", "ebp" ) );
125
126         if ( ( flags & CF ) || ( bios_disk->type == BIOS_DISK_NONE ) )
127                 return 0;
128
129         DBG ( "BIOS disk found valid drive %hhx\n", bios_disk->drive );
130         return 1;
131 }
132
133 /*
134  * Test whether or not a driver is capable of driving the device.
135  *
136  */
137 static int bios_disk_check_driver ( struct bus_dev *bus_dev,
138                                     struct device_driver *device_driver ) {
139         struct bios_disk_device *bios_disk
140                 = ( struct bios_disk_device * ) bus_dev;
141         struct bios_disk_driver *driver
142                 = ( struct bios_disk_driver * ) device_driver->bus_driver_info;
143
144         /* Compare against driver's valid ID range */
145         if ( ( bios_disk->drive >= driver->min_drive ) &&
146              ( bios_disk->drive <= driver->max_drive ) ) {
147                 driver->fill_drive_name ( bios_disk->name, bios_disk->drive );
148                 DBG ( "BIOS disk found drive %hhx (\"%s\") "
149                       "matching driver %s\n",
150                       bios_disk->drive, bios_disk->name,
151                       driver->name );
152                 return 1;
153         }
154
155         return 0;
156 }
157
158 /*
159  * Describe a BIOS disk device
160  *
161  */
162 static char * bios_disk_describe_device ( struct bus_dev *bus_dev ) {
163         struct bios_disk_device *bios_disk
164                 = ( struct bios_disk_device * ) bus_dev;
165         static char bios_disk_description[] = "BIOS disk 00";
166
167         sprintf ( bios_disk_description + 10, "%hhx", bios_disk->drive );
168         return bios_disk_description;
169 }
170
171 /*
172  * Name a BIOS disk device
173  *
174  */
175 static const char * bios_disk_name_device ( struct bus_dev *bus_dev ) {
176         struct bios_disk_device *bios_disk
177                 = ( struct bios_disk_device * ) bus_dev;
178         
179         return bios_disk->name;
180 }
181
182 /*
183  * BIOS disk bus operations table
184  *
185  */
186 struct bus_driver bios_disk_driver __bus_driver = {
187         .name                   = "BIOS DISK",
188         .next_location          = bios_disk_next_location,
189         .fill_device            = bios_disk_fill_device,
190         .check_driver           = bios_disk_check_driver,
191         .describe_device        = bios_disk_describe_device,
192         .name_device            = bios_disk_name_device,
193 };
194
195 /*
196  * Fill in a disk structure
197  *
198  */
199 void bios_disk_fill_disk ( struct disk *disk __unused,
200                            struct bios_disk_device *bios_disk __unused ) {
201
202 }
203
204 #endif