disk.c File Reference

#include "devices/disk.h"
#include <ctype.h>
#include <debug.h>
#include <stdbool.h>
#include <stdio.h>
#include "devices/timer.h"
#include "threads/io.h"
#include "threads/interrupt.h"
#include "threads/synch.h"

Include dependency graph for disk.c:

Classes
struct	disk
struct	channel

Macros
#define	reg_data(CHANNEL)   ((CHANNEL)->reg_base + 0) /* Data. */
#define	reg_error(CHANNEL)   ((CHANNEL)->reg_base + 1) /* Error. */
#define	reg_nsect(CHANNEL)   ((CHANNEL)->reg_base + 2) /* Sector Count. */
#define	reg_lbal(CHANNEL)   ((CHANNEL)->reg_base + 3) /* LBA 0:7. */
#define	reg_lbam(CHANNEL)   ((CHANNEL)->reg_base + 4) /* LBA 15:8. */
#define	reg_lbah(CHANNEL)   ((CHANNEL)->reg_base + 5) /* LBA 23:16. */
#define	reg_device(CHANNEL)   ((CHANNEL)->reg_base + 6) /* Device/LBA 27:24. */
#define	reg_status(CHANNEL)   ((CHANNEL)->reg_base + 7) /* Status (r/o). */
#define	reg_command(CHANNEL)   reg_status (CHANNEL) /* Command (w/o). */
#define	reg_ctl(CHANNEL)   ((CHANNEL)->reg_base + 0x206) /* Control (w/o). */
#define	reg_alt_status(CHANNEL)   reg_ctl (CHANNEL) /* Alt Status (r/o). */
#define	STA_BSY   0x80 /* Busy. */
#define	STA_DRDY   0x40 /* Device Ready. */
#define	STA_DRQ   0x08 /* Data Request. */
#define	CTL_SRST   0x04 /* Software Reset. */
#define	DEV_MBS   0xa0 /* Must be set. */
#define	DEV_LBA   0x40 /* Linear based addressing. */
#define	DEV_DEV   0x10 /* Select device: 0=master, 1=slave. */
#define	CMD_IDENTIFY_DEVICE   0xec /* IDENTIFY DEVICE. */
#define	CMD_READ_SECTOR_RETRY   0x20 /* READ SECTOR with retries. */
#define	CMD_WRITE_SECTOR_RETRY   0x30 /* WRITE SECTOR with retries. */
#define	CHANNEL_CNT   2

Functions
static void	reset_channel (struct channel *)
static bool	check_device_type (struct disk *)
static void	identify_ata_device (struct disk *)
static void	select_sector (struct disk *, disk_sector_t)
static void	issue_pio_command (struct channel *, uint8_t command)
static void	input_sector (struct channel *, void *)
static void	output_sector (struct channel *, const void *)
static void	wait_until_idle (const struct disk *)
static bool	wait_while_busy (const struct disk *)
static void	select_device (const struct disk *)
static void	select_device_wait (const struct disk *)
static void	interrupt_handler (struct intr_frame *)
void	disk_init (void)
void	disk_print_stats (void)
struct disk *	disk_get (int chan_no, int dev_no)
disk_sector_t	disk_size (struct disk *d)
void	disk_read (struct disk *d, disk_sector_t sec_no, void *buffer)
void	disk_write (struct disk *d, disk_sector_t sec_no, const void *buffer)
static void	print_ata_string (char *string, size_t size)
static void	inspect_read_cnt (struct intr_frame *f)
static void	inspect_write_cnt (struct intr_frame *f)
void	register_disk_inspect_intr (void)

Variables
static struct channel	channels [CHANNEL_CNT]

Macro Definition Documentation

CHANNEL_CNT

#define CHANNEL_CNT   2

CMD_IDENTIFY_DEVICE

#define CMD_IDENTIFY_DEVICE   0xec /* IDENTIFY DEVICE. */

CMD_READ_SECTOR_RETRY

