Move ata_detect call to 32bit code.
[people/mcb30/legacybios.git] / src / post.c
1 // 32bit code to Power On Self Test (POST) a machine.
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 "ioport.h" // PORT_*
9 #include "../out/rom16.offset.auto.h" // OFFSET_*
10 #include "config.h" // CONFIG_*
11 #include "cmos.h" // CMOS_*
12 #include "util.h" // memset
13 #include "biosvar.h" // struct bios_data_area_s
14 #include "ata.h"
15
16 #define bda ((struct bios_data_area_s *)0)
17 #define ebda ((struct extended_bios_data_area_s *)(EBDA_SEG<<4))
18 #define ipl ((struct ipl_s *)(IPL_SEG<<4))
19
20 static u8
21 checksum(u8 *p, u32 len)
22 {
23     u32 i;
24     u8 sum = 0;
25     for (i=0; i<len; i++)
26         sum += p[i];
27     return sum;
28 }
29
30 static void
31 init_bda()
32 {
33     memset(bda, 0, sizeof(*bda));
34
35     int i;
36     for (i=0; i<256; i++) {
37         SET_BDA(ivecs[i].seg, SEG_BIOS);
38         SET_BDA(ivecs[i].offset, OFFSET_dummy_iret_handler);
39     }
40
41     SET_BDA(mem_size_kb, BASE_MEM_IN_K);
42
43     // mov CMOS Equipment Byte to BDA Equipment Word
44     SET_BDA(equipment_list_flags, inb_cmos(CMOS_EQUIPMENT_INFO));
45 }
46
47 static void
48 init_handlers()
49 {
50     // set vector 0x79 to zero
51     // this is used by 'gardian angel' protection system
52     SET_BDA(ivecs[0x79].seg, 0);
53     SET_BDA(ivecs[0x79].offset, 0);
54
55     SET_BDA(ivecs[0x40].offset, OFFSET_entry_40);
56     SET_BDA(ivecs[0x0e].offset, OFFSET_entry_0e);
57     SET_BDA(ivecs[0x13].offset, OFFSET_entry_13);
58     SET_BDA(ivecs[0x76].offset, OFFSET_entry_76);
59     SET_BDA(ivecs[0x17].offset, OFFSET_entry_17);
60     SET_BDA(ivecs[0x18].offset, OFFSET_entry_18);
61     SET_BDA(ivecs[0x19].offset, OFFSET_entry_19);
62     SET_BDA(ivecs[0x1c].offset, OFFSET_entry_1c);
63     SET_BDA(ivecs[0x12].offset, OFFSET_entry_12);
64     SET_BDA(ivecs[0x11].offset, OFFSET_entry_11);
65     SET_BDA(ivecs[0x15].offset, OFFSET_entry_15);
66     SET_BDA(ivecs[0x08].offset, OFFSET_entry_08);
67     SET_BDA(ivecs[0x09].offset, OFFSET_entry_09);
68     SET_BDA(ivecs[0x16].offset, OFFSET_entry_16);
69     SET_BDA(ivecs[0x14].offset, OFFSET_entry_14);
70     SET_BDA(ivecs[0x1a].offset, OFFSET_entry_1a);
71     SET_BDA(ivecs[0x70].offset, OFFSET_entry_70);
72     SET_BDA(ivecs[0x74].offset, OFFSET_entry_74);
73     SET_BDA(ivecs[0x75].offset, OFFSET_entry_75);
74     SET_BDA(ivecs[0x10].offset, OFFSET_entry_10);
75 }
76
77 static void
78 init_ebda()
79 {
80     memset(ebda, 0, sizeof(*ebda));
81     ebda->size = EBDA_SIZE;
82     SET_BDA(ebda_seg, EBDA_SEG);
83     SET_BDA(ivecs[0x41].seg, EBDA_SEG);
84     SET_BDA(ivecs[0x41].offset
85             , offsetof(struct extended_bios_data_area_s, fdpt0));
86     SET_BDA(ivecs[0x46].seg, EBDA_SEG);
87     SET_BDA(ivecs[0x41].offset
88             , offsetof(struct extended_bios_data_area_s, fdpt1));
89 }
90
91 static void
92 pit_setup()
93 {
94     // timer0: binary count, 16bit count, mode 2
95     outb(0x34, PORT_PIT_MODE);
96     // maximum count of 0000H = 18.2Hz
97     outb(0x0, PORT_PIT_COUNTER0);
98     outb(0x0, PORT_PIT_COUNTER0);
99 }
100
101 //--------------------------------------------------------------------------
102 // keyboard_panic
103 //--------------------------------------------------------------------------
104 static void
105 keyboard_panic(u16 status)
106 {
107     // If you're getting a 993 keyboard panic here,
108     // please see the comment in keyboard_init
109
110     BX_PANIC("Keyboard error:%u\n",status);
111 }
112
113 static void
114 kbd_flush(u8 code)
115 {
116     u16 max = 0xffff;
117     while ((inb(PORT_PS2_STATUS) & 0x02) && (--max > 0))
118         outb(code, PORT_DIAG);
119     if (!max && code != 0xff)
120         keyboard_panic(code);
121 }
122
123 static void
124 kbd_waitdata(u8 code)
125 {
126     u16 max = 0xffff;
127     while ( ((inb(PORT_PS2_STATUS) & 0x01) == 0) && (--max>0) )
128         outb(code, PORT_DIAG);
129     if (!max)
130         keyboard_panic(code);
131 }
132
133 //--------------------------------------------------------------------------
134 // keyboard_init
135 //--------------------------------------------------------------------------
136 // this file is based on LinuxBIOS implementation of keyboard.c
137 static void
138 keyboard_init()
139 {
140     /* ------------------- Flush buffers ------------------------*/
141     /* Wait until buffer is empty */
142     kbd_flush(0xff);
143
144     /* flush incoming keys */
145     u16 max=0x2000;
146     while (--max > 0) {
147         outb(0x00, PORT_DIAG);
148         if (inb(PORT_PS2_STATUS) & 0x01) {
149             inb(PORT_PS2_DATA);
150             max = 0x2000;
151             }
152         }
153
154     // Due to timer issues, and if the IPS setting is > 15000000,
155     // the incoming keys might not be flushed here. That will
156     // cause a panic a few lines below.  See sourceforge bug report :
157     // [ 642031 ] FATAL: Keyboard RESET error:993
158
159     /* ------------------- controller side ----------------------*/
160     /* send cmd = 0xAA, self test 8042 */
161     outb(0xaa, PORT_PS2_STATUS);
162
163     kbd_flush(0x00);
164     kbd_waitdata(0x01);
165
166     /* read self-test result, 0x55 should be returned from 0x60 */
167     if (inb(PORT_PS2_DATA) != 0x55)
168         keyboard_panic(991);
169
170     /* send cmd = 0xAB, keyboard interface test */
171     outb(0xab, PORT_PS2_STATUS);
172
173     kbd_flush(0x10);
174     kbd_waitdata(0x11);
175
176     /* read keyboard interface test result, */
177     /* 0x00 should be returned form 0x60 */
178     if (inb(PORT_PS2_DATA) != 0x00)
179         keyboard_panic(992);
180
181     /* Enable Keyboard clock */
182     outb(0xae, PORT_PS2_STATUS);
183     outb(0xa8, PORT_PS2_STATUS);
184
185     /* ------------------- keyboard side ------------------------*/
186     /* reset kerboard and self test  (keyboard side) */
187     outb(0xff, PORT_PS2_DATA);
188
189     kbd_flush(0x20);
190     kbd_waitdata(0x21);
191
192     /* keyboard should return ACK */
193     if (inb(PORT_PS2_DATA) != 0xfa)
194         keyboard_panic(993);
195
196     kbd_waitdata(0x31);
197
198     if (inb(PORT_PS2_DATA) != 0xaa)
199         keyboard_panic(994);
200
201     /* Disable keyboard */
202     outb(0xf5, PORT_PS2_DATA);
203
204     kbd_flush(0x40);
205     kbd_waitdata(0x41);
206
207     /* keyboard should return ACK */
208     if (inb(PORT_PS2_DATA) != 0xfa)
209         keyboard_panic(995);
210
211     /* Write Keyboard Mode */
212     outb(0x60, PORT_PS2_STATUS);
213
214     kbd_flush(0x50);
215
216     /* send cmd: scan code convert, disable mouse, enable IRQ 1 */
217     outb(0x61, PORT_PS2_DATA);
218
219     kbd_flush(0x60);
220
221     /* Enable keyboard */
222     outb(0xf4, PORT_PS2_DATA);
223
224     kbd_flush(0x70);
225     kbd_waitdata(0x71);
226
227     /* keyboard should return ACK */
228     if (inb(PORT_PS2_DATA) != 0xfa)
229         keyboard_panic(996);
230
231     outb(0x77, PORT_DIAG);
232 }
233
234 static void
235 kbd_setup()
236 {
237     u16 x = offsetof(struct bios_data_area_s, kbd_buf) - 0x400;
238     SET_BDA(kbd_mode, 0x10);
239     SET_BDA(kbd_buf_head, x);
240     SET_BDA(kbd_buf_tail, x);
241     SET_BDA(kbd_buf_start_offset, x);
242
243     SET_BDA(kbd_buf_end_offset, x + sizeof(bda->kbd_buf));
244
245     keyboard_init();
246 }
247
248 static u16
249 detect_parport(u16 port, u8 timeout, u8 count)
250 {
251     // clear input mode
252     outb(inb(port+2) & 0xdf, port+2);
253
254     outb(0xaa, port);
255     if (inb(port) != 0xaa)
256         // Not present
257         return 0;
258     SET_BDA(port_lpt[count], port);
259     SET_BDA(lpt_timeout[count], timeout);
260     return 1;
261 }
262
263 static void
264 lpt_setup()
265 {
266     u16 count = 0;
267     count += detect_parport(0x378, 0x14, count);
268     count += detect_parport(0x278, 0x14, count);
269
270     // Equipment word bits 14..15 determing # parallel ports
271     u16 eqb = GET_BDA(equipment_list_flags);
272     SET_BDA(equipment_list_flags, (eqb & 0x3fff) | (count << 14));
273 }
274
275 static u16
276 detect_serial(u16 port, u8 timeout, u8 count)
277 {
278     outb(0x02, port+1);
279     if (inb(port+1) != 0x02)
280         return 0;
281     if (inb(port+2) != 0x02)
282         return 0;
283     outb(0x00, port+1);
284     SET_BDA(port_com[count], port);
285     SET_BDA(com_timeout[count], timeout);
286     return 1;
287 }
288
289 static void
290 serial_setup()
291 {
292     u16 count = 0;
293     count += detect_serial(0x3f8, 0x0a, count);
294     count += detect_serial(0x2f8, 0x0a, count);
295     count += detect_serial(0x3e8, 0x0a, count);
296     count += detect_serial(0x2e8, 0x0a, count);
297
298     // Equipment word bits 9..11 determing # serial ports
299     u16 eqb = GET_BDA(equipment_list_flags);
300     SET_BDA(equipment_list_flags, (eqb & 0xf1ff) | (count << 9));
301 }
302
303 static u32
304 bcd2bin(u8 val)
305 {
306     return (val & 0xf) + ((val >> 4) * 10);
307 }
308
309 static void
310 timer_setup()
311 {
312     u32 seconds = bcd2bin(inb_cmos(CMOS_RTC_SECONDS));
313     u32 ticks = (seconds * 18206507) / 1000000;
314     u32 minutes = bcd2bin(inb_cmos(CMOS_RTC_MINUTES));
315     ticks += (minutes * 10923904) / 10000;
316     u32 hours = bcd2bin(inb_cmos(CMOS_RTC_HOURS));
317     ticks += (hours * 65543427) / 1000;
318     SET_BDA(timer_counter, ticks);
319     SET_BDA(timer_rollover, 0);
320 }
321
322 static void
323 pic_setup()
324 {
325     outb(0x11, PORT_PIC1);
326     outb(0x11, PORT_PIC2);
327     outb(0x08, PORT_PIC1_DATA);
328     outb(0x70, PORT_PIC2_DATA);
329     outb(0x04, PORT_PIC1_DATA);
330     outb(0x02, PORT_PIC2_DATA);
331     outb(0x01, PORT_PIC1_DATA);
332     outb(0x01, PORT_PIC2_DATA);
333     outb(0xb8, PORT_PIC1_DATA);
334     if (CONFIG_PS2_MOUSE)
335         outb(0x8f, PORT_PIC2_DATA);
336     else
337         outb(0x9f, PORT_PIC2_DATA);
338 }
339
340 static void
341 floppy_drive_post()
342 {
343     u8 type = inb_cmos(CMOS_FLOPPY_DRIVE_TYPE);
344     u8 out = 0;
345     if (type & 0xf0)
346         out |= 0x07;
347     if (type & 0x0f)
348         out |= 0x70;
349     SET_BDA(floppy_harddisk_info, out);
350     outb(0x02, PORT_DMA1_MASK_REG);
351
352     SET_BDA(ivecs[0x1E].offset, OFFSET_diskette_param_table2);
353 }
354
355 static void
356 ata_init()
357 {
358     // hdidmap  and cdidmap init.
359     u8 device;
360     for (device=0; device < CONFIG_MAX_ATA_DEVICES; device++) {
361         ebda->ata.idmap[0][device] = CONFIG_MAX_ATA_DEVICES;
362         ebda->ata.idmap[1][device] = CONFIG_MAX_ATA_DEVICES;
363     }
364 }
365
366 static void
367 fill_hdinfo(struct fdpt_s *info, u8 typecmos, u8 basecmos)
368 {
369     u8 type = inb_cmos(typecmos);
370     if (type != 47)
371         // XXX - halt
372         return;
373
374     info->precompensation = (inb_cmos(basecmos+4) << 8) | inb_cmos(basecmos+3);
375     info->drive_control_byte = inb_cmos(basecmos+5);
376     info->landing_zone = (inb_cmos(basecmos+7) << 8) | inb_cmos(basecmos+6);
377     u16 cyl = (inb_cmos(basecmos+1) << 8) | inb_cmos(basecmos+0);
378     u8 heads = inb_cmos(basecmos+2);
379     u8 sectors = inb_cmos(basecmos+8);
380     if (cyl < 1024) {
381         // no logical CHS mapping used, just physical CHS
382         // use Standard Fixed Disk Parameter Table (FDPT)
383         info->cylinders = cyl;
384         info->heads = heads;
385         info->sectors = sectors;
386         return;
387     }
388
389     // complies with Phoenix style Translated Fixed Disk Parameter
390     // Table (FDPT)
391     info->phys_cylinders = cyl;
392     info->phys_heads = heads;
393     info->phys_sectors = sectors;
394     info->sectors = sectors;
395     info->a0h_signature = 0xa0;
396     if (cyl > 8192) {
397         cyl >>= 4;
398         heads <<= 4;
399     } else if (cyl > 4096) {
400         cyl >>= 3;
401         heads <<= 3;
402     } else if (cyl > 2048) {
403         cyl >>= 2;
404         heads <<= 2;
405     }
406     info->cylinders = cyl;
407     info->heads = heads;
408     info->checksum = ~checksum((u8*)info, sizeof(*info)-1) + 1;
409 }
410
411 static void
412 hard_drive_post()
413 {
414     outb(0x0a, 0x03f6); // 0000 1010 = reserved, disable IRQ 14
415     SET_BDA(disk_count, 1);
416     SET_BDA(disk_control_byte, 0xc0);
417
418     // move disk geometry data from CMOS to EBDA disk parameter table(s)
419     u8 diskinfo = inb_cmos(CMOS_DISK_DATA);
420     if ((diskinfo & 0xf0) == 0xf0)
421         // Fill EBDA table for hard disk 0.
422         fill_hdinfo(&ebda->fdpt0, CMOS_DISK_DRIVE1_TYPE, CMOS_DISK_DRIVE1_CYL);
423     if ((diskinfo & 0x0f) == 0x0f)
424         // XXX - bochs halts on any other type
425         // Fill EBDA table for hard disk 1.
426         fill_hdinfo(&ebda->fdpt0, CMOS_DISK_DRIVE2_TYPE, CMOS_DISK_DRIVE2_CYL);
427 }
428
429
430 static void
431 init_boot_vectors()
432 {
433     // Clear out the IPL table.
434     memset(ipl, 0, sizeof(*ipl));
435
436     // Floppy drive
437     struct ipl_entry_s *ip = &ipl->table[0];
438     ip->type = IPL_TYPE_FLOPPY;
439     ip++;
440
441     // First HDD
442     ip->type = IPL_TYPE_HARDDISK;
443     ip++;
444
445     // CDROM
446     if (CONFIG_CDROM_BOOT) {
447         ip->type = IPL_TYPE_CDROM;
448         ip++;
449     }
450
451     ipl->count = ip - ipl->table;
452     ipl->sequence = 0xffff;
453 }
454
455 static void
456 callrom(u16 seg, u16 offset)
457 {
458     struct bregs br;
459     memset(&br, 0, sizeof(br));
460     br.es = SEG_BIOS;
461     br.di = OFFSET_pnp_string + 1; // starts 1 past for alignment
462     br.cs = seg;
463     br.ip = offset;
464     call16(&br);
465 }
466
467 static void
468 rom_scan(u32 start, u32 end)
469 {
470     u8 *p = (u8*)start;
471     for (; p <= (u8*)end; p += 2048) {
472         u8 *rom = p;
473         if (*(u16*)rom != 0xaa55)
474             continue;
475         u32 len = rom[2] * 512;
476         if (checksum(rom, len) != 0)
477             continue;
478         p = (u8*)(((u32)p + len) / 2048 * 2048);
479         callrom(PTR_TO_SEG(rom), PTR_TO_OFFSET(rom + 3));
480
481         // Look at the ROM's PnP Expansion header.  Properly, we're supposed
482         // to init all the ROMs and then go back and build an IPL table of
483         // all the bootable devices, but we can get away with one pass.
484         if (rom[0x1a] != '$' || rom[0x1b] != 'P'
485             || rom[0x1c] != 'n' || rom[0x1d] != 'P')
486             continue;
487         // 0x1A is also the offset into the expansion header of...
488         // the Bootstrap Entry Vector, or zero if there is none.
489         u16 entry = *(u16*)&rom[0x1a+0x1a];
490         if (!entry)
491             continue;
492         // Found a device that thinks it can boot the system.  Record
493         // its BEV and product name string.
494
495         if (ipl->count >= ARRAY_SIZE(ipl->table))
496             continue;
497
498         struct ipl_entry_s *ip = &ipl->table[ipl->count];
499         ip->type = IPL_TYPE_BEV;
500         ip->vector = (PTR_TO_SEG(rom) << 16) | entry;
501
502         u16 desc = *(u16*)&rom[0x1a+0x10];
503         if (desc)
504             ip->description = (PTR_TO_SEG(rom) << 16) | desc;
505
506         ipl->count++;
507     }
508 }
509
510 static void
511 post()
512 {
513     BX_INFO("Start bios\n");
514
515     init_bda();
516     init_handlers();
517     init_ebda();
518
519     pit_setup();
520     kbd_setup();
521     lpt_setup();
522     serial_setup();
523     timer_setup();
524     pic_setup();
525
526     rom_scan(0xc0000, 0xc7800);
527
528     printf("BIOS - begin\n\n");
529
530     rombios32_init();
531
532     init_boot_vectors();
533
534     floppy_drive_post();
535     hard_drive_post();
536     if (CONFIG_ATA) {
537         ata_init();
538         ata_detect();
539     }
540
541     init_boot_vectors();
542
543     rom_scan(0xc8000, 0xe0000);
544
545     // reset the memory (some boot loaders such as syslinux suppose
546     // that the memory is set to zero)
547     memset((void*)0x40000, 0, 0x40000); // XXX - shouldn't use globals
548
549     // Invoke int 19 to start boot process.
550     struct bregs br;
551     memset(&br, 0, sizeof(br));
552     call16_int(0x19, &br);
553 }
554
555 static void
556 init_dma()
557 {
558     // first reset the DMA controllers
559     outb(0, PORT_DMA1_MASTER_CLEAR);
560     outb(0, PORT_DMA2_MASTER_CLEAR);
561
562     // then initialize the DMA controllers
563     outb(0xc0, PORT_DMA2_MODE_REG);
564     outb(0x00, PORT_DMA2_MASK_REG);
565 }
566
567 static void
568 check_restart_status()
569 {
570     // Get and then clear CMOS shutdown status.
571     u8 status = inb_cmos(CMOS_RESET_CODE);
572     outb_cmos(0, CMOS_RESET_CODE);
573
574     if (status == 0x00 || status == 0x09 || status >= 0x0d)
575         // Normal post
576         return;
577
578     if (status != 0x05) {
579         BX_PANIC("Unimplemented shutdown status: %02x\n", status);
580         return;
581     }
582
583     // XXX - this is supposed to jump without changing any memory -
584     // but the stack has been altered by the time the code gets here.
585     eoi_both_pics();
586     struct bregs br;
587     memset(&br, 0, sizeof(br));
588     br.cs = GET_BDA(jump_cs_ip) >> 16;
589     br.ip = GET_BDA(jump_cs_ip);
590     call16(&br);
591 }
592
593 void VISIBLE32
594 _start()
595 {
596     init_dma();
597     check_restart_status();
598
599     post();
600 }