/*
|
* Copyright (C) 2006 Matthias Fuchs <matthias.fuchs@esd-electronics.com>,
|
* Jan Kiszka <jan.kiszka@web.de>
|
*
|
* RTCAN driver for memory mapped SJA1000 CAN controller
|
* This code has been tested on esd's CPCI405/EPPC405 PPC405 systems.
|
*
|
* This driver is derived from the rtcan-isa driver by
|
* Wolfgang Grandegger and Sebastian Smolorz.
|
*
|
* Copyright (C) 2006 Wolfgang Grandegger <wg@grandegger.com>
|
* Copyright (C) 2005, 2006 Sebastian Smolorz
|
* <Sebastian.Smolorz@stud.uni-hannover.de>
|
*
|
*
|
* This program is free software; you can redistribute it and/or modify it
|
* under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; eitherer version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful, but
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software Foundation,
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
|
#include <linux/module.h>
|
#include <linux/ioport.h>
|
#include <linux/delay.h>
|
|
#include <rtdm/driver.h>
|
|
#include <rtdm/can.h>
|
#include <rtcan_dev.h>
|
#include <rtcan_raw.h>
|
#include <rtcan_internal.h>
|
#include <rtcan_sja1000.h>
|
#include <rtcan_sja1000_regs.h>
|
|
#define RTCAN_DEV_NAME "rtcan%d"
|
#define RTCAN_DRV_NAME "sja1000-mem"
|
|
#define RTCAN_MEM_MAX_DEV 4
|
|
static char *mem_board_name = "mem mapped";
|
|
MODULE_AUTHOR("Matthias Fuchs <matthias.fuchs@esd-electronics.com>");
|
MODULE_DESCRIPTION("RTCAN driver for memory mapped SJA1000 controller");
|
MODULE_LICENSE("GPL");
|
|
static u32 mem[RTCAN_MEM_MAX_DEV];
|
static int irq[RTCAN_MEM_MAX_DEV];
|
static u32 can_clock[RTCAN_MEM_MAX_DEV];
|
static u8 ocr[RTCAN_MEM_MAX_DEV];
|
static u8 cdr[RTCAN_MEM_MAX_DEV];
|
|
module_param_array(mem, uint, NULL, 0444);
|
module_param_array(irq, int, NULL, 0444);
|
module_param_array(can_clock, uint, NULL, 0444);
|
module_param_array(ocr, byte, NULL, 0444);
|
module_param_array(cdr, byte, NULL, 0444);
|
|
MODULE_PARM_DESC(mem, "The io-memory address");
|
MODULE_PARM_DESC(irq, "The interrupt number");
|
MODULE_PARM_DESC(can_clock, "External clock frequency (default 16 MHz)");
|
MODULE_PARM_DESC(ocr, "Value of output control register (default 0x1a)");
|
MODULE_PARM_DESC(cdr, "Value of clock divider register (default 0xc8");
|
|
#define RTCAN_MEM_RANGE 0x80
|
|
struct rtcan_mem
|
{
|
volatile void __iomem *vmem;
|
};
|
|
static struct rtcan_device *rtcan_mem_devs[RTCAN_MEM_MAX_DEV];
|
|
static u8 rtcan_mem_readreg(struct rtcan_device *dev, int reg)
|
{
|
struct rtcan_mem *board = (struct rtcan_mem *)dev->board_priv;
|
return readb(board->vmem + reg);
|
}
|
|
static void rtcan_mem_writereg(struct rtcan_device *dev, int reg, u8 val)
|
{
|
struct rtcan_mem *board = (struct rtcan_mem *)dev->board_priv;
|
writeb(val, board->vmem + reg);
|
}
|
|
int __init rtcan_mem_init_one(int idx)
|
{
|
struct rtcan_device *dev;
|
struct rtcan_sja1000 *chip;
|
struct rtcan_mem *board;
|
int ret;
|
|
if ((dev = rtcan_dev_alloc(sizeof(struct rtcan_sja1000),
|
sizeof(struct rtcan_mem))) == NULL)
|
return -ENOMEM;
|
|
chip = (struct rtcan_sja1000 *)dev->priv;
|
board = (struct rtcan_mem *)dev->board_priv;
|
|
dev->board_name = mem_board_name;
|
|
chip->irq_num = irq[idx];
|
chip->irq_flags = RTDM_IRQTYPE_SHARED;
|
chip->read_reg = rtcan_mem_readreg;
|
chip->write_reg = rtcan_mem_writereg;
|
|
if (!request_mem_region(mem[idx], RTCAN_MEM_RANGE, RTCAN_DRV_NAME)) {
|
ret = -EBUSY;
|
goto out_dev_free;
|
}
|
|
/* ioremap io memory */
|
if (!(board->vmem = ioremap(mem[idx], RTCAN_MEM_RANGE))) {
|
ret = -EBUSY;
|
goto out_release_mem;
|
}
|
|
/* Clock frequency in Hz */
|
if (can_clock[idx])
|
dev->can_sys_clock = can_clock[idx] / 2;
|
else
|
dev->can_sys_clock = 8000000; /* 16/2 MHz */
|
|
/* Output control register */
|
if (ocr[idx])
|
chip->ocr = ocr[idx];
|
else
|
chip->ocr = SJA_OCR_MODE_NORMAL | SJA_OCR_TX0_PUSHPULL;
|
|
if (cdr[idx])
|
chip->cdr = cdr[idx];
|
else
|
chip->cdr = SJA_CDR_CAN_MODE | SJA_CDR_CLK_OFF | SJA_CDR_CBP;
|
|
strncpy(dev->name, RTCAN_DEV_NAME, IFNAMSIZ);
|
|
ret = rtcan_sja1000_register(dev);
|
if (ret) {
|
printk(KERN_ERR "ERROR %d while trying to register SJA1000 "
|
"device!\n", ret);
|
goto out_iounmap;
|
}
|
|
rtcan_mem_devs[idx] = dev;
|
return 0;
|
|
out_iounmap:
|
iounmap((void *)board->vmem);
|
|
out_release_mem:
|
release_mem_region(mem[idx], RTCAN_MEM_RANGE);
|
|
out_dev_free:
|
rtcan_dev_free(dev);
|
|
return ret;
|
}
|
|
static void rtcan_mem_exit(void);
|
|
/** Init module */
|
static int __init rtcan_mem_init(void)
|
{
|
int i, err;
|
int devices = 0;
|
|
if (!rtdm_available())
|
return -ENOSYS;
|
|
for (i = 0; i < RTCAN_MEM_MAX_DEV && mem[i] != 0; i++) {
|
err = rtcan_mem_init_one(i);
|
if (err) {
|
rtcan_mem_exit();
|
return err;
|
}
|
devices++;
|
}
|
if (devices)
|
return 0;
|
|
printk(KERN_ERR "ERROR! No devices specified! "
|
"Use mem=<port1>[,...] irq=<irq1>[,...]\n");
|
return -EINVAL;
|
}
|
|
|
/** Cleanup module */
|
static void rtcan_mem_exit(void)
|
{
|
int i;
|
struct rtcan_device *dev;
|
volatile void __iomem *vmem;
|
|
for (i = 0; i < RTCAN_MEM_MAX_DEV; i++) {
|
dev = rtcan_mem_devs[i];
|
if (!dev)
|
continue;
|
vmem = ((struct rtcan_mem *)dev->board_priv)->vmem;
|
rtcan_sja1000_unregister(dev);
|
iounmap((void *)vmem);
|
release_mem_region(mem[i], RTCAN_MEM_RANGE);
|
rtcan_dev_free(dev);
|
}
|
}
|
|
module_init(rtcan_mem_init);
|
module_exit(rtcan_mem_exit);
|
