RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

bsps/lm32: Move shared drivers to bsps

Browse Source 
This patch is a part of the BSP source reorganization.

Update #3285.
This commit is contained in:
Sebastian Huber
2018-04-23 13:31:18 +02:00
parent fc79b268eb
commit 2197852371
22 changed files with 18 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
c/src/lib/libbsp/lm32/milkymist/Makefile.am
View File

@@ -31,56 +31,56 @@ librtemsbsp_a_SOURCES += ../../../../../../bsps/shared/start/sbrk.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/irq/irq.c
# clock
librtemsbsp_a_SOURCES += ../shared/milkymist_clock/ckinit.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_clock/ckinit.c
# console
librtemsbsp_a_SOURCES += ../shared/milkymist_console/console.c
librtemsbsp_a_SOURCES += ../shared/milkymist_console/uart.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_console/console.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_console/uart.c
# timer
librtemsbsp_a_SOURCES += ../shared/milkymist_timer/timer.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_timer/timer.c
# framebuffer
librtemsbsp_a_SOURCES += ../shared/milkymist_framebuffer/framebuffer.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_framebuffer/framebuffer.c
# GPIO
librtemsbsp_a_SOURCES += ../shared/milkymist_gpio/gpio.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_gpio/gpio.c
# buttons
librtemsbsp_a_SOURCES += ../shared/milkymist_buttons/buttons.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_buttons/buttons.c
# ac97
librtemsbsp_a_SOURCES += ../shared/milkymist_ac97/ac97.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_ac97/ac97.c
# usbinput
librtemsbsp_a_SOURCES += ../shared/milkymist_usbinput/usbinput.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_usbinput/usbinput.c
# PFPU
librtemsbsp_a_SOURCES += ../shared/milkymist_pfpu/pfpu.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_pfpu/pfpu.c
# TMU
librtemsbsp_a_SOURCES += ../shared/milkymist_tmu/tmu.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_tmu/tmu.c
# memory card
librtemsbsp_a_SOURCES += ../shared/milkymist_memcard/memcard.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_memcard/memcard.c
# flash
librtemsbsp_a_SOURCES += ../shared/milkymist_flash/flash.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_flash/flash.c
# DMX
librtemsbsp_a_SOURCES += ../shared/milkymist_dmx/dmx.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_dmx/dmx.c
# MIDI
librtemsbsp_a_SOURCES += ../shared/milkymist_midi/midi.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_midi/midi.c
# IR
librtemsbsp_a_SOURCES += ../shared/milkymist_ir/ir.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_ir/ir.c
# video input
librtemsbsp_a_SOURCES += ../shared/milkymist_video/video.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_video/video.c
# versions
librtemsbsp_a_SOURCES += ../shared/milkymist_versions/versions.c
librtemsbsp_a_SOURCES += ../../../../../../bsps/lm32/shared/milkymist_versions/versions.c
# Cache
librtemsbsp_a_SOURCES += ../../../../../../bsps/shared/cache/nocache.c

436
c/src/lib/libbsp/lm32/shared/milkymist_ac97/ac97.c
View File

