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