Renamed ATA core to main.c
[tpg/acess2.git] / Modules / ATA / main.c
1 /*
2  * Acess2 IDE Harddisk Driver
3  * - main.c
4  */
5 #define DEBUG   0
6 #include <acess.h>
7 #include <modules.h>
8 #include <vfs.h>
9 #include <fs_devfs.h>
10 #include <drv_pci.h>
11 #include <tpl_drv_common.h>
12 #include <tpl_drv_disk.h>
13
14 // --- Flags ---
15 #define START_BEFORE_CMD        0
16
17 // === CONSTANTS ===
18 #define MAX_ATA_DISKS   4
19 #define SECTOR_SIZE             512
20 #define MAX_DMA_SECTORS (0x1000 / SECTOR_SIZE)
21
22 #define IDE_PRI_BASE    0x1F0
23 #define IDE_SEC_BASE    0x170
24
25 #define IDE_PRDT_LAST   0x8000
26 /**
27  \enum HddControls
28  \brief Commands to be sent to HDD_CMD
29 */
30 enum HddControls {
31         HDD_PIO_R28 = 0x20,
32         HDD_PIO_R48 = 0x24,
33         HDD_DMA_R48 = 0x25,
34         HDD_PIO_W28 = 0x30,
35         HDD_PIO_W48 = 0x34,
36         HDD_DMA_W48 = 0x35,
37         HDD_DMA_R28 = 0xC8,
38         HDD_DMA_W28 = 0xCA,
39 };
40
41 // === STRUCTURES ===
42 typedef struct {
43         Uint32  PBufAddr;
44         Uint16  Bytes;
45         Uint16  Flags;
46 } tPRDT_Ent;
47 typedef struct {
48         Uint16  Flags;          // 1
49         Uint16  Usused1[9];     // 10
50         char    SerialNum[20];  // 20
51         Uint16  Usused2[3];     // 23
52         char    FirmwareVer[8]; // 27
53         char    ModelNumber[40];        // 47
54         Uint16  SectPerInt;     // 48 - and with 0xFF to get true value;
55         Uint16  Unused3;        // 49
56         Uint16  Capabilities[2];        // 51
57         Uint16  Unused4[2];     // 53
58         Uint16  ValidExtData;   // 54
59         Uint16  Unused5[5];      // 59
60         Uint16  SizeOfRWMultiple;       // 60
61         Uint32  Sectors28;      // 62
62         Uint16  Unused6[100-62];
63         Uint64  Sectors48;
64         Uint16  Unused7[256-104];
65 } tIdentify;
66 typedef struct {
67         Uint8   BootCode[0x1BE];
68         struct {
69                 Uint8   Boot;
70                 Uint8   Unused1;        // Also CHS Start
71                 Uint16  StartHi;        // Also CHS Start
72                 Uint8   SystemID;
73                 Uint8   Unused2;        // Also CHS Length
74                 Uint16  LengthHi;       // Also CHS Length
75                 Uint32  LBAStart;
76                 Uint32  LBALength;
77         } __attribute__ ((packed)) Parts[4];
78         Uint16  BootFlag;       // = 0xAA 55
79 } __attribute__ ((packed)) tMBR;
80
81 typedef struct {
82         Uint64  Start;
83         Uint64  Length;
84         char    Name[4];
85         tVFS_Node       Node;
86 } tATA_Partition;
87 typedef struct {
88         Uint64  Sectors;
89         char    Name[2];
90         tVFS_Node       Node;
91          int    NumPartitions;
92         tATA_Partition  *Partitions;
93 } tATA_Disk;
94
95 // === PROTOTYPES ===
96  int    ATA_Install();
97  int    ATA_SetupIO();
98 void    ATA_SetupPartitions();
99 void    ATA_SetupVFS();
100  int    ATA_ScanDisk(int Disk);
101 void    ATA_ParseGPT(int Disk);
102 void    ATA_ParseMBR(int Disk);
103 void    ATA_int_MakePartition(tATA_Partition *Part, int Disk, int Num, Uint64 Start, Uint64 Length);
104 Uint16  ATA_GetBasePort(int Disk);
105 // Filesystem Interface
106 char    *ATA_ReadDir(tVFS_Node *Node, int Pos);
107 tVFS_Node       *ATA_FindDir(tVFS_Node *Node, char *Name);
108 Uint64  ATA_ReadFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
109 Uint64  ATA_WriteFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
110  int    ATA_IOCtl(tVFS_Node *Node, int Id, void *Data);
111 // Read/Write Interface/Quantiser
112 Uint    ATA_ReadRaw(Uint64 Address, Uint Count, void *Buffer, Uint Disk);
113 Uint    ATA_WriteRaw(Uint64 Address, Uint Count, void *Buffer, Uint Disk);
114 // Read/Write DMA
115  int    ATA_ReadDMA(Uint8 Disk, Uint64 Address, Uint Count, void *Buffer);
116  int    ATA_WriteDMA(Uint8 Disk, Uint64 Address, Uint Count, void *Buffer);
117 // IRQs
118 void    ATA_IRQHandlerPri(int unused);
119 void    ATA_IRQHandlerSec(int unused);
120 // Controller IO
121 Uint8   ATA_int_BusMasterReadByte(int Ofs);
122 void    ATA_int_BusMasterWriteByte(int Ofs, Uint8 Value);
123 void    ATA_int_BusMasterWriteDWord(int Ofs, Uint32 Value);
124
125 // === GLOBALS ===
126 MODULE_DEFINE(0, 0x0032, i386ATA, ATA_Install, NULL, NULL);
127 tDevFS_Driver   gATA_DriverInfo = {
128         NULL, "ata",
129         {
130                 .NumACLs = 1,
131                 .Size = -1,
132                 .Flags = VFS_FFLAG_DIRECTORY,
133                 .ACLs = &gVFS_ACL_EveryoneRX,
134                 .ReadDir = ATA_ReadDir,
135                 .FindDir = ATA_FindDir
136         }
137 };
138 tATA_Disk       gATA_Disks[MAX_ATA_DISKS];
139  int    giATA_NumNodes;
140 tVFS_Node       **gATA_Nodes;
141 Uint16  gATA_BusMasterBase = 0;
142 Uint8   *gATA_BusMasterBasePtr = 0;
143  int    gATA_IRQPri = 14;
144  int    gATA_IRQSec = 15;
145  int    giaATA_ControllerLock[2] = {0}; //!< Spinlocks for each controller
146 Uint8   gATA_Buffers[2][4096] __attribute__ ((section(".padata")));
147  int    gaATA_IRQs[2] = {0};
148 tPRDT_Ent       gATA_PRDTs[2] = {
149         {0, 512, IDE_PRDT_LAST},
150         {0, 512, IDE_PRDT_LAST}
151 };
152
153 // === CODE ===
154 /**
155  * \fn int ATA_Install()
156  */
157 int ATA_Install()
158 {
159         int     ret;
160         
161         ret = ATA_SetupIO();
162         if(ret != 1)    return ret;
163         
164         ATA_SetupPartitions();
165         
166         ATA_SetupVFS();
167         
168         if( DevFS_AddDevice( &gATA_DriverInfo ) == 0 )
169                 return MODULE_INIT_FAILURE;
170         
171         return MODULE_INIT_SUCCESS;
172 }
173
174 /**
175  * \fn int ATA_SetupIO()
176  * \brief Sets up the ATA controller's DMA mode
177  */
178 int ATA_SetupIO()
179 {
180          int    ent;
181         tPAddr  addr;
182         
183         ENTER("");
184         
185         // Get IDE Controller's PCI Entry
186         ent = PCI_GetDeviceByClass(0x0101, 0xFFFF, -1);
187         LOG("ent = %i", ent);
188         gATA_BusMasterBase = PCI_GetBAR4( ent );
189         if( gATA_BusMasterBase == 0 ) {
190                 Warning("It seems that there is no Bus Master Controller on this machine. Get one");
191                 LEAVE('i', MODULE_INIT_FAILURE);
192                 return MODULE_INIT_FAILURE;
193         }
194         if( !(gATA_BusMasterBase & 1) )
195         {
196                 if( gATA_BusMasterBase < 0x100000 )
197                         gATA_BusMasterBasePtr = (void*)(0xC0000000|gATA_BusMasterBase);
198                 else
199                         gATA_BusMasterBasePtr = (void*)( MM_MapHWPage( gATA_BusMasterBase, 1 ) + (gATA_BusMasterBase&0xFFF) );
200                 LOG("gATA_BusMasterBasePtr = %p", gATA_BusMasterBasePtr);
201         }
202         else {
203                 // Bit 0 is left set as a flag to other functions
204                 LOG("gATA_BusMasterBase = 0x%x", gATA_BusMasterBase & ~1);
205         }
206         
207         IRQ_AddHandler( gATA_IRQPri, ATA_IRQHandlerPri );
208         IRQ_AddHandler( gATA_IRQSec, ATA_IRQHandlerSec );
209         
210         gATA_PRDTs[0].PBufAddr = MM_GetPhysAddr( (Uint)&gATA_Buffers[0] );
211         gATA_PRDTs[1].PBufAddr = MM_GetPhysAddr( (Uint)&gATA_Buffers[1] );
212         
213         LOG("gATA_PRDTs = {PBufAddr: 0x%x, PBufAddr: 0x%x}", gATA_PRDTs[0].PBufAddr, gATA_PRDTs[1].PBufAddr);
214         
215         addr = MM_GetPhysAddr( (Uint)&gATA_PRDTs[0] );
216         LOG("addr = 0x%x", addr);
217         ATA_int_BusMasterWriteDWord(4, addr);
218         addr = MM_GetPhysAddr( (Uint)&gATA_PRDTs[1] );
219         LOG("addr = 0x%x", addr);
220         ATA_int_BusMasterWriteDWord(12, addr);
221         
222         outb(IDE_PRI_BASE+1, 1);
223         outb(IDE_SEC_BASE+1, 1);
224         
225         LEAVE('i', MODULE_INIT_SUCCESS);
226         return MODULE_INIT_SUCCESS;
227 }
228
229 /**
230  * \fn void ATA_SetupPartitions()
231  */
232 void ATA_SetupPartitions()
233 {
234          int    i;
235         for( i = 0; i < MAX_ATA_DISKS; i ++ )
236         {
237                 if( !ATA_ScanDisk(i) ) {
238                         gATA_Disks[i].Name[0] = '\0';   // Mark as unused
239                         continue;
240                 }
241         }
242 }
243
244 /**
245  * \fn void ATA_SetupVFS()
246  * \brief Sets up the ATA drivers VFS information and registers with DevFS
247  */
248 void ATA_SetupVFS()
249 {
250          int    i, j, k;
251         
252         // Count number of nodes needed
253         giATA_NumNodes = 0;
254         for( i = 0; i < MAX_ATA_DISKS; i++ )
255         {
256                 if(gATA_Disks[i].Name[0] == '\0')       continue;       // Ignore
257                 giATA_NumNodes ++;
258                 giATA_NumNodes += gATA_Disks[i].NumPartitions;
259         }
260         
261         // Allocate Node space
262         gATA_Nodes = malloc( giATA_NumNodes * sizeof(void*) );
263         
264         // Set nodes
265         k = 0;
266         for( i = 0; i < MAX_ATA_DISKS; i++ )
267         {
268                 if(gATA_Disks[i].Name[0] == '\0')       continue;       // Ignore
269                 gATA_Nodes[ k++ ] = &gATA_Disks[i].Node;
270                 for( j = 0; j < gATA_Disks[i].NumPartitions; j ++ )
271                         gATA_Nodes[ k++ ] = &gATA_Disks[i].Partitions[j].Node;
272         }
273         
274         gATA_DriverInfo.RootNode.Size = giATA_NumNodes;
275 }
276
277 /**
278  * \fn int ATA_ScanDisk(int Disk)
279  */
280 int ATA_ScanDisk(int Disk)
281 {
282         Uint16  buf[256];
283         tIdentify       *identify = (void*)buf;
284         tMBR    *mbr = (void*)buf;
285         Uint16  base;
286         Uint8   val;
287          int    i;
288         tVFS_Node       *node;
289         
290         ENTER("iDisk", Disk);
291         
292         base = ATA_GetBasePort( Disk );
293         
294         LOG("base = 0x%x", base);
295         
296         // Send Disk Selector
297         if(Disk == 1 || Disk == 3)
298                 outb(base+6, 0xB0);
299         else
300                 outb(base+6, 0xA0);
301         
302         // Send IDENTIFY
303         outb(base+7, 0xEC);
304         val = inb(base+7);      // Read status
305         if(val == 0) {
306                 LEAVE('i', 0);
307                 return 0;       // Disk does not exist
308         }
309         
310         // Poll until BSY clears and DRQ sets or ERR is set
311         while( ((val & 0x80) || !(val & 0x08)) && !(val & 1))   val = inb(base+7);
312         
313         if(val & 1) {
314                 LEAVE('i', 0);
315                 return 0;       // Error occured, so return false
316         }
317         
318         // Read Data
319         for(i=0;i<256;i++)      buf[i] = inw(base);
320         
321         // Populate Disk Structure
322         if(identify->Sectors48 != 0)
323                 gATA_Disks[ Disk ].Sectors = identify->Sectors48;
324         else
325                 gATA_Disks[ Disk ].Sectors = identify->Sectors28;
326         
327         
328         LOG("gATA_Disks[ Disk ].Sectors = 0x%x", gATA_Disks[ Disk ].Sectors);
329         
330         if( gATA_Disks[ Disk ].Sectors / (2048*1024) )
331                 Log("Disk %i: 0x%llx Sectors (%i GiB)", Disk,
332                         gATA_Disks[ Disk ].Sectors, gATA_Disks[ Disk ].Sectors / (2048*1024));
333         else if( gATA_Disks[ Disk ].Sectors / 2048 )
334                 Log("Disk %i: 0x%llx Sectors (%i MiB)", Disk,
335                         gATA_Disks[ Disk ].Sectors, gATA_Disks[ Disk ].Sectors / 2048);
336         else
337                 Log("Disk %i: 0x%llx Sectors (%i KiB)", Disk,
338                         gATA_Disks[ Disk ].Sectors, gATA_Disks[ Disk ].Sectors / 2);
339         
340         // Create Name
341         gATA_Disks[ Disk ].Name[0] = 'A'+Disk;
342         gATA_Disks[ Disk ].Name[1] = '\0';
343         
344         // Get pointer to vfs node and populate it
345         node = &gATA_Disks[ Disk ].Node;
346         node->Size = gATA_Disks[Disk].Sectors * SECTOR_SIZE;
347         node->NumACLs = 0;      // Means Superuser only can access it
348         node->Inode = (Disk << 8) | 0xFF;
349         node->ImplPtr = gATA_Disks[ Disk ].Name;
350         
351         node->ATime = node->MTime
352                 = node->CTime = now();
353         
354         node->Read = ATA_ReadFS;
355         node->Write = ATA_WriteFS;
356         node->IOCtl = ATA_IOCtl;
357
358
359         // --- Scan Partitions ---
360         LOG("Reading MBR");
361         // Read Boot Sector
362         ATA_ReadDMA( Disk, 0, 1, mbr );
363         
364         // Check for a GPT table
365         if(mbr->Parts[0].SystemID == 0xEE)
366                 ATA_ParseGPT(Disk);
367         else    // No? Just parse the MBR
368                 ATA_ParseMBR(Disk);
369         
370         LEAVE('i', 0);
371         return 1;
372 }
373
374 /**
375  * \fn void ATA_ParseGPT(int Disk)
376  * \brief Parses the GUID Partition Table
377  */
378 void ATA_ParseGPT(int Disk)
379 {
380         ///\todo Support GPT Disks
381         Warning("GPT Disks are currently unsupported");
382 }
383
384 /**
385  * \fn void ATA_ParseMBR(int Disk)
386  */
387 void ATA_ParseMBR(int Disk)
388 {
389          int    i, j = 0, k = 4;
390         tMBR    mbr;
391         Uint64  extendedLBA;
392         
393         ENTER("iDisk", Disk);
394         
395         // Read Boot Sector
396         ATA_ReadDMA( Disk, 0, 1, &mbr );
397         
398         // Count Partitions
399         gATA_Disks[Disk].NumPartitions = 0;
400         extendedLBA = 0;
401         for( i = 0; i < 4; i ++ )
402         {
403                 if( mbr.Parts[i].SystemID == 0 )        continue;
404                 if(
405                         mbr.Parts[i].Boot == 0x0 || mbr.Parts[i].Boot == 0x80   // LBA 28
406                 ||      mbr.Parts[i].Boot == 0x1 || mbr.Parts[i].Boot == 0x81   // LBA 48
407                         )
408                 {
409                         if( mbr.Parts[i].SystemID == 0xF || mbr.Parts[i].SystemID == 5 ) {
410                                 LOG("Extended Partition");
411                                 if(extendedLBA != 0) {
412                                         Warning("Disk %i has multiple extended partitions, ignoring rest", Disk);
413                                         continue;
414                                 }
415                                 extendedLBA = mbr.Parts[i].LBAStart;
416                                 continue;
417                         }
418                         LOG("Primary Partition");
419                         
420                         gATA_Disks[Disk].NumPartitions ++;
421                         continue;
422                 }
423                 // Invalid Partition, so don't count it
424         }
425         while(extendedLBA != 0)
426         {
427                 if( ATA_ReadDMA( Disk, extendedLBA, 1, &mbr ) != 0 )
428                         break;  // Stop on Errors
429                 
430                 extendedLBA = 0;
431                 
432                 if( mbr.Parts[0].SystemID == 0 )        continue;
433                 if(     mbr.Parts[0].Boot == 0x0 || mbr.Parts[0].Boot == 0x80   // LBA 28
434                 ||      mbr.Parts[0].Boot == 0x1 || mbr.Parts[0].Boot == 0x81   // LBA 48
435                         )
436                 {
437                         if(mbr.Parts[0].SystemID == 0xF || mbr.Parts[0].SystemID == 0x7)
438                                 extendedLBA = mbr.Parts[0].LBAStart;
439                         else
440                                 gATA_Disks[Disk].NumPartitions ++;
441                 }
442                 
443                 if( mbr.Parts[1].SystemID == 0 )        continue;
444                 if(     mbr.Parts[1].Boot == 0x0 || mbr.Parts[1].Boot == 0x80   // LBA 28
445                 ||      mbr.Parts[1].Boot == 0x1 || mbr.Parts[1].Boot == 0x81   // LBA 48
446                         )
447                 {
448                         if(mbr.Parts[1].SystemID == 0xF || mbr.Parts[1].SystemID == 0x7) {
449                                 if(extendedLBA == 0) {
450                                         Warning("Disk %i has twp forward link in the extended partition",
451                                                 Disk);
452                                         break;
453                                 }
454                                 extendedLBA = mbr.Parts[1].LBAStart;
455                         }
456                         else {
457                                 if(extendedLBA != 0) {
458                                         Warning("Disk %i lacks a forward link in the extended partition",
459                                                 Disk);
460                                         break;
461                                 }
462                                 gATA_Disks[Disk].NumPartitions ++;
463                         }
464                 }
465         }
466         LOG("gATA_Disks[Disk].NumPartitions = %i", gATA_Disks[Disk].NumPartitions);
467         
468         // Create patition array
469         gATA_Disks[Disk].Partitions = malloc( gATA_Disks[Disk].NumPartitions * sizeof(tATA_Partition) );
470         
471         // --- Fill Partition Info ---
472         extendedLBA = 0;
473         for( i = 0; i < 4; i ++ )
474         {
475                 Log("mbr.Parts[%i].SystemID = 0x%02x", i, mbr.Parts[i].SystemID);
476                 if( mbr.Parts[i].SystemID == 0 )        continue;
477                 if(     mbr.Parts[i].Boot == 0x0 || mbr.Parts[i].Boot == 0x80 ) // LBA 28
478                 {
479                         if( mbr.Parts[1].SystemID == 0xF || mbr.Parts[1].SystemID == 5 ) {
480                                 if(extendedLBA != 0) {
481                                         Warning("Disk %i has multiple extended partitions, ignoring rest", Disk);
482                                         continue;
483                                 }
484                                 extendedLBA = mbr.Parts[1].LBAStart;
485                                 continue;
486                         }
487                         // Create Partition
488                         ATA_int_MakePartition( &gATA_Disks[Disk].Partitions[j], Disk, i,
489                                 mbr.Parts[i].LBAStart, mbr.Parts[i].LBALength
490                                 );
491                         j ++;
492                         continue;
493                 }
494                 if(     mbr.Parts[i].Boot == 0x1 || mbr.Parts[i].Boot == 0x81 ) // LBA 48
495                 {
496                         if( mbr.Parts[i].SystemID == 0xF || mbr.Parts[i].SystemID == 5 ) {
497                                 if(extendedLBA != 0) {
498                                         Warning("Disk %i has multiple extended partitions, ignoring rest", Disk);
499                                         continue;
500                                 }
501                                 extendedLBA = (mbr.Parts[i].StartHi << 16) | mbr.Parts[i].LBAStart;
502                                 continue;
503                         }
504                         ATA_int_MakePartition( &gATA_Disks[Disk].Partitions[j], Disk, i,
505                                 (mbr.Parts[i].StartHi << 16) | mbr.Parts[i].LBAStart,
506                                 (mbr.Parts[i].LengthHi << 16) | mbr.Parts[i].LBALength
507                                 );
508                         j ++;
509                 }
510                 // Invalid Partition, so don't count it
511         }
512         // Scan extended partition
513         while(extendedLBA != 0)
514         {
515                 if( ATA_ReadDMA( Disk, extendedLBA, 1, &mbr ) != 0 )
516                         break;  // Stop on Errors
517                 
518                 extendedLBA = 0;
519                 
520                 // Check first entry (should be partition)
521                 if( mbr.Parts[0].SystemID != 0)
522                 {
523                         if( mbr.Parts[0].Boot == 0x0 || mbr.Parts[0].Boot == 0x80 )     // LBA 28
524                         {
525                                 // Forward Link to next Extended partition entry
526                                 if(mbr.Parts[0].SystemID == 0xF || mbr.Parts[0].SystemID == 0x7)
527                                         extendedLBA = mbr.Parts[0].LBAStart;
528                                 else {
529                                         ATA_int_MakePartition( &gATA_Disks[Disk].Partitions[j], Disk, k,
530                                                 mbr.Parts[0].LBAStart, mbr.Parts[0].LBALength
531                                                 );
532                                         j ++;   k ++;
533                                 }
534                         }
535                         else if( mbr.Parts[0].Boot == 0x1 || mbr.Parts[0].Boot == 0x81 )        // LBA 48
536                         {
537                                 if(mbr.Parts[0].SystemID == 0xF || mbr.Parts[0].SystemID == 0x7)
538                                         extendedLBA = (mbr.Parts[0].StartHi << 16) | mbr.Parts[0].LBAStart;
539                                 else {
540                                         ATA_int_MakePartition( &gATA_Disks[Disk].Partitions[j], Disk, k,
541                                                 (mbr.Parts[0].StartHi << 16) | mbr.Parts[0].LBAStart,
542                                                 (mbr.Parts[0].LengthHi << 16) | mbr.Parts[0].LBALength
543                                                 );
544                                         j ++;   k ++;
545                                 }
546                         }
547                 }
548                 
549                 // Check second entry (should be forward link)
550                 if( mbr.Parts[1].SystemID != 0)
551                 {
552                         if(mbr.Parts[1].Boot == 0x0 || mbr.Parts[1].Boot == 0x80 )      // LBA 28
553                         {
554                                 if(mbr.Parts[1].SystemID == 0xF || mbr.Parts[1].SystemID == 0x7) {
555                                         if(extendedLBA == 0) {
556                                                 Warning("Disk %i has twp forward link in the extended partition",
557                                                         Disk);
558                                                 break;
559                                         }
560                                         extendedLBA = mbr.Parts[1].LBAStart;
561                                 }
562                                 else
563                                 {
564                                         if(extendedLBA != 0) {
565                                                 Warning("Disk %i lacks a forward link in the extended partition",
566                                                         Disk);
567                                                 break;
568                                         }
569                                         ATA_int_MakePartition( &gATA_Disks[Disk].Partitions[j], Disk, k,
570                                                 mbr.Parts[1].LBAStart, mbr.Parts[1].LBALength
571                                                 );
572                                         j ++;   k ++;
573                                 }
574                                 
575                         }
576                         else if( mbr.Parts[1].Boot == 0x1 || mbr.Parts[1].Boot == 0x81 )        // LBA 48
577                         {
578                                 if(mbr.Parts[1].SystemID == 0xF || mbr.Parts[1].SystemID == 0x7) {
579                                         if(extendedLBA == 0) {
580                                                 Warning("Disk %i has twp forward link in the extended partition",
581                                                         Disk);
582                                                 break;
583                                         }
584                                         extendedLBA = (mbr.Parts[1].StartHi << 16) | mbr.Parts[1].LBAStart;
585                                 }
586                                 else
587                                 {
588                                         if(extendedLBA != 0) {
589                                                 Warning("Disk %i lacks a forward link in the extended partition",
590                                                         Disk);
591                                                 break;
592                                         }
593                                         ATA_int_MakePartition( &gATA_Disks[Disk].Partitions[j], Disk, k,
594                                                 (mbr.Parts[1].StartHi << 16) | mbr.Parts[1].LBAStart,
595                                                 (mbr.Parts[1].LengthHi << 16) | mbr.Parts[1].LBALength
596                                                 );
597                                         j ++;   k ++;
598                                 }
599                         }
600                 }
601         }
602         
603         LEAVE('-');
604 }
605
606 /**
607  * \fn void ATA_int_MakePartition(tATA_Partition *Part, int Disk, int Num, Uint64 Start, Uint64 Length)
608  * \brief Fills a parition's information structure
609  */
610 void ATA_int_MakePartition(tATA_Partition *Part, int Disk, int Num, Uint64 Start, Uint64 Length)
611 {
612         ENTER("pPart iDisk iNum XStart XLength", Part, Disk, Num, Start, Length);
613         Part->Start = Start;
614         Part->Length = Length;
615         Part->Name[0] = 'A'+Disk;
616         if(Num >= 10) {
617                 Part->Name[1] = '1'+Num/10;
618                 Part->Name[2] = '1'+Num%10;
619                 Part->Name[3] = '\0';
620         } else {
621                 Part->Name[1] = '1'+Num;
622                 Part->Name[2] = '\0';
623         }
624         Part->Node.NumACLs = 0; // Only root can read/write raw block devices
625         Part->Node.Inode = (Disk << 8) | Num;
626         Part->Node.ImplPtr = Part->Name;
627         
628         Part->Node.Read = ATA_ReadFS;
629         Part->Node.Write = ATA_WriteFS;
630         Part->Node.IOCtl = ATA_IOCtl;
631         LOG("Made '%s' (&Node=%p)", Part->Name, &Part->Node);
632         LEAVE('-');
633 }
634
635 /**
636  * \fn Uint16 ATA_GetPortBase(int Disk)
637  * \brief Returns the base port for a given disk
638  */
639 Uint16 ATA_GetBasePort(int Disk)
640 {
641         switch(Disk)
642         {
643         case 0: case 1:         return IDE_PRI_BASE;
644         case 2: case 3:         return IDE_SEC_BASE;
645         }
646         return 0;
647 }
648
649 /**
650  * \fn char *ATA_ReadDir(tVFS_Node *Node, int Pos)
651  */
652 char *ATA_ReadDir(tVFS_Node *Node, int Pos)
653 {
654         if(Pos >= giATA_NumNodes || Pos < 0)    return NULL;
655         return strdup( gATA_Nodes[Pos]->ImplPtr );
656 }
657
658 /**
659  * \fn tVFS_Node *ATA_FindDir(tVFS_Node *Node, char *Name)
660  */
661 tVFS_Node *ATA_FindDir(tVFS_Node *Node, char *Name)
662 {
663          int    part;
664         // Check first character
665         if(Name[0] < 'A' || Name[0] > 'A'+MAX_ATA_DISKS)
666                 return NULL;
667         // Raw Disk
668         if(Name[1] == '\0') {
669                 if( gATA_Disks[Name[0]-'A'].Sectors == 0 )
670                         return NULL;
671                 return &gATA_Disks[Name[0]-'A'].Node;
672         }
673         
674         // Partitions
675         if(Name[1] < '0' || '9' < Name[1])      return NULL;
676         if(Name[2] == '\0') {   // <= 9
677                 part = Name[1] - '0';
678                 part --;
679                 return &gATA_Disks[Name[0]-'A'].Partitions[part].Node;
680         }
681         // > 9
682         if('0' > Name[2] || '9' < Name[2])      return NULL;
683         if(Name[3] != '\0')     return NULL;
684         
685         part = (Name[1] - '0') * 10;
686         part += Name[2] - '0';
687         part --;
688         return &gATA_Disks[Name[0]-'A'].Partitions[part].Node;
689         
690 }
691
692 /**
693  * \fn Uint64 ATA_ReadFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
694  */
695 Uint64 ATA_ReadFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
696 {
697          int    disk = Node->Inode >> 8;
698          int    part = Node->Inode & 0xFF;
699         
700         // Raw Disk Access
701         if(part == 0xFF)
702         {
703                 if( Offset >= gATA_Disks[disk].Sectors * SECTOR_SIZE )
704                         return 0;
705                 if( Offset + Length > gATA_Disks[disk].Sectors*SECTOR_SIZE )
706                         Length = gATA_Disks[disk].Sectors*SECTOR_SIZE - Offset;
707         }
708         // Partition
709         else
710         {
711                 if( Offset >= gATA_Disks[disk].Partitions[part].Length * SECTOR_SIZE )
712                         return 0;
713                 if( Offset + Length > gATA_Disks[disk].Partitions[part].Length * SECTOR_SIZE )
714                         Length = gATA_Disks[disk].Partitions[part].Length * SECTOR_SIZE - Offset;
715                 Offset += gATA_Disks[disk].Partitions[part].Start * SECTOR_SIZE;
716         }
717         
718         //Log("ATA_ReadFS: (Node=%p, Offset=0x%llx, Length=0x%llx, Buffer=%p)", Node, Offset, Length, Buffer);
719         return DrvUtil_ReadBlock(Offset, Length, Buffer, ATA_ReadRaw, SECTOR_SIZE, disk);
720 }
721
722 /**
723  * \fn Uint64 ATA_WriteFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
724  */
725 Uint64 ATA_WriteFS(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
726 {
727          int    disk = Node->Inode >> 8;
728          int    part = Node->Inode & 0xFF;
729         
730         // Raw Disk Access
731         if(part == 0xFF)
732         {
733                 if( Offset >= gATA_Disks[disk].Sectors * SECTOR_SIZE )
734                         return 0;
735                 if( Offset + Length > gATA_Disks[disk].Sectors*SECTOR_SIZE )
736                         Length = gATA_Disks[disk].Sectors*SECTOR_SIZE - Offset;
737         }
738         // Partition
739         else
740         {
741                 if( Offset >= gATA_Disks[disk].Partitions[part].Length * SECTOR_SIZE )
742                         return 0;
743                 if( Offset + Length > gATA_Disks[disk].Partitions[part].Length * SECTOR_SIZE )
744                         Length = gATA_Disks[disk].Partitions[part].Length * SECTOR_SIZE - Offset;
745                 Offset += gATA_Disks[disk].Partitions[part].Start * SECTOR_SIZE;
746         }
747         
748         Log("ATA_WriteFS: (Node=%p, Offset=0x%llx, Length=0x%llx, Buffer=%p)", Node, Offset, Length, Buffer);
749         Debug_HexDump("ATA_WriteFS", Buffer, Length);
750         return DrvUtil_WriteBlock(Offset, Length, Buffer, ATA_ReadRaw, ATA_WriteRaw, SECTOR_SIZE, disk);
751 }
752
753 /**
754  * \fn int ATA_IOCtl(tVFS_Node *Node, int Id, void *Data)
755  * \brief IO Control Funtion
756  */
757 int ATA_IOCtl(tVFS_Node *Node, int Id, void *Data)
758 {
759         switch(Id)
760         {
761         case DRV_IOCTL_TYPE:    return DRV_TYPE_DISK;
762         }
763         return 0;
764 }
765
766 // --- Disk Access ---
767 /**
768  * \fn Uint ATA_ReadRaw(Uint64 Address, Uint Count, void *Buffer, Uint Disk)
769  */
770 Uint ATA_ReadRaw(Uint64 Address, Uint Count, void *Buffer, Uint Disk)
771 {
772          int    ret;
773         Uint    offset;
774         Uint    done = 0;
775          
776         // Pass straight on to ATA_ReadDMAPage if we can
777         if(Count <= MAX_DMA_SECTORS)
778         {
779                 ret = ATA_ReadDMA(Disk, Address, Count, Buffer);
780                 if(ret == 0)    return 0;
781                 return Count;
782         }
783         
784         // Else we will have to break up the transfer
785         offset = 0;
786         while(Count > MAX_DMA_SECTORS)
787         {
788                 ret = ATA_ReadDMA(Disk, Address+offset, MAX_DMA_SECTORS, Buffer+offset);
789                 // Check for errors
790                 if(ret != 1)    return done;
791                 // Change Position
792                 done += MAX_DMA_SECTORS;
793                 Count -= MAX_DMA_SECTORS;
794                 offset += MAX_DMA_SECTORS*SECTOR_SIZE;
795         }
796         
797         ret = ATA_ReadDMA(Disk, Address+offset, Count, Buffer+offset);
798         if(ret != 1)    return 0;
799         return done+Count;
800 }
801
802 /**
803  * \fn Uint ATA_WriteRaw(Uint64 Address, Uint Count, void *Buffer, Uint Disk)
804  */
805 Uint ATA_WriteRaw(Uint64 Address, Uint Count, void *Buffer, Uint Disk)
806 {
807          int    ret;
808         Uint    offset;
809         Uint    done = 0;
810          
811         // Pass straight on to ATA_WriteDMA if we can
812         if(Count <= MAX_DMA_SECTORS)
813         {
814                 ret = ATA_WriteDMA(Disk, Address, Count, Buffer);
815                 if(ret == 0)    return 0;
816                 return Count;
817         }
818         
819         // Else we will have to break up the transfer
820         offset = 0;
821         while(Count > MAX_DMA_SECTORS)
822         {
823                 ret = ATA_WriteDMA(Disk, Address+offset, MAX_DMA_SECTORS, Buffer+offset);
824                 // Check for errors
825                 if(ret != 1)    return done;
826                 // Change Position
827                 done += MAX_DMA_SECTORS;
828                 Count -= MAX_DMA_SECTORS;
829                 offset += MAX_DMA_SECTORS*SECTOR_SIZE;
830         }
831         
832         ret = ATA_WriteDMA(Disk, Address+offset, Count, Buffer+offset);
833         if(ret != 1)    return 0;
834         return done+Count;
835 }
836
837 /**
838  * \fn int ATA_ReadDMA(Uint8 Disk, Uint64 Address, Uint Count, void *Buffer)
839  */
840 int ATA_ReadDMA(Uint8 Disk, Uint64 Address, Uint Count, void *Buffer)
841 {
842          int    cont = (Disk>>1)&1;     // Controller ID
843          int    disk = Disk & 1;
844         Uint16  base;
845         
846         ENTER("iDisk XAddress iCount pBuffer", Disk, Address, Count, Buffer);
847         
848         // Check if the count is small enough
849         if(Count > MAX_DMA_SECTORS) {
850                 Warning("Passed too many sectors for a bulk DMA read (%i > %i)",
851                         Count, MAX_DMA_SECTORS);
852                 LEAVE('i');
853                 return 0;
854         }
855         
856         // Get exclusive access to the disk controller
857         LOCK( &giaATA_ControllerLock[ cont ] );
858         
859         // Set Size
860         gATA_PRDTs[ cont ].Bytes = Count * SECTOR_SIZE;
861         
862         // Get Port Base
863         base = ATA_GetBasePort(Disk);
864         
865         // Reset IRQ Flag
866         gaATA_IRQs[cont] = 0;
867         
868         // Set up transfer
869         outb(base+0x01, 0x00);
870         if( Address > 0x0FFFFFFF )      // Use LBA48
871         {
872                 outb(base+0x6, 0x40 | (disk << 4));
873                 outb(base+0x2, 0 >> 8); // Upper Sector Count
874                 outb(base+0x3, Address >> 24);  // Low 2 Addr
875                 outb(base+0x3, Address >> 28);  // Mid 2 Addr
876                 outb(base+0x3, Address >> 32);  // High 2 Addr
877         }
878         else
879         {
880                 outb(base+0x06, 0xE0 | (disk << 4) | ((Address >> 24) & 0x0F)); //Disk,Magic,High addr
881         }
882         
883         outb(base+0x02, (Uint8) Count);         // Sector Count
884         outb(base+0x03, (Uint8) Address);               // Low Addr
885         outb(base+0x04, (Uint8) (Address >> 8));        // Middle Addr
886         outb(base+0x05, (Uint8) (Address >> 16));       // High Addr
887         
888         LOG("Starting Transfer");
889         #if START_BEFORE_CMD
890         // Start transfer
891         ATA_int_BusMasterWriteByte( cont << 3, 9 );     // Read and start
892         if( Address > 0x0FFFFFFF )
893                 outb(base+0x07, HDD_DMA_R48);   // Read Command (LBA48)
894         else
895                 outb(base+0x07, HDD_DMA_R28);   // Read Command (LBA28)
896         #else
897         if( Address > 0x0FFFFFFF )
898                 outb(base+0x07, HDD_DMA_R48);   // Read Command (LBA48)
899         else
900                 outb(base+0x07, HDD_DMA_R28);   // Read Command (LBA28)
901         // Start transfer
902         ATA_int_BusMasterWriteByte( cont << 3, 9 );     // Read and start
903         #endif
904         
905         // Wait for transfer to complete
906         //ATA_int_BusMasterWriteByte( (cont << 3) + 2, 0x4 );
907         while( gaATA_IRQs[cont] == 0 ) {
908                 //Uint8 val = ATA_int_BusMasterReadByte( (cont << 3) + 2, 0x4 );
909                 //LOG("val = 0x%02x", val);
910                 Threads_Yield();
911         }
912         
913         // Complete Transfer
914         ATA_int_BusMasterWriteByte( cont << 3, 0 );     // Write and stop
915         
916         LOG("Transfer Completed & Acknowledged");
917         
918         // Copy to destination buffer
919         memcpy( Buffer, gATA_Buffers[cont], Count*SECTOR_SIZE );
920         
921         // Release controller lock
922         RELEASE( &giaATA_ControllerLock[ cont ] );
923         
924         LEAVE('i', 1);
925         return 1;
926 }
927
928 /**
929  * \fn int ATA_WriteDMA(Uint8 Disk, Uint64 Address, Uint Count, void *Buffer)
930  */
931 int ATA_WriteDMA(Uint8 Disk, Uint64 Address, Uint Count, void *Buffer)
932 {
933          int    cont = (Disk>>1)&1;     // Controller ID
934          int    disk = Disk & 1;
935         Uint16  base;
936         
937         // Check if the count is small enough
938         if(Count > MAX_DMA_SECTORS)     return 0;
939         
940         // Get exclusive access to the disk controller
941         LOCK( &giaATA_ControllerLock[ cont ] );
942         
943         // Set Size
944         gATA_PRDTs[ cont ].Bytes = Count * SECTOR_SIZE;
945         
946         // Get Port Base
947         base = ATA_GetBasePort(Disk);
948         
949         // Set up transfer
950         outb(base+0x01, 0x00);
951         if( Address > 0x0FFFFFFF )      // Use LBA48
952         {
953                 outb(base+0x6, 0x40 | (disk << 4));
954                 outb(base+0x2, 0 >> 8); // Upper Sector Count
955                 outb(base+0x3, Address >> 24);  // Low 2 Addr
956                 outb(base+0x3, Address >> 28);  // Mid 2 Addr
957                 outb(base+0x3, Address >> 32);  // High 2 Addr
958         }
959         else
960         {
961                 outb(base+0x06, 0xE0 | (disk << 4) | ((Address >> 24) & 0x0F)); //Disk,Magic,High addr
962         }
963         
964         outb(base+0x02, (Uint8) Count);         // Sector Count
965         outb(base+0x03, (Uint8) Address);               // Low Addr
966         outb(base+0x04, (Uint8) (Address >> 8));        // Middle Addr
967         outb(base+0x05, (Uint8) (Address >> 16));       // High Addr
968         if( Address > 0x0FFFFFFF )
969                 outb(base+0x07, HDD_DMA_W48);   // Write Command (LBA48)
970         else
971                 outb(base+0x07, HDD_DMA_W28);   // Write Command (LBA28)
972         
973         // Reset IRQ Flag
974         gaATA_IRQs[cont] = 0;
975         
976         // Copy to output buffer
977         memcpy( gATA_Buffers[cont], Buffer, Count*SECTOR_SIZE );
978         
979         // Start transfer
980         ATA_int_BusMasterWriteByte( cont << 3, 1 );     // Write and start
981         
982         // Wait for transfer to complete
983         while( gaATA_IRQs[cont] == 0 )  Threads_Yield();
984         
985         // Complete Transfer
986         ATA_int_BusMasterWriteByte( cont << 3, 0 );     // Write and stop
987         
988         // Release controller lock
989         RELEASE( &giaATA_ControllerLock[ cont ] );
990         
991         return 1;
992 }
993
994 /**
995  * \fn void ATA_IRQHandlerPri(int unused)
996  */
997 void ATA_IRQHandlerPri(int unused)
998 {
999         Uint8   val;
1000         
1001         // IRQ bit set for Primary Controller
1002         val = ATA_int_BusMasterReadByte( 0x2 );
1003         LOG("IRQ val = 0x%x", val);
1004         if(val & 4) {
1005                 LOG("IRQ hit (val = 0x%x)", val);
1006                 ATA_int_BusMasterWriteByte( 0x2, 4 );
1007                 gaATA_IRQs[0] = 1;
1008                 return ;
1009         }
1010 }
1011
1012 /**
1013  * \fn void ATA_IRQHandlerSec(int unused)
1014  */
1015 void ATA_IRQHandlerSec(int unused)
1016 {
1017         Uint8   val;
1018         // IRQ bit set for Secondary Controller
1019         val = ATA_int_BusMasterReadByte( 0xA );
1020         if(val & 4) {
1021                 LOG("IRQ hit (val = 0x%x)", val);
1022                 ATA_int_BusMasterWriteByte( 0xA, 4 );
1023                 gaATA_IRQs[1] = 1;
1024                 return ;
1025         }
1026 }
1027
1028 /**
1029  * \fn Uint8 ATA_int_BusMasterReadByte(int Ofs)
1030  */
1031 Uint8 ATA_int_BusMasterReadByte(int Ofs)
1032 {
1033         if( gATA_BusMasterBase & 1 )
1034                 return inb( (gATA_BusMasterBase & ~1) + Ofs );
1035         else
1036                 return *(Uint8*)(gATA_BusMasterBasePtr + Ofs);
1037 }
1038
1039 /**
1040  * \fn void ATA_int_BusMasterWriteByte(int Ofs, Uint8 Value)
1041  * \brief Writes a byte to a Bus Master Register
1042  */
1043 void ATA_int_BusMasterWriteByte(int Ofs, Uint8 Value)
1044 {
1045         if( gATA_BusMasterBase & 1 )
1046                 outb( (gATA_BusMasterBase & ~1) + Ofs, Value );
1047         else
1048                 *(Uint8*)(gATA_BusMasterBasePtr + Ofs) = Value;
1049 }
1050
1051 /**
1052  * \fn void ATA_int_BusMasterWriteDWord(int Ofs, Uint32 Value)
1053  * \brief Writes a dword to a Bus Master Register
1054  */
1055 void ATA_int_BusMasterWriteDWord(int Ofs, Uint32 Value)
1056 {
1057         
1058         if( gATA_BusMasterBase & 1 )
1059                 outd( (gATA_BusMasterBase & ~1) + Ofs, Value );
1060         else
1061                 *(Uint32*)(gATA_BusMasterBasePtr + Ofs) = Value;
1062 }

UCC git Repository :: git.ucc.asn.au