@@ -1,436 +0,0 @@
/* ac97.c
*
* Sound driver for Milkymist SoC
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <rtems.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include <rtems/status-checks.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_ac97.h>
#define SND_DEVICE_NAME "/dev/snd"
#define MIXER_DEVICE_NAME "/dev/mixer"
static rtems_id cr_write_sem;
static rtems_id cr_read_sem;
static rtems_isr crrequest_handler(rtems_vector_number n)
{
rtems_semaphore_release(cr_write_sem);
lm32_interrupt_ack(1 << MM_IRQ_AC97CRREQUEST);
}
static rtems_isr crreply_handler(rtems_vector_number n)
{
rtems_semaphore_release(cr_read_sem);
lm32_interrupt_ack(1 << MM_IRQ_AC97CRREPLY);
}
/* queued playback buffers */
#define PLAY_Q_SIZE 8
#define PLAY_Q_MASK (PLAY_Q_SIZE-1)
static struct snd_buffer *play_q[PLAY_Q_SIZE];
static int play_produce;
static int play_consume;
static int play_level;
/* buffers played, for application to collect */
static rtems_id play_q_done;
static void play_start(struct snd_buffer *buf)
{
if (buf->nsamples > (AC97_MAX_DMASIZE/4))
buf->nsamples = AC97_MAX_DMASIZE/4;
MM_WRITE(MM_AC97_DADDRESS, (unsigned int)buf->samples);
MM_WRITE(MM_AC97_DREMAINING, buf->nsamples*4);
MM_WRITE(MM_AC97_DCTL, AC97_SCTL_EN);
}
static rtems_isr pcmplay_handler(rtems_vector_number n)
{
lm32_interrupt_ack(1 << MM_IRQ_AC97DMAR);
rtems_message_queue_send(play_q_done, &play_q[play_consume],
sizeof(void *));
play_consume = (play_consume + 1) & PLAY_Q_MASK;
play_level--;
if(play_level > 0)
play_start(play_q[play_consume]);
else
MM_WRITE(MM_AC97_DCTL, 0);
}
/* queued record buffers */
#define RECORD_Q_SIZE 8
#define RECORD_Q_MASK (RECORD_Q_SIZE-1)
static struct snd_buffer *record_q[RECORD_Q_SIZE];
static int record_produce;
static int record_consume;
static int record_level;
/* buffers recorded, for application to collect */
static rtems_id record_q_done;
static void record_start(struct snd_buffer *buf)
{
if (buf->nsamples > (AC97_MAX_DMASIZE/4))
buf->nsamples = AC97_MAX_DMASIZE/4;
MM_WRITE(MM_AC97_UADDRESS, (unsigned int)buf->samples);
MM_WRITE(MM_AC97_UREMAINING, buf->nsamples*4);
MM_WRITE(MM_AC97_UCTL, AC97_SCTL_EN);
}
static rtems_isr pcmrecord_handler(rtems_vector_number n)
{
lm32_interrupt_ack(1 << MM_IRQ_AC97DMAW);
__asm__ volatile( /* Invalidate Level-1 data cache */
"wcsr DCC, r0\n"
"nop\n"
);
rtems_message_queue_send(record_q_done, &record_q[record_consume],
sizeof(void *));
record_consume = (record_consume + 1) & RECORD_Q_MASK;
record_level--;
if(record_level > 0)
record_start(record_q[record_consume]);
else
MM_WRITE(MM_AC97_UCTL, 0);
}
rtems_device_driver ac97_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(SND_DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create snd device");
sc = rtems_io_register_name(MIXER_DEVICE_NAME, major, 1);
RTEMS_CHECK_SC(sc, "create mixer device");
sc = rtems_semaphore_create(
rtems_build_name('C', 'R', 'W', 'S'),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&cr_write_sem
);
RTEMS_CHECK_SC(sc, "create AC97 register write semaphore");
sc = rtems_semaphore_create(
rtems_build_name('C', 'R', 'R', 'S'),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&cr_read_sem
);
RTEMS_CHECK_SC(sc, "create AC97 register read semaphore");
sc = rtems_message_queue_create(
rtems_build_name('P', 'L', 'Y', 'Q'),
PLAY_Q_SIZE*2,
sizeof(void *),
0,
&play_q_done
);
RTEMS_CHECK_SC(sc, "create playback done queue");
sc = rtems_message_queue_create(
rtems_build_name('R', 'E', 'C', 'Q'),
RECORD_Q_SIZE*2,
sizeof(void *),
0,
&record_q_done
);
RTEMS_CHECK_SC(sc, "create record done queue");
rtems_interrupt_catch(crrequest_handler, MM_IRQ_AC97CRREQUEST, &dummy);
rtems_interrupt_catch(crreply_handler, MM_IRQ_AC97CRREPLY, &dummy);
rtems_interrupt_catch(pcmplay_handler, MM_IRQ_AC97DMAR, &dummy);
rtems_interrupt_catch(pcmrecord_handler, MM_IRQ_AC97DMAW, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_AC97CRREQUEST);
bsp_interrupt_vector_enable(MM_IRQ_AC97CRREPLY);
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAR);
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAW);
play_produce = 0;
play_consume = 0;
play_level = 0;
record_produce = 0;
record_consume = 0;
record_level = 0;
return RTEMS_SUCCESSFUL;
}
static rtems_status_code submit_play(struct snd_buffer *buf)
{
bsp_interrupt_vector_disable(MM_IRQ_AC97DMAR);
if (play_level == PLAY_Q_SIZE) {
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAR);
return RTEMS_UNSATISFIED;
}
play_q[play_produce] = buf;
play_produce = (play_produce + 1) & PLAY_Q_MASK;
play_level++;
if (play_level == 1)
play_start(buf);
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAR);
return RTEMS_SUCCESSFUL;
}
static rtems_status_code collect_play(struct snd_buffer **buf)
{
size_t s;
return rtems_message_queue_receive(
play_q_done,
buf,
&s,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
}
static rtems_status_code submit_record(struct snd_buffer *buf)
{
bsp_interrupt_vector_disable(MM_IRQ_AC97DMAW);
if (record_level == RECORD_Q_SIZE) {
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAW);
return RTEMS_UNSATISFIED;
}
record_q[record_produce] = buf;
record_produce = (record_produce + 1) & RECORD_Q_MASK;
record_level++;
if (record_level == 1)
record_start(buf);
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAW);
return RTEMS_SUCCESSFUL;
}
static rtems_status_code collect_record(struct snd_buffer **buf)
{
size_t s;
return rtems_message_queue_receive(
record_q_done,
buf,
&s,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
}
#define CR_TIMEOUT 10
static int read_cr(unsigned int adr)
{
rtems_status_code sc;
MM_WRITE(MM_AC97_CRADDR, adr);
MM_WRITE(MM_AC97_CRCTL, AC97_CRCTL_RQEN);
sc = rtems_semaphore_obtain(cr_write_sem, RTEMS_WAIT, CR_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return -1;
sc = rtems_semaphore_obtain(cr_read_sem, RTEMS_WAIT, CR_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return -1;
return MM_READ(MM_AC97_CRDATAIN);
}
static int write_cr(unsigned int adr, unsigned int val)
{
rtems_status_code sc;
MM_WRITE(MM_AC97_CRADDR, adr);
MM_WRITE(MM_AC97_CRDATAOUT, val);
MM_WRITE(MM_AC97_CRCTL, AC97_CRCTL_RQEN|AC97_CRCTL_WRITE);
sc = rtems_semaphore_obtain(cr_write_sem, RTEMS_WAIT, CR_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return 0;
return 1;
}
rtems_device_driver ac97_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
int codec_id;
if (minor == 0) {
/* snd */
return RTEMS_SUCCESSFUL;
} else {
/* mixer */
codec_id = read_cr(0x00);
if ((codec_id != 0x0d50) && (codec_id != 0x6150)) {
printk("AC97 codec detection failed\n");
return RTEMS_UNSATISFIED;
}
write_cr(0x02, 0x0000); /* master volume */
write_cr(0x04, 0x0f0f); /* headphones volume */
write_cr(0x18, 0x0000); /* PCM out volume */
write_cr(0x1c, 0x0f0f); /* record gain */
write_cr(0x1a, 0x0505); /* record select: stereo mix */
return RTEMS_SUCCESSFUL;
}
}
static rtems_status_code ioctl_read_channel(void *buf,
unsigned int chan, int mono)
{
unsigned int *val = (unsigned int *)buf;
int mic_boost;
int codec;
int left, right;
codec = read_cr(chan);
if (codec < 0)
return RTEMS_UNSATISFIED;
if (codec & 0x8000) {
/* muted */
*val = 0;
return RTEMS_SUCCESSFUL;
}
if (mono) {
left = 100-(((codec & 0x1f) + 1)*100)/32;
mic_boost = (codec & (1 << 6)) >> 6;
*val = left | mic_boost << 8;
} else {
right = 100-(((codec & 0x1f) + 1)*100)/32;
left = 100-((((codec & 0x1f00) >> 8) + 1)*100)/32;
*val = left | (right << 8);
}
return RTEMS_SUCCESSFUL;
}
static rtems_status_code ioctl_write_channel(void *buf,
unsigned int chan, int mono)
{
unsigned int *val = (unsigned int *)buf;
int mic_boost;
int left, right;
int codec;
rtems_status_code sc;
left = *val & 0xff;
left = (left*32)/100 - 1;
if (left < 0)
left = 0;
if (mono) {
mic_boost = *val >> 8;
right = 31;
} else {
right = (*val >> 8) & 0xff;
right = (right*32)/100 - 1;
if (right < 0)
right = 0;
}
if ((left == 0) && (right == 0))
/* mute */
codec = 0x8000;
else
codec = (31-left) | ((31-right) << 8);
if (mono) {
if (mic_boost)
codec |= (1 << 6);
else
codec &= ~(1 << 6);
}
if (!write_cr(chan, codec))
sc = RTEMS_UNSATISFIED;
else
sc = RTEMS_SUCCESSFUL;
return sc;
}
rtems_device_driver ac97_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
rtems_status_code sc;
args->ioctl_return = -1;
if(minor == 0) {
/* dsp */
switch (args->command) {
case SOUND_SND_SUBMIT_PLAY:
return submit_play((struct snd_buffer *)args->buffer);
case SOUND_SND_COLLECT_PLAY:
return collect_play((struct snd_buffer **)args->buffer);
case SOUND_SND_SUBMIT_RECORD:
return submit_record((struct snd_buffer *)args->buffer);
case SOUND_SND_COLLECT_RECORD:
return collect_record((struct snd_buffer **)args->buffer);
default:
return RTEMS_UNSATISFIED;
}
} else {
/* mixer */
switch (args->command) {
case SOUND_MIXER_READ(SOUND_MIXER_MIC):
sc = ioctl_read_channel(args->buffer, 0x0e, 1);
if(sc == RTEMS_SUCCESSFUL)
args->ioctl_return = 0;
return sc;
case SOUND_MIXER_READ(SOUND_MIXER_LINE):
sc = ioctl_read_channel(args->buffer, 0x10, 0);
if(sc == RTEMS_SUCCESSFUL)
args->ioctl_return = 0;
return sc;
case SOUND_MIXER_WRITE(SOUND_MIXER_MIC):
sc = ioctl_write_channel(args->buffer, 0x0e, 1);
if(sc == RTEMS_SUCCESSFUL)
args->ioctl_return = 0;
return sc;
case SOUND_MIXER_WRITE(SOUND_MIXER_LINE):
sc = ioctl_write_channel(args->buffer, 0x10, 0);
if(sc == RTEMS_SUCCESSFUL)
args->ioctl_return = 0;
return sc;
default:
return RTEMS_UNSATISFIED;
}
}
}

130
c/src/lib/libbsp/lm32/shared/milkymist_buttons/buttons.c
View File

@@ -1,130 +0,0 @@
/* buttons.c
*
* Buttons driver for the Milkymist One board
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <rtems.h>
#include <rtems/status-checks.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_buttons.h>
#define DEVICE_NAME "/dev/buttons"
static rtems_id event_q;
static void send_byte(char b)
{
rtems_message_queue_send(event_q, &b, 1);
}
static rtems_isr interrupt_handler(rtems_vector_number n)
{
static unsigned int previous_keys;
unsigned int keys, pushed_keys, released_keys;
keys = MM_READ(MM_GPIO_IN) & (GPIO_BTN1|GPIO_BTN2|GPIO_BTN3);
pushed_keys = keys & ~previous_keys;
released_keys = previous_keys & ~keys;
previous_keys = keys;
if(pushed_keys & GPIO_BTN1)
send_byte('A');
if(pushed_keys & GPIO_BTN2)
send_byte('B');
if(pushed_keys & GPIO_BTN3)
send_byte('C');
if(released_keys & GPIO_BTN1)
send_byte('a');
if(released_keys & GPIO_BTN2)
send_byte('b');
if(released_keys & GPIO_BTN3)
send_byte('c');
lm32_interrupt_ack(1 << MM_IRQ_GPIO);
}
rtems_device_driver buttons_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create buttons device");
sc = rtems_message_queue_create(
rtems_build_name('B', 'T', 'N', 'Q'),
24,
1,
0,
&event_q
);
RTEMS_CHECK_SC(sc, "create buttons event queue");
rtems_interrupt_catch(interrupt_handler, MM_IRQ_GPIO, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_GPIO);
MM_WRITE(MM_GPIO_INTEN, GPIO_BTN1|GPIO_BTN2|GPIO_BTN3);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver buttons_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
uint32_t count;
rtems_message_queue_flush(event_q, &count);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver buttons_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
rtems_status_code sc;
if(rw_args->count < 1) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
sc = rtems_message_queue_receive(
event_q,
rw_args->buffer,
(size_t *)&rw_args->bytes_moved,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if(sc == RTEMS_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
else {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
}

52
c/src/lib/libbsp/lm32/shared/milkymist_clock/ckinit.c
View File

@@ -1,52 +0,0 @@
/*
* Clock device driver for Lattice Mico32 (lm32).
*/
/*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) Yann Sionneau <yann.sionneau@telecom-sudparis.eu> (GSoC 2010)
* Telecom SudParis
*/
#include <bsp.h>
#include <bsp/irq-generic.h>
#include "../include/system_conf.h"
#include "clock.h"
#include "bspopts.h"
#if ON_SIMULATOR
#define CLOCK_DRIVER_USE_FAST_IDLE 1
#endif
#define Clock_driver_support_at_tick() \
do { \
lm32_interrupt_ack(1 << MM_IRQ_TIMER0); \
} while (0)
#define Clock_driver_support_install_isr(_new ) \
do { \
rtems_isr_entry _old; \
rtems_interrupt_catch(_new, MM_IRQ_TIMER0, &_old); \
} while (0)
static void Clock_driver_support_initialize_hardware(void)
{
MM_WRITE(MM_TIMER0_COMPARE,
(MM_READ(MM_FREQUENCY)/(1000000/rtems_configuration_get_microseconds_per_tick())));
MM_WRITE(MM_TIMER0_COUNTER, 0);
MM_WRITE(MM_TIMER0_CONTROL, TIMER_ENABLE | TIMER_AUTORESTART);
bsp_interrupt_vector_enable(MM_IRQ_TIMER0);
}
#define Clock_driver_support_shutdown_hardware() \
do { \
bsp_interrupt_vector_disable(MM_IRQ_TIMER0); \
MM_WRITE(MM_TIMER0_CONTROL, 0); \
} while (0)
#define CLOCK_DRIVER_USE_DUMMY_TIMECOUNTER
#include "../../../shared/dev/clock/clockimpl.h"

22
c/src/lib/libbsp/lm32/shared/milkymist_clock/clock.h
View File

@@ -1,22 +0,0 @@
/**
* @file
* @ingroup lm32_clock lm32_milkymist_shared
* @brief LatticeMico32 Timer (Clock) definitions
*/
/*
* This file contains definitions for LatticeMico32 Timer (Clock)
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) Yann Sionneau <yann.sionneau@telecom-sudparis.eu> (GSoC 2010)
* Telecom SudParis
*/
#ifndef _BSPCLOCK_H
#define _BSPCLOCK_H
#endif /* _BSPCLOCK_H */

216
c/src/lib/libbsp/lm32/shared/milkymist_console/console.c
View File

@@ -1,216 +0,0 @@
/*
* Console driver for Milkymist
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010 Sebastien Bourdeauducq
*/
#include <unistd.h>
#include <termios.h>
#include <rtems.h>
#include <rtems/bspIo.h>
#include <rtems/libio.h>
#include <rtems/console.h>
#include <rtems/termiostypes.h>
#include <bsp/irq-generic.h>
#include "../include/system_conf.h"
#include "uart.h"
BSP_output_char_function_type BSP_output_char = BSP_uart_polled_write;
BSP_polling_getchar_function_type BSP_poll_char = BSP_uart_polled_read;
static struct rtems_termios_tty *tty;
static int mmconsole_first_open(int major, int minor, void *arg)
{
tty = ((rtems_libio_open_close_args_t *) arg)->iop->data1;
return rtems_termios_set_initial_baud(tty, UART_BAUD_RATE);
}
static int mmconsole_last_close(int major, int minor, void *arg)
{
return 0;
}
static int mmconsole_set_attributes(int minor, const struct termios *t)
{
int baud;
switch (t->c_ospeed) {
case B0:
baud = 0;
break;
case B50:
baud = 50;
break;
case B75:
baud = 75;
break;
case B110:
baud = 110;
break;
case B134:
baud = 134;
break;
case B150:
baud = 150;
break;
case B200:
baud = 200;
break;
case B300:
baud = 300;
break;
case B600:
baud = 600;
break;
case B1200:
baud = 1200;
break;
case B1800:
baud = 1800;
break;
case B2400:
baud = 2400;
break;
case B4800:
baud = 4800;
break;
case B9600:
baud = 9600;
break;
case B19200:
baud = 19200;
break;
case B38400:
baud = 38400;
break;
case B57600:
baud = 57600;
break;
case B115200:
baud = 115200;
break;
case B230400:
baud = 230400;
break;
case B460800:
baud = 460800;
break;
default:
baud = -1;
break;
}
if (baud > 0)
MM_WRITE(MM_UART_DIV, MM_READ(MM_FREQUENCY)/baud/16);
return 0;
}
static ssize_t mmconsole_write(int minor, const char *buf, size_t n)
{
if (n > 0) {
MM_WRITE(MM_UART_RXTX, *buf);
}
return 0;
}
static rtems_isr mmconsole_interrupt(rtems_vector_number n)
{
char c;
while (MM_READ(MM_UART_STAT) & UART_STAT_RX_EVT) {
c = MM_READ(MM_UART_RXTX);
MM_WRITE(MM_UART_STAT, UART_STAT_RX_EVT);
rtems_termios_enqueue_raw_characters(tty, &c, 1);
}
if (MM_READ(MM_UART_STAT) & UART_STAT_TX_EVT) {
MM_WRITE(MM_UART_STAT, UART_STAT_TX_EVT);
rtems_termios_dequeue_characters(tty, 1);
}
lm32_interrupt_ack(1 << MM_IRQ_UART);
}
static const rtems_termios_callbacks mmconsole_callbacks = {
.firstOpen = mmconsole_first_open,
.lastClose = mmconsole_last_close,
.pollRead = NULL,
.write = mmconsole_write,
.setAttributes = mmconsole_set_attributes,
.stopRemoteTx = NULL,
.startRemoteTx = NULL,
.outputUsesInterrupts = TERMIOS_IRQ_DRIVEN
};
rtems_device_driver console_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code status;
rtems_isr_entry dummy;
rtems_termios_initialize();
status = rtems_io_register_name("/dev/console", major, 0);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
rtems_interrupt_catch(mmconsole_interrupt, MM_IRQ_UART, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_UART);
MM_WRITE(MM_UART_CTRL, UART_CTRL_RX_INT|UART_CTRL_TX_INT);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver console_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
return rtems_termios_open(major, minor, arg, &mmconsole_callbacks);
}
rtems_device_driver console_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
return rtems_termios_close(arg);
}
rtems_device_driver console_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
return rtems_termios_read(arg);
}
rtems_device_driver console_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
return rtems_termios_write(arg);
}
rtems_device_driver console_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
return rtems_termios_ioctl(arg);
}

