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

leon, grcan: function based user interface

Browse Source 
This commit preserves all driver services, using a function based user
interface instead of the I/O interface.

The messages count parameter is now number of CAN messages instead of
number of bytes.
This commit is contained in:
Martin Aberg
2017-01-24 10:00:07 +01:00
committed by Daniel Hellstrom
parent 229c42499e
commit ad203e5887
2 changed files with 445 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

679
c/src/lib/libbsp/sparc/shared/can/grcan.c
View File

@@ -10,7 +10,6 @@
*/ */
#include <bsp.h> #include <bsp.h>
#include <rtems/libio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@@ -23,6 +22,9 @@
#include <drvmgr/ambapp_bus.h> #include <drvmgr/ambapp_bus.h>
#include <ambapp.h> #include <ambapp.h>
/* Maximum number of GRCAN devices supported by driver */
#define GRCAN_COUNT_MAX 8
#define WRAP_AROUND_TX_MSGS 1 #define WRAP_AROUND_TX_MSGS 1
#define WRAP_AROUND_RX_MSGS 2 #define WRAP_AROUND_RX_MSGS 2
#define GRCAN_MSG_SIZE sizeof(struct grcan_msg) #define GRCAN_MSG_SIZE sizeof(struct grcan_msg)
@@ -137,15 +139,6 @@ struct grcan_priv {
rtems_id rx_sem, tx_sem, txempty_sem, dev_sem; rtems_id rx_sem, tx_sem, txempty_sem, dev_sem;
}; };
static rtems_device_driver grcan_initialize(rtems_device_major_number major, rtems_device_minor_number minor, void *arg);
static rtems_device_driver grcan_open(rtems_device_major_number major, rtems_device_minor_number minor, void *arg);
static rtems_device_driver grcan_close(rtems_device_major_number major, rtems_device_minor_number minor, void *arg);
static rtems_device_driver grcan_read(rtems_device_major_number major, rtems_device_minor_number minor, void *arg);
static rtems_device_driver grcan_write(rtems_device_major_number major, rtems_device_minor_number minor, void *arg);
static rtems_device_driver grcan_ioctl(rtems_device_major_number major, rtems_device_minor_number minor, void *arg);
#define GRCAN_DRIVER_TABLE_ENTRY { grcan_initialize, grcan_open, grcan_close, grcan_read, grcan_write, grcan_ioctl }
static void __inline__ grcan_hw_reset(struct grcan_regs *regs); static void __inline__ grcan_hw_reset(struct grcan_regs *regs);
static unsigned int grcan_hw_read_try( static unsigned int grcan_hw_read_try(
@@ -209,15 +202,12 @@ static unsigned int __inline__ _grcan_read_nocache(unsigned int address)
} }
#endif #endif
static int grcan_count = 0;
static rtems_driver_address_table grcan_driver = GRCAN_DRIVER_TABLE_ENTRY; static struct grcan_priv *priv_tab[GRCAN_COUNT_MAX];
static int grcan_driver_io_registered = 0;
static rtems_device_major_number grcan_driver_io_major = 0;
/******************* Driver manager interface ***********************/ /******************* Driver manager interface ***********************/
/* Driver prototypes */ /* Driver prototypes */
int grcan_register_io(rtems_device_major_number *m);
int grcan_device_init(struct grcan_priv *pDev); int grcan_device_init(struct grcan_priv *pDev);
int grcan_init2(struct drvmgr_dev *dev); int grcan_init2(struct drvmgr_dev *dev);
@@ -265,6 +255,8 @@ int grcan_init2(struct drvmgr_dev *dev)
struct grcan_priv *priv; struct grcan_priv *priv;
DBG("GRCAN[%d] on bus %s\n", dev->minor_drv, dev->parent->dev->name); DBG("GRCAN[%d] on bus %s\n", dev->minor_drv, dev->parent->dev->name);
if (GRCAN_COUNT_MAX <= grcan_count)
return DRVMGR_ENORES;
priv = dev->priv = malloc(sizeof(struct grcan_priv)); priv = dev->priv = malloc(sizeof(struct grcan_priv));
if ( !priv ) if ( !priv )
return DRVMGR_NOMEM; return DRVMGR_NOMEM;
@@ -280,24 +272,10 @@ int grcan_init3(struct drvmgr_dev *dev)
{ {
struct grcan_priv *priv; struct grcan_priv *priv;
char prefix[32]; char prefix[32];
rtems_status_code status;
priv = dev->priv; priv = dev->priv;
/* Do initialization */ /*
if ( grcan_driver_io_registered == 0) {
/* Register the I/O driver only once for all cores */
if ( grcan_register_io(&grcan_driver_io_major) ) {
/* Failed to register I/O driver */
dev->priv = NULL;
return DRVMGR_FAIL;
}
grcan_driver_io_registered = 1;
}
/* I/O system registered and initialized
* Now we take care of device initialization. * Now we take care of device initialization.
*/ */
@@ -305,6 +283,9 @@ int grcan_init3(struct drvmgr_dev *dev)
return DRVMGR_FAIL; return DRVMGR_FAIL;
} }
priv_tab[grcan_count] = priv;
grcan_count++;
/* Get Filesystem name prefix */ /* Get Filesystem name prefix */
prefix[0] = '\0'; prefix[0] = '\0';
if ( drvmgr_get_dev_prefix(dev, prefix) ) { if ( drvmgr_get_dev_prefix(dev, prefix) ) {
@@ -319,42 +300,9 @@ int grcan_init3(struct drvmgr_dev *dev)
sprintf(priv->devName, "/dev/%sgrcan%d", prefix, dev->minor_bus); sprintf(priv->devName, "/dev/%sgrcan%d", prefix, dev->minor_bus);
} }
/* Register Device */
status = rtems_io_register_name(priv->devName, grcan_driver_io_major, dev->minor_drv);
if (status != RTEMS_SUCCESSFUL) {
return DRVMGR_FAIL;
}
return DRVMGR_OK; return DRVMGR_OK;
} }
/******************* Driver Implementation ***********************/
int grcan_register_io(rtems_device_major_number *m)
{
rtems_status_code r;
if ((r = rtems_io_register_driver(0, &grcan_driver, m)) == RTEMS_SUCCESSFUL) {
DBG("GRCAN driver successfully registered, major: %d\n", *m);
} else {
switch(r) {
case RTEMS_TOO_MANY:
printk("GRCAN rtems_io_register_driver failed: RTEMS_TOO_MANY\n");
return -1;
case RTEMS_INVALID_NUMBER:
printk("GRCAN rtems_io_register_driver failed: RTEMS_INVALID_NUMBER\n");
return -1;
case RTEMS_RESOURCE_IN_USE:
printk("GRCAN rtems_io_register_driver failed: RTEMS_RESOURCE_IN_USE\n");
return -1;
default:
printk("GRCAN rtems_io_register_driver failed\n");
return -1;
}
}
return 0;
}
int grcan_device_init(struct grcan_priv *pDev) int grcan_device_init(struct grcan_priv *pDev)
{ {
struct amba_dev_info *ambadev; struct amba_dev_info *ambadev;
@@ -428,7 +376,7 @@ static void __inline__ grcan_hw_reset(struct grcan_regs *regs)
regs->ctrl = GRCAN_CTRL_RESET; regs->ctrl = GRCAN_CTRL_RESET;
} }
static rtems_device_driver grcan_start(struct grcan_priv *pDev) static rtems_device_driver grcan_hw_start(struct grcan_priv *pDev)
{ {
/* /*
* tmp is set but never used. GCC gives a warning for this * tmp is set but never used. GCC gives a warning for this
@@ -503,7 +451,7 @@ static rtems_device_driver grcan_start(struct grcan_priv *pDev)
return RTEMS_SUCCESSFUL; return RTEMS_SUCCESSFUL;
} }
static void grcan_stop(struct grcan_priv *pDev) static void grcan_hw_stop(struct grcan_priv *pDev)
{ {
FUNCDBG(); FUNCDBG();
@@ -1210,39 +1158,34 @@ static void grcan_free_buffers(struct grcan_priv *pDev, int rx, int tx)
} }
} }
static rtems_device_driver grcan_initialize( int grcan_dev_count(void)
rtems_device_major_number major,
rtems_device_minor_number unused,
void *arg
)
{ {
return RTEMS_SUCCESSFUL; return grcan_count;
} }
static rtems_device_driver grcan_open(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) void *grcan_open(int dev_no)
{ {
struct grcan_priv *pDev; struct grcan_priv *pDev;
rtems_device_driver ret; void *ret;
struct drvmgr_dev *dev;
union drvmgr_key_value *value; union drvmgr_key_value *value;
FUNCDBG(); FUNCDBG();
if ( drvmgr_get_dev(&grcan_drv_info.general, minor, &dev) ) { if (grcan_count == 0 || (grcan_count <= dev_no)) {
DBG("Wrong minor %d\n", minor); return NULL;
return RTEMS_INVALID_NAME;
} }
pDev = (struct grcan_priv *)dev->priv;
pDev = priv_tab[dev_no];
/* Wait until we get semaphore */ /* Wait until we get semaphore */
if (rtems_semaphore_obtain(pDev->dev_sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT) if (rtems_semaphore_obtain(pDev->dev_sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT)
!= RTEMS_SUCCESSFUL) { != RTEMS_SUCCESSFUL) {
return RTEMS_INTERNAL_ERROR; return NULL;
} }
/* is device busy/taken? */ /* is device busy/taken? */
if ( pDev->open ) { if ( pDev->open ) {
ret=RTEMS_RESOURCE_IN_USE; ret = NULL;
goto out; goto out;
} }
@@ -1297,33 +1240,27 @@ static rtems_device_driver grcan_open(rtems_device_major_number major, rtems_dev
grcan_calc_timing(GRCAN_DEFAULT_BAUD,pDev->corefreq_hz,GRCAN_SAMPLING_POINT,&pDev->config.timing); grcan_calc_timing(GRCAN_DEFAULT_BAUD,pDev->corefreq_hz,GRCAN_SAMPLING_POINT,&pDev->config.timing);
if ( grcan_alloc_buffers(pDev,1,1) ) { if ( grcan_alloc_buffers(pDev,1,1) ) {
ret=RTEMS_NO_MEMORY; ret = NULL;
goto out; goto out;
} }
/* Clear statistics */ /* Clear statistics */
memset(&pDev->stats,0,sizeof(struct grcan_stats)); memset(&pDev->stats,0,sizeof(struct grcan_stats));
ret = RTEMS_SUCCESSFUL; ret = pDev;
out: out:
rtems_semaphore_release(pDev->dev_sem); rtems_semaphore_release(pDev->dev_sem);
return ret; return ret;
} }
static rtems_device_driver grcan_close(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) int grcan_close(void *d)
{ {
struct grcan_priv *pDev; struct grcan_priv *pDev = d;
struct drvmgr_dev *dev;
FUNCDBG(); FUNCDBG();
if ( drvmgr_get_dev(&grcan_drv_info.general, minor, &dev) ) {
return RTEMS_INVALID_NAME;
}
pDev = (struct grcan_priv *)dev->priv;
if ( pDev->started ) if ( pDev->started )
grcan_stop(pDev); grcan_hw_stop(pDev);
grcan_hw_reset(pDev->regs); grcan_hw_reset(pDev->regs);
@@ -1332,34 +1269,26 @@ static rtems_device_driver grcan_close(rtems_device_major_number major, rtems_de
/* Mark Device as closed */ /* Mark Device as closed */
pDev->open = 0; pDev->open = 0;
return RTEMS_SUCCESSFUL; return 0;
} }
static rtems_device_driver grcan_read(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) int grcan_read(void *d, CANMsg *msg, size_t ucount)
{ {
struct grcan_priv *pDev; struct grcan_priv *pDev = d;
struct drvmgr_dev *dev;
rtems_libio_rw_args_t *rw_args;
CANMsg *dest; CANMsg *dest;
unsigned int count, left; unsigned int count, left;
int req_cnt; int req_cnt;
FUNCDBG(); FUNCDBG();
if ( drvmgr_get_dev(&grcan_drv_info.general, minor, &dev) ) { dest = msg;
return RTEMS_INVALID_NAME; req_cnt = ucount;
}
pDev = (struct grcan_priv *)dev->priv;
rw_args = (rtems_libio_rw_args_t *) arg;
dest = (CANMsg *) rw_args->buffer;
req_cnt = rw_args->count / sizeof(CANMsg);
if ( (!dest) || (req_cnt<1) ) if ( (!dest) || (req_cnt<1) )
return RTEMS_INVALID_NAME; return -1;
if ( !pDev->started ) if ( !pDev->started )
return RTEMS_RESOURCE_IN_USE; return -2;
/*FUNCDBG("grcan_read [%i,%i]: buf: 0x%x len: %i\n",major, minor, (unsigned int)rw_args->buffer,rw_args->count);*/ /*FUNCDBG("grcan_read [%i,%i]: buf: 0x%x len: %i\n",major, minor, (unsigned int)rw_args->buffer,rw_args->count);*/
@@ -1367,15 +1296,13 @@ static rtems_device_driver grcan_read(rtems_device_major_number major, rtems_dev
if ( !( pDev->rxblock && pDev->rxcomplete && (count!=req_cnt) ) ){ if ( !( pDev->rxblock && pDev->rxcomplete && (count!=req_cnt) ) ){
if ( count > 0 ) { if ( count > 0 ) {
/* Successfully received messages (at least one) */ /* Successfully received messages (at least one) */
rw_args->bytes_moved = count * sizeof(CANMsg); return count;
return RTEMS_SUCCESSFUL;
} }
/* nothing read, shall we block? */ /* nothing read, shall we block? */
if ( !pDev->rxblock ) { if ( !pDev->rxblock ) {
/* non-blocking mode */ /* non-blocking mode */
rw_args->bytes_moved = 0; return -3;
return RTEMS_TIMEOUT;
} }
} }
@@ -1401,8 +1328,7 @@ static rtems_device_driver grcan_read(rtems_device_major_number major, rtems_dev
* the device driver has been closed by another * the device driver has been closed by another
* thread. * thread.
*/ */
rw_args->bytes_moved = count * sizeof(CANMsg); return count;
return RTEMS_UNSATISFIED;
} }
/* Try read bytes from circular buffer */ /* Try read bytes from circular buffer */
@@ -1413,51 +1339,40 @@ static rtems_device_driver grcan_read(rtems_device_major_number major, rtems_dev
req_cnt-count); req_cnt-count);
} }
/* no need to unmask IRQ as IRQ Handler do that for us. */ /* no need to unmask IRQ as IRQ Handler do that for us. */
rw_args->bytes_moved = count * sizeof(CANMsg); return count;
return RTEMS_SUCCESSFUL;
} }
static rtems_device_driver grcan_write(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) int grcan_write(void *d, CANMsg *msg, size_t ucount)
{ {
struct grcan_priv *pDev; struct grcan_priv *pDev = d;
struct drvmgr_dev *dev;
rtems_libio_rw_args_t *rw_args;
CANMsg *source; CANMsg *source;
unsigned int count, left; unsigned int count, left;
int req_cnt; int req_cnt;
DBGC(DBG_TX,"\n"); DBGC(DBG_TX,"\n");
if ( drvmgr_get_dev(&grcan_drv_info.general, minor, &dev) ) {
return RTEMS_INVALID_NAME;
}
pDev = (struct grcan_priv *)dev->priv;
if ( !pDev->started || pDev->config.silent || pDev->flushing ) if ( !pDev->started || pDev->config.silent || pDev->flushing )
return RTEMS_RESOURCE_IN_USE; return -2;
rw_args = (rtems_libio_rw_args_t *) arg; req_cnt = ucount;
req_cnt = rw_args->count / sizeof(CANMsg); source = (CANMsg *) msg;
source = (CANMsg *) rw_args->buffer;
/* check proper length and buffer pointer */ /* check proper length and buffer pointer */
if (( req_cnt < 1) || (source == NULL) ){ if (( req_cnt < 1) || (source == NULL) ){
return RTEMS_INVALID_NAME; return -1;
} }
count = grcan_hw_write_try(pDev,pDev->regs,source,req_cnt); count = grcan_hw_write_try(pDev,pDev->regs,source,req_cnt);
if ( !(pDev->txblock && pDev->txcomplete && (count!=req_cnt)) ) { if ( !(pDev->txblock && pDev->txcomplete && (count!=req_cnt)) ) {
if ( count > 0 ) { if ( count > 0 ) {
/* Successfully transmitted chars (at least one char) */ /* Successfully transmitted chars (at least one char) */
rw_args->bytes_moved = count * sizeof(CANMsg); return count;
return RTEMS_SUCCESSFUL;
} }
/* nothing written, shall we block? */ /* nothing written, shall we block? */
if ( !pDev->txblock ) { if ( !pDev->txblock ) {
/* non-blocking mode */ /* non-blocking mode */
rw_args->bytes_moved = 0; return -3;
return RTEMS_TIMEOUT;
} }
} }
@@ -1488,8 +1403,7 @@ static rtems_device_driver grcan_write(rtems_device_major_number major, rtems_de
* thread. To avoid deadlock we return directly * thread. To avoid deadlock we return directly
* with error status. * with error status.
*/ */
rw_args->bytes_moved = count * sizeof(CANMsg); return count;
return RTEMS_UNSATISFIED;
} }
if ( pDev->txerror ){ if ( pDev->txerror ){
@@ -1509,230 +1423,309 @@ static rtems_device_driver grcan_write(rtems_device_major_number major, rtems_de
} }
/* no need to unmask IRQ as IRQ Handler do that for us. */ /* no need to unmask IRQ as IRQ Handler do that for us. */
rw_args->bytes_moved = count * sizeof(CANMsg); return count;
return RTEMS_SUCCESSFUL;
} }
static rtems_device_driver grcan_ioctl(rtems_device_major_number major, rtems_device_minor_number minor, void *arg) int grcan_start(void *d)
{ {
struct grcan_priv *pDev; struct grcan_priv *pDev = d;
struct drvmgr_dev *dev;
rtems_libio_ioctl_args_t *ioarg = (rtems_libio_ioctl_args_t *)arg;
unsigned int *data = ioarg->buffer;
struct grcan_timing timing;
unsigned int speed;
struct grcan_selection *selection;
int tmp,ret;
rtems_device_driver status; rtems_device_driver status;
struct grcan_stats *stats;
struct grcan_filter *filter; FUNCDBG();
if ( pDev->started )
return -1;
if ( (status=grcan_hw_start(pDev)) != RTEMS_SUCCESSFUL ){
return -2;
}
/* Read and write are now open... */
pDev->started = 1;
/* Register interrupt routine and enable IRQ at IRQ ctrl */
drvmgr_interrupt_register(pDev->dev, 0, "grcan", grcan_interrupt, pDev);
return 0;
}
int grcan_stop(void *d)
{
struct grcan_priv *pDev = d;
FUNCDBG();
if ( !pDev->started )
return -1;
/* Disable interrupts */
drvmgr_interrupt_unregister(pDev->dev, 0, grcan_interrupt, pDev);
grcan_hw_stop(pDev);
pDev->started = 0;
return 0;
}
int grcan_isstarted(void *d)
{
struct grcan_priv *pDev = d;
FUNCDBG();
return pDev->started;
}
int grcan_flush(void *d)
{
struct grcan_priv *pDev = d;
int tmp;
FUNCDBG();
if ( !pDev->started || pDev->flushing || pDev->config.silent )
return -1;
pDev->flushing = 1;
tmp = grcan_tx_flush(pDev);
pDev->flushing = 0;
if ( tmp ) {
/* The wait has been aborted, probably due to
* the device driver has been closed by another
* thread.
*/
return -1;
}
return 0;
}
int grcan_set_silent(void* d, int silent)
{
struct grcan_priv *pDev = d;
FUNCDBG();
if ( pDev->started )
return -1;
pDev->config.silent = silent;
pDev->config_changed = 1;
return 0;
}
int grcan_set_abort(void* d, int abort)
{
struct grcan_priv *pDev = d;
FUNCDBG();
if ( pDev->started )
return -1;
pDev->config.abort = abort;
/* This Configuration parameter doesn't need HurriCANe reset
* ==> no pDev->config_changed = 1;
*/
return 0;
}
int grcan_set_selection(void *d, const struct grcan_selection *selection)
{
struct grcan_priv *pDev = d;
FUNCDBG();
if ( pDev->started )
return -1;
if ( !selection )
return -2;
pDev->config.selection = *selection;
pDev->config_changed = 1;
return 0;
}
int grcan_set_rxblock(void *d, int block)
{
struct grcan_priv *pDev = d;
FUNCDBG();
pDev->rxblock = block;
return 0;
}
int grcan_set_txblock(void *d, int block)
{
struct grcan_priv *pDev = d;
FUNCDBG();
pDev->txblock = block;
return 0;
}
int grcan_set_txcomplete(void *d, int complete)
{
struct grcan_priv *pDev = d;
FUNCDBG();
pDev->txcomplete = complete;
return 0;
}
int grcan_set_rxcomplete(void *d, int complete)
{
struct grcan_priv *pDev = d;
FUNCDBG();
pDev->rxcomplete = complete;
return 0;
}
int grcan_get_stats(void *d, struct grcan_stats *stats)
{
struct grcan_priv *pDev = d;
FUNCDBG();
if ( !stats )
return -1;
*stats = pDev->stats;
return 0;
}
int grcan_clr_stats(void *d)
{
struct grcan_priv *pDev = d;
IRQ_GLOBAL_PREPARE(oldLevel); IRQ_GLOBAL_PREPARE(oldLevel);
FUNCDBG(); FUNCDBG();
if ( drvmgr_get_dev(&grcan_drv_info.general, minor, &dev) ) { IRQ_GLOBAL_DISABLE(oldLevel);
return RTEMS_INVALID_NAME; memset(&pDev->stats,0,sizeof(struct grcan_stats));
IRQ_GLOBAL_ENABLE(oldLevel);
return 0;
}
int grcan_set_speed(void *d, unsigned int speed)
{
struct grcan_priv *pDev = d;
struct grcan_timing timing;
int ret;
FUNCDBG();
/* cannot change speed during run mode */
if ( pDev->started )
return -1;
/* get speed rate from argument */
ret = grcan_calc_timing(speed, pDev->corefreq_hz, GRCAN_SAMPLING_POINT, &timing);
if ( ret )
return -2;
/* save timing/speed */
pDev->config.timing = timing;
pDev->config_changed = 1;
return 0;
}
int grcan_set_btrs(void *d, const struct grcan_timing *timing)
{
struct grcan_priv *pDev = d;
FUNCDBG();
/* Set BTR registers manually
* Read GRCAN/HurriCANe Manual.
*/
if ( pDev->started )
return -1;
if ( !timing )
return -2;
pDev->config.timing = *timing;
pDev->config_changed = 1;
return 0;
}
int grcan_set_afilter(void *d, const struct grcan_filter *filter)
{
struct grcan_priv *pDev = d;
FUNCDBG();
if ( !filter ){
/* Disable filtering - let all messages pass */
pDev->afilter.mask = 0x0;
pDev->afilter.code = 0x0;
}else{
/* Save filter */
pDev->afilter = *filter;
} }
pDev = (struct grcan_priv *)dev->priv; /* Set hardware acceptance filter */
grcan_hw_accept(pDev->regs,&pDev->afilter);
if (!ioarg) return 0;
return RTEMS_INVALID_NAME; }
ioarg->ioctl_return = 0; int grcan_set_sfilter(void *d, const struct grcan_filter *filter)
switch(ioarg->command) { {
case GRCAN_IOC_START: struct grcan_priv *pDev = d;
if ( pDev->started )
return RTEMS_RESOURCE_IN_USE; /* EBUSY */
if ( (status=grcan_start(pDev)) != RTEMS_SUCCESSFUL ){ FUNCDBG();
return status;
}
/* Read and write are now open... */
pDev->started = 1;
/* Register interrupt routine and enable IRQ at IRQ ctrl */ if ( !filter ){
drvmgr_interrupt_register(dev, 0, "grcan", grcan_interrupt, pDev); /* disable TX/RX SYNC filtering */
pDev->sfilter.mask = 0xffffffff;
pDev->sfilter.mask = 0;
break; /* disable Sync interrupt */
pDev->regs->imr = READ_REG(&pDev->regs->imr) & ~(GRCAN_RXSYNC_IRQ|GRCAN_TXSYNC_IRQ);
}else{
/* Save filter */
pDev->sfilter = *filter;
case GRCAN_IOC_STOP: /* Enable Sync interrupt */
if ( !pDev->started ) pDev->regs->imr = READ_REG(&pDev->regs->imr) | (GRCAN_RXSYNC_IRQ|GRCAN_TXSYNC_IRQ);
return RTEMS_RESOURCE_IN_USE;
/* Disable interrupts */
drvmgr_interrupt_unregister(dev, 0, grcan_interrupt, pDev);
grcan_stop(pDev);
pDev->started = 0;
break;
case GRCAN_IOC_ISSTARTED:
if ( !pDev->started )
return RTEMS_RESOURCE_IN_USE;
break;
case GRCAN_IOC_FLUSH:
if ( !pDev->started || pDev->flushing || pDev->config.silent )
return RTEMS_RESOURCE_IN_USE;
pDev->flushing = 1;
tmp = grcan_tx_flush(pDev);
pDev->flushing = 0;
if ( tmp ) {
/* The wait has been aborted, probably due to
* the device driver has been closed by another
* thread.
*/
return RTEMS_UNSATISFIED;
}
break;
#if 0
/* Set physical link */
case GRCAN_IOC_SET_LINK:
#ifdef REDUNDANT_CHANNELS
if ( pDev->started )
return RTEMS_RESOURCE_IN_USE; /* EBUSY */
/* switch HW channel */
pDev->channel = (unsigned int)ioargs->buffer;
#else
return RTEMS_NOT_IMPLEMENTED;
#endif
break;
#endif
case GRCAN_IOC_SET_SILENT:
if ( pDev->started )
return RTEMS_RESOURCE_IN_USE;
pDev->config.silent = (int)ioarg->buffer;
pDev->config_changed = 1;
break;
case GRCAN_IOC_SET_ABORT:
if ( pDev->started )
return RTEMS_RESOURCE_IN_USE;
pDev->config.abort = (int)ioarg->buffer;
/* This Configuration parameter doesn't need HurriCANe reset
* ==> no pDev->config_changed = 1;
*/
break;
case GRCAN_IOC_SET_SELECTION:
if ( pDev->started )
return RTEMS_RESOURCE_IN_USE;
selection = (struct grcan_selection *)ioarg->buffer;
if ( !selection )
return RTEMS_INVALID_NAME;
pDev->config.selection = *selection;
pDev->config_changed = 1;
break;
case GRCAN_IOC_SET_RXBLOCK:
pDev->rxblock = (int)ioarg->buffer;
break;
case GRCAN_IOC_SET_TXBLOCK:
pDev->txblock = (int)ioarg->buffer;
break;
case GRCAN_IOC_SET_TXCOMPLETE:
pDev->txcomplete = (int)ioarg->buffer;
break;
case GRCAN_IOC_SET_RXCOMPLETE:
pDev->rxcomplete = (int)ioarg->buffer;
break;
case GRCAN_IOC_GET_STATS:
stats = (struct grcan_stats *)ioarg->buffer;
if ( !stats )
return RTEMS_INVALID_NAME;
*stats = pDev->stats;
break;
case GRCAN_IOC_CLR_STATS:
IRQ_GLOBAL_DISABLE(oldLevel);
memset(&pDev->stats,0,sizeof(struct grcan_stats));
IRQ_GLOBAL_ENABLE(oldLevel);
break;
case GRCAN_IOC_SET_SPEED:
/* cannot change speed during run mode */
if ( pDev->started )
return RTEMS_RESOURCE_IN_USE; /* EBUSY */
/* get speed rate from argument */
speed = (unsigned int)ioarg->buffer;
ret = grcan_calc_timing(speed, pDev->corefreq_hz, GRCAN_SAMPLING_POINT, &timing);
if ( ret )
return RTEMS_INVALID_NAME; /* EINVAL */
/* save timing/speed */
pDev->config.timing = timing;
pDev->config_changed = 1;
break;
case GRCAN_IOC_SET_BTRS:
/* Set BTR registers manually
* Read GRCAN/HurriCANe Manual.
*/
if ( pDev->started )
return RTEMS_RESOURCE_IN_USE; /* EBUSY */
if ( !ioarg->buffer )
return RTEMS_INVALID_NAME;
pDev->config.timing = *(struct grcan_timing *)ioarg->buffer;
pDev->config_changed = 1;
break;
case GRCAN_IOC_SET_AFILTER:
filter = (struct grcan_filter *)ioarg->buffer;
if ( !filter ){
/* Disable filtering - let all messages pass */
pDev->afilter.mask = 0x0;
pDev->afilter.code = 0x0;
}else{
/* Save filter */
pDev->afilter = *filter;
}
/* Set hardware acceptance filter */
grcan_hw_accept(pDev->regs,&pDev->afilter);
break;
case GRCAN_IOC_SET_SFILTER:
filter = (struct grcan_filter *)ioarg->buffer;
if ( !filter ){
/* disable TX/RX SYNC filtering */
pDev->sfilter.mask = 0xffffffff;
pDev->sfilter.mask = 0;
/* disable Sync interrupt */
pDev->regs->imr = READ_REG(&pDev->regs->imr) & ~(GRCAN_RXSYNC_IRQ|GRCAN_TXSYNC_IRQ);
}else{
/* Save filter */
pDev->sfilter = *filter;
/* Enable Sync interrupt */
pDev->regs->imr = READ_REG(&pDev->regs->imr) | (GRCAN_RXSYNC_IRQ|GRCAN_TXSYNC_IRQ);
}
/* Set Sync RX/TX filter */
grcan_hw_sync(pDev->regs,&pDev->sfilter);
break;
case GRCAN_IOC_GET_STATUS:
if ( !data )
return RTEMS_INVALID_NAME;
/* Read out the statsu register from the GRCAN core */
data[0] = READ_REG(&pDev->regs->stat);
break;
default:
return RTEMS_NOT_DEFINED;
} }
return RTEMS_SUCCESSFUL; /* Set Sync RX/TX filter */
grcan_hw_sync(pDev->regs,&pDev->sfilter);
return 0;
}
int grcan_get_status(void* d, unsigned int *data)
{
struct grcan_priv *pDev = d;
FUNCDBG();
if ( !data )
return -1;
/* Read out the statsu register from the GRCAN core */
data[0] = READ_REG(&pDev->regs->stat);
return 0;
} }
/* Handle the IRQ */ /* Handle the IRQ */
@@ -1763,7 +1756,7 @@ static void grcan_interrupt(void *arg)
* to read/write until user has called ioctl(fd,START,0). * to read/write until user has called ioctl(fd,START,0).
*/ */
pDev->started = 0; pDev->started = 0;
grcan_stop(pDev); /* this mask all IRQ sources */ grcan_hw_stop(pDev); /* this mask all IRQ sources */
status=0x1ffff; /* clear all interrupts */ status=0x1ffff; /* clear all interrupts */
goto out; goto out;
} }