#define CMD_READ_SECTOR_RETRY   0x20 /* READ SECTOR with retries. */

CMD_WRITE_SECTOR_RETRY

#define CMD_WRITE_SECTOR_RETRY   0x30 /* WRITE SECTOR with retries. */

CTL_SRST

#define CTL_SRST   0x04 /* Software Reset. */

DEV_DEV

#define DEV_DEV   0x10 /* Select device: 0=master, 1=slave. */

DEV_LBA

#define DEV_LBA   0x40 /* Linear based addressing. */

DEV_MBS

#define DEV_MBS   0xa0 /* Must be set. */

reg_alt_status

#define reg_alt_status

(

CHANNEL

)

reg_ctl (CHANNEL) /* Alt Status (r/o). */

reg_command

#define reg_command

(

CHANNEL

)

reg_status (CHANNEL) /* Command (w/o). */

reg_ctl

#define reg_ctl

(

CHANNEL

)

((CHANNEL)->reg_base + 0x206) /* Control (w/o). */

reg_data

#define reg_data

(

CHANNEL

)

((CHANNEL)->reg_base + 0) /* Data. */

reg_device

#define reg_device

(

CHANNEL

)

((CHANNEL)->reg_base + 6) /* Device/LBA 27:24. */

reg_error

#define reg_error

(

CHANNEL

)

((CHANNEL)->reg_base + 1) /* Error. */

reg_lbah

#define reg_lbah

(

CHANNEL

)

((CHANNEL)->reg_base + 5) /* LBA 23:16. */

reg_lbal

#define reg_lbal

(

CHANNEL

)

((CHANNEL)->reg_base + 3) /* LBA 0:7. */

reg_lbam

#define reg_lbam

(

CHANNEL

)

((CHANNEL)->reg_base + 4) /* LBA 15:8. */

reg_nsect

#define reg_nsect

(

CHANNEL

)

((CHANNEL)->reg_base + 2) /* Sector Count. */

reg_status

#define reg_status

(

CHANNEL

)

((CHANNEL)->reg_base + 7) /* Status (r/o). */

STA_BSY

#define STA_BSY   0x80 /* Busy. */

STA_DRDY

#define STA_DRDY   0x40 /* Device Ready. */

STA_DRQ

#define STA_DRQ   0x08 /* Data Request. */

Function Documentation

check_device_type()

static bool check_device_type ( struct disk *  d )

