OpenCores
URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [rc203soc/] [sw/] [uClinux/] [arch/] [armnommu/] [kernel/] [dma-a5k.c] - Diff between revs 1765 and 1782

Only display areas with differences | Details | Blame | View Log

Rev 1765 Rev 1782
/*
/*
 * arch/arm/kernel/dma-a5k.c
 * arch/arm/kernel/dma-a5k.c
 *
 *
 * Copyright (C) 1998 Russell King
 * Copyright (C) 1998 Russell King
 *
 *
 * DMA functions specific to A5000 architecture
 * DMA functions specific to A5000 architecture
 */
 */
#include <linux/sched.h>
#include <linux/sched.h>
 
 
#include <asm/dma.h>
#include <asm/dma.h>
#include <asm/io.h>
#include <asm/io.h>
#include <asm/hardware.h>
#include <asm/hardware.h>
#include <asm/pgtable.h>
#include <asm/pgtable.h>
 
 
#include "dma.h"
#include "dma.h"
 
 
int arch_request_dma(dmach_t channel, dma_t *dma, const char *devname)
int arch_request_dma(dmach_t channel, dma_t *dma, const char *devname)
{
{
        if (channel == DMA_VIRTUAL_FLOPPY)
        if (channel == DMA_VIRTUAL_FLOPPY)
                return 0;
                return 0;
        else
        else
                return -EINVAL;
                return -EINVAL;
}
}
 
 
void arch_free_dma(dmach_t channel, dma_t *dma)
void arch_free_dma(dmach_t channel, dma_t *dma)
{
{
        if (channel != DMA_VIRTUAL_FLOPPY)
        if (channel != DMA_VIRTUAL_FLOPPY)
                printk ("arch_free_dma: invalid channel %d\n", channel);
                printk ("arch_free_dma: invalid channel %d\n", channel);
}
}
 
 
int arch_get_dma_residue(dmach_t channel, dma_t *dma)
int arch_get_dma_residue(dmach_t channel, dma_t *dma)
{
{
        if (channel != DMA_VIRTUAL_FLOPPY) {
        if (channel != DMA_VIRTUAL_FLOPPY) {
                printk ("arch_dma_count: invalid channel %d\n", channel);
                printk ("arch_dma_count: invalid channel %d\n", channel);
                return 0;
                return 0;
        } else {
        } else {
                extern int floppy_fiqresidual(void);
                extern int floppy_fiqresidual(void);
                return floppy_fiqresidual();
                return floppy_fiqresidual();
        }
        }
}
}
 
 
void arch_enable_dma(dmach_t channel, dma_t *dma)
void arch_enable_dma(dmach_t channel, dma_t *dma)
{
{
        if (channel != DMA_VIRTUAL_FLOPPY)
        if (channel != DMA_VIRTUAL_FLOPPY)
                printk ("arch_enable_dma: invalid channel %d\n", channel);
                printk ("arch_enable_dma: invalid channel %d\n", channel);
        else {
        else {
                void *fiqhandler_start;
                void *fiqhandler_start;
                unsigned int fiqhandler_length;
                unsigned int fiqhandler_length;
                extern void floppy_fiqsetup (unsigned long len, unsigned long addr,
                extern void floppy_fiqsetup (unsigned long len, unsigned long addr,
                                             unsigned long port);
                                             unsigned long port);
 
 
                if (dma->dma_mode == DMA_MODE_READ) {
                if (dma->dma_mode == DMA_MODE_READ) {
                        extern unsigned char floppy_fiqin_start, floppy_fiqin_end;
                        extern unsigned char floppy_fiqin_start, floppy_fiqin_end;
                        fiqhandler_start = &floppy_fiqin_start;
                        fiqhandler_start = &floppy_fiqin_start;
                        fiqhandler_length = &floppy_fiqin_end - &floppy_fiqin_start;
                        fiqhandler_length = &floppy_fiqin_end - &floppy_fiqin_start;
                } else {
                } else {
                        extern unsigned char floppy_fiqout_start, floppy_fiqout_end;
                        extern unsigned char floppy_fiqout_start, floppy_fiqout_end;
                        fiqhandler_start = &floppy_fiqout_start;
                        fiqhandler_start = &floppy_fiqout_start;
                        fiqhandler_length = &floppy_fiqout_end - &floppy_fiqout_start;
                        fiqhandler_length = &floppy_fiqout_end - &floppy_fiqout_start;
                }
                }
                memcpy ((void *)0x1c, fiqhandler_start, fiqhandler_length);
                memcpy ((void *)0x1c, fiqhandler_start, fiqhandler_length);
                flush_page_to_ram(0);
                flush_page_to_ram(0);
                floppy_fiqsetup (dma->buf.length, __bus_to_virt(dma->buf.address), (int)PCIO_FLOPPYDMABASE);
                floppy_fiqsetup (dma->buf.length, __bus_to_virt(dma->buf.address), (int)PCIO_FLOPPYDMABASE);
                enable_irq (dma->dma_irq);
                enable_irq (dma->dma_irq);
        }
        }
}
}
 
 
void arch_disable_dma(dmach_t channel, dma_t *dma)
void arch_disable_dma(dmach_t channel, dma_t *dma)
{
{
        if (channel != DMA_VIRTUAL_FLOPPY)
        if (channel != DMA_VIRTUAL_FLOPPY)
                printk ("arch_disable_dma: invalid channel %d\n", channel);
                printk ("arch_disable_dma: invalid channel %d\n", channel);
        else
        else
                disable_irq (dma->dma_irq);
                disable_irq (dma->dma_irq);
}
}
 
 
void arch_dma_init(dma_t *dma)
void arch_dma_init(dma_t *dma)
{
{
        dma[DMA_VIRTUAL_FLOPPY].dma_irq = 64;
        dma[DMA_VIRTUAL_FLOPPY].dma_irq = 64;
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.