floppy.c

Go to the documentation of this file.

/*
 * kernel_drivers/adi_block/floppy.c
 *
 * Copyright (c) 2003-2004 Lukasz Dembinski <dembol@nasa.com.pl>
 * All Rights Reserved
 * 
 * Date:        2004/09
 * Author:      Lukasz Dembinski
 * Info:        floppy.c core file
 * Contact:     mailto: <dembol@nasa.com.pl>
 *
 */

#include <agnix/agnix.h>
#include <agnix/irq.h>
#include <agnix/adi/adi.h>
#include <agnix/memory.h>
#include <agnix/ioport.h>
#include <agnix/list.h>
#include <agnix/spinlock.h>
#include <agnix/console.h>

#define MOD_NAME                "FLOPPY: "

u8 floppy_DOR = DOR_DMA_GATE_NEG | DOR_RESET_NEG;
int floppy_was_request = 0;

extern struct chip_s dma_chip;

int floppy_reset(void)
{
    return 0;
}

int floppy_set_defaults(void)
{
    outb(floppy_DOR, FLOPPY_DOR);

    return 0;
}

int floppy_request_command(u8 command)
{
    int i;
    u8 msr;

    for (i = 0; i < FLOPPY_MAX_POLL_REQ_REPLIES; i++) {
        msr = inb(FLOPPY_MSR);
        if ((msr & MSR_RQM) && (!(msr & MSR_DIO))) {
            printk("send command ok\n");
            outb(command, FLOPPY_FIFO);
            return 0;
        }
    }
    
    floppy_was_request = 1;
    
    return -1;
}

int floppy_result_command(u8 *result_buf, int max_len)
{
    int i;
    int k = 0;
    u8 msr;

    for (k = 0; k < max_len; k++) {
        for (i = 0; i < FLOPPY_MAX_POLL_RES_REPLIES; i++) {
            msr = inb(FLOPPY_MSR);
            if ((msr & (MSR_RQM | MSR_DIO | MSR_CMD_BUSY)) == (MSR_RQM | MSR_DIO | MSR_CMD_BUSY)) {
                result_buf[k] = inb(FLOPPY_FIFO);
                break;
            }
        }
        
        if (i == FLOPPY_MAX_POLL_RES_REPLIES) {
            printk(MOD_NAME "%d %x\n", k, msr);
            break;
        }
    }
    
    floppy_was_request = 0;
    
    return k;    
}

int floppy_interrupt_check(void)
{
    return floppy_was_request;
}

void floppy_interrupt(u32 irq)
{
    printk("floppy irq\n");    
}


void floppy_motor_on(void)
{
    floppy_DOR |= DOR_MOT_EN0;
    outb(floppy_DOR, FLOPPY_DOR);
}

void floppy_motor_off(void)
{
    floppy_DOR &= ~DOR_MOT_EN0;
    outb(floppy_DOR, FLOPPY_DOR);
}

int floppy_setup_DMA(struct adi_blkreq_s *blkreq)
{
    dma_ops(&dma_chip)->dma_lock     (&dma_chip);
    dma_ops(&dma_chip)->dma_disable  (&dma_chip, FLOPPY_DMA);
    dma_ops(&dma_chip)->dma_clear_ff (&dma_chip, FLOPPY_DMA);
    dma_ops(&dma_chip)->dma_set_mode (&dma_chip, FLOPPY_DMA, DMA_MODE_READ);    
    dma_ops(&dma_chip)->dma_set_addr (&dma_chip, FLOPPY_DMA, (u32)virt_to_phys(blkreq->req_buf));    
    dma_ops(&dma_chip)->dma_set_count(&dma_chip, FLOPPY_DMA, (u16)blkreq->req_len_bytes);    
    dma_ops(&dma_chip)->dma_enable   (&dma_chip, FLOPPY_DMA);
    dma_ops(&dma_chip)->dma_unlock   (&dma_chip);

    return 0;
}

int floppy_request_read(struct adi_blkreq_s *blkreq)
{
    floppy_setup_DMA(blkreq);

    int i, k;
    for (k = 0; k < 4; k++) {
    floppy_motor_on();
    for (i = 0; i < 200000; i++);    
    floppy_motor_off();
    for (i = 0; i < 200000; i++);    
    }
    
    return 0;
}

