xv6-65oo2/ide.c

169 lines
3.6 KiB
C
Raw Normal View History

2006-09-06 17:50:20 +00:00
// Simple PIO-based (non-DMA) IDE driver code.
2006-06-16 20:29:25 +00:00
#include "types.h"
2007-08-27 23:26:33 +00:00
#include "defs.h"
2006-06-16 20:29:25 +00:00
#include "param.h"
#include "memlayout.h"
2006-06-16 20:29:25 +00:00
#include "mmu.h"
#include "proc.h"
#include "x86.h"
#include "traps.h"
2006-07-17 05:00:25 +00:00
#include "spinlock.h"
#include "sleeplock.h"
#include "fs.h"
2007-08-24 19:32:36 +00:00
#include "buf.h"
2006-06-16 20:29:25 +00:00
#define SECTOR_SIZE 512
2006-09-06 17:54:29 +00:00
#define IDE_BSY 0x80
#define IDE_DRDY 0x40
#define IDE_DF 0x20
#define IDE_ERR 0x01
#define IDE_CMD_READ 0x20
#define IDE_CMD_WRITE 0x30
#define IDE_CMD_RDMUL 0xc4
#define IDE_CMD_WRMUL 0xc5
2006-06-16 20:29:25 +00:00
2009-05-31 01:29:01 +00:00
// idequeue points to the buf now being read/written to the disk.
// idequeue->qnext points to the next buf to be processed.
// You must hold idelock while manipulating queue.
2006-09-07 14:28:12 +00:00
2009-05-31 01:29:01 +00:00
static struct spinlock idelock;
static struct buf *idequeue;
2006-09-07 14:28:12 +00:00
2009-05-31 01:29:01 +00:00
static int havedisk1;
static void idestart(struct buf*);
2006-08-30 18:55:06 +00:00
2006-09-07 15:29:54 +00:00
// Wait for IDE disk to become ready.
2006-06-16 20:29:25 +00:00
static int
idewait(int checkerr)
2006-06-16 20:29:25 +00:00
{
int r;
2006-06-16 20:29:25 +00:00
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
2006-09-06 17:50:20 +00:00
;
if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
return -1;
return 0;
2006-06-16 20:29:25 +00:00
}
void
ideinit(void)
{
2007-08-24 22:17:41 +00:00
int i;
2009-05-31 01:29:01 +00:00
initlock(&idelock, "ide");
picenable(IRQ_IDE);
ioapicenable(IRQ_IDE, ncpu - 1);
idewait(0);
2007-08-24 22:17:41 +00:00
// Check if disk 1 is present
2007-08-28 18:23:48 +00:00
outb(0x1f6, 0xe0 | (1<<4));
2007-08-24 22:17:41 +00:00
for(i=0; i<1000; i++){
if(inb(0x1f7) != 0){
2009-05-31 01:29:01 +00:00
havedisk1 = 1;
2007-08-24 22:17:41 +00:00
break;
}
}
2007-08-24 22:17:41 +00:00
// Switch back to disk 0.
2007-08-28 18:23:48 +00:00
outb(0x1f6, 0xe0 | (0<<4));
}
2009-05-31 01:29:01 +00:00
// Start the request for b. Caller must hold idelock.
2007-08-24 22:17:41 +00:00
static void
idestart(struct buf *b)
2006-06-16 20:29:25 +00:00
{
2007-08-24 22:17:41 +00:00
if(b == 0)
panic("idestart");
2015-04-10 11:15:06 +00:00
if(b->blockno >= FSSIZE)
panic("incorrect blockno");
int sector_per_block = BSIZE/SECTOR_SIZE;
int sector = b->blockno * sector_per_block;
int read_cmd = (sector_per_block == 1) ? IDE_CMD_READ : IDE_CMD_RDMUL;
int write_cmd = (sector_per_block == 1) ? IDE_CMD_WRITE : IDE_CMD_WRMUL;
if (sector_per_block > 7) panic("idestart");
idewait(0);
2007-08-24 22:17:41 +00:00
outb(0x3f6, 0); // generate interrupt
outb(0x1f2, sector_per_block); // number of sectors
outb(0x1f3, sector & 0xff);
outb(0x1f4, (sector >> 8) & 0xff);
outb(0x1f5, (sector >> 16) & 0xff);
outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f));
if(b->flags & B_DIRTY){
outb(0x1f7, write_cmd);
outsl(0x1f0, b->data, BSIZE/4);
2007-08-28 18:37:41 +00:00
} else {
outb(0x1f7, read_cmd);
2007-08-24 22:17:41 +00:00
}
2006-06-16 20:29:25 +00:00
}
2007-08-24 22:17:41 +00:00
// Interrupt handler.
2006-09-08 14:33:27 +00:00
void
ideintr(void)
2006-09-08 14:33:27 +00:00
{
2007-08-24 22:17:41 +00:00
struct buf *b;
2011-10-11 10:41:37 +00:00
// First queued buffer is the active request.
2009-05-31 01:29:01 +00:00
acquire(&idelock);
if((b = idequeue) == 0){
release(&idelock);
// cprintf("spurious IDE interrupt\n");
2007-08-24 22:17:41 +00:00
return;
2007-08-24 19:32:36 +00:00
}
2009-05-31 01:29:01 +00:00
idequeue = b->qnext;
2006-09-08 14:33:27 +00:00
2007-08-24 22:17:41 +00:00
// Read data if needed.
if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
insl(0x1f0, b->data, BSIZE/4);
2007-08-24 22:17:41 +00:00
// Wake process waiting for this buf.
b->flags |= B_VALID;
b->flags &= ~B_DIRTY;
2007-08-24 22:17:41 +00:00
wakeup(b);
2007-08-24 22:17:41 +00:00
// Start disk on next buf in queue.
2009-05-31 01:29:01 +00:00
if(idequeue != 0)
idestart(idequeue);
2007-08-24 22:17:41 +00:00
2009-05-31 01:29:01 +00:00
release(&idelock);
2006-07-10 19:06:48 +00:00
}
2007-08-24 22:17:41 +00:00
//PAGEBREAK!
// Sync buf with disk.
// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
// Else if B_VALID is not set, read buf from disk, set B_VALID.
2006-09-07 15:29:54 +00:00
void
iderw(struct buf *b)
2006-06-16 20:29:25 +00:00
{
2007-08-24 19:32:36 +00:00
struct buf **pp;
if(!holdingsleep(&b->lock))
panic("iderw: buf not locked");
if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
panic("iderw: nothing to do");
2009-05-31 01:29:01 +00:00
if(b->dev != 0 && !havedisk1)
panic("iderw: ide disk 1 not present");
2012-08-28 18:41:08 +00:00
acquire(&idelock); //DOC:acquire-lock
2006-09-06 17:27:19 +00:00
2009-05-31 01:29:01 +00:00
// Append b to idequeue.
2007-08-24 19:32:36 +00:00
b->qnext = 0;
2012-08-28 18:41:08 +00:00
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
2007-08-24 22:17:41 +00:00
;
2007-08-24 19:32:36 +00:00
*pp = b;
2007-08-24 22:17:41 +00:00
// Start disk if necessary.
2009-05-31 01:29:01 +00:00
if(idequeue == b)
idestart(b);
2007-08-24 22:17:41 +00:00
// Wait for request to finish.
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
2009-05-31 01:29:01 +00:00
sleep(b, &idelock);
}
2009-05-31 01:29:01 +00:00
release(&idelock);
2006-06-16 20:29:25 +00:00
}