46
c/src/lib/libbsp/lm32/shared/milkymist_console/uart.c
View File

@@ -1,46 +0,0 @@
/*
* Driver for Milkymist UART
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010 Sebastien Bourdeauducq
* COPYRIGHT (c) Yann Sionneau <yann.sionneau@telecom-sudparis.eu> (GSoC 2010)
* Telecom SudParis
*/
#include <rtems.h>
#include <rtems/libio.h>
#include "../include/system_conf.h"
#include "uart.h"
void BSP_uart_init(int baud)
{
MM_WRITE(MM_UART_DIV, MM_READ(MM_FREQUENCY)/baud/16);
}
void BSP_uart_polled_write(char ch)
{
rtems_interrupt_level level;
rtems_interrupt_disable(level);
while(!(MM_READ(MM_UART_STAT) & UART_STAT_THRE));
MM_WRITE(MM_UART_RXTX, ch);
while(!(MM_READ(MM_UART_STAT) & UART_STAT_THRE));
rtems_interrupt_enable(level);
}
int BSP_uart_polled_read(void)
{
char r;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
while(!(MM_READ(MM_UART_STAT) & UART_STAT_RX_EVT));
r = MM_READ(MM_UART_RXTX);
MM_WRITE(MM_UART_STAT, UART_STAT_RX_EVT);
rtems_interrupt_enable(level);
return r;
}

22
c/src/lib/libbsp/lm32/shared/milkymist_console/uart.h
View File

@@ -1,22 +0,0 @@
/**
* @file
* @ingroup lm32_uart lm32_milkymist_shared
* @brief Milkymist UART definitions
*/
/*
* This file contains definitions for the Milkymist UART
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*/
#ifndef _BSPUART_H
#define _BSPUART_H
void BSP_uart_init(int baud);
void BSP_uart_polled_write(char ch);
int BSP_uart_polled_read(void);
#endif /* _BSPUART_H */

128
c/src/lib/libbsp/lm32/shared/milkymist_dmx/dmx.c
View File

@@ -1,128 +0,0 @@
/* dmx.c
*
* Milkymist DMX512 driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <sys/types.h>
#include <rtems.h>
#include <rtems/status-checks.h>
#include <bsp.h>
#include <rtems/libio.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_dmx.h>
#define IN_DEVICE_NAME "/dev/dmx_in"
#define OUT_DEVICE_NAME "/dev/dmx_out"
rtems_device_driver dmx_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
sc = rtems_io_register_name(IN_DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create DMX input device");
sc = rtems_io_register_name(OUT_DEVICE_NAME, major, 1);
RTEMS_CHECK_SC(sc, "create DMX output device");
return RTEMS_SUCCESSFUL;
}
rtems_device_driver dmx_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
int len;
unsigned int i;
unsigned char *values = (unsigned char *)rw_args->buffer;
len = 512 - rw_args->offset;
if (len < 0) {
rw_args->bytes_moved = 0;
return RTEMS_SUCCESSFUL;
}
if (len > rw_args->count)
len = rw_args->count;
if (minor == 0) {
for (i=0;i<len;i++)
values[i] = MM_READ(MM_DMX_RX((unsigned int)rw_args->offset+i));
} else {
for (i=0;i<len;i++)
values[i] = MM_READ(MM_DMX_TX((unsigned int)rw_args->offset+i));
}
rw_args->bytes_moved = len;
return RTEMS_SUCCESSFUL;
}
rtems_device_driver dmx_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
int len;
unsigned int i;
unsigned char *values = (unsigned char *)rw_args->buffer;
if (minor == 0) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
len = 512 - rw_args->offset;
if (len < 0) {
rw_args->bytes_moved = 0;
return RTEMS_SUCCESSFUL;
}
if (len > rw_args->count)
len = rw_args->count;
for (i=0;i<len;i++)
MM_WRITE(MM_DMX_TX((unsigned int)rw_args->offset+i), values[i]);
rw_args->bytes_moved = len;
return RTEMS_SUCCESSFUL;
}
rtems_device_driver dmx_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
switch (args->command) {
case DMX_SET_THRU:
args->ioctl_return = 0;
MM_WRITE(MM_DMX_THRU, (unsigned int)args->buffer);
return RTEMS_SUCCESSFUL;
case DMX_GET_THRU:
args->ioctl_return = 0;
*((unsigned int *)args->buffer) = MM_READ(MM_DMX_THRU);
return RTEMS_SUCCESSFUL;
default:
args->ioctl_return = -1;
return RTEMS_UNSATISFIED;
}
}

193
c/src/lib/libbsp/lm32/shared/milkymist_flash/flash.c
View File

@@ -1,193 +0,0 @@
/* flash.c
*
* Milkymist flash driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <rtems.h>
#include <stdio.h>
#include <bsp.h>
#include <string.h>
#include <rtems/libio.h>
#include <rtems/status-checks.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_flash.h>
static struct flash_partition partitions[FLASH_PARTITION_COUNT]
= FLASH_PARTITIONS;
static rtems_id flash_lock;
rtems_device_driver flash_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
int i;
char devname[16];
for (i=0;i<FLASH_PARTITION_COUNT;i++) {
sprintf(devname, "/dev/flash%d", i+1);
sc = rtems_io_register_name(devname, major, i);
RTEMS_CHECK_SC(sc, "Create flash device");
}
sc = rtems_semaphore_create(
rtems_build_name('F', 'L', 'S', 'H'),
1,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&flash_lock
);
RTEMS_CHECK_SC(sc, "create semaphore");
return RTEMS_SUCCESSFUL;
}
rtems_device_driver flash_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
void *startaddr;
int len;
if (minor >= FLASH_PARTITION_COUNT)
return RTEMS_UNSATISFIED;
startaddr = (void *)(partitions[minor].start_address
+ (unsigned int)rw_args->offset);
len = partitions[minor].length - rw_args->offset;
if (len > rw_args->count)
len = rw_args->count;
if (len <= 0) {
rw_args->bytes_moved = 0;
return RTEMS_SUCCESSFUL;
}
rtems_semaphore_obtain(flash_lock, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
memcpy(rw_args->buffer, startaddr, len);
rtems_semaphore_release(flash_lock);
rw_args->bytes_moved = len;
return RTEMS_SUCCESSFUL;
}
rtems_device_driver flash_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
volatile unsigned short *startaddr;
unsigned short *srcdata;
int len;
int this_time;
int remaining;
int i;
if (minor >= FLASH_PARTITION_COUNT)
return RTEMS_UNSATISFIED;
startaddr = (unsigned short *)(partitions[minor].start_address
+ (unsigned int)rw_args->offset);
len = partitions[minor].length - rw_args->offset;
if (len > rw_args->count)
len = rw_args->count;
if (len <= 2) {
rw_args->bytes_moved = 0;
return RTEMS_SUCCESSFUL;
}
len /= 2;
srcdata = (unsigned short *)rw_args->buffer;
remaining = len;
rtems_semaphore_obtain(flash_lock, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
while (remaining > 0) {
this_time = remaining;
if (this_time > 256)
this_time = 256;
/* Issue "Buffered Programming Setup" command
* and wait for buffer available.
*/
do {
*startaddr = 0x00e8;
} while (!(*startaddr & 0x0080));
/* Load word count */
*startaddr = this_time-1;
/* Fill buffer */
for(i=0;i<this_time;i++)
startaddr[i] = srcdata[i];
/* Issue "Buffer Programming Confirm" command */
*startaddr = 0x00d0;
while (!(*startaddr & 0x0080)); /* read status register, wait for ready */
*startaddr = 0x0050; /* clear status register */
/* update state */
startaddr += this_time;
srcdata += this_time;
remaining -= this_time;
}
*startaddr = 0x00ff; /* back to read array mode */
rtems_semaphore_release(flash_lock);
rw_args->bytes_moved = 2*len;
return RTEMS_SUCCESSFUL;
}
rtems_device_driver flash_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
unsigned int eraseaddr_i;
volatile unsigned short *eraseaddr;
if (minor >= FLASH_PARTITION_COUNT) {
args->ioctl_return = -1;
return RTEMS_UNSATISFIED;
}
switch (args->command) {
case FLASH_GET_SIZE:
*((unsigned int *)args->buffer) = partitions[minor].length;
break;
case FLASH_GET_BLOCKSIZE:
*((unsigned int *)args->buffer) = 128*1024;
break;
case FLASH_ERASE_BLOCK:
eraseaddr_i = (unsigned int)args->buffer;
if (eraseaddr_i >= partitions[minor].length) {
args->ioctl_return = -1;
return RTEMS_UNSATISFIED;
}
eraseaddr_i = eraseaddr_i + partitions[minor].start_address;
eraseaddr = (unsigned short *)eraseaddr_i;
rtems_semaphore_obtain(flash_lock, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
*eraseaddr = 0x0020; /* erase */
*eraseaddr = 0x00d0;
while(!(*eraseaddr & 0x0080)); /* read status register, wait for ready */
*eraseaddr = 0x0050; /* clear status register */
*eraseaddr = 0x00ff; /* back to read array mode */
rtems_semaphore_release(flash_lock);
break;
default:
args->ioctl_return = -1;
return RTEMS_UNSATISFIED;
}
args->ioctl_return = 0;
return RTEMS_SUCCESSFUL;
}

