2006-09-06 19:50:20 +02:00
|
|
|
// Simple PIO-based (non-DMA) IDE driver code.
|
2006-06-16 22:29:25 +02:00
|
|
|
|
|
|
|
#include "types.h"
|
|
|
|
#include "param.h"
|
|
|
|
#include "mmu.h"
|
|
|
|
#include "proc.h"
|
|
|
|
#include "defs.h"
|
|
|
|
#include "x86.h"
|
2006-09-03 17:39:29 +02:00
|
|
|
#include "traps.h"
|
2006-07-17 07:00:25 +02:00
|
|
|
#include "spinlock.h"
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-09-06 19:54:29 +02: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
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-09-07 16:28:12 +02:00
|
|
|
// IDE request queue.
|
|
|
|
// The next request will be stored in request[head],
|
|
|
|
// and the request currently being served by the disk
|
|
|
|
// is request[tail].
|
|
|
|
// Must hold ide_lock while manipulating queue.
|
|
|
|
|
2006-07-10 21:06:48 +02:00
|
|
|
struct ide_request {
|
2006-07-20 11:07:53 +02:00
|
|
|
int diskno;
|
|
|
|
uint secno;
|
2006-08-06 22:28:15 +02:00
|
|
|
void *addr;
|
2006-07-17 03:52:13 +02:00
|
|
|
uint nsecs;
|
2006-08-06 22:28:15 +02:00
|
|
|
uint read;
|
2006-07-10 21:06:48 +02:00
|
|
|
};
|
2006-09-06 19:04:06 +02:00
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
static struct ide_request request[NREQUEST];
|
|
|
|
static int head, tail;
|
|
|
|
static struct spinlock ide_lock;
|
2006-09-07 16:28:12 +02:00
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
static int disk_1_present;
|
|
|
|
static int disk_queue;
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
static int ide_probe_disk1(void);
|
2006-08-30 20:55:06 +02:00
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Wait for IDE disk to become ready.
|
2006-06-16 22:29:25 +02:00
|
|
|
static int
|
|
|
|
ide_wait_ready(int check_error)
|
|
|
|
{
|
2006-07-05 22:00:14 +02:00
|
|
|
int r;
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-09-06 19:27:19 +02:00
|
|
|
while(((r = inb(0x1F7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
|
2006-09-06 19:50:20 +02:00
|
|
|
;
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-09-06 19:27:19 +02:00
|
|
|
if(check_error && (r & (IDE_DF|IDE_ERR)) != 0)
|
2006-07-05 22:00:14 +02:00
|
|
|
return -1;
|
|
|
|
return 0;
|
2006-06-16 22:29:25 +02:00
|
|
|
}
|
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
void
|
|
|
|
ide_init(void)
|
|
|
|
{
|
2006-08-11 00:08:14 +02:00
|
|
|
initlock(&ide_lock, "ide");
|
2006-09-07 17:29:54 +02:00
|
|
|
irq_enable(IRQ_IDE);
|
|
|
|
ioapic_enable(IRQ_IDE, ncpu - 1);
|
2006-07-05 22:00:14 +02:00
|
|
|
ide_wait_ready(0);
|
2006-08-30 20:55:06 +02:00
|
|
|
disk_1_present = ide_probe_disk1();
|
2006-07-05 22:00:14 +02:00
|
|
|
}
|
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Interrupt handler - wake up the request that just finished.
|
2006-07-06 23:47:22 +02:00
|
|
|
void
|
|
|
|
ide_intr(void)
|
|
|
|
{
|
2006-07-29 03:20:15 +02:00
|
|
|
acquire(&ide_lock);
|
2006-07-10 21:06:48 +02:00
|
|
|
wakeup(&request[tail]);
|
2006-07-29 03:20:15 +02:00
|
|
|
release(&ide_lock);
|
2006-07-06 23:47:22 +02:00
|
|
|
}
|
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Probe to see if disk 1 exists (we assume disk 0 exists).
|
|
|
|
static int
|
2006-06-16 22:29:25 +02:00
|
|
|
ide_probe_disk1(void)
|
|
|
|
{
|
2006-07-05 22:00:14 +02:00
|
|
|
int r, x;
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
// wait for Device 0 to be ready
|
|
|
|
ide_wait_ready(0);
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
// switch to Device 1
|
|
|
|
outb(0x1F6, 0xE0 | (1<<4));
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
// check for Device 1 to be ready for a while
|
2006-09-06 19:27:19 +02:00
|
|
|
for(x = 0; x < 1000 && (r = inb(0x1F7)) == 0; x++)
|
2006-09-06 19:50:20 +02:00
|
|
|
;
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
// switch back to Device 0
|
|
|
|
outb(0x1F6, 0xE0 | (0<<4));
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-09-06 19:27:19 +02:00
|
|
|
return x < 1000;
|
2006-06-16 22:29:25 +02:00
|
|
|
}
|
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Start the next request in the queue.
|
|
|
|
static void
|
2006-07-10 21:06:48 +02:00
|
|
|
ide_start_request (void)
|
|
|
|
{
|
|
|
|
struct ide_request *r;
|
|
|
|
|
2006-09-06 19:27:19 +02:00
|
|
|
if(head != tail) {
|
2006-07-10 21:06:48 +02:00
|
|
|
r = &request[tail];
|
|
|
|
ide_wait_ready(0);
|
2006-08-06 22:28:15 +02:00
|
|
|
outb(0x3f6, 0); // generate interrupt
|
2006-07-10 21:06:48 +02:00
|
|
|
outb(0x1F2, r->nsecs);
|
|
|
|
outb(0x1F3, r->secno & 0xFF);
|
|
|
|
outb(0x1F4, (r->secno >> 8) & 0xFF);
|
|
|
|
outb(0x1F5, (r->secno >> 16) & 0xFF);
|
2006-07-20 11:07:53 +02:00
|
|
|
outb(0x1F6, 0xE0 | ((r->diskno&1)<<4) | ((r->secno>>24)&0x0F));
|
2006-09-06 19:54:29 +02:00
|
|
|
if(r->read)
|
|
|
|
outb(0x1F7, IDE_CMD_READ);
|
2006-08-07 03:38:46 +02:00
|
|
|
else {
|
2006-09-06 19:54:29 +02:00
|
|
|
outb(0x1F7, IDE_CMD_WRITE);
|
2006-08-07 03:38:46 +02:00
|
|
|
outsl(0x1F0, r->addr, 512/4);
|
|
|
|
}
|
2006-07-10 21:06:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Run an entire disk operation.
|
|
|
|
void
|
|
|
|
ide_rw(int diskno, uint secno, void *addr, uint nsecs, int read)
|
2006-06-16 22:29:25 +02:00
|
|
|
{
|
2006-07-10 21:06:48 +02:00
|
|
|
struct ide_request *r;
|
2006-08-06 22:28:15 +02:00
|
|
|
|
2006-08-30 20:55:06 +02:00
|
|
|
if(diskno && !disk_1_present)
|
|
|
|
panic("ide disk 1 not present");
|
2006-07-05 22:00:14 +02:00
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
acquire(&ide_lock);
|
|
|
|
|
|
|
|
// Add request to queue.
|
2006-09-06 19:27:19 +02:00
|
|
|
while((head + 1) % NREQUEST == tail)
|
2006-09-07 17:29:54 +02:00
|
|
|
sleep(&disk_queue, &ide_lock);
|
2006-07-05 22:00:14 +02:00
|
|
|
|
2006-07-10 21:06:48 +02:00
|
|
|
r = &request[head];
|
|
|
|
r->secno = secno;
|
2006-08-06 22:28:15 +02:00
|
|
|
r->addr = addr;
|
2006-07-10 21:06:48 +02:00
|
|
|
r->nsecs = nsecs;
|
2006-07-21 15:18:04 +02:00
|
|
|
r->diskno = diskno;
|
2006-08-06 22:28:15 +02:00
|
|
|
r->read = read;
|
2006-07-10 21:06:48 +02:00
|
|
|
head = (head + 1) % NREQUEST;
|
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Start request if necessary.
|
2006-07-21 15:18:04 +02:00
|
|
|
ide_start_request();
|
2006-09-07 17:29:54 +02:00
|
|
|
|
|
|
|
// Wait for request to finish.
|
|
|
|
sleep(r, &ide_lock);
|
|
|
|
|
|
|
|
// Finish request.
|
|
|
|
if(read){
|
|
|
|
if(ide_wait_ready(1) >= 0)
|
|
|
|
insl(0x1F0, addr, 512/4);
|
2006-07-10 21:06:48 +02:00
|
|
|
}
|
2006-09-06 19:27:19 +02:00
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Remove request from queue.
|
|
|
|
if((head + 1) % NREQUEST == tail)
|
|
|
|
wakeup(&disk_queue);
|
2006-07-10 21:06:48 +02:00
|
|
|
tail = (tail + 1) % NREQUEST;
|
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
release(&ide_lock);
|
2006-06-16 22:29:25 +02:00
|
|
|
}
|
|
|
|
|
2006-09-07 17:29:54 +02:00
|
|
|
// Synchronous disk write.
|
2006-06-16 22:29:25 +02:00
|
|
|
int
|
2006-07-21 15:18:04 +02:00
|
|
|
ide_write(int diskno, uint secno, const void *src, uint nsecs)
|
2006-06-16 22:29:25 +02:00
|
|
|
{
|
2006-07-05 22:00:14 +02:00
|
|
|
int r;
|
2006-09-06 19:04:06 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
if(nsecs > 256)
|
|
|
|
panic("ide_write");
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
ide_wait_ready(0);
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
outb(0x1F2, nsecs);
|
|
|
|
outb(0x1F3, secno & 0xFF);
|
|
|
|
outb(0x1F4, (secno >> 8) & 0xFF);
|
|
|
|
outb(0x1F5, (secno >> 16) & 0xFF);
|
|
|
|
outb(0x1F6, 0xE0 | ((diskno&1)<<4) | ((secno>>24)&0x0F));
|
2006-09-06 19:04:06 +02:00
|
|
|
outb(0x1F7, 0x30); // CMD 0x30 means write sector
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-09-06 19:27:19 +02:00
|
|
|
for(; nsecs > 0; nsecs--, src += 512) {
|
|
|
|
if((r = ide_wait_ready(1)) < 0)
|
2006-07-05 22:00:14 +02:00
|
|
|
return r;
|
|
|
|
outsl(0x1F0, src, 512/4);
|
|
|
|
}
|
2006-06-16 22:29:25 +02:00
|
|
|
|
2006-07-05 22:00:14 +02:00
|
|
|
return 0;
|
2006-06-16 22:29:25 +02:00
|
|
|
}
|