static

                                   {
    struct channel *c = d->channel;
    uint8_t error, lbam, lbah, status;
 
    select_device (d);
 
    error = inb (reg_error (c));
    lbam = inb (reg_lbam (c));
    lbah = inb (reg_lbah (c));
    status = inb (reg_status (c));
 
    if ((error != 1 && (error != 0x81 || d->dev_no == 1))
            || (status & STA_DRDY) == 0
            || (status & STA_BSY) != 0) {
        d->is_ata = false;
        return error != 0x81;
    } else {
        d->is_ata = (lbam == 0 && lbah == 0) || (lbam == 0x3c && lbah == 0xc3);
        return true;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

disk_get()

struct disk * disk_get	(	int	chan_no,
		int	dev_no
	)

                                   {
    ASSERT (dev_no == 0 || dev_no == 1);
 
    if (chan_no < (int) CHANNEL_CNT) {
        struct disk *d = &channels[chan_no].devices[dev_no];
        if (d->is_ata)
            return d;
    }
    return NULL;
}

Here is the caller graph for this function:

disk_init()

void disk_init

(

void

)

                 {
    size_t chan_no;
 
    for (chan_no = 0; chan_no < CHANNEL_CNT; chan_no++) {
        struct channel *c = &channels[chan_no];
        int dev_no;
 
        /* Initialize channel. */
        snprintf (c->name, sizeof c->name, "hd%zu", chan_no);
        switch (chan_no) {
            case 0:
                c->reg_base = 0x1f0;
                c->irq = 14 + 0x20;
                break;
            case 1:
                c->reg_base = 0x170;
                c->irq = 15 + 0x20;
                break;
            default:
                NOT_REACHED ();
        }
        lock_init (&c->lock);
        c->expecting_interrupt = false;
        sema_init (&c->completion_wait, 0);
 
        /* Initialize devices. */
        for (dev_no = 0; dev_no < 2; dev_no++) {
            struct disk *d = &c->devices[dev_no];
            snprintf (d->name, sizeof d->name, "%s:%d", c->name, dev_no);
            d->channel = c;
            d->dev_no = dev_no;
 
            d->is_ata = false;
            d->capacity = 0;
 
            d->read_cnt = d->write_cnt = 0;
        }
 
        /* Register interrupt handler. */
        intr_register_ext (c->irq, interrupt_handler, c->name);
 
        /* Reset hardware. */
        reset_channel (c);
 
        /* Distinguish ATA hard disks from other devices. */
        if (check_device_type (&c->devices[0]))
            check_device_type (&c->devices[1]);
 
        /* Read hard disk identity information. */
        for (dev_no = 0; dev_no < 2; dev_no++)
            if (c->devices[dev_no].is_ata)
                identify_ata_device (&c->devices[dev_no]);
    }
 
    /* DO NOT MODIFY BELOW LINES. */
    register_disk_inspect_intr ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

disk_print_stats()

void disk_print_stats

(

void

)

                        {
    int chan_no;
 
    for (chan_no = 0; chan_no < CHANNEL_CNT; chan_no++) {
        int dev_no;
 
        for (dev_no = 0; dev_no < 2; dev_no++) {
            struct disk *d = disk_get (chan_no, dev_no);
            if (d != NULL && d->is_ata)
                printf ("%s: %lld reads, %lld writes\n",
                        d->name, d->read_cnt, d->write_cnt);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

disk_read()

void disk_read	(	struct disk *	d,
		disk_sector_t	sec_no,
		void *	buffer
	)

                                                               {
    struct channel *c;
 
    ASSERT (d != NULL);
    ASSERT (buffer != NULL);
 
    c = d->channel;
    lock_acquire (&c->lock);
    select_sector (d, sec_no);
    issue_pio_command (c, CMD_READ_SECTOR_RETRY);
    sema_down (&c->completion_wait);
    if (!wait_while_busy (d))
        PANIC ("%s: disk read failed, sector=%"PRDSNu, d->name, sec_no);
    input_sector (c, buffer);
    d->read_cnt++;
    lock_release (&c->lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

disk_size()

disk_sector_t disk_size

(

struct disk *

d

)

                           {
    ASSERT (d != NULL);
 
    return d->capacity;
}

Here is the caller graph for this function:

disk_write()

void disk_write	(	struct disk *	d,
		disk_sector_t	sec_no,
		const void *	buffer
	)

                                                                      {
    struct channel *c;
 
    ASSERT (d != NULL);
    ASSERT (buffer != NULL);
 
    c = d->channel;
    lock_acquire (&c->lock);
    select_sector (d, sec_no);
    issue_pio_command (c, CMD_WRITE_SECTOR_RETRY);
    if (!wait_while_busy (d))
        PANIC ("%s: disk write failed, sector=%"PRDSNu, d->name, sec_no);
    output_sector (c, buffer);
    sema_down (&c->completion_wait);
    d->write_cnt++;
    lock_release (&c->lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

identify_ata_device()

static void identify_ata_device ( struct disk *  d )

static

                                     {
    struct channel *c = d->channel;
    uint16_t id[DISK_SECTOR_SIZE / 2];
 
    ASSERT (d->is_ata);
 
    /* Send the IDENTIFY DEVICE command, wait for an interrupt
       indicating the device's response is ready, and read the data
       into our buffer. */
    select_device_wait (d);
    issue_pio_command (c, CMD_IDENTIFY_DEVICE);
    sema_down (&c->completion_wait);
    if (!wait_while_busy (d)) {
        d->is_ata = false;
        return;
    }
    input_sector (c, id);
 
    /* Calculate capacity. */
    d->capacity = id[60] | ((uint32_t) id[61] << 16);
 
    /* Print identification message. */
    printf ("%s: detected %'"PRDSNu" sector (", d->name, d->capacity);
    if (d->capacity > 1024 / DISK_SECTOR_SIZE * 1024 * 1024)
        printf ("%"PRDSNu" GB",
                d->capacity / (1024 / DISK_SECTOR_SIZE * 1024 * 1024));
    else if (d->capacity > 1024 / DISK_SECTOR_SIZE * 1024)
        printf ("%"PRDSNu" MB", d->capacity / (1024 / DISK_SECTOR_SIZE * 1024));
    else if (d->capacity > 1024 / DISK_SECTOR_SIZE)
        printf ("%"PRDSNu" kB", d->capacity / (1024 / DISK_SECTOR_SIZE));
    else
        printf ("%"PRDSNu" byte", d->capacity * DISK_SECTOR_SIZE);
    printf (") disk, model \"");
    print_ata_string ((char *) &id[27], 40);
    printf ("\", serial \"");
    print_ata_string ((char *) &id[10], 20);
    printf ("\"\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

input_sector()

static void input_sector ( struct channel *  c, void *  sector  )

static

                                               {
    insw (reg_data (c), sector, DISK_SECTOR_SIZE / 2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

inspect_read_cnt()

static void inspect_read_cnt ( struct intr_frame *  f )

static

                                        {
    struct disk * d = disk_get (f->R.rdx, f->R.rcx);
    f->R.rax = d->read_cnt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

inspect_write_cnt()

static void inspect_write_cnt ( struct intr_frame *  f )

static

                                         {
    struct disk * d = disk_get (f->R.rdx, f->R.rcx);
    f->R.rax = d->write_cnt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

interrupt_handler()

static void interrupt_handler ( struct intr_frame *  f )

static

                                         {
    struct channel *c;
 
    for (c = channels; c < channels + CHANNEL_CNT; c++)
        if (f->vec_no == c->irq) {
            if (c->expecting_interrupt) {
                inb (reg_status (c));               /* Acknowledge interrupt. */
                sema_up (&c->completion_wait);      /* Wake up waiter. */
            } else
                printf ("%s: unexpected interrupt\n", c->name);
            return;
        }
 
    NOT_REACHED ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

issue_pio_command()

static void issue_pio_command ( struct channel *  c, uint8_t  command  )

static

                                                       {
    /* Interrupts must be enabled or our semaphore will never be
       up'd by the completion handler. */
    ASSERT (intr_get_level () == INTR_ON);
 
    c->expecting_interrupt = true;
    outb (reg_command (c), command);
}

Here is the call graph for this function:

Here is the caller graph for this function:

output_sector()

static void output_sector ( struct channel *  c, const void *  sector  )

static

                                                      {
    outsw (reg_data (c), sector, DISK_SECTOR_SIZE / 2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_ata_string()

static void print_ata_string ( char *  string, size_t  size  )

static

                                             {
    size_t i;
 
    /* Find the last non-white, non-null character. */
    for (; size > 0; size--) {
        int c = string[(size - 1) ^ 1];
        if (c != '\0' && !isspace (c))
            break;
    }
 
    /* Print. */
    for (i = 0; i < size; i++)
        printf ("%c", string[i ^ 1]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

register_disk_inspect_intr()

void register_disk_inspect_intr

(

void

)

                                  {
    intr_register_int (0x43, 3, INTR_OFF, inspect_read_cnt, "Inspect Disk Read Count");
    intr_register_int (0x44, 3, INTR_OFF, inspect_write_cnt, "Inspect Disk Write Count");
}

Here is the call graph for this function:

Here is the caller graph for this function:

reset_channel()

static void reset_channel ( struct channel *  c )

static

                                  {
    bool present[2];
    int dev_no;
 
    /* The ATA reset sequence depends on which devices are present,
       so we start by detecting device presence. */
    for (dev_no = 0; dev_no < 2; dev_no++) {
        struct disk *d = &c->devices[dev_no];
 
        select_device (d);
 
        outb (reg_nsect (c), 0x55);
        outb (reg_lbal (c), 0xaa);
 
        outb (reg_nsect (c), 0xaa);
        outb (reg_lbal (c), 0x55);
 
        outb (reg_nsect (c), 0x55);
        outb (reg_lbal (c), 0xaa);
 
        present[dev_no] = (inb (reg_nsect (c)) == 0x55
                && inb (reg_lbal (c)) == 0xaa);
    }
 
    /* Issue soft reset sequence, which selects device 0 as a side effect.
       Also enable interrupts. */
    outb (reg_ctl (c), 0);
    timer_usleep (10);
    outb (reg_ctl (c), CTL_SRST);
    timer_usleep (10);
    outb (reg_ctl (c), 0);
 
    timer_msleep (150);
 
    /* Wait for device 0 to clear BSY. */
    if (present[0]) {
        select_device (&c->devices[0]);
        wait_while_busy (&c->devices[0]);
    }
 
    /* Wait for device 1 to clear BSY. */
    if (present[1]) {
        int i;
 
        select_device (&c->devices[1]);
        for (i = 0; i < 3000; i++) {
            if (inb (reg_nsect (c)) == 1 && inb (reg_lbal (c)) == 1)
                break;
            timer_msleep (10);
        }
        wait_while_busy (&c->devices[1]);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

select_device()

static void select_device ( const struct disk *  d )

static

                                     {
    struct channel *c = d->channel;
    uint8_t dev = DEV_MBS;
    if (d->dev_no == 1)
        dev |= DEV_DEV;
    outb (reg_device (c), dev);
    inb (reg_alt_status (c));
    timer_nsleep (400);
}

Here is the call graph for this function:

Here is the caller graph for this function:

select_device_wait()

static void select_device_wait ( const struct disk *  d )

static

                                          {
    wait_until_idle (d);
    select_device (d);
    wait_until_idle (d);
}

Here is the call graph for this function:

Here is the caller graph for this function:

select_sector()

static void select_sector ( struct disk *  d, disk_sector_t  sec_no  )

static

                                                     {
    struct channel *c = d->channel;
 
    ASSERT (sec_no < d->capacity);
    ASSERT (sec_no < (1UL << 28));
 
    select_device_wait (d);
    outb (reg_nsect (c), 1);
    outb (reg_lbal (c), sec_no);
    outb (reg_lbam (c), sec_no >> 8);
    outb (reg_lbah (c), (sec_no >> 16));
    outb (reg_device (c),
            DEV_MBS | DEV_LBA | (d->dev_no == 1 ? DEV_DEV : 0) | (sec_no >> 24));
}

Here is the call graph for this function:

Here is the caller graph for this function:

wait_until_idle()

static void wait_until_idle ( const struct disk *  d )

static

                                       {
    int i;
 
    for (i = 0; i < 1000; i++) {
        if ((inb (reg_status (d->channel)) & (STA_BSY | STA_DRQ)) == 0)
            return;
        timer_usleep (10);
    }
 
    printf ("%s: idle timeout\n", d->name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

wait_while_busy()

static bool wait_while_busy ( const struct disk *  d )

static

                                       {
    struct channel *c = d->channel;
    int i;
 
    for (i = 0; i < 3000; i++) {
        if (i == 700)
            printf ("%s: busy, waiting...", d->name);
        if (!(inb (reg_alt_status (c)) & STA_BSY)) {
            if (i >= 700)
                printf ("ok\n");
            return (inb (reg_alt_status (c)) & STA_DRQ) != 0;
        }
        timer_msleep (10);
    }
 
    printf ("failed\n");
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

channels

struct channel channels[CHANNEL_CNT]

static