251
c/src/lib/libbsp/lm32/shared/milkymist_framebuffer/framebuffer.c
View File

@@ -1,251 +0,0 @@
/* framebuffer.c
*
* This file is the framebuffer driver for the Milkymist VGA IP-core
* This VGA Core is a part of Milkymist System-on-Chip
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) Yann Sionneau <yann.sionneau@telecom-sudparis.eu> (GSoC 2010)
* Telecom SudParis
* Copyright (c) 2011 Sebastien Bourdeauducq
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <rtems.h>
#include <bsp.h>
#include "../include/system_conf.h"
#include <rtems/libio.h>
#include <rtems/fb.h>
#include <rtems/framebuffer.h>
#include <rtems/bspIo.h>
static unsigned short int framebufferA[1024*768]
__attribute__((aligned(32)));
static unsigned short int framebufferB[1024*768]
__attribute__((aligned(32)));
static unsigned short int framebufferC[1024*768]
__attribute__((aligned(32)));
static unsigned short int *frontbuffer;
static unsigned short int *backbuffer;
static unsigned short int *lastbuffer;
static struct fb_var_screeninfo fb_var = {
.xres = 640,
.yres = 480,
.bits_per_pixel = 16
};
static struct fb_fix_screeninfo fb_fix = {
.smem_len = 1024 * 768 * 2,
.type = FB_TYPE_VGA_PLANES,
.visual = FB_VISUAL_TRUECOLOR,
.line_length = 80
};
static int get_fix_screen_info( struct fb_fix_screeninfo *info )
{
*info = fb_fix;
return 0;
}
static int get_var_screen_info( struct fb_var_screeninfo *info )
{
*info = fb_var;
return 0;
}
static void init_buffers(void)
{
frontbuffer = framebufferA;
backbuffer = framebufferB;
lastbuffer = framebufferC;
}
static void swap_buffers(void)
{
unsigned short int *p;
/* Make sure last buffer swap has been executed */
while (MM_READ(MM_VGA_BASEADDRESS_ACT) != MM_READ(MM_VGA_BASEADDRESS));
p = frontbuffer;
frontbuffer = backbuffer;
backbuffer = lastbuffer;
lastbuffer = p;
fb_fix.smem_start = (volatile char *)backbuffer;
MM_WRITE(MM_VGA_BASEADDRESS, (unsigned int)frontbuffer);
}
static void set_video_mode(int mode)
{
int hres, vres;
MM_WRITE(MM_VGA_RESET, VGA_RESET);
hres = vres = 0;
switch(mode) {
case 0: // 640x480, pixel clock: 25MHz
hres = 640;
vres = 480;
MM_WRITE(MM_VGA_HSYNC_START, 656);
MM_WRITE(MM_VGA_HSYNC_END, 752);
MM_WRITE(MM_VGA_HSCAN, 799);
MM_WRITE(MM_VGA_VSYNC_START, 492);
MM_WRITE(MM_VGA_VSYNC_END, 494);
MM_WRITE(MM_VGA_VSCAN, 524);
MM_WRITE(MM_VGA_CLKSEL, 0);
break;
case 1: // 800x600, pixel clock: 50MHz
hres = 800;
vres = 600;
MM_WRITE(MM_VGA_HSYNC_START, 848);
MM_WRITE(MM_VGA_HSYNC_END, 976);
MM_WRITE(MM_VGA_HSCAN, 1040);
MM_WRITE(MM_VGA_VSYNC_START, 636);
MM_WRITE(MM_VGA_VSYNC_END, 642);
MM_WRITE(MM_VGA_VSCAN, 665);
MM_WRITE(MM_VGA_CLKSEL, 1);
break;
case 2: // 1024x768, pixel clock: 65MHz
hres = 1024;
vres = 768;
MM_WRITE(MM_VGA_HSYNC_START, 1048);
MM_WRITE(MM_VGA_HSYNC_END, 1184);
MM_WRITE(MM_VGA_HSCAN, 1344);
MM_WRITE(MM_VGA_VSYNC_START, 772);
MM_WRITE(MM_VGA_VSYNC_END, 778);
MM_WRITE(MM_VGA_VSCAN, 807);
MM_WRITE(MM_VGA_CLKSEL, 2);
break;
}
if((hres != 0) && (vres != 0)) {
MM_WRITE(MM_VGA_HRES, hres);
MM_WRITE(MM_VGA_VRES, vres);
fb_var.xres = hres;
fb_var.yres = vres;
memset(framebufferA, 0, hres*vres*2);
memset(framebufferB, 0, hres*vres*2);
memset(framebufferC, 0, hres*vres*2);
MM_WRITE(MM_VGA_BURST_COUNT, hres*vres/16);
MM_WRITE(MM_VGA_RESET, 0);
} /* otherwise, leave the VGA controller in reset */
}
rtems_device_driver frame_buffer_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code status;
init_buffers();
fb_fix.smem_start = (volatile char *)frontbuffer;
MM_WRITE(MM_VGA_BASEADDRESS, (unsigned int)frontbuffer);
status = rtems_io_register_name(FRAMEBUFFER_DEVICE_0_NAME, major, 0);
if (status != RTEMS_SUCCESSFUL) {
printk("Error registering frame buffer device!\n");
rtems_fatal_error_occurred( status );
}
return RTEMS_SUCCESSFUL;
}
rtems_device_driver frame_buffer_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
return RTEMS_SUCCESSFUL;
}
rtems_device_driver frame_buffer_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
return RTEMS_SUCCESSFUL;
}
rtems_device_driver frame_buffer_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
rw_args->bytes_moved = ((rw_args->offset + rw_args->count) > fb_fix.smem_len)
? (fb_fix.smem_len - rw_args->offset) : rw_args->count;
memcpy(rw_args->buffer, (const void *)(fb_fix.smem_start + rw_args->offset),
rw_args->bytes_moved);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver frame_buffer_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
rw_args->bytes_moved = ((rw_args->offset + rw_args->count) > fb_fix.smem_len)
? (fb_fix.smem_len - rw_args->offset) : rw_args->count;
memcpy((void *)(fb_fix.smem_start + rw_args->offset), rw_args->buffer,
rw_args->bytes_moved);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver frame_buffer_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
switch (args->command) {
case FBIOGET_FSCREENINFO:
args->ioctl_return =
get_fix_screen_info((struct fb_fix_screeninfo *)args->buffer);
return RTEMS_SUCCESSFUL;
case FBIOGET_VSCREENINFO:
args->ioctl_return =
get_var_screen_info((struct fb_var_screeninfo *)args->buffer);
return RTEMS_SUCCESSFUL;
case FBIOSWAPBUFFERS:
swap_buffers();
args->ioctl_return = 0;
return RTEMS_SUCCESSFUL;
case FBIOSETBUFFERMODE:
args->ioctl_return = 0;
switch ((unsigned int)args->buffer) {
case FB_SINGLE_BUFFERED:
init_buffers();
fb_fix.smem_start = (volatile char *)frontbuffer;
MM_WRITE(MM_VGA_BASEADDRESS, (unsigned int)frontbuffer);
return RTEMS_SUCCESSFUL;
case FB_TRIPLE_BUFFERED:
fb_fix.smem_start = (volatile char *)backbuffer;
return RTEMS_SUCCESSFUL;
default:
return RTEMS_UNSATISFIED;
}
case FBIOSETVIDEOMODE:
set_video_mode((int)args->buffer);
return RTEMS_SUCCESSFUL;
default:
args->ioctl_return = -1;
return RTEMS_UNSATISFIED;
}
}

119
c/src/lib/libbsp/lm32/shared/milkymist_gpio/gpio.c
View File

