Don't pass segment to ata_cmd_packet.
[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, u16 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), 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     }
502     else {
503         u16 loops = 0;
504         u8 sc;
505         while (1) {
506
507             if (loops == 0) {//first time through
508                 status = inb(iobase2 + ATA_CB_ASTAT);
509                 await_ide(NOT_BSY_DRQ, iobase1, IDE_TIMEOUT);
510             }
511             else
512                 await_ide(NOT_BSY, iobase1, IDE_TIMEOUT);
513             loops++;
514
515             status = inb(iobase1 + ATA_CB_STAT);
516             sc = inb(iobase1 + ATA_CB_SC);
517
518             // Check if command completed
519             if(((inb(iobase1 + ATA_CB_SC)&0x7)==0x3) &&
520                ((status & (ATA_CB_STAT_RDY | ATA_CB_STAT_ERR)) == ATA_CB_STAT_RDY))
521                 break;
522
523             if (status & ATA_CB_STAT_ERR) {
524                 BX_DEBUG_ATA("ata_cmd_packet : error (status %02x)\n",status);
525                 return 3;
526             }
527
528             // Normalize address
529             bufseg += (bufoff / 16);
530             bufoff %= 16;
531
532             // Get the byte count
533             lcount =  ((u16)(inb(iobase1 + ATA_CB_CH))<<8)+inb(iobase1 + ATA_CB_CL);
534
535             // adjust to read what we want
536             if(header>lcount) {
537                 lbefore=lcount;
538                 header-=lcount;
539                 lcount=0;
540             }
541             else {
542                 lbefore=header;
543                 header=0;
544                 lcount-=lbefore;
545             }
546
547             if(lcount>length) {
548                 lafter=lcount-length;
549                 lcount=length;
550                 length=0;
551             }
552             else {
553                 lafter=0;
554                 length-=lcount;
555             }
556
557             // Save byte count
558             count = lcount;
559
560             BX_DEBUG_ATA("Trying to read %04x bytes (%04x %04x %04x) "
561                          ,lbefore+lcount+lafter,lbefore,lcount,lafter);
562             BX_DEBUG_ATA("to 0x%04x:0x%04x\n",bufseg,bufoff);
563
564             // If counts not dividable by 4, use 16bits mode
565             lmode = mode;
566             if (lbefore & 0x03) lmode=ATA_MODE_PIO16;
567             if (lcount  & 0x03) lmode=ATA_MODE_PIO16;
568             if (lafter  & 0x03) lmode=ATA_MODE_PIO16;
569
570             // adds an extra byte if count are odd. before is always even
571             if (lcount & 0x01) {
572                 lcount+=1;
573                 if ((lafter > 0) && (lafter & 0x01)) {
574                     lafter-=1;
575                 }
576             }
577
578             if (lmode == ATA_MODE_PIO32) {
579                 lcount>>=2; lbefore>>=2; lafter>>=2;
580             } else {
581                 lcount>>=1; lbefore>>=1; lafter>>=1;
582             }
583
584             int i;
585             for (i=0; i<lbefore; i++)
586                 if (lmode == ATA_MODE_PIO32)
587                     inl(iobase1);
588                 else
589                     inw(iobase1);
590
591             if (lmode == ATA_MODE_PIO32)
592                 insl(iobase1, bufoff, bufseg, lcount);
593             else
594                 insw(iobase1, bufoff, bufseg, lcount);
595
596             for (i=0; i<lafter; i++)
597                 if (lmode == ATA_MODE_PIO32)
598                     inl(iobase1);
599                 else
600                     inw(iobase1);
601
602             // Compute new buffer address
603             bufoff += count;
604
605             // Save transferred bytes count
606             transfer += count;
607             SET_EBDA(ata.trsfbytes,transfer);
608         }
609     }
610
611     // Final check, device must be ready
612     if ( (status & (ATA_CB_STAT_BSY | ATA_CB_STAT_RDY | ATA_CB_STAT_DF
613                     | ATA_CB_STAT_DRQ | ATA_CB_STAT_ERR) )
614          != ATA_CB_STAT_RDY ) {
615         BX_DEBUG_ATA("ata_cmd_packet : not ready (status %02x)\n"
616                      , (unsigned) status);
617         return 4;
618     }
619
620     // Enable interrupts
621     outb(ATA_CB_DC_HD15, iobase2+ATA_CB_DC);
622     return 0;
623 }
624
625 // ---------------------------------------------------------------------------
626 // ATA/ATAPI driver : device detection
627 // ---------------------------------------------------------------------------
628
629 void
630 ata_detect()
631 {
632     u8  hdcount, cdcount, device, type;
633     u8  buffer[0x0200];
634     memset(buffer, 0, sizeof(buffer));
635
636 #if CONFIG_MAX_ATA_INTERFACES > 0
637     SET_EBDA(ata.channels[0].iface,ATA_IFACE_ISA);
638     SET_EBDA(ata.channels[0].iobase1,0x1f0);
639     SET_EBDA(ata.channels[0].iobase2,0x3f0);
640     SET_EBDA(ata.channels[0].irq,14);
641 #endif
642 #if CONFIG_MAX_ATA_INTERFACES > 1
643     SET_EBDA(ata.channels[1].iface,ATA_IFACE_ISA);
644     SET_EBDA(ata.channels[1].iobase1,0x170);
645     SET_EBDA(ata.channels[1].iobase2,0x370);
646     SET_EBDA(ata.channels[1].irq,15);
647 #endif
648 #if CONFIG_MAX_ATA_INTERFACES > 2
649     SET_EBDA(ata.channels[2].iface,ATA_IFACE_ISA);
650     SET_EBDA(ata.channels[2].iobase1,0x1e8);
651     SET_EBDA(ata.channels[2].iobase2,0x3e0);
652     SET_EBDA(ata.channels[2].irq,12);
653 #endif
654 #if CONFIG_MAX_ATA_INTERFACES > 3
655     SET_EBDA(ata.channels[3].iface,ATA_IFACE_ISA);
656     SET_EBDA(ata.channels[3].iobase1,0x168);
657     SET_EBDA(ata.channels[3].iobase2,0x360);
658     SET_EBDA(ata.channels[3].irq,11);
659 #endif
660 #if CONFIG_MAX_ATA_INTERFACES > 4
661 #error Please fill the ATA interface informations
662 #endif
663
664     // Device detection
665     hdcount=cdcount=0;
666
667     for(device=0; device<CONFIG_MAX_ATA_DEVICES; device++) {
668         u16 iobase1, iobase2;
669         u8  channel, slave, shift;
670         u8  sc, sn, cl, ch, st;
671
672         channel = device / 2;
673         slave = device % 2;
674
675         iobase1 =GET_EBDA(ata.channels[channel].iobase1);
676         iobase2 =GET_EBDA(ata.channels[channel].iobase2);
677
678         // Disable interrupts
679         outb(ATA_CB_DC_HD15 | ATA_CB_DC_NIEN, iobase2+ATA_CB_DC);
680
681         // Look for device
682         outb(slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0, iobase1+ATA_CB_DH);
683         outb(0x55, iobase1+ATA_CB_SC);
684         outb(0xaa, iobase1+ATA_CB_SN);
685         outb(0xaa, iobase1+ATA_CB_SC);
686         outb(0x55, iobase1+ATA_CB_SN);
687         outb(0x55, iobase1+ATA_CB_SC);
688         outb(0xaa, iobase1+ATA_CB_SN);
689
690         // If we found something
691         sc = inb(iobase1+ATA_CB_SC);
692         sn = inb(iobase1+ATA_CB_SN);
693
694         if ( (sc == 0x55) && (sn == 0xaa) ) {
695             SET_EBDA(ata.devices[device].type,ATA_TYPE_UNKNOWN);
696
697             // reset the channel
698             ata_reset(device);
699
700             // check for ATA or ATAPI
701             outb(slave ? ATA_CB_DH_DEV1 : ATA_CB_DH_DEV0, iobase1+ATA_CB_DH);
702             sc = inb(iobase1+ATA_CB_SC);
703             sn = inb(iobase1+ATA_CB_SN);
704             if ((sc==0x01) && (sn==0x01)) {
705                 cl = inb(iobase1+ATA_CB_CL);
706                 ch = inb(iobase1+ATA_CB_CH);
707                 st = inb(iobase1+ATA_CB_STAT);
708
709                 if ((cl==0x14) && (ch==0xeb)) {
710                     SET_EBDA(ata.devices[device].type,ATA_TYPE_ATAPI);
711                 } else if ((cl==0x00) && (ch==0x00) && (st!=0x00)) {
712                     SET_EBDA(ata.devices[device].type,ATA_TYPE_ATA);
713                 } else if ((cl==0xff) && (ch==0xff)) {
714                     SET_EBDA(ata.devices[device].type,ATA_TYPE_NONE);
715                 }
716             }
717         }
718
719         type=GET_EBDA(ata.devices[device].type);
720
721         // Now we send a IDENTIFY command to ATA device
722         if(type == ATA_TYPE_ATA) {
723             u32 sectors;
724             u16 cylinders, heads, spt, blksize;
725             u8  translation, removable, mode;
726
727             //Temporary values to do the transfer
728             SET_EBDA(ata.devices[device].device,ATA_DEVICE_HD);
729             SET_EBDA(ata.devices[device].mode, ATA_MODE_PIO16);
730
731             u16 ret = ata_cmd_data_in(device,ATA_CMD_IDENTIFY_DEVICE
732                                       , 1, 0, 0, 0, 0L
733                                       , GET_SEG(SS), (u32)buffer);
734             if (ret)
735                 BX_PANIC("ata-detect: Failed to detect ATA device\n");
736
737             removable = (buffer[0] & 0x80) ? 1 : 0;
738             mode      = buffer[96] ? ATA_MODE_PIO32 : ATA_MODE_PIO16;
739             blksize   = *(u16*)&buffer[10];
740
741             cylinders = *(u16*)&buffer[1*2]; // word 1
742             heads     = *(u16*)&buffer[3*2]; // word 3
743             spt       = *(u16*)&buffer[6*2]; // word 6
744
745             sectors   = *(u32*)&buffer[60*2]; // word 60 and word 61
746
747             SET_EBDA(ata.devices[device].device,ATA_DEVICE_HD);
748             SET_EBDA(ata.devices[device].removable, removable);
749             SET_EBDA(ata.devices[device].mode, mode);
750             SET_EBDA(ata.devices[device].blksize, blksize);
751             SET_EBDA(ata.devices[device].pchs.heads, heads);
752             SET_EBDA(ata.devices[device].pchs.cylinders, cylinders);
753             SET_EBDA(ata.devices[device].pchs.spt, spt);
754             SET_EBDA(ata.devices[device].sectors, sectors);
755             BX_INFO("ata%d-%d: PCHS=%u/%d/%d translation=", channel, slave,cylinders, heads, spt);
756
757             translation = inb_cmos(CMOS_BIOS_DISKTRANSFLAG + channel/2);
758             for (shift=device%4; shift>0; shift--)
759                 translation >>= 2;
760             translation &= 0x03;
761
762             SET_EBDA(ata.devices[device].translation, translation);
763
764             switch (translation) {
765             case ATA_TRANSLATION_NONE:
766                 BX_INFO("none");
767                 break;
768             case ATA_TRANSLATION_LBA:
769                 BX_INFO("lba");
770                 break;
771             case ATA_TRANSLATION_LARGE:
772                 BX_INFO("large");
773                 break;
774             case ATA_TRANSLATION_RECHS:
775                 BX_INFO("r-echs");
776                 break;
777             }
778             switch (translation) {
779             case ATA_TRANSLATION_NONE:
780                 break;
781             case ATA_TRANSLATION_LBA:
782                 spt = 63;
783                 sectors /= 63;
784                 heads = sectors / 1024;
785                 if (heads>128) heads = 255;
786                 else if (heads>64) heads = 128;
787                 else if (heads>32) heads = 64;
788                 else if (heads>16) heads = 32;
789                 else heads=16;
790                 cylinders = sectors / heads;
791                 break;
792             case ATA_TRANSLATION_RECHS:
793                 // Take care not to overflow
794                 if (heads==16) {
795                     if(cylinders>61439) cylinders=61439;
796                     heads=15;
797                     cylinders = (u16)((u32)(cylinders)*16/15);
798                 }
799                 // then go through the large bitshift process
800             case ATA_TRANSLATION_LARGE:
801                 while(cylinders > 1024) {
802                     cylinders >>= 1;
803                     heads <<= 1;
804
805                     // If we max out the head count
806                     if (heads > 127) break;
807                 }
808                 break;
809             }
810             // clip to 1024 cylinders in lchs
811             if (cylinders > 1024)
812                 cylinders=1024;
813             BX_INFO(" LCHS=%d/%d/%d\n", cylinders, heads, spt);
814
815             SET_EBDA(ata.devices[device].lchs.heads, heads);
816             SET_EBDA(ata.devices[device].lchs.cylinders, cylinders);
817             SET_EBDA(ata.devices[device].lchs.spt, spt);
818
819             // fill hdidmap
820             SET_EBDA(ata.hdidmap[hdcount], device);
821             hdcount++;
822         }
823
824         // Now we send a IDENTIFY command to ATAPI device
825         if(type == ATA_TYPE_ATAPI) {
826
827             u8  type, removable, mode;
828             u16 blksize;
829
830             //Temporary values to do the transfer
831             SET_EBDA(ata.devices[device].device,ATA_DEVICE_CDROM);
832             SET_EBDA(ata.devices[device].mode, ATA_MODE_PIO16);
833
834             u16 ret = ata_cmd_data_in(device,ATA_CMD_IDENTIFY_DEVICE_PACKET
835                                       , 1, 0, 0, 0, 0L
836                                       , GET_SEG(SS), (u32)buffer);
837             if (ret != 0)
838                 BX_PANIC("ata-detect: Failed to detect ATAPI device\n");
839
840             type      = buffer[1] & 0x1f;
841             removable = (buffer[0] & 0x80) ? 1 : 0;
842             mode      = buffer[96] ? ATA_MODE_PIO32 : ATA_MODE_PIO16;
843             blksize   = 2048;
844
845             SET_EBDA(ata.devices[device].device, type);
846             SET_EBDA(ata.devices[device].removable, removable);
847             SET_EBDA(ata.devices[device].mode, mode);
848             SET_EBDA(ata.devices[device].blksize, blksize);
849
850             // fill cdidmap
851             SET_EBDA(ata.cdidmap[cdcount], device);
852             cdcount++;
853         }
854
855         u32 sizeinmb = 0;
856         u16 ataversion;
857         u8  c, i, version=0, model[41];
858
859         switch (type) {
860         case ATA_TYPE_ATA:
861             sizeinmb = GET_EBDA(ata.devices[device].sectors);
862             sizeinmb >>= 11;
863         case ATA_TYPE_ATAPI:
864             // Read ATA/ATAPI version
865             ataversion=((u16)(buffer[161])<<8) | buffer[160];
866             for(version=15;version>0;version--) {
867                 if ((ataversion&(1<<version))!=0)
868                     break;
869             }
870
871             // Read model name
872             for (i=0;i<20;i++) {
873                 model[i*2] = buffer[(i*2)+54+1];
874                 model[(i*2)+1] = buffer[(i*2)+54];
875             }
876
877             // Reformat
878             model[40] = 0x00;
879             for (i=39;i>0;i--) {
880                 if (model[i]==0x20)
881                     model[i] = 0x00;
882                 else
883                     break;
884             }
885             break;
886         }
887
888         switch (type) {
889         case ATA_TYPE_ATA:
890             printf("ata%d %s: ",channel,slave?" slave":"master");
891             i=0;
892             while ((c=model[i++]))
893                 printf("%c",c);
894             if (sizeinmb < (1UL<<16))
895                 printf(" ATA-%d Hard-Disk (%u MBytes)\n", version, (u16)sizeinmb);
896             else
897                 printf(" ATA-%d Hard-Disk (%u GBytes)\n", version, (u16)(sizeinmb>>10));
898             break;
899         case ATA_TYPE_ATAPI:
900             printf("ata%d %s: ",channel,slave?" slave":"master");
901             i=0;
902             while ((c=model[i++]))
903                 printf("%c",c);
904             if (GET_EBDA(ata.devices[device].device)==ATA_DEVICE_CDROM)
905                 printf(" ATAPI-%d CD-Rom/DVD-Rom\n",version);
906             else
907                 printf(" ATAPI-%d Device\n",version);
908             break;
909         case ATA_TYPE_UNKNOWN:
910             printf("ata%d %s: Unknown device\n",channel,slave?" slave":"master");
911             break;
912         }
913     }
914
915     // Store the devices counts
916     SET_EBDA(ata.hdcount, hdcount);
917     SET_EBDA(ata.cdcount, cdcount);
918     SET_BDA(disk_count, hdcount);
919
920     printf("\n");
921
922     // FIXME : should use bios=cmos|auto|disable bits
923     // FIXME : should know about translation bits
924     // FIXME : move hard_drive_post here
925 }