int floppy_request_set_data(struct adi_blkreq_s *blkreq)
{
    u32 req_pages  = 1;
    u8  page_order = 0;
    
    while((req_pages << PAGE_SHIFT) < blkreq->req_len_bytes) {
        req_pages <<= 1;
        page_order++;
    }

    blkreq->req_buf = (u8 *)get_free_dma_pages(page_order);
    
    return 0;
}

int floppy_request(struct adi_blkreq_s *blkreq)
{
    /* TODO */

    blkreq->req_len_bytes = 10;
    floppy_request_set_data(blkreq);
    floppy_request_read(blkreq);    

    return 0;
}

int floppy_get_version(void)
{
    int result_len;
    u8 result_buf[16];

    floppy_request_command(FLOPPY_CMD_DUMPREGS);
    if ((result_len = floppy_result_command(result_buf, 16)) <= 0) {
        printk(MOD_NAME "bad FDC version\n");
        return -1;
    }
    
    if (result_len == 1 && result_buf[0] == 0x80) {
        printk(MOD_NAME "FDC 8272A detected\n");
        return FLOPPY_VER_8272A;
    }
    else
        printk(MOD_NAME "FDC version = %02x\n", result_buf[0]);
    
    floppy_request_command(FLOPPY_CMD_PARTID);
    if ((result_len = floppy_result_command(result_buf, 16)) != 1) {
        printk(MOD_NAME "PARTID cmd error\n");
        return FLOPPY_VER_UNKNOWN;
    }
    
    switch(result_buf[0]) {
        case 0x00:
            printk(MOD_NAME "FDC 82078 detected\n");
            return FLOPPY_VER_82078;
        
        case 0x20:
            printk(MOD_NAME "FDC 44-pin 82078 detected\n");
            return FLOPPY_VER_82078;

        case 0x40:
            printk(MOD_NAME "FDC 44-pin S82078B detected\n");
            return FLOPPY_VER_S82078B;

        case 0x60:
            printk(MOD_NAME "FDC National Semiconductor PC87306 detected\n");
            return FLOPPY_VER_87306;
            
        case 0x80:
            printk(MOD_NAME "FDC 82077 detected\n");
            return FLOPPY_VER_82077;
        
        default:
            printk(MOD_NAME "FDC with unknown PARTID detected\n");
            return FLOPPY_VER_UNKNOWN;
    }
    
    return -1;
}

struct irq_routine_s floppy_irq = {
    .proc       = floppy_interrupt,
    .check      = floppy_interrupt_check,
    .flags      = IRQ_FLAG_RANDOM
};

int floppy_set_irq(void)
{
    if (install_irq(FLOPPY_IRQ, &floppy_irq) < 0) {     
        printk(MOD_NAME "can not install irq %d routine\n", FLOPPY_IRQ);
        return -1;
    }
    
    return 0;
}

int floppy_set_dma(void)
{
    if (dma_ops(&dma_chip)->dma_request_channel(&dma_chip, FLOPPY_DMA) < 0) {
        printk(MOD_NAME "can not request dma %d channel\n", FLOPPY_DMA);
        return -1;
    }

    return 0;
}

int floppy_free_irq(void)
{
    return free_irq(FLOPPY_IRQ, &floppy_irq);
}

int floppy_free_dma(void)
{
    if (dma_ops(&dma_chip)->dma_put_channel(&dma_chip, FLOPPY_DMA) < 0) {
        printk(MOD_NAME "can not free dma %d channel\n", FLOPPY_DMA);
        return -1;
    }

    return 0;
}

struct adi_blkdev_ops_s floppy_ops = {
    .block_req          = floppy_request
};

struct adi_blkdev_s floppy_dev = {
    .dev_name           = "floppy",
    .dev_nr             = BLKDEV_FLOPPY_NR,
    .dev_flags          = BLKDEV_FLAG_DMA_REQ,
    .dev_ops            = &floppy_ops
};

int floppy_init(void)
{
    
    if (floppy_set_irq() < 0)
        return -1; 

    if (floppy_set_dma() < 0) {
        floppy_free_irq();
        return -1; 
    }

    adi_register_blkdev(&floppy_dev);
        
    floppy_set_defaults();
    floppy_get_version();

    return 0;
}

int adi_blkdrv_floppy_init(void)
{
    return floppy_init();
}