@@ -1,119 +0,0 @@
/* gpio.c
*
* GPIO driver for the Milkymist One board
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
* COPYRIGHT (c) Yann Sionneau <yann.sionneau@telecom-sudparis.eu> (GSoC 2010)
* Telecom SudParis
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <rtems.h>
#include <rtems/status-checks.h>
#include <bsp.h>
#include <rtems/libio.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_gpio.h>
struct milkymist_gpio {
char *name;
unsigned int mask;
bool readonly;
};
static const struct milkymist_gpio gpio[] = {
{
.name = "/dev/led1",
.mask = GPIO_LED1,
.readonly = false
},
{
.name = "/dev/led2",
.mask = GPIO_LED2,
.readonly = false
},
};
rtems_device_driver gpio_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
int i;
for (i=0;i<sizeof(gpio)/sizeof(struct milkymist_gpio);i++) {
sc = rtems_io_register_name(gpio[i].name, major, i);
RTEMS_CHECK_SC(sc, "create GPIO device");
}
return RTEMS_SUCCESSFUL;
}
rtems_device_driver gpio_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
unsigned int data;
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
if (rw_args->offset > 0) {
rw_args->bytes_moved = 0;
return RTEMS_SUCCESSFUL;
}
rw_args->bytes_moved = 1;
if (gpio[minor].readonly)
data = MM_READ(MM_GPIO_IN);
else
data = MM_READ(MM_GPIO_OUT);
if (data & gpio[minor].mask)
*(uint8_t *)rw_args->buffer = '1';
else
*(uint8_t *)rw_args->buffer = '0';
return RTEMS_SUCCESSFUL;
}
rtems_device_driver gpio_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
if (gpio[minor].readonly) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
if (rw_args->offset > 0) {
rw_args->bytes_moved = 0;
return RTEMS_SUCCESSFUL;
}
rw_args->bytes_moved = 1;
if (*(uint8_t *)rw_args->buffer == '1')
MM_WRITE(MM_GPIO_OUT, MM_READ(MM_GPIO_OUT)|gpio[minor].mask);
else
MM_WRITE(MM_GPIO_OUT, MM_READ(MM_GPIO_OUT) & ~gpio[minor].mask);
return RTEMS_SUCCESSFUL;
}

104
c/src/lib/libbsp/lm32/shared/milkymist_ir/ir.c
View File

@@ -1,104 +0,0 @@
/* ir.c
*
* Milkymist RC5 IR driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <sys/types.h>
#include <rtems.h>
#include <rtems/status-checks.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_ir.h>
#define DEVICE_NAME "/dev/ir"
static rtems_id ir_q;
static rtems_isr interrupt_handler(rtems_vector_number n)
{
unsigned short int msg;
lm32_interrupt_ack(1 << MM_IRQ_IR);
msg = MM_READ(MM_IR_RX);
rtems_message_queue_send(ir_q, &msg, 2);
}
rtems_device_driver ir_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create IR input device");
sc = rtems_message_queue_create(
rtems_build_name('R', 'C', '5', 'Q'),
64,
2,
0,
&ir_q
);
RTEMS_CHECK_SC(sc, "create IR queue");
rtems_interrupt_catch(interrupt_handler, MM_IRQ_IR, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_IR);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver ir_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
uint32_t count;
rtems_message_queue_flush(ir_q, &count);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver ir_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
rtems_status_code sc;
if (rw_args->count < 2) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
sc = rtems_message_queue_receive(
ir_q,
rw_args->buffer,
(size_t *)&rw_args->bytes_moved,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if(sc == RTEMS_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
else {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
}

370
c/src/lib/libbsp/lm32/shared/milkymist_memcard/memcard.c
View File

@@ -1,370 +0,0 @@
/* memcard.c
*
* Milkymist memory card driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <rtems.h>
#include <rtems/libio.h>
#include <rtems/diskdevs.h>
#include <rtems/blkdev.h>
#include <rtems/status-checks.h>
#include <errno.h>
#include <bsp.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_memcard.h>
//#define MEMCARD_DEBUG
#define BLOCK_SIZE 512
static void memcard_start_cmd_tx(void)
{
MM_WRITE(MM_MEMCARD_ENABLE, MEMCARD_ENABLE_CMD_TX);
}
static void memcard_start_cmd_rx(void)
{
MM_WRITE(MM_MEMCARD_PENDING, MEMCARD_PENDING_CMD_RX);
MM_WRITE(MM_MEMCARD_START, MEMCARD_START_CMD_RX);
MM_WRITE(MM_MEMCARD_ENABLE, MEMCARD_ENABLE_CMD_RX);
}
static void memcard_start_cmd_dat_rx(void)
{
MM_WRITE(MM_MEMCARD_PENDING, MEMCARD_PENDING_CMD_RX|MEMCARD_PENDING_DAT_RX);
MM_WRITE(MM_MEMCARD_START, MEMCARD_START_CMD_RX|MEMCARD_START_DAT_RX);
MM_WRITE(MM_MEMCARD_ENABLE, MEMCARD_ENABLE_CMD_RX|MEMCARD_ENABLE_DAT_RX);
}
static void memcard_send_command(unsigned char cmd, unsigned int arg)
{
unsigned char packet[6];
int a;
int i;
unsigned char data;
unsigned char crc;
packet[0] = cmd | 0x40;
packet[1] = ((arg >> 24) & 0xff);
packet[2] = ((arg >> 16) & 0xff);
packet[3] = ((arg >> 8) & 0xff);
packet[4] = (arg & 0xff);
crc = 0;
for(a=0;a<5;a++) {
data = packet[a];
for(i=0;i<8;i++) {
crc <<= 1;
if((data & 0x80) ^ (crc & 0x80))
crc ^= 0x09;
data <<= 1;
}
}
crc = (crc<<1) | 1;
packet[5] = crc;
#ifdef MEMCARD_DEBUG
printk(">> %02x %02x %02x %02x %02x %02x\n",
packet[0], packet[1], packet[2], packet[3], packet[4], packet[5]);
#endif
for(i=0;i<6;i++) {
MM_WRITE(MM_MEMCARD_CMD, packet[i]);
while(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_CMD_TX);
}
}
static void memcard_send_dummy(void)
{
MM_WRITE(MM_MEMCARD_CMD, 0xff);
while(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_CMD_TX);
}
static bool memcard_receive_command(unsigned char *buffer, int len)
{
int i;
int timeout;
for(i=0;i<len;i++) {
timeout = 2000000;
while(!(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_CMD_RX)) {
timeout--;
if(timeout == 0) {
#ifdef MEMCARD_DEBUG
printk("Command receive timeout\n");
#endif
return false;
}
}
buffer[i] = MM_READ(MM_MEMCARD_CMD);
MM_WRITE(MM_MEMCARD_PENDING, MEMCARD_PENDING_CMD_RX);
}
while(!(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_CMD_RX));
#ifdef MEMCARD_DEBUG
printk("<< ");
for(i=0;i<len;i++)
printk("%02x ", buffer[i]);
printk("\n");
#endif
return true;
}
static bool memcard_receive_command_data(unsigned char *command,
unsigned int *data)
{
int i, j;
int timeout;
i = 0;
j = 0;
while(j < 128) {
timeout = 2000000;
while(!(MM_READ(MM_MEMCARD_PENDING) &
(MEMCARD_PENDING_CMD_RX|MEMCARD_PENDING_DAT_RX))) {
timeout--;
if(timeout == 0) {
#ifdef MEMCARD_DEBUG
printk("Command receive timeout\n");
#endif
return false;
}
}
if(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_CMD_RX) {
command[i++] = MM_READ(MM_MEMCARD_CMD);
MM_WRITE(MM_MEMCARD_PENDING, MEMCARD_PENDING_CMD_RX);
if(i == 6)
/* disable command RX */
MM_WRITE(MM_MEMCARD_ENABLE, MEMCARD_ENABLE_DAT_RX);
}
if(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_DAT_RX) {
data[j++] = MM_READ(MM_MEMCARD_DAT);
MM_WRITE(MM_MEMCARD_PENDING, MEMCARD_PENDING_DAT_RX);
}
}
/* Get CRC (ignored) */
for(i=0;i<2;i++) {
while(!(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_DAT_RX));
#ifdef MEMCARD_DEBUG
printk("CRC: %08x\n", MM_READ(MM_MEMCARD_DAT));
#endif
MM_WRITE(MM_MEMCARD_PENDING, MEMCARD_PENDING_DAT_RX);
}
while(!(MM_READ(MM_MEMCARD_PENDING) & MEMCARD_PENDING_DAT_RX));
#ifdef MEMCARD_DEBUG
printk("<< %02x %02x %02x %02x %02x %02x\n",
command[0], command[1], command[2], command[3], command[4], command[5]);
#endif
//for(i=0;i<128;i++)
// printk("%08x ", data[i]);
//printk("\n");
return true;
}
static unsigned int block_count;
static int memcard_disk_block_read(rtems_blkdev_request *r)
{
unsigned char b[6];
unsigned int i, nblocks;
unsigned int block;
block = RTEMS_BLKDEV_START_BLOCK(r);
nblocks = r->bufnum;
for(i=0;i<nblocks;i++) {
/* CMD17 - read block */
memcard_start_cmd_tx();
memcard_send_command(17, (block+i)*BLOCK_SIZE);
memcard_start_cmd_dat_rx();
if(!memcard_receive_command_data(b, (unsigned int *)r->bufs[i].buffer))
return -RTEMS_IO_ERROR;
}
rtems_blkdev_request_done(r, RTEMS_SUCCESSFUL);
return 0;
}
static int memcard_disk_block_write(rtems_blkdev_request *r)
{
rtems_blkdev_request_done(r, RTEMS_IO_ERROR);
return 0;
}
static rtems_status_code memcard_init(void)
{
unsigned char b[17];
unsigned int rca;
unsigned int block_shift;
unsigned int c_size;
unsigned int c_size_mult;
MM_WRITE(MM_MEMCARD_CLK2XDIV, 250);
/* CMD0 */
memcard_start_cmd_tx();
memcard_send_command(0, 0);
memcard_send_dummy();
/* CMD8 */
memcard_send_command(8, 0x1aa);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 6)) return RTEMS_IO_ERROR;
/* ACMD41 - initialize */
while(1) {
memcard_start_cmd_tx();
memcard_send_command(55, 0);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 6)) return RTEMS_IO_ERROR;
memcard_start_cmd_tx();
memcard_send_command(41, 0x00300000);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 6)) return RTEMS_IO_ERROR;
if(b[1] & 0x80) break;
#ifdef MEMCARD_DEBUG
printk("Card is busy, retrying\n");
#endif
}
/* CMD2 - get CID */
memcard_start_cmd_tx();
memcard_send_command(2, 0);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 17)) return RTEMS_IO_ERROR;
/* CMD3 - get RCA */
memcard_start_cmd_tx();
memcard_send_command(3, 0);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 6)) return RTEMS_IO_ERROR;
rca = (((unsigned int)b[1]) << 8)|((unsigned int)b[2]);
#ifdef MEMCARD_DEBUG
printk("RCA: %04x\n", rca);
#endif
/* CMD9 - get CSD */
memcard_start_cmd_tx();
memcard_send_command(9, rca << 16);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 17)) return RTEMS_IO_ERROR;
if(((b)[0] >> 6) != 0)
return RTEMS_IO_ERROR;
block_shift = ((unsigned int)(b)[5] & 0xf);
c_size = ((((unsigned int)(b)[6] & 0x3) << 10)
+ (((unsigned int)(b)[7]) << 2)
+ ((((unsigned int)(b)[8]) >> 6) & 0x3));
c_size_mult = ((((b)[9] & 0x3) << 1) + (((b)[10] >> 7) & 0x1));
block_count = (c_size + 1) * (1U << (c_size_mult + 2));
/* convert to 512-byte blocks for the sake of simplicity */
if(block_shift < 9)
return RTEMS_IO_ERROR;
block_count <<= block_shift - 9;
/* CMD7 - select card */
memcard_start_cmd_tx();
memcard_send_command(7, rca << 16);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 6)) return RTEMS_IO_ERROR;
/* ACMD6 - set bus width */
memcard_start_cmd_tx();
memcard_send_command(55, rca << 16);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 6)) return RTEMS_IO_ERROR;
memcard_start_cmd_tx();
memcard_send_command(6, 2);
memcard_start_cmd_rx();
if(!memcard_receive_command(b, 6)) return RTEMS_IO_ERROR;
MM_WRITE(MM_MEMCARD_CLK2XDIV, 3);
return RTEMS_SUCCESSFUL;
}
static int memcard_disk_ioctl(rtems_disk_device *dd, uint32_t req, void *arg)
{
if (req == RTEMS_BLKIO_REQUEST) {
rtems_blkdev_request *r = (rtems_blkdev_request *)arg;
switch (r->req) {
case RTEMS_BLKDEV_REQ_READ:
return memcard_disk_block_read(r);
case RTEMS_BLKDEV_REQ_WRITE:
return memcard_disk_block_write(r);
default:
errno = EINVAL;
return -1;
}
} else if (req == RTEMS_BLKIO_CAPABILITIES) {
*(uint32_t *)arg = RTEMS_BLKDEV_CAP_MULTISECTOR_CONT;
return 0;
} else {
errno = EINVAL;
return -1;
}
}
static rtems_status_code memcard_disk_init(
rtems_device_major_number major, rtems_device_minor_number minor,
void *arg)
{
rtems_status_code sc;
dev_t dev;
sc = rtems_disk_io_initialize();
RTEMS_CHECK_SC(sc, "Initialize RTEMS disk IO");
dev = rtems_filesystem_make_dev_t(major, 0);
sc = memcard_init();
RTEMS_CHECK_SC(sc, "Initialize memory card");
sc = rtems_disk_create_phys(dev, BLOCK_SIZE, block_count, memcard_disk_ioctl,
NULL, "/dev/memcard");
RTEMS_CHECK_SC(sc, "Create disk device");
return RTEMS_SUCCESSFUL;
}
static const rtems_driver_address_table memcard_disk_ops = {
.initialization_entry = memcard_disk_init,
.open_entry = rtems_blkdev_generic_open,
.close_entry = rtems_blkdev_generic_close,
.read_entry = rtems_blkdev_generic_read,
.write_entry = rtems_blkdev_generic_write,
.control_entry = rtems_blkdev_generic_ioctl
};
rtems_status_code memcard_register(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
sc = rtems_io_register_driver(0, &memcard_disk_ops, &major);
RTEMS_CHECK_SC(sc, "Register disk memory card driver");
return RTEMS_SUCCESSFUL;
}