131
c/src/lib/libbsp/sparc/shared/include/grcan.h
View File

@@ -156,34 +156,121 @@ typedef struct {
#define GRCAN_STAT_RXERRCNT 0xff00 #define GRCAN_STAT_RXERRCNT 0xff00
#define GRCAN_STAT_TXERRCNT 0xff0000 #define GRCAN_STAT_TXERRCNT 0xff0000
/* IOCTL Commands controlling operational /*
* Return number of GRCAN devices available to driver
*/
extern int grcan_dev_count(void);
/*
* Open a GRCAN device
*
* dev_no: Device number to open
* return: Device handle to use with all other grcan_ API functions. The
* function returns NULL if device can not be opened.
*/
extern void *grcan_open(int dev_no);
/*
* Close a GRCAN device
*
* return: This function always returns 0 (success)
*/
extern int grcan_close(void *d);
/*
* Receive CAN messages
*
* Multiple CAN messages can be received in one call.
*
* d: Device handle
* msg: Pointer to receive messages
* count: Number of CAN messages to receive
*
* return:
* >=0: Number of CAN messages received. This can be less than the
* count parameter.
* -1: count parameter less than size of struct grcan_msg or NULL msg.
* -2: Device not in started mode
* -3: Timeout in non-blocking mode
* -4: A blocking read was interrupted by a Bus-off error. Device has
* left started mode.
*/
extern int grcan_read(
void *d,
CANMsg *msg,
size_t count
);
/*
* Transmit CAN messages
*
* Multiple CAN messages can be transmit in one call.
*
* d: Device handle
* msg: Pointer to messages to transmit
* count: Number of CAN messages to transmit
*
* return:
* >=0: Number of CAN messages transmitted. This can be less than the
* count parameter.
* -1: count parameter less than size of struct grcan_msg
* -2: Device not in started mode
* -3: Timeout in non-blocking mode
* -4: Bus-off error. Device has left started mode
*/
extern int grcan_write(
void *d,
CANMsg *msg,
size_t count
);
/* The remaining functions return 0 on success and non-zero on failure. */
/* Functions controlling operational
* mode * mode
*/ */
#define GRCAN_IOC_START 1 /* Bring the link up after open or bus-off */ /* Bring the link up after open or bus-off */
#define GRCAN_IOC_STOP 2 /* stop to change baud rate/config or closing down */ extern int grcan_start(void *d);
#define GRCAN_IOC_ISSTARTED 3 /* return RTEMS_SUCCESSFUL when started, othervise EBUSY */ /* stop to change baud rate/config or closing down */
#define GRCAN_IOC_FLUSH 4 /* Waits until all TX messages has been sent */ extern int grcan_stop(void *d);
/* return 1 when started, othervise 0 */
extern int grcan_isstarted(void *d);
/* Wait until all TX messages have been sent */
extern int grcan_flush(void *d);
/* IOCTL Commands that require connection /* Functions that require connection
* to be stopped * to be stopped
*/ */
#define GRCAN_IOC_SET_SILENT 16 /* enable silent mode read only state */ /* enable silent mode read only state */
#define GRCAN_IOC_SET_ABORT 17 /* enable/disable stopping link on AHB Error */ extern int grcan_set_silent(void *d, int silent);
#define GRCAN_IOC_SET_SELECTION 18 /* Set Enable0,Enable1,Selection */ /* enable/disable stopping link on AHB Error */
#define GRCAN_IOC_SET_SPEED 19 /* Set baudrate by using driver's baud rate timing calculation routines */ extern int grcan_set_abort(void *d, int abort);
#define GRCAN_IOC_SET_BTRS 20 /* Set baudrate by specifying the timing registers manually */ /* Set Enable0,Enable1,Selection */
extern int grcan_set_selection(void *d, const struct grcan_selection *selection);
/* IOCTL Commands can be called whenever */ /* Set baudrate by using driver's baud rate timing calculation routines */
#define GRCAN_IOC_SET_RXBLOCK 32 /* Enable/disable Blocking on reception (until at least one message has been received) */ extern int grcan_set_speed(void *d, unsigned int hz);
#define GRCAN_IOC_SET_TXBLOCK 33 /* Enable/disable Blocking on transmission (until at least one message has been transmitted) */ /* Set baudrate by specifying the timing registers manually */
#define GRCAN_IOC_SET_TXCOMPLETE 34 /* Enable/disable Blocking until all requested messages has been sent */ extern int grcan_set_btrs(void *d, const struct grcan_timing *timing);
#define GRCAN_IOC_SET_RXCOMPLETE 35 /* Enable/disable Blocking until all requested has been received */
#define GRCAN_IOC_GET_STATS 36 /* Get Statistics */
#define GRCAN_IOC_CLR_STATS 37 /* Clear Statistics */
#define GRCAN_IOC_SET_AFILTER 38 /* Set Acceptance filters, provide pointer to "struct grcan_filter" or NULL to disable filtering (let all messages pass) */
#define GRCAN_IOC_SET_SFILTER 40 /* Set Sync Messages RX/TX filters, NULL disables the IRQ completely */
#define GRCAN_IOC_GET_STATUS 41 /* Get status register of GRCAN core */
/* Functions can be called whenever */
/* Enable/disable Blocking on reception (until at least one message has been received) */
int grcan_set_rxblock(void* d, int block);
/* Enable/disable Blocking on transmission (until at least one message has been transmitted) */
int grcan_set_txblock(void* d, int block);
/* Enable/disable Blocking until all requested messages has been sent */
int grcan_set_txcomplete(void* d, int complete);
/* Enable/disable Blocking until all requested has been received */
int grcan_set_rxcomplete(void* d, int complete);
/* Get statistics */
extern int grcan_get_stats(void *d, struct grcan_stats *stats);
/* Clear statistics */
extern int grcan_clr_stats(void *d);
/* Set Acceptance filters, provide pointer to "struct grcan_filter" or NULL to disable filtering (let all messages pass) */
extern int grcan_set_afilter(void *d, const struct grcan_filter *filter);
/* Set Sync Messages RX/TX filters, NULL disables the IRQ completely */
extern int grcan_set_sfilter(void *d, const struct grcan_filter *filter);
/* Get status register of GRCAN core */
extern int grcan_get_status(void *d, unsigned int *status);
void grcan_register_drv(void); void grcan_register_drv(void);