Get CDROM emulation working.
[people/mcb30/legacybios.git] / src / ata.c
1 // Low level ATA disk access
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 "ata.h" // ATA_*
9 #include "types.h" // u8
10 #include "ioport.h" // inb
11 #include "util.h" // BX_INFO
12 #include "cmos.h" // inb_cmos
13
14 #define TIMEOUT 0
15 #define BSY 1
16 #define NOT_BSY 2
17 #define NOT_BSY_DRQ 3
18 #define NOT_BSY_NOT_DRQ 4
19 #define NOT_BSY_RDY 5
20
21 #define IDE_TIMEOUT 32000u //32 seconds max for IDE ops
22
23 #define BX_DEBUG_ATA BX_INFO
24
25 // XXX - lots of redundancy in this file.
26
27 static int
28 await_ide(u8 when_done, u16 base, u16 timeout)
29 {
30     u32 time=0,last=0;
31     // for the times you're supposed to throw one away
32     u16 status = inb(base + ATA_CB_STAT);
33     for (;;) {
34         status = inb(base+ATA_CB_STAT);
35         time++;
36         u8 result;
37         if (when_done == BSY)
38             result = status & ATA_CB_STAT_BSY;
39         else if (when_done == NOT_BSY)
40             result = !(status & ATA_CB_STAT_BSY);
41         else if (when_done == NOT_BSY_DRQ)
42             result = !(status & ATA_CB_STAT_BSY) && (status & ATA_CB_STAT_DRQ);
43         else if (when_done == NOT_BSY_NOT_DRQ)
44             result = !(status & ATA_CB_STAT_BSY) && !(status & ATA_CB_STAT_DRQ);
45         else if (when_done == NOT_BSY_RDY)
46             result = !(status & ATA_CB_STAT_BSY) && (status & ATA_CB_STAT_RDY);
47         else if (when_done == TIMEOUT)
48             result = 0;
49
50         if (result)
51             return 0;
52         // mod 2048 each 16 ms
53         if (time>>16 != last) {
54             last = time >>16;
55             BX_DEBUG_ATA("await_ide: (TIMEOUT,BSY,!BSY,!BSY_DRQ,!BSY_!DRQ,!BSY_RDY) %d time= %d timeout= %d\n",when_done,time>>11, timeout);
56         }
57         if (status & ATA_CB_STAT_ERR) {
58             BX_DEBUG_ATA("await_ide: ERROR (TIMEOUT,BSY,!BSY,!BSY_DRQ,!BSY_!DRQ,!BSY_RDY) %d time= %d timeout= %d\n",when_done,time>>11, timeout);
59             return -1;
60         }
61         if ((timeout == 0) || ((time>>11) > timeout))
62             break;
63     }
64     BX_INFO("IDE time out\n");
65     return -1;
66 }
67
68
69 // ---------------------------------------------------------------------------
70 // ATA/ATAPI driver : software reset
71 // ---------------------------------------------------------------------------
72 // ATA-3
73 // 8.2.1 Software reset - Device 0
74
75 void
76 ata_reset(u16 device)
77 {
78     u16 iobase1, iobase2;
79     u8  channel, slave, sn, sc;
80     u8  type;
81
82     channel = device / 2;
83     slave = device % 2;
84
85     iobase1 = GET_EBDA(ata.channels[channel].iobase1);
86     iobase2 = GET_EBDA(ata.channels[channel].iobase2);
87
88     // Reset
89
90     // 8.2.1 (a) -- set SRST in DC
91     outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN | ATA_CB_DC_SRST, iobase2+ATA_CB_DC);
92
93     // 8.2.1 (b) -- wait for BSY
94     await_ide(BSY, iobase1, 20);
95
96     // 8.2.1 (f) -- clear SRST
97     outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2+ATA_CB_DC);
98
99     type=GET_EBDA(ata.devices[device].type);
100     if (type != ATA_TYPE_NONE) {
101
102         // 8.2.1 (g) -- check for sc==sn==0x01
103         // select device
104         outb(slave?ATA_CB_DH_DEV1:ATA_CB_DH_DEV0, iobase1+ATA_CB_DH);
105         sc = inb(iobase1+ATA_CB_SC);
106         sn = inb(iobase1+ATA_CB_SN);
107
108         if ( (sc==0x01) && (sn==0x01) ) {
109             if (type == ATA_TYPE_ATA) //ATA
110                 await_ide(NOT_BSY_RDY, iobase1, IDE_TIMEOUT);
111             else //ATAPI
112                 await_ide(NOT_BSY, iobase1, IDE_TIMEOUT);
113         }
114
115         // 8.2.1 (h) -- wait for not BSY
116         await_ide(NOT_BSY, iobase1, IDE_TIMEOUT);
117     }
118
119     // Enable interrupts
120     outb(ATA_CB_DC_HD15, iobase2+ATA_CB_DC);
121 }
122
123 static void
124 insw(u16 port, u16 segment, u16 offset, u16 count)
125 {
126     u16 i;
127     for (i=0; i<count; i++) {
128         u16 d = inw(port);
129         SET_FARVAR(segment, *(u16*)(offset + 2*i), d);
130     }
131 }
132
133 static void
134 insl(u16 port, u16 segment, u16 offset, u16 count)
135 {
136     u16 i;
137     for (i=0; i<count; i++) {
138         u32 d = inl(port);
139         SET_FARVAR(segment, *(u32*)(offset + 4*i), d);
140     }
141 }
142
143 static void
144 outsw(u16 port, u16 segment, u16 offset, u16 count)
145 {
146     u16 i;
147     for (i=0; i<count; i++) {
148         u16 d = GET_FARVAR(segment, *(u16*)(offset + 2*i));
149         outw(d, port);
150     }
151 }
152
153 static void
154 outsl(u16 port, u16 segment, u16 offset, u16 count)
155 {
156     u16 i;
157     for (i=0; i<count; i++) {
158         u32 d = GET_FARVAR(segment, *(u32*)(offset + 4*i));
159         outl(d, port);
160     }
161 }
162
163
164 // ---------------------------------------------------------------------------
165 // ATA/ATAPI driver : execute a data-in command
166 // ---------------------------------------------------------------------------
167       // returns
168       // 0 : no error
169       // 1 : BUSY bit set
170       // 2 : read error
171       // 3 : expected DRQ=1
172       // 4 : no sectors left to read/verify
173       // 5 : more sectors to read/verify
174       // 6 : no sectors left to write
175       // 7 : more sectors to write
176 u16
177 ata_cmd_data_in(u16 device, u16 command, u16 count, u16 cylinder
178                 , u16 head, u16 sector, u32 lba, u16 segment, u16 offset)
179 {
180     u16 iobase1, iobase2, blksize;
181     u8  channel, slave;
182     u8  status, current, mode;
183
184     channel = device / 2;
185     slave   = device % 2;
186
187     iobase1 = GET_EBDA(ata.channels[channel].iobase1);
188     iobase2 = GET_EBDA(ata.channels[channel].iobase2);
189     mode    = GET_EBDA(ata.devices[device].mode);
190     blksize = 0x200;
191     if (mode == ATA_MODE_PIO32)
192         blksize>>=2;
193     else
194         blksize>>=1;
195
196     // Reset count of transferred data
197     SET_EBDA(ata.trsfsectors,0);
198     SET_EBDA(ata.trsfbytes,0L);
199     current = 0;
200
201     status = inb(iobase1 + ATA_CB_STAT);
202     if (status & ATA_CB_STAT_BSY)
203         return 1;
204
205     outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2 + ATA_CB_DC);
206
207     // sector will be 0 only on lba access. Convert to lba-chs
208     if (sector == 0) {
209         if ((count >= 1 << 8) || (lba + count >= 1UL << 28)) {
210             outb(0x00, iobase1 + ATA_CB_FR);
211             outb((count >> 8) & 0xff, iobase1 + ATA_CB_SC);
212             outb(lba >> 24, iobase1 + ATA_CB_SN);
213             outb(0, iobase1 + ATA_CB_CL);
214             outb(0, iobase1 + ATA_CB_CH);
215             command |= 0x04;
216             count &= (1UL << 8) - 1;
217             lba &= (1UL << 24) - 1;
218         }
219         sector = (u16) (lba & 0x000000ffL);
220         cylinder = (u16) ((lba>>8) & 0x0000ffffL);
221         head = ((u16) ((lba>>24) & 0x0000000fL)) | ATA_CB_DH_LBA;
222     }
223
224     outb(0x00, iobase1 + ATA_CB_FR);
225     outb(count, iobase1 + ATA_CB_SC);
226     outb(sector, iobase1 + ATA_CB_SN);
227     outb(cylinder & 0x00ff, iobase1 + ATA_CB_CL);
228     outb(cylinder >> 8, iobase1 + ATA_CB_CH);
229     outb((slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0) | (u8) head
230          , iobase1 + ATA_CB_DH);
231     outb(command, iobase1 + ATA_CB_CMD);
232
233     await_ide(NOT_BSY_DRQ, iobase1, IDE_TIMEOUT);
234     status = inb(iobase1 + ATA_CB_STAT);
235
236     if (status & ATA_CB_STAT_ERR) {
237         BX_DEBUG_ATA("ata_cmd_data_in : read error\n");
238         return 2;
239     } else if ( !(status & ATA_CB_STAT_DRQ) ) {
240         BX_DEBUG_ATA("ata_cmd_data_in : DRQ not set (status %02x)\n"
241                      , (unsigned) status);
242         return 3;
243     }
244
245     // FIXME : move seg/off translation here
246
247     irq_enable();
248
249     while (1) {
250
251         if (offset > 0xf800) {
252             offset -= 0x800;
253             segment += 0x80;
254         }
255
256         if (mode == ATA_MODE_PIO32)
257             insl(iobase1, segment, offset, blksize);
258         else
259             insw(iobase1, segment, offset, blksize);
260
261         current++;
262         SET_EBDA(ata.trsfsectors,current);
263         count--;
264         await_ide(NOT_BSY, iobase1, IDE_TIMEOUT);
265         status = inb(iobase1 + ATA_CB_STAT);
266         if (count == 0) {
267             if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DRQ
268                             | ATA_CB_STAT_ERR) )
269                  != ATA_CB_STAT_RDY ) {
270                 BX_DEBUG_ATA("ata_cmd_data_in : no sectors left (status %02x)\n"
271                              , (unsigned) status);
272                 return 4;
273             }
274             break;
275         }
276         else {
277             if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DRQ
278                             | ATA_CB_STAT_ERR) )
279                  != (ATA_CB_STAT_RDY | ATA_CB_STAT_DRQ) ) {
280                 BX_DEBUG_ATA("ata_cmd_data_in : more sectors left (status %02x)\n"
281                              , (unsigned) status);
282                 return 5;
283             }
284             continue;
285         }
286     }
287     // Enable interrupts
288     outb(ATA_CB_DC_HD15, iobase2+ATA_CB_DC);
289     return 0;
290 }
291
292 // ---------------------------------------------------------------------------
293 // ATA/ATAPI driver : execute a data-out command
294 // ---------------------------------------------------------------------------
295       // returns
296       // 0 : no error
297       // 1 : BUSY bit set
298       // 2 : read error
299       // 3 : expected DRQ=1
300       // 4 : no sectors left to read/verify
301       // 5 : more sectors to read/verify
302       // 6 : no sectors left to write
303       // 7 : more sectors to write
304 u16
305 ata_cmd_data_out(u16 device, u16 command, u16 count, u16 cylinder
306                  , u16 head, u16 sector, u32 lba, u16 segment, u16 offset)
307 {
308     u16 iobase1, iobase2, blksize;
309     u8  channel, slave;
310     u8  status, current, mode;
311
312     channel = device / 2;
313     slave   = device % 2;
314
315     iobase1 = GET_EBDA(ata.channels[channel].iobase1);
316     iobase2 = GET_EBDA(ata.channels[channel].iobase2);
317     mode    = GET_EBDA(ata.devices[device].mode);
318     blksize = 0x200;
319     if (mode == ATA_MODE_PIO32)
320         blksize>>=2;
321     else
322         blksize>>=1;
323
324     // Reset count of transferred data
325     SET_EBDA(ata.trsfsectors,0);
326     SET_EBDA(ata.trsfbytes,0L);
327     current = 0;
328
329     status = inb(iobase1 + ATA_CB_STAT);
330     if (status & ATA_CB_STAT_BSY)
331         return 1;
332
333     outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2 + ATA_CB_DC);
334
335     // sector will be 0 only on lba access. Convert to lba-chs
336     if (sector == 0) {
337         if ((count >= 1 << 8) || (lba + count >= 1UL << 28)) {
338             outb(0x00, iobase1 + ATA_CB_FR);
339             outb((count >> 8) & 0xff, iobase1 + ATA_CB_SC);
340             outb(lba >> 24, iobase1 + ATA_CB_SN);
341             outb(0, iobase1 + ATA_CB_CL);
342             outb(0, iobase1 + ATA_CB_CH);
343             command |= 0x04;
344             count &= (1UL << 8) - 1;
345             lba &= (1UL << 24) - 1;
346         }
347         sector = (u16) (lba & 0x000000ffL);
348         cylinder = (u16) ((lba>>8) & 0x0000ffffL);
349         head = ((u16) ((lba>>24) & 0x0000000fL)) | ATA_CB_DH_LBA;
350     }
351
352     outb(0x00, iobase1 + ATA_CB_FR);
353     outb(count, iobase1 + ATA_CB_SC);
354     outb(sector, iobase1 + ATA_CB_SN);
355     outb(cylinder & 0x00ff, iobase1 + ATA_CB_CL);
356     outb(cylinder >> 8, iobase1 + ATA_CB_CH);
357     outb((slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0) | (u8) head
358          , iobase1 + ATA_CB_DH);
359     outb(command, iobase1 + ATA_CB_CMD);
360
361     await_ide(NOT_BSY_DRQ, iobase1, IDE_TIMEOUT);
362     status = inb(iobase1 + ATA_CB_STAT);
363
364     if (status & ATA_CB_STAT_ERR) {
365         BX_DEBUG_ATA("ata_cmd_data_out : read error\n");
366         return 2;
367     } else if ( !(status & ATA_CB_STAT_DRQ) ) {
368         BX_DEBUG_ATA("ata_cmd_data_out : DRQ not set (status %02x)\n"
369                      , (unsigned) status);
370         return 3;
371     }
372
373     // FIXME : move seg/off translation here
374
375     irq_enable();
376
377     while (1) {
378
379         if (offset > 0xf800) {
380             offset -= 0x800;
381             segment += 0x80;
382         }
383
384         if (mode == ATA_MODE_PIO32)
385             outsl(iobase1, segment, offset, blksize);
386         else
387             outsw(iobase1, segment, offset, blksize);
388
389         current++;
390         SET_EBDA(ata.trsfsectors,current);
391         count--;
392         status = inb(iobase1 + ATA_CB_STAT);
393         if (count == 0) {
394             if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DF
395                             | ATA_CB_STAT_DRQ | ATA_CB_STAT_ERR) )
396                  != ATA_CB_STAT_RDY ) {
397                 BX_DEBUG_ATA("ata_cmd_data_out : no sectors left (status %02x)\n"
398                              , (unsigned) status);
399                 return 6;
400             }
401             break;
402         } else {
403             if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DRQ
404                             | ATA_CB_STAT_ERR) )
405                  != (ATA_CB_STAT_RDY | ATA_CB_STAT_DRQ) ) {
406                 BX_DEBUG_ATA("ata_cmd_data_out : more sectors left (status %02x)\n"
407                              , (unsigned) status);
408                 return 7;
409             }
410             continue;
411         }
412     }
413     // Enable interrupts
414     outb(ATA_CB_DC_HD15, iobase2+ATA_CB_DC);
415     return 0;
416 }
417
418 // ---------------------------------------------------------------------------
419 // ATA/ATAPI driver : execute a packet command
420 // ---------------------------------------------------------------------------
421       // returns
422       // 0 : no error
423       // 1 : error in parameters
424       // 2 : BUSY bit set
425       // 3 : error
426       // 4 : not ready
427 u16
428 ata_cmd_packet(u16 device, u8 *cmdbuf, u8 cmdlen, u16 header
429                , u32 length, u8 inout, u16 bufseg, u16 bufoff)
430 {
431     u16 iobase1, iobase2;
432     u16 lcount, lbefore, lafter, count;
433     u8  channel, slave;
434     u8  status, mode, lmode;
435     u32 transfer;
436
437     channel = device / 2;
438     slave = device % 2;
439
440     // Data out is not supported yet
441     if (inout == ATA_DATA_OUT) {
442         BX_INFO("ata_cmd_packet: DATA_OUT not supported yet\n");
443         return 1;
444     }
445
446     // The header length must be even
447     if (header & 1) {
448         BX_DEBUG_ATA("ata_cmd_packet : header must be even (%04x)\n",header);
449         return 1;
450     }
451
452     iobase1 = GET_EBDA(ata.channels[channel].iobase1);
453     iobase2 = GET_EBDA(ata.channels[channel].iobase2);
454     mode    = GET_EBDA(ata.devices[device].mode);
455     transfer= 0L;
456
457     if (cmdlen < 12)
458         cmdlen=12;
459     if (cmdlen > 12)
460         cmdlen=16;
461     cmdlen>>=1;
462
463     // Reset count of transferred data
464     SET_EBDA(ata.trsfsectors,0);
465     SET_EBDA(ata.trsfbytes,0L);
466
467     status = inb(iobase1 + ATA_CB_STAT);
468     if (status & ATA_CB_STAT_BSY)
469         return 2;
470
471     outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2 + ATA_CB_DC);
472     outb(0x00, iobase1 + ATA_CB_FR);
473     outb(0x00, iobase1 + ATA_CB_SC);
474     outb(0x00, iobase1 + ATA_CB_SN);
475     outb(0xfff0 & 0x00ff, iobase1 + ATA_CB_CL);
476     outb(0xfff0 >> 8, iobase1 + ATA_CB_CH);
477     outb(slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0, iobase1 + ATA_CB_DH);
478     outb(ATA_CMD_PACKET, iobase1 + ATA_CB_CMD);
479
480     // Device should ok to receive command
481     await_ide(NOT_BSY_DRQ, iobase1, IDE_TIMEOUT);
482     status = inb(iobase1 + ATA_CB_STAT);
483
484     if (status & ATA_CB_STAT_ERR) {
485         BX_DEBUG_ATA("ata_cmd_packet : error, status is %02x\n",status);
486         return 3;
487     } else if ( !(status & ATA_CB_STAT_DRQ) ) {
488         BX_DEBUG_ATA("ata_cmd_packet : DRQ not set (status %02x)\n"
489                      , (unsigned) status);
490         return 4;
491     }
492
493     // Send command to device
494     irq_enable();
495
496     outsw(iobase1, GET_SEG(SS), (u32)cmdbuf, cmdlen);
497
498     if (inout == ATA_DATA_NO) {
499         await_ide(NOT_BSY, iobase1, IDE_TIMEOUT);
500         status = inb(iobase1 + ATA_CB_STAT);
501     } else {
502         u16 loops = 0;
503         u8 sc;
504         while (1) {
505
506             if (loops == 0) {//first time through
507                 status = inb(iobase2 + ATA_CB_ASTAT);
508                 await_ide(NOT_BSY_DRQ, iobase1, IDE_TIMEOUT);
509             } else
510                 await_ide(NOT_BSY, iobase1, IDE_TIMEOUT);
511             loops++;
512
513             status = inb(iobase1 + ATA_CB_STAT);
514             sc = inb(iobase1 + ATA_CB_SC);
515
516             // Check if command completed
517             if(((inb(iobase1 + ATA_CB_SC)&0x7)==0x3) &&
518                ((status & (ATA_CB_STAT_RDY | ATA_CB_STAT_ERR)) == ATA_CB_STAT_RDY))
519                 break;
520
521             if (status & ATA_CB_STAT_ERR) {
522                 BX_DEBUG_ATA("ata_cmd_packet : error (status %02x)\n",status);
523                 return 3;
524             }
525
526             // Normalize address
527             bufseg += (bufoff / 16);
528             bufoff %= 16;
529
530             // Get the byte count
531             lcount =  ((u16)(inb(iobase1 + ATA_CB_CH))<<8)+inb(iobase1 + ATA_CB_CL);
532
533             // adjust to read what we want
534             if (header > lcount) {
535                 lbefore=lcount;
536                 header-=lcount;
537                 lcount=0;
538             } else {
539                 lbefore=header;
540                 header=0;
541                 lcount-=lbefore;
542             }
543
544             if (lcount > length) {
545                 lafter=lcount-length;
546                 lcount=length;
547                 length=0;
548             } else {
549                 lafter=0;
550                 length-=lcount;
551             }
552
553             // Save byte count
554             count = lcount;
555
556             BX_DEBUG_ATA("Trying to read %04x bytes (%04x %04x %04x) "
557                          ,lbefore+lcount+lafter,lbefore,lcount,lafter);
558             BX_DEBUG_ATA("to 0x%04x:0x%04x\n",bufseg,bufoff);
559
560             // If counts not dividable by 4, use 16bits mode
561             lmode = mode;
562             if (lbefore & 0x03) lmode=ATA_MODE_PIO16;
563             if (lcount  & 0x03) lmode=ATA_MODE_PIO16;
564             if (lafter  & 0x03) lmode=ATA_MODE_PIO16;
565
566             // adds an extra byte if count are odd. before is always even
567             if (lcount & 0x01) {
568                 lcount+=1;
569                 if ((lafter > 0) && (lafter & 0x01)) {
570                     lafter-=1;
571                 }
572             }
573
574             if (lmode == ATA_MODE_PIO32) {
575                 lcount>>=2; lbefore>>=2; lafter>>=2;
576             } else {
577                 lcount>>=1; lbefore>>=1; lafter>>=1;
578             }
579
580             int i;
581             for (i=0; i<lbefore; i++)
582                 if (lmode == ATA_MODE_PIO32)
583                     inl(iobase1);
584                 else
585                     inw(iobase1);
586
587             if (lmode == ATA_MODE_PIO32)
588                 insl(iobase1, bufseg, bufoff, lcount);
589             else
590                 insw(iobase1, bufseg, bufoff, lcount);
591
592             for (i=0; i<lafter; i++)
593                 if (lmode == ATA_MODE_PIO32)
594                     inl(iobase1);
595                 else
596                     inw(iobase1);
597
598             // Compute new buffer address
599             bufoff += count;
600
601             // Save transferred bytes count
602             transfer += count;
603             SET_EBDA(ata.trsfbytes,transfer);
604         }
605     }
606
607     // Final check, device must be ready
608     if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DF
609                     | ATA_CB_STAT_DRQ | ATA_CB_STAT_ERR) )
610          != ATA_CB_STAT_RDY ) {
611         BX_DEBUG_ATA("ata_cmd_packet : not ready (status %02x)\n"
612                      , (unsigned) status);
613         return 4;
614     }
615
616     // Enable interrupts
617     outb(ATA_CB_DC_HD15, iobase2+ATA_CB_DC);
618     return 0;
619 }
620
621 u16
622 cdrom_read(u16 device, u32 lba, u32 count, u16 segment, u16 offset, u16 skip)
623 {
624     u16 sectors = (count + 2048 - 1) / 2048;
625
626     u8 atacmd[12];
627     memset(atacmd, 0, sizeof(atacmd));
628     atacmd[0]=0x28;                      // READ command
629     atacmd[7]=(sectors & 0xff00) >> 8;   // Sectors
630     atacmd[8]=(sectors & 0x00ff);        // Sectors
631     atacmd[2]=(lba & 0xff000000) >> 24;  // LBA
632     atacmd[3]=(lba & 0x00ff0000) >> 16;
633     atacmd[4]=(lba & 0x0000ff00) >> 8;
634     atacmd[5]=(lba & 0x000000ff);
635
636     return ata_cmd_packet(device, atacmd, sizeof(atacmd)
637                           , skip, count, ATA_DATA_IN
638                           , segment, offset);
639 }
640
641 // ---------------------------------------------------------------------------
642 // ATA/ATAPI driver : device detection
643 // ---------------------------------------------------------------------------
644
645 void
646 ata_detect()
647 {
648     u8  hdcount, cdcount, device, type;
649     u8  buffer[0x0200];
650     memset(buffer, 0, sizeof(buffer));
651
652 #if CONFIG_MAX_ATA_INTERFACES > 0
653     SET_EBDA(ata.channels[0].iface,ATA_IFACE_ISA);
654     SET_EBDA(ata.channels[0].iobase1,0x1f0);
655     SET_EBDA(ata.channels[0].iobase2,0x3f0);
656     SET_EBDA(ata.channels[0].irq,14);
657 #endif
658 #if CONFIG_MAX_ATA_INTERFACES > 1
659     SET_EBDA(ata.channels[1].iface,ATA_IFACE_ISA);
660     SET_EBDA(ata.channels[1].iobase1,0x170);
661     SET_EBDA(ata.channels[1].iobase2,0x370);
662     SET_EBDA(ata.channels[1].irq,15);
663 #endif
664 #if CONFIG_MAX_ATA_INTERFACES > 2
665     SET_EBDA(ata.channels[2].iface,ATA_IFACE_ISA);
666     SET_EBDA(ata.channels[2].iobase1,0x1e8);
667     SET_EBDA(ata.channels[2].iobase2,0x3e0);
668     SET_EBDA(ata.channels[2].irq,12);
669 #endif
670 #if CONFIG_MAX_ATA_INTERFACES > 3
671     SET_EBDA(ata.channels[3].iface,ATA_IFACE_ISA);
672     SET_EBDA(ata.channels[3].iobase1,0x168);
673     SET_EBDA(ata.channels[3].iobase2,0x360);
674     SET_EBDA(ata.channels[3].irq,11);
675 #endif
676 #if CONFIG_MAX_ATA_INTERFACES > 4
677 #error Please fill the ATA interface informations
678 #endif
679
680     // Device detection
681     hdcount=cdcount=0;
682
683     for(device=0; device<CONFIG_MAX_ATA_DEVICES; device++) {
684         u16 iobase1, iobase2;
685         u8  channel, slave, shift;
686         u8  sc, sn, cl, ch, st;
687
688         channel = device / 2;
689         slave = device % 2;
690
691         iobase1 =GET_EBDA(ata.channels[channel].iobase1);
692         iobase2 =GET_EBDA(ata.channels[channel].iobase2);
693
694         // Disable interrupts
695         outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2+ATA_CB_DC);
696
697         // Look for device
698         outb(slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0, iobase1+ATA_CB_DH);
699         outb(0x55, iobase1+ATA_CB_SC);
700         outb(0xaa, iobase1+ATA_CB_SN);
701         outb(0xaa, iobase1+ATA_CB_SC);
702         outb(0x55, iobase1+ATA_CB_SN);
703         outb(0x55, iobase1+ATA_CB_SC);
704         outb(0xaa, iobase1+ATA_CB_SN);
705
706         // If we found something
707         sc = inb(iobase1+ATA_CB_SC);
708         sn = inb(iobase1+ATA_CB_SN);
709
710         if ( (sc == 0x55) && (sn == 0xaa) ) {
711             SET_EBDA(ata.devices[device].type,ATA_TYPE_UNKNOWN);
712
713             // reset the channel
714             ata_reset(device);
715
716             // check for ATA or ATAPI
717             outb(slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0, iobase1+ATA_CB_DH);
718             sc = inb(iobase1+ATA_CB_SC);
719             sn = inb(iobase1+ATA_CB_SN);
720             if ((sc==0x01) && (sn==0x01)) {
721                 cl = inb(iobase1+ATA_CB_CL);
722                 ch = inb(iobase1+ATA_CB_CH);
723                 st = inb(iobase1+ATA_CB_STAT);
724
725                 if ((cl==0x14) && (ch==0xeb)) {
726                     SET_EBDA(ata.devices[device].type,ATA_TYPE_ATAPI);
727                 } else if ((cl==0x00) && (ch==0x00) && (st!=0x00)) {
728                     SET_EBDA(ata.devices[device].type,ATA_TYPE_ATA);
729                 } else if ((cl==0xff) && (ch==0xff)) {
730                     SET_EBDA(ata.devices[device].type,ATA_TYPE_NONE);
731                 }
732             }
733         }
734
735         type=GET_EBDA(ata.devices[device].type);
736
737         // Now we send a IDENTIFY command to ATA device
738         if(type == ATA_TYPE_ATA) {
739             u32 sectors;
740             u16 cylinders, heads, spt, blksize;
741             u8  translation, removable, mode;
742
743             //Temporary values to do the transfer
744             SET_EBDA(ata.devices[device].device,ATA_DEVICE_HD);
745             SET_EBDA(ata.devices[device].mode, ATA_MODE_PIO16);
746
747             u16 ret = ata_cmd_data_in(device,ATA_CMD_IDENTIFY_DEVICE
748                                       , 1, 0, 0, 0, 0L
749                                       , GET_SEG(SS), (u32)buffer);
750             if (ret)
751                 BX_PANIC("ata-detect: Failed to detect ATA device\n");
752
753             removable = (buffer[0] & 0x80) ? 1 : 0;
754             mode      = buffer[96] ? ATA_MODE_PIO32 : ATA_MODE_PIO16;
755             blksize   = *(u16*)&buffer[10];
756
757             cylinders = *(u16*)&buffer[1*2]; // word 1
758             heads     = *(u16*)&buffer[3*2]; // word 3
759             spt       = *(u16*)&buffer[6*2]; // word 6
760
761             sectors   = *(u32*)&buffer[60*2]; // word 60 and word 61
762
763             SET_EBDA(ata.devices[device].device,ATA_DEVICE_HD);
764             SET_EBDA(ata.devices[device].removable, removable);
765             SET_EBDA(ata.devices[device].mode, mode);
766             SET_EBDA(ata.devices[device].blksize, blksize);
767             SET_EBDA(ata.devices[device].pchs.heads, heads);
768             SET_EBDA(ata.devices[device].pchs.cylinders, cylinders);
769             SET_EBDA(ata.devices[device].pchs.spt, spt);
770             SET_EBDA(ata.devices[device].sectors, sectors);
771             BX_INFO("ata%d-%d: PCHS=%u/%d/%d translation=", channel, slave,cylinders, heads, spt);
772
773             translation = inb_cmos(CMOS_BIOS_DISKTRANSFLAG + channel/2);
774             for (shift=device%4; shift>0; shift--)
775                 translation >>= 2;
776             translation &= 0x03;
777
778             SET_EBDA(ata.devices[device].translation, translation);
779
780             switch (translation) {
781             case ATA_TRANSLATION_NONE:
782                 BX_INFO("none");
783                 break;
784             case ATA_TRANSLATION_LBA:
785                 BX_INFO("lba");
786                 break;
787             case ATA_TRANSLATION_LARGE:
788                 BX_INFO("large");
789                 break;
790             case ATA_TRANSLATION_RECHS:
791                 BX_INFO("r-echs");
792                 break;
793             }
794             switch (translation) {
795             case ATA_TRANSLATION_NONE:
796                 break;
797             case ATA_TRANSLATION_LBA:
798                 spt = 63;
799                 sectors /= 63;
800                 heads = sectors / 1024;
801                 if (heads>128) heads = 255;
802                 else if (heads>64) heads = 128;
803                 else if (heads>32) heads = 64;
804                 else if (heads>16) heads = 32;
805                 else heads=16;
806                 cylinders = sectors / heads;
807                 break;
808             case ATA_TRANSLATION_RECHS:
809                 // Take care not to overflow
810                 if (heads==16) {
811                     if(cylinders>61439) cylinders=61439;
812                     heads=15;
813                     cylinders = (u16)((u32)(cylinders)*16/15);
814                 }
815                 // then go through the large bitshift process
816             case ATA_TRANSLATION_LARGE:
817                 while(cylinders > 1024) {
818                     cylinders >>= 1;
819                     heads <<= 1;
820
821                     // If we max out the head count
822                     if (heads > 127) break;
823                 }
824                 break;
825             }
826             // clip to 1024 cylinders in lchs
827             if (cylinders > 1024)
828                 cylinders=1024;
829             BX_INFO(" LCHS=%d/%d/%d\n", cylinders, heads, spt);
830
831             SET_EBDA(ata.devices[device].lchs.heads, heads);
832             SET_EBDA(ata.devices[device].lchs.cylinders, cylinders);
833             SET_EBDA(ata.devices[device].lchs.spt, spt);
834
835             // fill hdidmap
836             SET_EBDA(ata.idmap[0][hdcount], device);
837             hdcount++;
838         }
839
840         // Now we send a IDENTIFY command to ATAPI device
841         if(type == ATA_TYPE_ATAPI) {
842
843             u8  type, removable, mode;
844             u16 blksize;
845
846             //Temporary values to do the transfer
847             SET_EBDA(ata.devices[device].device,ATA_DEVICE_CDROM);
848             SET_EBDA(ata.devices[device].mode, ATA_MODE_PIO16);
849
850             u16 ret = ata_cmd_data_in(device,ATA_CMD_IDENTIFY_DEVICE_PACKET
851                                       , 1, 0, 0, 0, 0L
852                                       , GET_SEG(SS), (u32)buffer);
853             if (ret != 0)
854                 BX_PANIC("ata-detect: Failed to detect ATAPI device\n");
855
856             type      = buffer[1] & 0x1f;
857             removable = (buffer[0] & 0x80) ? 1 : 0;
858             mode      = buffer[96] ? ATA_MODE_PIO32 : ATA_MODE_PIO16;
859             blksize   = 2048;
860
861             SET_EBDA(ata.devices[device].device, type);
862             SET_EBDA(ata.devices[device].removable, removable);
863             SET_EBDA(ata.devices[device].mode, mode);
864             SET_EBDA(ata.devices[device].blksize, blksize);
865
866             // fill cdidmap
867             SET_EBDA(ata.idmap[1][cdcount], device);
868             cdcount++;
869         }
870
871         u32 sizeinmb = 0;
872         u16 ataversion;
873         u8  c, i, version=0, model[41];
874
875         switch (type) {
876         case ATA_TYPE_ATA:
877             sizeinmb = GET_EBDA(ata.devices[device].sectors);
878             sizeinmb >>= 11;
879         case ATA_TYPE_ATAPI:
880             // Read ATA/ATAPI version
881             ataversion=((u16)(buffer[161])<<8) | buffer[160];
882             for(version=15;version>0;version--) {
883                 if ((ataversion&(1<<version))!=0)
884                     break;
885             }
886
887             // Read model name
888             for (i=0;i<20;i++) {
889                 model[i*2] = buffer[(i*2)+54+1];
890                 model[(i*2)+1] = buffer[(i*2)+54];
891             }
892
893             // Reformat
894             model[40] = 0x00;
895             for (i=39;i>0;i--) {
896                 if (model[i]==0x20)
897                     model[i] = 0x00;
898                 else
899                     break;
900             }
901             break;
902         }
903
904         switch (type) {
905         case ATA_TYPE_ATA:
906             printf("ata%d %s: ",channel,slave?" slave":"master");
907             i=0;
908             while ((c=model[i++]))
909                 printf("%c",c);
910             if (sizeinmb < (1UL<<16))
911                 printf(" ATA-%d Hard-Disk (%u MBytes)\n", version, (u16)sizeinmb);
912             else
913                 printf(" ATA-%d Hard-Disk (%u GBytes)\n", version, (u16)(sizeinmb>>10));
914             break;
915         case ATA_TYPE_ATAPI:
916             printf("ata%d %s: ",channel,slave?" slave":"master");
917             i=0;
918             while ((c=model[i++]))
919                 printf("%c",c);
920             if (GET_EBDA(ata.devices[device].device)==ATA_DEVICE_CDROM)
921                 printf(" ATAPI-%d CD-Rom/DVD-Rom\n",version);
922             else
923                 printf(" ATAPI-%d Device\n",version);
924             break;
925         case ATA_TYPE_UNKNOWN:
926             printf("ata%d %s: Unknown device\n",channel,slave?" slave":"master");
927             break;
928         }
929     }
930
931     // Store the devices counts
932     SET_EBDA(ata.hdcount, hdcount);
933     SET_EBDA(ata.cdcount, cdcount);
934     SET_BDA(disk_count, hdcount);
935
936     printf("\n");
937
938     // FIXME : should use bios=cmos|auto|disable bits
939     // FIXME : should know about translation bits
940     // FIXME : move hard_drive_post here
941 }