122
c/src/lib/libbsp/lm32/shared/milkymist_midi/midi.c
View File

@@ -1,122 +0,0 @@
/* midi.c
*
* Milkymist MIDI driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <sys/types.h>
#include <rtems.h>
#include <rtems/status-checks.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_midi.h>
#define DEVICE_NAME "/dev/midi"
static rtems_id midi_q;
static unsigned char *midi_p = NULL;
static unsigned char midi_msg[3];
static rtems_isr interrupt_handler(rtems_vector_number n)
{
unsigned char msg;
while (MM_READ(MM_MIDI_STAT) & MIDI_STAT_RX_EVT) {
msg = MM_READ(MM_MIDI_RXTX);
MM_WRITE(MM_MIDI_STAT, MIDI_STAT_RX_EVT);
if ((msg & 0xf8) == 0xf8)
continue; /* ignore system real-time */
if (msg & 0x80)
midi_p = midi_msg; /* status byte */
if (!midi_p)
continue; /* ignore extra or unsynchronized data */
*midi_p++ = msg;
if (midi_p == midi_msg+3) {
/* received a complete MIDI message */
rtems_message_queue_send(midi_q, midi_msg, 3);
midi_p = NULL;
}
}
lm32_interrupt_ack(1 << MM_IRQ_MIDI);
}
rtems_device_driver midi_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create MIDI input device");
sc = rtems_message_queue_create(
rtems_build_name('M', 'I', 'D', 'I'),
32,
3,
0,
&midi_q
);
RTEMS_CHECK_SC(sc, "create MIDI queue");
rtems_interrupt_catch(interrupt_handler, MM_IRQ_MIDI, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_MIDI);
/* Only MIDI THRU mode is supported atm */
MM_WRITE(MM_MIDI_CTRL, MIDI_CTRL_RX_INT|MIDI_CTRL_THRU);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver midi_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
uint32_t count;
rtems_message_queue_flush(midi_q, &count);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver midi_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
rtems_status_code sc;
sc = rtems_message_queue_receive(
midi_q,
rw_args->buffer,
(size_t *)&rw_args->bytes_moved,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if(sc == RTEMS_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
else {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
}

143
c/src/lib/libbsp/lm32/shared/milkymist_pfpu/pfpu.c
View File

@@ -1,143 +0,0 @@
/* pfpu.c
*
* Milkymist PFPU driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <rtems.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include <rtems/status-checks.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_pfpu.h>
#define DEVICE_NAME "/dev/pfpu"
static rtems_id done_sem;
static rtems_isr done_handler(rtems_vector_number n)
{
rtems_semaphore_release(done_sem);
lm32_interrupt_ack(1 << MM_IRQ_PFPU);
}
rtems_device_driver pfpu_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create PFPU device");
sc = rtems_semaphore_create(
rtems_build_name('P', 'F', 'P', 'U'),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&done_sem
);
RTEMS_CHECK_SC(sc, "create PFPU done semaphore");
rtems_interrupt_catch(done_handler, MM_IRQ_PFPU, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_PFPU);
return RTEMS_SUCCESSFUL;
}
static void load_program(unsigned int *program, int size)
{
int page;
int word;
volatile unsigned int *pfpu_prog = (unsigned int *)MM_PFPU_CODEBASE;
for (page=0;page<(PFPU_PROGSIZE/PFPU_PAGESIZE);page++) {
MM_WRITE(MM_PFPU_CODEPAGE, page);
for (word=0;word<PFPU_PAGESIZE;word++) {
if (size == 0) return;
pfpu_prog[word] = *program;
program++;
size--;
}
}
}
static void load_registers(float *registers)
{
volatile float *pfpu_regs = (float *)MM_PFPU_DREGBASE;
int i;
for (i=PFPU_SPREG_COUNT;i<PFPU_REG_COUNT;i++)
pfpu_regs[i] = registers[i];
}
static void update_registers(float *registers)
{
volatile float *pfpu_regs = (float *)MM_PFPU_DREGBASE;
int i;
for (i=PFPU_SPREG_COUNT;i<PFPU_REG_COUNT;i++)
registers[i] = pfpu_regs[i];
}
static rtems_status_code pfpu_execute(struct pfpu_td *td)
{
rtems_status_code sc;
load_program(td->program, td->progsize);
load_registers(td->registers);
MM_WRITE(MM_PFPU_MESHBASE, (unsigned int)td->output);
MM_WRITE(MM_PFPU_HMESHLAST, td->hmeshlast);
MM_WRITE(MM_PFPU_VMESHLAST, td->vmeshlast);
MM_WRITE(MM_PFPU_CTL, PFPU_CTL_START);
sc = rtems_semaphore_obtain(done_sem, RTEMS_WAIT, 10);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (td->update) {
update_registers(td->registers);
if (td->invalidate) {
__asm__ volatile( /* Invalidate Level-1 data cache */
"wcsr DCC, r0\n"
"nop\n"
);
}
}
return RTEMS_SUCCESSFUL;
}
rtems_device_driver pfpu_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
args->ioctl_return = -1;
if (args->command != PFPU_EXECUTE)
return RTEMS_UNSATISFIED;
if (pfpu_execute((struct pfpu_td *)args->buffer) != RTEMS_SUCCESSFUL)
return RTEMS_UNSATISFIED;
args->ioctl_return = 0;
return RTEMS_SUCCESSFUL;
}

78
c/src/lib/libbsp/lm32/shared/milkymist_timer/timer.c
View File

@@ -1,78 +0,0 @@
/* timer.c
*
* This file manages the benchmark timer used by the RTEMS Timing
* Test Suite. Each measured time period is demarcated by calls to
* benchmark_timer_initialize() and benchmark_timer_read().
* benchmark_timer_read() usually returns the number of microseconds
* since benchmark_timer_initialize() exitted.
*
* NOTE: It is important that the timer start/stop overhead be
* determined when porting or modifying this code.
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) Yann Sionneau <yann.sionneau@telecom-sudparis.eu> (GSoC 2010)
* Telecom SudParis
*/
#include <rtems.h>
#include <bsp.h>
#include <rtems/btimer.h>
#include <rtems/bspIo.h>
#include "../include/system_conf.h"
#include "../../shared/clock/clock.h"
bool benchmark_timer_find_average_overhead;
void benchmark_timer_initialize(void)
{
MM_WRITE(MM_TIMER1_COMPARE, 0xffffffff);
MM_WRITE(MM_TIMER1_COUNTER, 0);
MM_WRITE(MM_TIMER1_CONTROL, TIMER_ENABLE);
}
/*
* The following controls the behavior of benchmark_timer_read().
*
* AVG_OVEREHAD is the overhead for starting and stopping the timer. It
* is usually deducted from the number returned.
*
* LEAST_VALID is the lowest number this routine should trust. Numbers
* below this are "noise" and zero is returned.
*/
#define AVG_OVERHEAD 4 /* It typically takes X.X microseconds */
/* (Y countdowns) to start/stop the timer. */
/* This value is in microseconds. */
#define LEAST_VALID 4 /* Don't trust a clicks value lower than this */
benchmark_timer_t benchmark_timer_read(void)
{
uint32_t ticks;
uint32_t total;
ticks = MM_READ(MM_TIMER1_COUNTER);
if (ticks == 0xffffffff)
printk("Timer overflow!\n");
total = ticks / (MM_READ(MM_FREQUENCY) / 1000000);
if (benchmark_timer_find_average_overhead)
return total;
else
{
if (total < LEAST_VALID)
return 0;
return (total - AVG_OVERHEAD);
}
}
void benchmark_timer_disable_subtracting_average_overhead(
bool find_flag
)
{
benchmark_timer_find_average_overhead = find_flag;
}

161
c/src/lib/libbsp/lm32/shared/milkymist_tmu/tmu.c
View File

