Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 1 | // 16bit code to access hard drives. |
| 2 | // |
| 3 | // Copyright (C) 2008 Kevin O'Connor <kevin@koconnor.net> |
| 4 | // Copyright (C) 2002 MandrakeSoft S.A. |
| 5 | // |
| 6 | // This file may be distributed under the terms of the GNU GPLv3 license. |
| 7 | |
| 8 | #include "disk.h" // floppy_13 |
| 9 | #include "biosvar.h" // struct bregs |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 10 | #include "config.h" // CONFIG_* |
| 11 | #include "cmos.h" // inb_cmos |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 12 | #include "util.h" // debug_enter |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 13 | #include "ata.h" // ATA_* |
| 14 | |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 15 | static inline void |
| 16 | disk_ret(struct bregs *regs, u8 code) |
| 17 | { |
| 18 | regs->ah = code; |
| 19 | SET_BDA(disk_last_status, code); |
| 20 | set_cf(regs, code); |
| 21 | } |
| 22 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 23 | #define DISK_STUB(regs) do { \ |
| 24 | struct bregs *__regs = (regs); \ |
| 25 | debug_stub(__regs); \ |
| 26 | disk_ret(__regs, DISK_RET_SUCCESS); \ |
| 27 | } while (0) |
| 28 | |
| 29 | static u8 |
| 30 | checksum_seg(u16 seg, u16 offset, u32 len) |
| 31 | { |
| 32 | u32 i; |
| 33 | u8 sum = 0; |
| 34 | for (i=0; i<len; i++) |
| 35 | sum += GET_FARVAR(seg, *(u8*)(offset+i)); |
| 36 | return sum; |
| 37 | } |
| 38 | |
| 39 | static void |
| 40 | basic_access(struct bregs *regs, u8 device, u16 command) |
| 41 | { |
| 42 | u16 count = regs->al; |
| 43 | u16 cylinder = regs->ch | ((((u16) regs->cl) << 2) & 0x300); |
| 44 | u16 sector = regs->cl & 0x3f; |
| 45 | u16 head = regs->dh; |
| 46 | |
| 47 | if ((count > 128) || (count == 0) || (sector == 0)) { |
| 48 | BX_INFO("int13_harddisk: function %02x, parameter out of range!\n" |
| 49 | , regs->ah); |
| 50 | disk_ret(regs, DISK_RET_EPARAM); |
| 51 | return; |
| 52 | } |
| 53 | |
| 54 | u16 nlc = GET_EBDA(ata.devices[device].lchs.cylinders); |
| 55 | u16 nlh = GET_EBDA(ata.devices[device].lchs.heads); |
| 56 | u16 nlspt = GET_EBDA(ata.devices[device].lchs.spt); |
| 57 | u16 nph = GET_EBDA(ata.devices[device].pchs.heads); |
| 58 | u16 npspt = GET_EBDA(ata.devices[device].pchs.spt); |
| 59 | |
| 60 | // sanity check on cyl heads, sec |
| 61 | if ( (cylinder >= nlc) || (head >= nlh) || (sector > nlspt )) { |
| 62 | BX_INFO("int13_harddisk: function %02x, parameters out of" |
| 63 | " range %04x/%04x/%04x!\n" |
| 64 | , regs->ah, cylinder, head, sector); |
| 65 | disk_ret(regs, DISK_RET_EPARAM); |
| 66 | return; |
| 67 | } |
| 68 | |
| 69 | u32 lba = 0; |
| 70 | // if needed, translate lchs to lba, and execute command |
| 71 | if ( (nph != nlh) || (npspt != nlspt)) { |
| 72 | lba = (((((u32)cylinder * (u32)nlh) + (u32)head) * (u32)nlspt) |
| 73 | + (u32)sector - 1); |
| 74 | sector = 0; // this forces the command to be lba |
| 75 | } |
| 76 | |
| 77 | u16 segment = regs->es; |
| 78 | u16 offset = regs->bx; |
| 79 | |
| 80 | u8 status; |
| 81 | switch (command) { |
| 82 | case ATA_CMD_READ_SECTORS: |
| 83 | status = ata_cmd_data_in(device, ATA_CMD_READ_SECTORS |
| 84 | , count, cylinder, head, sector |
| 85 | , lba, segment, offset); |
| 86 | break; |
| 87 | case ATA_CMD_WRITE_SECTORS: |
| 88 | status = ata_cmd_data_out(device, ATA_CMD_WRITE_SECTORS |
| 89 | , count, cylinder, head, sector |
| 90 | , lba, segment, offset); |
| 91 | break; |
| 92 | default: |
| 93 | disk_ret(regs, DISK_RET_SUCCESS); |
| 94 | return; |
| 95 | } |
| 96 | |
| 97 | // Set nb of sector transferred |
| 98 | regs->al = GET_EBDA(ata.trsfsectors); |
| 99 | |
| 100 | if (status != 0) { |
| 101 | BX_INFO("int13_harddisk: function %02x, error %02x !\n",regs->ah,status); |
| 102 | disk_ret(regs, DISK_RET_EBADTRACK); |
| 103 | } |
| 104 | disk_ret(regs, DISK_RET_SUCCESS); |
| 105 | } |
| 106 | |
| 107 | static void |
| 108 | extended_access(struct bregs *regs, u8 device, u16 command) |
| 109 | { |
| 110 | u16 count = GET_INT13EXT(regs, count); |
| 111 | u16 segment = GET_INT13EXT(regs, segment); |
| 112 | u16 offset = GET_INT13EXT(regs, offset); |
| 113 | |
| 114 | // Can't use 64 bits lba |
| 115 | u32 lba = GET_INT13EXT(regs, lba2); |
| 116 | if (lba != 0L) { |
| 117 | BX_PANIC("int13_harddisk: function %02x. Can't use 64bits lba\n" |
| 118 | , regs->ah); |
| 119 | disk_ret(regs, DISK_RET_EPARAM); |
| 120 | return; |
| 121 | } |
| 122 | |
| 123 | // Get 32 bits lba and check |
| 124 | lba = GET_INT13EXT(regs, lba1); |
| 125 | if (lba >= GET_EBDA(ata.devices[device].sectors)) { |
| 126 | BX_INFO("int13_harddisk: function %02x. LBA out of range\n", regs->ah); |
| 127 | disk_ret(regs, DISK_RET_EPARAM); |
| 128 | return; |
| 129 | } |
| 130 | |
| 131 | u8 status; |
| 132 | switch (command) { |
| 133 | case ATA_CMD_READ_SECTORS: |
| 134 | status = ata_cmd_data_in(device, ATA_CMD_READ_SECTORS |
| 135 | , count, 0, 0, 0 |
| 136 | , lba, segment, offset); |
| 137 | break; |
| 138 | case ATA_CMD_WRITE_SECTORS: |
| 139 | status = ata_cmd_data_out(device, ATA_CMD_WRITE_SECTORS |
| 140 | , count, 0, 0, 0 |
| 141 | , lba, segment, offset); |
| 142 | break; |
| 143 | default: |
| 144 | // If verify or seek |
| 145 | disk_ret(regs, DISK_RET_SUCCESS); |
| 146 | return; |
| 147 | } |
| 148 | |
| 149 | SET_INT13EXT(regs, count, GET_EBDA(ata.trsfsectors)); |
| 150 | |
| 151 | if (status != 0) { |
| 152 | BX_INFO("int13_harddisk: function %02x, error %02x !\n" |
| 153 | , regs->ah, status); |
| 154 | disk_ret(regs, DISK_RET_EBADTRACK); |
| 155 | return; |
| 156 | } |
| 157 | disk_ret(regs, DISK_RET_SUCCESS); |
| 158 | } |
| 159 | |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 160 | // disk controller reset |
| 161 | static void |
| 162 | disk_1300(struct bregs *regs, u8 device) |
| 163 | { |
| 164 | ata_reset(device); |
| 165 | } |
| 166 | |
| 167 | // read disk status |
| 168 | static void |
| 169 | disk_1301(struct bregs *regs, u8 device) |
| 170 | { |
| 171 | regs->ah = GET_BDA(disk_last_status); |
| 172 | disk_ret(regs, DISK_RET_SUCCESS); |
| 173 | } |
| 174 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 175 | // read disk sectors |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 176 | static void |
| 177 | disk_1302(struct bregs *regs, u8 device) |
| 178 | { |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 179 | basic_access(regs, device, ATA_CMD_READ_SECTORS); |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 180 | } |
| 181 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 182 | // write disk sectors |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 183 | static void |
| 184 | disk_1303(struct bregs *regs, u8 device) |
| 185 | { |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 186 | basic_access(regs, device, ATA_CMD_WRITE_SECTORS); |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 187 | } |
| 188 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 189 | // verify disk sectors |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 190 | static void |
| 191 | disk_1304(struct bregs *regs, u8 device) |
| 192 | { |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 193 | basic_access(regs, device, 0); |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 194 | // FIXME verify |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 195 | } |
| 196 | |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 197 | // format disk track |
| 198 | static void |
| 199 | disk_1305(struct bregs *regs, u8 device) |
| 200 | { |
| 201 | DISK_STUB(regs); |
| 202 | } |
| 203 | |
| 204 | // read disk drive parameters |
| 205 | static void |
| 206 | disk_1308(struct bregs *regs, u8 device) |
| 207 | { |
| 208 | // Get logical geometry from table |
| 209 | u16 nlc = GET_EBDA(ata.devices[device].lchs.cylinders); |
| 210 | u16 nlh = GET_EBDA(ata.devices[device].lchs.heads); |
| 211 | u16 nlspt = GET_EBDA(ata.devices[device].lchs.spt); |
| 212 | u16 count = GET_EBDA(ata.hdcount); |
| 213 | |
| 214 | nlc = nlc - 2; /* 0 based , last sector not used */ |
| 215 | regs->al = 0; |
| 216 | regs->ch = nlc & 0xff; |
| 217 | regs->cl = ((nlc >> 2) & 0xc0) | (nlspt & 0x3f); |
| 218 | regs->dh = nlh - 1; |
| 219 | regs->dl = count; /* FIXME returns 0, 1, or n hard drives */ |
| 220 | |
| 221 | // FIXME should set ES & DI |
| 222 | disk_ret(regs, DISK_RET_SUCCESS); |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 223 | } |
| 224 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 225 | // initialize drive parameters |
| 226 | static void |
| 227 | disk_1309(struct bregs *regs, u8 device) |
| 228 | { |
| 229 | DISK_STUB(regs); |
| 230 | } |
| 231 | |
| 232 | // seek to specified cylinder |
| 233 | static void |
| 234 | disk_130c(struct bregs *regs, u8 device) |
| 235 | { |
| 236 | DISK_STUB(regs); |
| 237 | } |
| 238 | |
| 239 | // alternate disk reset |
| 240 | static void |
| 241 | disk_130d(struct bregs *regs, u8 device) |
| 242 | { |
| 243 | DISK_STUB(regs); |
| 244 | } |
| 245 | |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 246 | // check drive ready |
| 247 | static void |
| 248 | disk_1310(struct bregs *regs, u8 device) |
| 249 | { |
| 250 | // should look at 40:8E also??? |
| 251 | |
| 252 | // Read the status from controller |
| 253 | u8 status = inb(GET_EBDA(ata.channels[device/2].iobase1) + ATA_CB_STAT); |
| 254 | if ( (status & ( ATA_CB_STAT_BSY | ATA_CB_STAT_RDY )) == ATA_CB_STAT_RDY ) |
| 255 | disk_ret(regs, DISK_RET_SUCCESS); |
| 256 | else |
| 257 | disk_ret(regs, DISK_RET_ENOTREADY); |
| 258 | } |
| 259 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 260 | // recalibrate |
| 261 | static void |
| 262 | disk_1311(struct bregs *regs, u8 device) |
| 263 | { |
| 264 | DISK_STUB(regs); |
| 265 | } |
| 266 | |
| 267 | // controller internal diagnostic |
| 268 | static void |
| 269 | disk_1314(struct bregs *regs, u8 device) |
| 270 | { |
| 271 | DISK_STUB(regs); |
| 272 | } |
| 273 | |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 274 | // read disk drive size |
| 275 | static void |
| 276 | disk_1315(struct bregs *regs, u8 device) |
| 277 | { |
| 278 | // Get logical geometry from table |
| 279 | u16 nlc = GET_EBDA(ata.devices[device].lchs.cylinders); |
| 280 | u16 nlh = GET_EBDA(ata.devices[device].lchs.heads); |
| 281 | u16 nlspt = GET_EBDA(ata.devices[device].lchs.spt); |
| 282 | |
| 283 | // Compute sector count seen by int13 |
| 284 | u32 lba = (u32)(nlc - 1) * (u32)nlh * (u32)nlspt; |
| 285 | regs->cx = lba >> 16; |
| 286 | regs->dx = lba & 0xffff; |
| 287 | |
| 288 | disk_ret(regs, 0); |
| 289 | regs->ah = 3; // hard disk accessible |
| 290 | } |
| 291 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 292 | // IBM/MS installation check |
| 293 | static void |
| 294 | disk_1341(struct bregs *regs, u8 device) |
| 295 | { |
| 296 | regs->bx = 0xaa55; // install check |
| 297 | regs->cx = 0x0007; // ext disk access and edd, removable supported |
| 298 | disk_ret(regs, DISK_RET_SUCCESS); |
| 299 | regs->ah = 0x30; // EDD 3.0 |
| 300 | } |
| 301 | |
| 302 | // IBM/MS extended read |
| 303 | static void |
| 304 | disk_1342(struct bregs *regs, u8 device) |
| 305 | { |
| 306 | extended_access(regs, device, ATA_CMD_READ_SECTORS); |
| 307 | } |
| 308 | |
| 309 | // IBM/MS extended write |
| 310 | static void |
| 311 | disk_1343(struct bregs *regs, u8 device) |
| 312 | { |
| 313 | extended_access(regs, device, ATA_CMD_WRITE_SECTORS); |
| 314 | } |
| 315 | |
| 316 | // IBM/MS verify |
| 317 | static void |
| 318 | disk_1344(struct bregs *regs, u8 device) |
| 319 | { |
| 320 | extended_access(regs, device, 0); |
| 321 | } |
| 322 | |
| 323 | // IBM/MS lock/unlock drive |
| 324 | static void |
| 325 | disk_1345(struct bregs *regs, u8 device) |
| 326 | { |
| 327 | // Always success for HD |
| 328 | disk_ret(regs, DISK_RET_SUCCESS); |
| 329 | } |
| 330 | |
| 331 | // IBM/MS eject media |
| 332 | static void |
| 333 | disk_1346(struct bregs *regs, u8 device) |
| 334 | { |
| 335 | // Volume Not Removable |
| 336 | disk_ret(regs, DISK_RET_ENOTREMOVABLE); |
| 337 | } |
| 338 | |
| 339 | // IBM/MS extended seek |
| 340 | static void |
| 341 | disk_1347(struct bregs *regs, u8 device) |
| 342 | { |
| 343 | extended_access(regs, device, 0); |
| 344 | } |
| 345 | |
| 346 | // IBM/MS get drive parameters |
| 347 | static void |
| 348 | disk_1348(struct bregs *regs, u8 device) |
| 349 | { |
| 350 | u16 size = GET_INT13DPT(regs, size); |
| 351 | |
| 352 | // Buffer is too small |
| 353 | if (size < 0x1a) { |
| 354 | disk_ret(regs, DISK_RET_EPARAM); |
| 355 | return; |
| 356 | } |
| 357 | |
| 358 | // EDD 1.x |
| 359 | |
| 360 | u16 npc = GET_EBDA(ata.devices[device].pchs.cylinders); |
| 361 | u16 nph = GET_EBDA(ata.devices[device].pchs.heads); |
| 362 | u16 npspt = GET_EBDA(ata.devices[device].pchs.spt); |
| 363 | u32 lba = GET_EBDA(ata.devices[device].sectors); |
| 364 | u16 blksize = GET_EBDA(ata.devices[device].blksize); |
| 365 | |
| 366 | SET_INT13DPT(regs, size, 0x1a); |
| 367 | if ((lba/npspt)/nph > 0x3fff) { |
| 368 | SET_INT13DPT(regs, infos, 0x00); // geometry is invalid |
| 369 | SET_INT13DPT(regs, cylinders, 0x3fff); |
| 370 | } else { |
| 371 | SET_INT13DPT(regs, infos, 0x02); // geometry is valid |
| 372 | SET_INT13DPT(regs, cylinders, (u32)npc); |
| 373 | } |
| 374 | SET_INT13DPT(regs, heads, (u32)nph); |
| 375 | SET_INT13DPT(regs, spt, (u32)npspt); |
| 376 | SET_INT13DPT(regs, sector_count1, lba); // FIXME should be Bit64 |
| 377 | SET_INT13DPT(regs, sector_count2, 0L); |
| 378 | SET_INT13DPT(regs, blksize, blksize); |
| 379 | |
| 380 | if (size < 0x1e) { |
| 381 | disk_ret(regs, DISK_RET_SUCCESS); |
| 382 | return; |
| 383 | } |
| 384 | |
| 385 | // EDD 2.x |
| 386 | |
| 387 | SET_INT13DPT(regs, size, 0x1e); |
| 388 | |
| 389 | SET_INT13DPT(regs, dpte_segment, EBDA_SEG); |
| 390 | SET_INT13DPT(regs, dpte_offset |
| 391 | , offsetof(struct extended_bios_data_area_s, ata.dpte)); |
| 392 | |
| 393 | // Fill in dpte |
| 394 | u8 channel = device / 2; |
| 395 | u16 iobase1 = GET_EBDA(ata.channels[channel].iobase1); |
| 396 | u16 iobase2 = GET_EBDA(ata.channels[channel].iobase2); |
| 397 | u8 irq = GET_EBDA(ata.channels[channel].irq); |
| 398 | u8 mode = GET_EBDA(ata.devices[device].mode); |
| 399 | u8 translation = GET_EBDA(ata.devices[device].translation); |
| 400 | |
| 401 | u16 options = (translation==ATA_TRANSLATION_NONE?0:1)<<3; // chs translation |
| 402 | options |= (1<<4); // lba translation |
| 403 | options |= (mode==ATA_MODE_PIO32?1:0)<<7; |
| 404 | options |= (translation==ATA_TRANSLATION_LBA?1:0)<<9; |
| 405 | options |= (translation==ATA_TRANSLATION_RECHS?3:0)<<9; |
| 406 | |
| 407 | SET_EBDA(ata.dpte.iobase1, iobase1); |
| 408 | SET_EBDA(ata.dpte.iobase2, iobase2 + ATA_CB_DC); |
| 409 | SET_EBDA(ata.dpte.prefix, (0xe | (device % 2))<<4 ); |
| 410 | SET_EBDA(ata.dpte.unused, 0xcb ); |
| 411 | SET_EBDA(ata.dpte.irq, irq ); |
| 412 | SET_EBDA(ata.dpte.blkcount, 1 ); |
| 413 | SET_EBDA(ata.dpte.dma, 0 ); |
| 414 | SET_EBDA(ata.dpte.pio, 0 ); |
| 415 | SET_EBDA(ata.dpte.options, options); |
| 416 | SET_EBDA(ata.dpte.reserved, 0); |
| 417 | if (size >= 0x42) |
| 418 | SET_EBDA(ata.dpte.revision, 0x11); |
| 419 | else |
| 420 | SET_EBDA(ata.dpte.revision, 0x10); |
| 421 | |
| 422 | u8 sum = checksum_seg(EBDA_SEG |
| 423 | , offsetof(struct extended_bios_data_area_s, ata.dpte) |
| 424 | , 15); |
| 425 | SET_EBDA(ata.dpte.checksum, ~sum); |
| 426 | |
| 427 | if (size < 0x42) { |
| 428 | disk_ret(regs, DISK_RET_SUCCESS); |
| 429 | return; |
| 430 | } |
| 431 | |
| 432 | // EDD 3.x |
| 433 | channel = device / 2; |
| 434 | u8 iface = GET_EBDA(ata.channels[channel].iface); |
| 435 | iobase1 = GET_EBDA(ata.channels[channel].iobase1); |
| 436 | |
| 437 | SET_INT13DPT(regs, size, 0x42); |
| 438 | SET_INT13DPT(regs, key, 0xbedd); |
| 439 | SET_INT13DPT(regs, dpi_length, 0x24); |
| 440 | SET_INT13DPT(regs, reserved1, 0); |
| 441 | SET_INT13DPT(regs, reserved2, 0); |
| 442 | |
| 443 | if (iface==ATA_IFACE_ISA) { |
| 444 | SET_INT13DPT(regs, host_bus[0], 'I'); |
| 445 | SET_INT13DPT(regs, host_bus[1], 'S'); |
| 446 | SET_INT13DPT(regs, host_bus[2], 'A'); |
| 447 | SET_INT13DPT(regs, host_bus[3], 0); |
| 448 | } else { |
| 449 | // FIXME PCI |
| 450 | } |
| 451 | SET_INT13DPT(regs, iface_type[0], 'A'); |
| 452 | SET_INT13DPT(regs, iface_type[1], 'T'); |
| 453 | SET_INT13DPT(regs, iface_type[2], 'A'); |
| 454 | SET_INT13DPT(regs, iface_type[3], 0); |
| 455 | |
| 456 | if (iface==ATA_IFACE_ISA) { |
| 457 | SET_INT13DPT(regs, iface_path[0], iobase1); |
| 458 | SET_INT13DPT(regs, iface_path[2], 0); |
| 459 | SET_INT13DPT(regs, iface_path[4], 0L); |
| 460 | } else { |
| 461 | // FIXME PCI |
| 462 | } |
| 463 | SET_INT13DPT(regs, device_path[0], device%2); |
| 464 | SET_INT13DPT(regs, device_path[1], 0); |
| 465 | SET_INT13DPT(regs, device_path[2], 0); |
| 466 | SET_INT13DPT(regs, device_path[4], 0L); |
| 467 | |
| 468 | sum = checksum_seg(regs->ds, 30, 34); |
| 469 | SET_INT13DPT(regs, checksum, ~sum); |
| 470 | } |
| 471 | |
| 472 | // IBM/MS extended media change |
| 473 | static void |
| 474 | disk_1349(struct bregs *regs, u8 device) |
| 475 | { |
| 476 | // Always success for HD |
| 477 | disk_ret(regs, DISK_RET_SUCCESS); |
| 478 | } |
| 479 | |
| 480 | static void |
| 481 | disk_134e01(struct bregs *regs, u8 device) |
| 482 | { |
| 483 | disk_ret(regs, DISK_RET_SUCCESS); |
| 484 | } |
| 485 | |
| 486 | static void |
| 487 | disk_134e03(struct bregs *regs, u8 device) |
| 488 | { |
| 489 | disk_ret(regs, DISK_RET_SUCCESS); |
| 490 | } |
| 491 | |
| 492 | static void |
| 493 | disk_134e04(struct bregs *regs, u8 device) |
| 494 | { |
| 495 | disk_ret(regs, DISK_RET_SUCCESS); |
| 496 | } |
| 497 | |
| 498 | static void |
| 499 | disk_134e06(struct bregs *regs, u8 device) |
| 500 | { |
| 501 | disk_ret(regs, DISK_RET_SUCCESS); |
| 502 | } |
| 503 | |
| 504 | static void |
| 505 | disk_134eXX(struct bregs *regs, u8 device) |
| 506 | { |
| 507 | debug_stub(regs); |
| 508 | disk_ret(regs, DISK_RET_EPARAM); |
| 509 | } |
| 510 | |
| 511 | // IBM/MS set hardware configuration |
| 512 | static void |
| 513 | disk_134e(struct bregs *regs, u8 device) |
| 514 | { |
| 515 | switch (regs->al) { |
| 516 | case 0x01: disk_134e01(regs, device); break; |
| 517 | case 0x03: disk_134e03(regs, device); break; |
| 518 | case 0x04: disk_134e04(regs, device); break; |
| 519 | case 0x06: disk_134e06(regs, device); break; |
| 520 | default: disk_134eXX(regs, device); break; |
| 521 | } |
| 522 | } |
| 523 | |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 524 | static void |
| 525 | disk_13XX(struct bregs *regs, u8 device) |
| 526 | { |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 527 | debug_stub(regs); |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 528 | disk_ret(regs, DISK_RET_EPARAM); |
| 529 | } |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 530 | |
| 531 | static void |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 532 | disk_13(struct bregs *regs, u8 device) |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 533 | { |
Kevin O'Connor | 15aee2e | 2008-03-01 13:34:04 -0500 | [diff] [blame] | 534 | //debug_stub(regs); |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 535 | |
| 536 | // clear completion flag |
| 537 | SET_BDA(disk_interrupt_flag, 0); |
| 538 | |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 539 | switch (regs->ah) { |
| 540 | case 0x00: disk_1300(regs, device); break; |
| 541 | case 0x01: disk_1301(regs, device); break; |
| 542 | case 0x02: disk_1302(regs, device); break; |
| 543 | case 0x03: disk_1303(regs, device); break; |
| 544 | case 0x04: disk_1304(regs, device); break; |
| 545 | case 0x05: disk_1305(regs, device); break; |
| 546 | case 0x08: disk_1308(regs, device); break; |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 547 | case 0x09: disk_1309(regs, device); break; |
| 548 | case 0x0c: disk_130c(regs, device); break; |
| 549 | case 0x0d: disk_130d(regs, device); break; |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 550 | case 0x10: disk_1310(regs, device); break; |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 551 | case 0x11: disk_1311(regs, device); break; |
| 552 | case 0x14: disk_1314(regs, device); break; |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 553 | case 0x15: disk_1315(regs, device); break; |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 554 | case 0x41: disk_1341(regs, device); break; |
| 555 | case 0x42: disk_1342(regs, device); break; |
| 556 | case 0x43: disk_1343(regs, device); break; |
| 557 | case 0x44: disk_1344(regs, device); break; |
| 558 | case 0x45: disk_1345(regs, device); break; |
| 559 | case 0x46: disk_1346(regs, device); break; |
| 560 | case 0x47: disk_1347(regs, device); break; |
| 561 | case 0x48: disk_1348(regs, device); break; |
| 562 | case 0x49: disk_1349(regs, device); break; |
| 563 | case 0x4e: disk_134e(regs, device); break; |
Kevin O'Connor | 3491e8b | 2008-02-29 00:22:27 -0500 | [diff] [blame] | 564 | default: disk_13XX(regs, device); break; |
| 565 | } |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 566 | } |
| 567 | |
| 568 | static void |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 569 | cdrom_13(struct bregs *regs, u8 device) |
| 570 | { |
| 571 | // XXX |
| 572 | disk_13XX(regs, device); |
| 573 | } |
| 574 | |
| 575 | static u8 |
| 576 | get_device(struct bregs *regs, u8 drive) |
| 577 | { |
| 578 | // basic check : device has to be defined |
| 579 | if (drive >= CONFIG_MAX_ATA_DEVICES) { |
| 580 | disk_ret(regs, DISK_RET_EPARAM); |
| 581 | return CONFIG_MAX_ATA_DEVICES; |
| 582 | } |
| 583 | |
| 584 | // Get the ata channel |
| 585 | u8 device = GET_EBDA(ata.hdidmap[drive]); |
| 586 | |
| 587 | // basic check : device has to be valid |
| 588 | if (device >= CONFIG_MAX_ATA_DEVICES) { |
| 589 | disk_ret(regs, DISK_RET_EPARAM); |
| 590 | return CONFIG_MAX_ATA_DEVICES; |
| 591 | } |
| 592 | |
| 593 | return device; |
| 594 | } |
| 595 | |
| 596 | static void |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 597 | handle_legacy_disk(struct bregs *regs, u8 drive) |
| 598 | { |
| 599 | if (drive < 0x80) { |
| 600 | floppy_13(regs, drive); |
| 601 | return; |
| 602 | } |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 603 | |
| 604 | if (! CONFIG_ATA) { |
| 605 | // XXX - old code had other disk access method. |
| 606 | disk_ret(regs, DISK_RET_EPARAM); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 607 | return; |
| 608 | } |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 609 | |
Kevin O'Connor | e43df9e | 2008-03-01 22:16:32 -0500 | [diff] [blame^] | 610 | if (drive >= 0xe0) { |
| 611 | u8 device = get_device(regs, drive - 0xe0); |
| 612 | if (device >= CONFIG_MAX_ATA_DEVICES) |
| 613 | return; |
| 614 | cdrom_13(regs, device); |
| 615 | return; |
| 616 | } |
| 617 | |
| 618 | u8 device = get_device(regs, drive - 0x80); |
| 619 | if (device >= CONFIG_MAX_ATA_DEVICES) |
| 620 | return; |
| 621 | disk_13(regs, device); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 622 | } |
| 623 | |
| 624 | void VISIBLE |
| 625 | handle_40(struct bregs *regs) |
| 626 | { |
| 627 | debug_enter(regs); |
| 628 | handle_legacy_disk(regs, regs->dl); |
| 629 | debug_exit(regs); |
| 630 | } |
| 631 | |
| 632 | // INT 13h Fixed Disk Services Entry Point |
| 633 | void VISIBLE |
| 634 | handle_13(struct bregs *regs) |
| 635 | { |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 636 | //debug_enter(regs); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 637 | u8 drive = regs->dl; |
Kevin O'Connor | 38fcbfe | 2008-02-25 22:30:47 -0500 | [diff] [blame] | 638 | // XXX |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 639 | #if BX_ELTORITO_BOOT |
| 640 | if (regs->ah >= 0x4a || regs->ah <= 0x4d) { |
| 641 | int13_eltorito(regs); |
| 642 | } else if (cdemu_isactive() && cdrom_emulated_drive()) { |
| 643 | int13_cdemu(regs); |
| 644 | } else |
| 645 | #endif |
| 646 | handle_legacy_disk(regs, drive); |
| 647 | debug_exit(regs); |
| 648 | } |
| 649 | |
| 650 | // record completion in BIOS task complete flag |
| 651 | void VISIBLE |
| 652 | handle_76(struct bregs *regs) |
| 653 | { |
| 654 | debug_enter(regs); |
| 655 | SET_BDA(floppy_harddisk_info, 0xff); |
| 656 | eoi_both_pics(); |
| 657 | } |