ide.c

   1 // Simple PIO-based (non-DMA) IDE driver code.
   2
   3 #include "types.h"
   4 #include "defs.h"
   5 #include "param.h"
   6 #include "mmu.h"
   7 #include "proc.h"
   8 #include "x86.h"
   9 #include "traps.h"
  10 #include "spinlock.h"
  11 #include "buf.h"
  12
  13 #define IDE_BSY       0x80
  14 #define IDE_DRDY      0x40
  15 #define IDE_DF        0x20
  16 #define IDE_ERR       0x01
  17
  18 #define IDE_CMD_READ  0x20
  19 #define IDE_CMD_WRITE 0x30
  20
  21 // idequeue points to the buf now being read/written to the disk.
  22 // idequeue->qnext points to the next buf to be processed.
  23 // You must hold idelock while manipulating queue.
  24
  25 static struct spinlock idelock;
  26 static struct buf *idequeue;
  27
  28 static int havedisk1;
  29 static void idestart(struct buf*);
  30
  31 // Wait for IDE disk to become ready.
  32 static int
  33 idewait(int checkerr)
  34 {
  35   int r;
  36
  37   while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
  38     ;
  39   if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
  40     return -1;
  41   return 0;
  42 }
  43
  44 void
  45 ideinit(void)
  46 {
  47   int i;
  48
  49   initlock(&idelock, "ide");
  50   picenable(IRQ_IDE);
  51   ioapicenable(IRQ_IDE, ncpu - 1);
  52   idewait(0);
  53
  54   // Check if disk 1 is present
  55   outb(0x1f6, 0xe0 | (1<<4));
  56   for(i=0; i<1000; i++){
  57     if(inb(0x1f7) != 0){
  58       havedisk1 = 1;
  59       break;
  60     }
  61   }
  62
  63   // Switch back to disk 0.
  64   outb(0x1f6, 0xe0 | (0<<4));
  65 }
  66
  67 // Start the request for b.  Caller must hold idelock.
  68 static void
  69 idestart(struct buf *b)
  70 {
  71   if(b == 0)
  72     panic("idestart");
  73
  74   idewait(0);
  75   outb(0x3f6, 0);  // generate interrupt
  76   outb(0x1f2, 1);  // number of sectors
  77   outb(0x1f3, b->sector & 0xff);
  78   outb(0x1f4, (b->sector >> 8) & 0xff);
  79   outb(0x1f5, (b->sector >> 16) & 0xff);
  80   outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((b->sector>>24)&0x0f));
  81   if(b->flags & B_DIRTY){
  82     outb(0x1f7, IDE_CMD_WRITE);
  83     outsl(0x1f0, b->data, 512/4);
  84   } else {
  85     outb(0x1f7, IDE_CMD_READ);
  86   }
  87 }
  88
  89 // Interrupt handler.
  90 void
  91 ideintr(void)
  92 {
  93   struct buf *b;
  94
  95   // Take first buffer off queue.
  96   acquire(&idelock);
  97   if((b = idequeue) == 0){
  98     release(&idelock);
  99     // cprintf("spurious IDE interrupt\n");
 100     return;
 101   }
 102   idequeue = b->qnext;
 103
 104   // Read data if needed.
 105   if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
 106     insl(0x1f0, b->data, 512/4);
 107
 108   // Wake process waiting for this buf.
 109   b->flags |= B_VALID;
 110   b->flags &= ~B_DIRTY;
 111   wakeup(b);
 112
 113   // Start disk on next buf in queue.
 114   if(idequeue != 0)
 115     idestart(idequeue);
 116
 117   release(&idelock);
 118 }
 119
 120 // Sync buf with disk.
 121 // If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
 122 // Else if B_VALID is not set, read buf from disk, set B_VALID.
 123 void
 124 iderw(struct buf *b)
 125 {
 126   struct buf **pp;
 127
 128   if(!(b->flags & B_BUSY))
 129     panic("iderw: buf not busy");
 130   if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
 131     panic("iderw: nothing to do");
 132   if(b->dev != 0 && !havedisk1)
 133     panic("iderw: ide disk 1 not present");
 134
 135   acquire(&idelock);
 136
 137   // Append b to idequeue.
 138   b->qnext = 0;
 139   for(pp=&idequeue; *pp; pp=&(*pp)->qnext)
 140     ;
 141   *pp = b;
 142
 143   // Start disk if necessary.
 144   if(idequeue == b)
 145     idestart(b);
 146
 147   // Wait for request to finish.
 148   // Assuming will not sleep too long: ignore proc->killed.
 149   while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
 150     sleep(b, &idelock);
 151   }
 152
 153   release(&idelock);
 154 }