@@ -1,161 +0,0 @@
/* tmu.c
*
* Milkymist TMU driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <rtems.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include <rtems/status-checks.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_tmu.h>
#define DEVICE_NAME "/dev/tmu"
static rtems_id done_sem;
static rtems_isr done_handler(rtems_vector_number n)
{
rtems_semaphore_release(done_sem);
lm32_interrupt_ack(1 << MM_IRQ_TMU);
}
rtems_device_driver tmu_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create TMU device");
sc = rtems_semaphore_create(
rtems_build_name('T', 'M', 'U', ' '),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&done_sem
);
RTEMS_CHECK_SC(sc, "create TMU done semaphore");
rtems_interrupt_catch(done_handler, MM_IRQ_TMU, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_TMU);
return RTEMS_SUCCESSFUL;
}
static void invalidate_l2(void)
{
volatile char *flushbase = (char *)FMLBRG_FLUSH_BASE;
int i, offset;
offset = 0;
for (i=0;i<FMLBRG_LINE_COUNT;i++) {
flushbase[offset] = 0;
offset += FMLBRG_LINE_LENGTH;
}
}
static bool invalidate_after;
static void tmu_start(struct tmu_td *td)
{
if (td->invalidate_before)
invalidate_l2();
MM_WRITE(MM_TMU_HMESHLAST, td->hmeshlast);
MM_WRITE(MM_TMU_VMESHLAST, td->vmeshlast);
MM_WRITE(MM_TMU_BRIGHTNESS, td->brightness);
MM_WRITE(MM_TMU_CHROMAKEY, td->chromakey);
MM_WRITE(MM_TMU_VERTICESADR, (unsigned int)td->vertices);
MM_WRITE(MM_TMU_TEXFBUF, (unsigned int)td->texfbuf);
MM_WRITE(MM_TMU_TEXHRES, td->texhres);
MM_WRITE(MM_TMU_TEXVRES, td->texvres);
MM_WRITE(MM_TMU_TEXHMASK, td->texhmask);
MM_WRITE(MM_TMU_TEXVMASK, td->texvmask);
MM_WRITE(MM_TMU_DSTFBUF, (unsigned int)td->dstfbuf);
MM_WRITE(MM_TMU_DSTHRES, td->dsthres);
MM_WRITE(MM_TMU_DSTVRES, td->dstvres);
MM_WRITE(MM_TMU_DSTHOFFSET, td->dsthoffset);
MM_WRITE(MM_TMU_DSTVOFFSET, td->dstvoffset);
MM_WRITE(MM_TMU_DSTSQUAREW, td->dstsquarew);
MM_WRITE(MM_TMU_DSTSQUAREH, td->dstsquareh);
MM_WRITE(MM_TMU_ALPHA, td->alpha);
MM_WRITE(MM_TMU_CTL, td->flags|TMU_CTL_START);
invalidate_after = td->invalidate_after;
}
static rtems_status_code tmu_finalize(void)
{
rtems_status_code sc;
sc = rtems_semaphore_obtain(done_sem, RTEMS_WAIT, 100);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (invalidate_after) {
invalidate_l2();
__asm__ volatile( /* Invalidate Level-1 data cache */
"wcsr DCC, r0\n"
"nop\n"
);
}
return RTEMS_SUCCESSFUL;
}
rtems_device_driver tmu_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
struct tmu_td *td = (struct tmu_td *)args->buffer;
rtems_status_code sc;
switch (args->command) {
case TMU_EXECUTE:
tmu_start(td);
sc = tmu_finalize();
break;
case TMU_EXECUTE_NONBLOCK:
tmu_start(td);
sc = RTEMS_SUCCESSFUL;
break;
case TMU_EXECUTE_WAIT:
sc = tmu_finalize();
break;
default:
sc = RTEMS_UNSATISFIED;
break;
}
if (sc == RTEMS_SUCCESSFUL)
args->ioctl_return = 0;
else
args->ioctl_return = -1;
return sc;
}

32
c/src/lib/libbsp/lm32/shared/milkymist_usbinput/comloc.h
View File

@@ -1,32 +0,0 @@
/**
* @file
* @ingroup lm32_milkymist_usbinput lm32_milkymist_shared
* @brief Milkymist USB input devices driver
*/
/* comloc.h
*
* Milkymist USB input devices driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010 Sebastien Bourdeauducq
*/
#ifndef __COMLOC_H_
#define __COMLOC_H_
#define COMLOCV(x) (*(volatile unsigned char *)(x))
#define COMLOC_DEBUG_PRODUCE COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1000)
#define COMLOC_DEBUG(offset) COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1001+offset)
#define COMLOC_MEVT_PRODUCE COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1101)
#define COMLOC_MEVT(offset) COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1102+offset)
#define COMLOC_KEVT_PRODUCE COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1142)
#define COMLOC_KEVT(offset) COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1143+offset)
#define COMLOC_MIDI_PRODUCE COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1183)
#define COMLOC_MIDI(offset) COMLOCV(MM_SOFTUSB_DMEM_BASE+0x1184+offset)
#endif /* __COMLOC_H_ */

179
c/src/lib/libbsp/lm32/shared/milkymist_usbinput/usbinput.c
View File

@@ -1,179 +0,0 @@
/* usbinput.c
*
* Milkymist USB input devices driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011, 2012 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <rtems.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include <rtems/status-checks.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_usbinput.h>
#include "comloc.h"
#define DEVICE_NAME "/dev/usbinput"
static int mouse_consume;
static int keyboard_consume;
static int midi_consume;
static rtems_id event_q;
static rtems_isr interrupt_handler(rtems_vector_number n)
{
unsigned char msg[8];
int i;
lm32_interrupt_ack(1 << MM_IRQ_USB);
while(mouse_consume != COMLOC_MEVT_PRODUCE) {
for(i=0;i<4;i++)
msg[i] = COMLOC_MEVT(4*mouse_consume+i);
rtems_message_queue_send(event_q, msg, 4);
mouse_consume = (mouse_consume + 1) & 0x0f;
}
while(keyboard_consume != COMLOC_KEVT_PRODUCE) {
for(i=0;i<8;i++)
msg[i] = COMLOC_KEVT(8*keyboard_consume+i);
rtems_message_queue_send(event_q, msg, 8);
keyboard_consume = (keyboard_consume + 1) & 0x07;
}
while(midi_consume != COMLOC_MIDI_PRODUCE) {
for(i=0;i<3;i++)
msg[i] = COMLOC_MIDI(4*midi_consume+i+1);
rtems_message_queue_send(event_q, msg, 3);
midi_consume = (midi_consume + 1) & 0x0f;
}
}
rtems_device_driver usbinput_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
MM_WRITE(MM_SOFTUSB_CONTROL, SOFTUSB_CONTROL_RESET);
mouse_consume = 0;
keyboard_consume = 0;
midi_consume = 0;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create USB input device");
sc = rtems_message_queue_create(
rtems_build_name('U', 'S', 'B', 'I'),
64,
8,
0,
&event_q
);
RTEMS_CHECK_SC(sc, "create USB event queue");
rtems_interrupt_catch(interrupt_handler, MM_IRQ_USB, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_USB);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver usbinput_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
uint32_t count;
rtems_message_queue_flush(event_q, &count);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver usbinput_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
rtems_status_code sc;
if(rw_args->count < 8) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
sc = rtems_message_queue_receive(
event_q,
rw_args->buffer,
(size_t *)&rw_args->bytes_moved,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if(sc == RTEMS_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
else {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
}
static void load_firmware(const unsigned char *firmware, int length)
{
int i, nwords;
volatile unsigned int *usb_dmem
= (volatile unsigned int *)MM_SOFTUSB_DMEM_BASE;
volatile unsigned int *usb_pmem
= (volatile unsigned int *)MM_SOFTUSB_PMEM_BASE;
MM_WRITE(MM_SOFTUSB_CONTROL, SOFTUSB_CONTROL_RESET);
for(i=0;i<SOFTUSB_DMEM_SIZE/4;i++)
usb_dmem[i] = 0;
for(i=0;i<SOFTUSB_PMEM_SIZE/2;i++)
usb_pmem[i] = 0;
nwords = (length+1)/2;
for(i=0;i<nwords;i++)
usb_pmem[i] = ((unsigned int)(firmware[2*i]))
|((unsigned int)(firmware[2*i+1]) << 8);
MM_WRITE(MM_SOFTUSB_CONTROL, 0);
}
rtems_device_driver usbinput_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
struct usbinput_firmware_description *fd
= (struct usbinput_firmware_description *)args->buffer;
if(args->command == USBINPUT_LOAD_FIRMWARE) {
load_firmware(fd->data, fd->length);
args->ioctl_return = 0;
return RTEMS_SUCCESSFUL;
} else {
args->ioctl_return = -1;
return RTEMS_UNSATISFIED;
}
}

132
c/src/lib/libbsp/lm32/shared/milkymist_versions/versions.c
View File

@@ -1,132 +0,0 @@
/* versions.c
*
* Milkymist versioning driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <rtems.h>
#include <rtems/status-checks.h>
#include <bsp.h>
#include <rtems/libio.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_versions.h>
#define SOC_DEVICE_NAME "/dev/soc"
#define PCB_DEVICE_NAME "/dev/pcb"
#define PCBREV_DEVICE_NAME "/dev/pcb_rev"
rtems_device_driver versions_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
sc = rtems_io_register_name(SOC_DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create SoC version device");
sc = rtems_io_register_name(PCB_DEVICE_NAME, major, 1);
RTEMS_CHECK_SC(sc, "create PCB type device");
sc = rtems_io_register_name(PCBREV_DEVICE_NAME, major, 2);
RTEMS_CHECK_SC(sc, "create PCB revision device");
return RTEMS_SUCCESSFUL;
}
static int get_soc_version(char *buffer)
{
char fmt[13];
char *version;
int len;
unsigned int id;
unsigned int major, minor, subminor, rc;
id = MM_READ(MM_SYSTEM_ID);
major = (id & 0xf0000000) >> 28;
minor = (id & 0x0f000000) >> 24;
subminor = (id & 0x00f00000) >> 20;
rc = (id & 0x000f0000) >> 16;
version = fmt;
version += sprintf(version, "%u.%u", major, minor);
if (subminor != 0)
version += sprintf(version, ".%u", subminor);
if (rc != 0)
version += sprintf(version, "RC%u", rc);
len = version - fmt;
memcpy(buffer, fmt, len);
return len;
}
static int get_pcb_type(char *buffer)
{
unsigned int id;
id = MM_READ(MM_SYSTEM_ID);
buffer[0] = (id & 0x0000ff00) >> 8;
buffer[1] = id & 0x000000ff;
return 2;
}
static int get_pcb_revision(char *buffer)
{
unsigned int v;
v = MM_READ(MM_GPIO_IN);
v = (v & 0x78) >> 3;
buffer[0] = '0' + v;
return 1;
}
rtems_device_driver versions_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *)arg;
if(rw_args->offset != 0) {
rw_args->bytes_moved = 0;
return RTEMS_SUCCESSFUL;
}
switch (minor) {
case 0:
if (rw_args->count < 12) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
rw_args->bytes_moved = get_soc_version((char *)rw_args->buffer);
return RTEMS_SUCCESSFUL;
case 1:
if (rw_args->count < 2) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
rw_args->bytes_moved = get_pcb_type((char *)rw_args->buffer);
return RTEMS_SUCCESSFUL;
case 2:
if (rw_args->count < 1) {
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}
rw_args->bytes_moved = get_pcb_revision((char *)rw_args->buffer);
return RTEMS_SUCCESSFUL;
}
rw_args->bytes_moved = 0;
return RTEMS_UNSATISFIED;
}

391
c/src/lib/libbsp/lm32/shared/milkymist_video/video.c
View File

@@ -1,391 +0,0 @@
/* video.c
*
* Milkymist video input driver for RTEMS
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*
* COPYRIGHT (c) 2010, 2011 Sebastien Bourdeauducq
*/
#define RTEMS_STATUS_CHECKS_USE_PRINTK
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <rtems.h>
#include <bsp.h>
#include <bsp/irq-generic.h>
#include <rtems/libio.h>
#include <rtems/status-checks.h>
#include <rtems/bspIo.h>
#include "../include/system_conf.h"
#include <bsp/milkymist_video.h>
#define DEVICE_NAME "/dev/video"
#define N_BUFFERS 3
#define FRAME_W 720
#define FRAME_H 288
static bool buffers_locked[N_BUFFERS];
static void *buffers[N_BUFFERS];
static int last_buffer;
static int current_buffer;
static rtems_isr frame_handler(rtems_vector_number n)
{
int remaining_attempts;
lm32_interrupt_ack(1 << MM_IRQ_VIDEOIN);
last_buffer = current_buffer;
/* get a new buffer */
remaining_attempts = N_BUFFERS;
do {
current_buffer++;
if(current_buffer == N_BUFFERS)
current_buffer = 0;
remaining_attempts--;
} while(buffers_locked[current_buffer] && (remaining_attempts > 0));
MM_WRITE(MM_BT656_BASE, (unsigned int)buffers[current_buffer]);
if(buffers_locked[current_buffer])
printk("Failed to find unlocked buffer\n");
}
static void i2c_delay(void)
{
unsigned int i;
for(i=0;i<1000;i++) __asm__("nop");
}
/* I2C bit-banging functions from http://en.wikipedia.org/wiki/I2c */
static unsigned int i2c_read_bit(void)
{
unsigned int bit;
/* Let the slave drive data */
MM_WRITE(MM_BT656_I2C, 0);
i2c_delay();
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDC);
i2c_delay();
bit = MM_READ(MM_BT656_I2C) & BT656_I2C_SDAIN;
i2c_delay();
MM_WRITE(MM_BT656_I2C, 0);
return bit;
}
static void i2c_write_bit(unsigned int bit)
{
if(bit) {
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDAOE|BT656_I2C_SDAOUT);
} else {
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDAOE);
}
i2c_delay();
MM_WRITE(MM_BT656_I2C, MM_READ(MM_BT656_I2C) | BT656_I2C_SDC);
i2c_delay();
MM_WRITE(MM_BT656_I2C, MM_READ(MM_BT656_I2C) & ~BT656_I2C_SDC);
}
static int i2c_started;
static void i2c_start_cond(void)
{
if(i2c_started) {
/* set SDA to 1 */
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDAOE|BT656_I2C_SDAOUT);
i2c_delay();
MM_WRITE(MM_BT656_I2C, MM_READ(MM_BT656_I2C) | BT656_I2C_SDC);
}
/* SCL is high, set SDA from 1 to 0 */
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDAOE|BT656_I2C_SDC);
i2c_delay();
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDAOE);
i2c_started = 1;
}
static void i2c_stop_cond(void)
{
/* set SDA to 0 */
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDAOE);
i2c_delay();
/* Clock stretching */
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDAOE|BT656_I2C_SDC);
/* SCL is high, set SDA from 0 to 1 */
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDC);
i2c_delay();
i2c_started = 0;
}
static unsigned int i2c_write(unsigned char byte)
{
unsigned int bit;
unsigned int ack;
for(bit = 0; bit < 8; bit++) {
i2c_write_bit(byte & 0x80);
byte <<= 1;
}
ack = !i2c_read_bit();
return ack;
}
static unsigned char i2c_read(int ack)
{
unsigned char byte = 0;
unsigned int bit;
for(bit = 0; bit < 8; bit++) {
byte <<= 1;
byte |= i2c_read_bit();
}
i2c_write_bit(!ack);
return byte;
}
static unsigned char read_reg(unsigned char addr)
{
unsigned char r;
i2c_start_cond();
i2c_write(0x40);
i2c_write(addr);
i2c_start_cond();
i2c_write(0x41);
r = i2c_read(0);
i2c_stop_cond();
return r;
}
static void write_reg(unsigned char addr, unsigned char val)
{
i2c_start_cond();
i2c_write(0x40);
i2c_write(addr);
i2c_write(val);
i2c_stop_cond();
}
static const char vreg_addr[] = {
0x1d, 0xc3, 0xc4
};
static const char vreg_dat[] = {
0x40, 0x05, 0x80
};
rtems_device_driver video_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
int i;
MM_WRITE(MM_BT656_I2C, BT656_I2C_SDC);
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create video input device");
rtems_interrupt_catch(frame_handler, MM_IRQ_VIDEOIN, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_VIDEOIN);
for(i=0;i<sizeof(vreg_addr);i++)
write_reg(vreg_addr[i], vreg_dat[i]);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver video_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
int i;
int status;
for(i=0;i<N_BUFFERS;i++) {
status = posix_memalign(&buffers[i], 32, 2*FRAME_W*FRAME_H);
if(status != 0) {
i--;
while(i > 0) {
free(buffers[i]);
i--;
}
return RTEMS_UNSATISFIED;
}
}
last_buffer = -1;
current_buffer = 0;
MM_WRITE(MM_BT656_BASE, (unsigned int)buffers[current_buffer]);
MM_WRITE(MM_BT656_FILTERSTATUS, BT656_FILTER_FIELD1);
return RTEMS_SUCCESSFUL;
}
rtems_device_driver video_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
int i;
MM_WRITE(MM_BT656_FILTERSTATUS, 0);
while(MM_READ(MM_BT656_FILTERSTATUS) & BT656_FILTER_INFRAME);
for(i=0;i<N_BUFFERS;i++)
free(buffers[i]);
return RTEMS_SUCCESSFUL;
}
static void invalidate_caches(void)
{
volatile char *flushbase = (char *)FMLBRG_FLUSH_BASE;
int i, offset;
offset = 0;
for (i=0;i<FMLBRG_LINE_COUNT;i++) {
flushbase[offset] = 0;
offset += FMLBRG_LINE_LENGTH;
}
__asm__ volatile( /* Invalidate Level-1 data cache */
"wcsr DCC, r0\n"
"nop\n"
);
}
static void set_format(int format)
{
switch(format) {
case VIDEO_FORMAT_CVBS6:
write_reg(0x00, 0x00);
write_reg(0xc3, 0x05);
write_reg(0xc4, 0x80);
break;
case VIDEO_FORMAT_CVBS5:
write_reg(0x00, 0x00);
write_reg(0xc3, 0x0d);
write_reg(0xc4, 0x80);
break;
case VIDEO_FORMAT_CVBS4:
write_reg(0x00, 0x00);
write_reg(0xc3, 0x04);
write_reg(0xc4, 0x80);
break;
case VIDEO_FORMAT_SVIDEO:
write_reg(0x00, 0x06);
write_reg(0xc3, 0xd5);
write_reg(0xc4, 0x80);
break;
case VIDEO_FORMAT_COMPONENT:
write_reg(0x00, 0x09);
write_reg(0xc3, 0x45);
write_reg(0xc4, 0x8d);
break;
}
}
rtems_device_driver video_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_libio_ioctl_args_t *args = arg;
unsigned int *a = (unsigned int *)args->buffer;
rtems_status_code sc;
switch (args->command) {
case VIDEO_BUFFER_LOCK:
if (last_buffer == -1) {
*a = 0;
} else {
bsp_interrupt_vector_disable(MM_IRQ_VIDEOIN);
if(*a) invalidate_caches();
*a = (unsigned int)buffers[last_buffer];
buffers_locked[last_buffer] = true;
bsp_interrupt_vector_enable(MM_IRQ_VIDEOIN);
}
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_BUFFER_UNLOCK: {
int i;
for(i=0;i<N_BUFFERS;i++) {
if ((unsigned int)buffers[i] == (unsigned int)a) {
buffers_locked[i] = false;
break;
}
}
sc = RTEMS_SUCCESSFUL;
break;
}
case VIDEO_SET_BRIGHTNESS:
write_reg(0x0a, (unsigned int)a);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_GET_BRIGHTNESS:
*a = read_reg(0x0a);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_SET_CONTRAST:
write_reg(0x08, (unsigned int)a);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_GET_CONTRAST:
*a = read_reg(0x08);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_SET_HUE:
write_reg(0x0b, (unsigned int)a);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_GET_HUE:
*a = read_reg(0x0b);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_GET_SIGNAL:
*a = read_reg(0x10);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_SET_REGISTER:
write_reg(((unsigned int)a & 0xffff0000) >> 16,
(unsigned int)a & 0x0000ffff);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_GET_REGISTER:
*a = read_reg(*a);
sc = RTEMS_SUCCESSFUL;
break;
case VIDEO_SET_FORMAT:
set_format((int)a);
sc = RTEMS_SUCCESSFUL;
break;
default:
sc = RTEMS_UNSATISFIED;
break;
}
if (sc == RTEMS_SUCCESSFUL)
args->ioctl_return = 0;
else
args->ioctl_return = -1;
return sc;
}