--- /dev/null
+/****************************************************************************/
+// Ingenieria Almudi (www.almudi.com)
+// Ported to LinCAN by Jose Pascual Ramírez (josepascual@almudi.com)
+//
+//
+// Copyright (C) 2001,2002,2003,2004 PEAK System-Technik GmbH
+//
+// linux@peak-system.com
+// www.peak-system.com
+//
+// 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; either 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// Maintainer(s): Klaus Hitschler (klaus.hitschler@gmx.de)
+//
+// Contributions: Marcel Offermans (marcel.offermans@luminis.nl)
+// Philipp Baer (philipp.baer@informatik.uni-ulm.de)
+/****************************************************************************/
+
+/****************************************************************************/
+//
+// all parts to handle the interface specific parts of pcan-dongle
+//
+// Revision 1.38 2004/07/28 22:03:29 jose pascual
+// ported to LinCAN
+//
+// Revision 1.37 2004/04/11 22:03:29 klaus
+// cosmetic changes
+//
+// Revision 1.36 2004/04/10 12:25:39 klaus
+// merge polished between HEAD and kernel-2.6 branch
+//
+// Revision 1.35 2004/04/10 08:57:26 klaus
+// merge finished between HEAD and kernel-2.6 branch
+//
+// Revision 1.32.2.1 2004/03/21 12:09:09 klaus
+// first commit for branch to kernel 2.6 code
+//
+// Revision 1.34 2004/03/27 16:57:06 klaus
+// modified for use with kernels <= 2.2.14
+//
+// Revision 1.33 2004/03/27 15:10:54 klaus
+// prepared for use with gcc 3.x, modified for use with kernels < 2.2.4
+//
+// Revision 1.32 2004/03/04 18:50:08 klaus
+// renamed PA,PB,PC to _PA_, ... to support (partially) cross-compiling for MIPS
+//
+// Revision 1.31 2003/06/22 15:34:50 klaus
+// added parts to support devfs provided by Philipp Baer (partially untested)
+//
+// Revision 1.30 2003/06/04 19:26:15 klaus
+// adapted to kernel 2.5.69 using GCC 3.2.3 (marcel), released release_20030604_x
+//
+// Revision 1.28 2003/03/02 10:58:07 klaus
+// merged USB thread into main path
+//
+// Revision 1.27 2003/03/02 10:58:07 klaus
+// merged USB thread into main path
+//
+// Revision 1.26.2.5 2003/01/29 20:34:20 klaus
+// release_20030129_a and release_20030129_u released
+//
+// Revision 1.26.2.4 2003/01/29 20:34:19 klaus
+// release_20030129_a and release_20030129_u released
+//
+// Revision 1.26.2.3 2003/01/28 23:28:26 klaus
+// reorderd pcan_usb.c and pcan_usb_kernel.c, tidied up
+//
+// Revision 1.26.2.2 2003/01/14 20:31:53 klaus
+// read/write/minor assigment is working
+//
+/****************************************************************************/
+
+/****************************************************************************/
+// INCLUDES
+
+
+#include "../include/can.h"
+#include "../include/can_sysdep.h"
+#include "../include/main.h"
+#include "../include/sja1000p.h"
+
+#include <linux/parport.h>
+
+#include "../include/pcan_dongle.h"
+
+
+
+/****************************************************************************/
+// DEFINES
+#define PCAN_DNG_SP_MINOR_BASE 16 // starting point of minors for SP devices
+#define PCAN_DNG_EPP_MINOR_BASE 24 // starting point of minors for EPP devices
+#define DNG_PORT_SIZE 4 // the address range of the dongle-port
+#define ECR_PORT_SIZE 1 // size of the associated ECR register
+#define DNG_DEFAULT_COUNT 4 // count of defaults for init
+
+typedef void (*PARPORT_IRQ_HANLDER)(int, void *, struct pt_regs *);
+
+/****************************************************************************/
+// GLOBALS
+spinlock_t pcan_lock = SPIN_LOCK_UNLOCKED;
+
+/****************************************************************************/
+// LOCALS
+static u16 dng_ports[] = {0x378, 0x278, 0x3bc, 0x2bc};
+static u8 dng_irqs[] = {7, 5, 7, 5};
+static u16 dng_devices = 0; // the number of accepted dng_devices
+static u16 epp_devices = 0; // ... epp_devices
+static u16 sp_devices = 0; // ... sp_devices
+
+static unsigned char nibble_decode[32] =
+{
+ 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
+ 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
+ 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
+ 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7
+};
+
+struct DONGLE_PORT dongle_port;
+
+char dongle_type[] = "epp_dongle";
+//char dongle_type[] = "sp_dongle";
+
+/****************************************************************************/
+// CODE
+
+//----------------------------------------------------------------------------
+// enable and disable irqs
+static void _parport_disable_irq(struct DONGLE_PORT *dng)
+{
+ u16 _PC_ = (u16)dng->dwPort + 2;
+ outb(inb(_PC_) & ~0x10, _PC_);
+}
+
+static void _parport_enable_irq(struct DONGLE_PORT *dng)
+{
+ u16 _PC_ = (u16)dng->dwPort + 2;
+ outb(inb(_PC_) | 0x10, _PC_);
+}
+
+
+// functions for SP port
+static u8 pcan_dongle_sp_readreg(struct DONGLE_PORT *dng, u8 port) // read a register
+{
+ u16 _PA_ = (u16)dng->dwPort;
+ u16 _PB_ = _PA_ + 1;
+ u16 _PC_ = _PB_ + 1;
+ u8 b0, b1 ;
+ u8 irqEnable = inb(_PC_) & 0x10; // don't influence irqEnable
+ unsigned long flags;
+
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
+ save_flags(flags);
+ cli();
+ #else
+ spin_lock_irqsave(&pcan_lock, flags);
+ #endif
+
+ outb((0x0B ^ 0x0D) | irqEnable, _PC_);
+ outb((port & 0x1F) | 0x80, _PA_);
+ outb((0x0B ^ 0x0C) | irqEnable, _PC_);
+ b1=nibble_decode[inb(_PB_)>>3];
+ outb(0x40, _PA_);
+ b0=nibble_decode[inb(_PB_)>>3];
+ outb((0x0B ^ 0x0D) | irqEnable, _PC_);
+
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
+ restore_flags(flags);
+ #else
+ spin_unlock_irqrestore(&pcan_lock, flags);
+ #endif
+
+ return (b1 << 4) | b0 ;
+}
+
+static void pcan_dongle_writereg(struct DONGLE_PORT *dng, u8 port, u8 data) // write a register
+{
+ u16 _PA_ = (u16)dng->dwPort;
+ u16 _PC_ = _PA_ + 2;
+ u8 irqEnable = inb(_PC_) & 0x10; // don't influence irqEnable
+ unsigned long flags;
+
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
+ save_flags(flags);
+ cli();
+ #else
+ spin_lock_irqsave(&pcan_lock, flags);
+ #endif
+
+ outb((0x0B ^ 0x0D) | irqEnable, _PC_);
+ outb(port & 0x1F, _PA_);
+ outb((0x0B ^ 0x0C) | irqEnable, _PC_);
+ outb(data, _PA_);
+ outb((0x0B ^ 0x0D) | irqEnable, _PC_);
+
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
+ restore_flags(flags);
+ #else
+ spin_unlock_irqrestore(&pcan_lock, flags);
+ #endif
+}
+
+// functions for EPP port
+static u8 pcan_dongle_epp_readreg(struct DONGLE_PORT *dng, u8 port) // read a register
+{
+ u16 _PA_ = (u16)dng->dwPort;
+ u16 _PC_ = _PA_ + 2;
+ u8 wert;
+ u8 irqEnable = inb(_PC_) & 0x10; // don't influence irqEnable
+ unsigned long flags;
+
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
+ save_flags(flags);
+ cli();
+ #else
+ spin_lock_irqsave(&pcan_lock, flags);
+ #endif
+
+ outb((0x0B ^ 0x0F) | irqEnable, _PC_);
+ outb((port & 0x1F) | 0x80, _PA_);
+ outb((0x0B ^ 0x2E) | irqEnable, _PC_);
+ wert = inb(_PA_);
+ outb((0x0B ^ 0x0F) | irqEnable, _PC_);
+
+ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
+ restore_flags(flags);
+ #else
+ spin_unlock_irqrestore(&pcan_lock, flags);
+ #endif
+
+ return wert;
+}
+
+static int pcan_dongle_req_irq(struct DONGLE_PORT *dng)
+{
+ if (dng->wInitStep == 3)
+ {
+ dng->wInitStep++;
+ }
+
+ return 0;
+}
+
+static void pcan_dongle_free_irq(struct DONGLE_PORT *dng)
+{
+ if (dng->wInitStep == 4)
+ {
+ dng->wInitStep--;
+ }
+}
+
+// release and probe functions
+static int pcan_dongle_cleanup(struct DONGLE_PORT *dng)
+{
+ DEBUGMSG("%s: pcan_dongle_cleanup()\n", DEVICE_NAME);
+
+ switch(dng->wInitStep)
+ {
+ case 4: pcan_dongle_free_irq(dng);
+ case 3: if (dng->wType == HW_DONGLE_SJA)
+ sp_devices--;
+ else
+ epp_devices--;
+ dng_devices = sp_devices + epp_devices;
+ case 2:
+ case 1:
+ parport_unregister_device(dng->pardev);
+ case 0: dng->wInitStep = 0;
+ }
+
+ return 0;
+}
+
+// to switch epp on or restore register
+static void setECR(struct DONGLE_PORT *dng)
+{
+ u16 wEcr = dng->wEcr;
+
+ dng->ucOldECRContent = inb(wEcr);
+ outb((dng->ucOldECRContent & 0x1F) | 0x20, wEcr);
+
+ if (dng->ucOldECRContent == 0xff)
+ DEBUGMSG("%s: realy ECP mode configured?\n", DEVICE_NAME);
+}
+
+static void restoreECR(struct DONGLE_PORT *dng)
+{
+ u16 wEcr = dng->wEcr;
+
+ outb(dng->ucOldECRContent, wEcr);
+
+ DEBUGMSG("%s: restore ECR\n", DEVICE_NAME);
+}
+
+static int pcan_dongle_probe(struct DONGLE_PORT *dng) // probe for type
+{
+ struct parport *p;
+
+ DEBUGMSG("%s: pcan_dongle_probe() - PARPORT_SUBSYSTEM\n", DEVICE_NAME);
+
+ // probe does not probe for the sja1000 device here - this is done at sja1000_open()
+ p = parport_find_base(dng->dwPort);
+ if (!p)
+ {
+ DEBUGMSG("found no parport\n");
+ return -ENXIO;
+ }
+ else
+ {
+ dng->pardev = parport_register_device(p, "can", NULL, NULL,
+ (PARPORT_IRQ_HANLDER)dng->chip->chipspecops->irq_handler,
+ 0, (void *)dng->chip);
+
+// DEBUGMSG("datos IRQ: irq_handler=0x%x p=0x%x dng->chip=0x%x dng->pardev->port->irq=0x%x irq_handler2=0x%x\n",
+// dng->chip->chipspecops->irq_handler,
+// p,dng->chip,dng->pardev->port->irq, &sja1000p_irq_handler);
+
+ if (!dng->pardev)
+ {
+ DEBUGMSG("found no parport device\n");
+ return -ENODEV;
+ }
+
+ }
+
+ return 0;
+}
+
+// interface depended open and close
+static int pcan_dongle_open(struct DONGLE_PORT *dng)
+{
+ int result = 0;
+ u16 wPort;
+
+ DEBUGMSG("%s: pcan_dongle_open()\n", DEVICE_NAME);
+
+ result = parport_claim(dng->pardev);
+
+ if (!result)
+ {
+ if (dng->pardev->port->irq == PARPORT_IRQ_NONE)
+ {
+ DEBUGMSG(KERN_ERR "%s: no irq associated to parport.\n", DEVICE_NAME);
+ result = -ENXIO;
+ }
+ }
+ else
+ DEBUGMSG(KERN_ERR "%s: can't claim parport.\n", DEVICE_NAME);
+
+ // save port state
+ if (!result)
+ {
+ wPort = (u16)dng->dwPort;
+
+ // save old port contents
+ dng->ucOldDataContent = inb(wPort);
+ dng->ucOldControlContent = inb(wPort + 2);
+
+ // switch to epp mode if possible
+ if (dng->wType == HW_DONGLE_SJA_EPP)
+ setECR(dng);
+
+ // enable irqs
+ _parport_enable_irq(dng); // parport_enable_irq(dng->pardev->port); not working since 2.4.18
+ }
+
+ return result;
+}
+
+static int pcan_dongle_release(struct DONGLE_PORT *dng)
+{
+ u16 wPort = (u16)dng->dwPort;
+
+ DEBUGMSG("%s: pcan_dongle_release()\n", DEVICE_NAME);
+
+ // disable irqs
+ _parport_disable_irq(dng); // parport_disable_irq(dng->pardev->port); not working since 2.4.18
+
+ if (dng->wType == HW_DONGLE_SJA_EPP)
+ restoreECR(dng);
+
+ // restore port state
+ outb(dng->ucOldDataContent, wPort);
+ outb(dng->ucOldControlContent, wPort + 2);
+
+ parport_release(dng->pardev);
+
+ return 0;
+}
+
+int pcan_dongle_init(struct DONGLE_PORT *dng, u32 dwPort, u16 wIrq, char *type)
+{
+ int err;
+
+ DEBUGMSG("%s: pcan_dongle_init(), dng_devices = %d\n", DEVICE_NAME, dng_devices);
+
+ dng->type = type;
+
+ dng->wType = (!strncmp(dongle_type, "sp", 4)) ? HW_DONGLE_SJA : HW_DONGLE_SJA_EPP;
+
+ // set this before any instructions, fill struct pcandev, part 1
+ dng->wInitStep = 0;
+
+ // fill struct pcandev, 1st check if a default is set
+ if (!dwPort)
+ {
+ // there's no default available
+ if (dng_devices >= DNG_DEFAULT_COUNT)
+ return -ENODEV;
+
+ dng->dwPort = dng_ports[dng_devices];
+ }
+ else
+ dng->dwPort = dwPort;
+
+ if (!wIrq)
+ {
+ if (dng_devices >= DNG_DEFAULT_COUNT)
+ return -ENODEV;
+
+ dng->wIrq = dng_irqs[dng_devices];
+ }
+ else
+ dng->wIrq = wIrq;
+
+ if (dng->wType == HW_DONGLE_SJA)
+ {
+ dng->nMinor = PCAN_DNG_SP_MINOR_BASE + sp_devices;
+ dng->wEcr = 0; // set to anything
+ }
+ else
+ {
+ dng->nMinor = PCAN_DNG_EPP_MINOR_BASE + epp_devices;
+ dng->wEcr = (u16)dng->dwPort + 0x402;
+ }
+
+ // is the device really available?
+ if ((err = pcan_dongle_probe(dng)) < 0)
+ return err;
+
+ if (dng->wType == HW_DONGLE_SJA)
+ sp_devices++;
+ else
+ epp_devices++;
+
+ dng_devices = sp_devices + epp_devices;
+
+ dng->wInitStep = 3;
+
+ DEBUGMSG(KERN_INFO "%s: %s device minor %d prepared (io=0x%04x,irq=%d)\n", DEVICE_NAME,
+ dng->type, dng->nMinor, dng->dwPort, dng->wIrq);
+
+ return 0;
+}
+
+
+
+
+/**
+ * template_request_io: - reserve io or memory range for can board
+ * @candev: pointer to candevice/board which asks for io. Field @io_addr
+ * of @candev is used in most cases to define start of the range
+ *
+ * The function template_request_io() is used to reserve the io-memory. If your
+ * hardware uses a dedicated memory range as hardware control registers you
+ * will have to add the code to reserve this memory as well.
+ * %IO_RANGE is the io-memory range that gets reserved, please adjust according
+ * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
+ * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
+ * Return Value: The function returns zero on success or %-ENODEV on failure
+ * File: src/template.c
+ */
+int pcan_dongle_request_io(struct candevice_t *candev)
+{
+ int res_init;
+
+ dongle_port.chip = candev->chip[0];
+
+ res_init = pcan_dongle_init(&dongle_port, 0, 0, dongle_type);
+
+ return res_init;
+}
+
+/**
+ * template_elease_io - free reserved io memory range
+ * @candev: pointer to candevice/board which releases io
+ *
+ * The function template_release_io() is used to free reserved io-memory.
+ * In case you have reserved more io memory, don't forget to free it here.
+ * IO_RANGE is the io-memory range that gets released, please adjust according
+ * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
+ * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
+ * Return Value: The function always returns zero
+ * File: src/template.c
+ */
+int pcan_dongle_release_io(struct candevice_t *candev)
+{
+ /* release I/O port */
+ pcan_dongle_release(&dongle_port);
+
+ pcan_dongle_cleanup(&dongle_port);
+
+ return 0;
+}
+
+/**
+ * template_reset - hardware reset routine
+ * @candev: Pointer to candevice/board structure
+ *
+ * The function template_reset() is used to give a hardware reset. This is
+ * rather hardware specific so I haven't included example code. Don't forget to
+ * check the reset status of the chip before returning.
+ * Return Value: The function returns zero on success or %-ENODEV on failure
+ * File: src/template.c
+ */
+int pcan_dongle_reset(struct candevice_t *candev)
+{
+ int i=0;
+ struct chip_t *chip;
+ int chipnr;
+ unsigned cdr;
+
+ DEBUGMSG("Resetting pcan_dongle hardware ...\n");
+ for(chipnr=0;chipnr<candev->nr_sja1000_chips;chipnr++) {
+ chip=candev->chip[chipnr];
+
+ pcan_dongle_write_register(sjaMOD_RM, chip->chip_base_addr+SJAMOD);
+ udelay(1000);
+
+ cdr=pcan_dongle_read_register(chip->chip_base_addr+SJACDR);
+ pcan_dongle_write_register(cdr|sjaCDR_PELICAN, chip->chip_base_addr+SJACDR);
+
+ pcan_dongle_write_register(0, chip->chip_base_addr+SJAIER);
+
+ i=20;
+ pcan_dongle_write_register(0, chip->chip_base_addr+SJAMOD);
+ while (pcan_dongle_read_register(chip->chip_base_addr+SJAMOD)&sjaMOD_RM) {
+ if(!i--) {
+ CANMSG("Reset status timeout!\n");
+ CANMSG("Please check your hardware.\n");
+ return -ENODEV;
+ }
+ udelay(1000);
+ pcan_dongle_write_register(0, chip->chip_base_addr+SJAMOD);
+ }
+
+ cdr = pcan_dongle_read_register(chip->chip_base_addr+SJACDR);
+ pcan_dongle_write_register(cdr|sjaCDR_PELICAN, chip->chip_base_addr+SJACDR);
+
+ pcan_dongle_write_register(0, chip->chip_base_addr+SJAIER);
+ }
+ return 0;
+}
+
+#define RESET_ADDR 0x0
+#define NR_82527 0
+#define NR_SJA1000 1
+
+/**
+ * template_init_hw_data - Initialize hardware cards
+ * @candev: Pointer to candevice/board structure
+ *
+ * The function template_init_hw_data() is used to initialize the hardware
+ * structure containing information about the installed CAN-board.
+ * %RESET_ADDR represents the io-address of the hardware reset register.
+ * %NR_82527 represents the number of intel 82527 chips on the board.
+ * %NR_SJA1000 represents the number of philips sja1000 chips on the board.
+ * The flags entry can currently only be %CANDEV_PROGRAMMABLE_IRQ to indicate that
+ * the hardware uses programmable interrupts.
+ * Return Value: The function always returns zero
+ * File: src/template.c
+ */
+int pcan_dongle_init_hw_data(struct candevice_t *candev)
+{
+ candev->res_addr=RESET_ADDR;
+ candev->nr_82527_chips=NR_82527;
+ candev->nr_sja1000_chips=NR_SJA1000;
+ candev->nr_all_chips=NR_82527+NR_SJA1000;
+// candev->flags &= ~CANDEV_PROGRAMMABLE_IRQ;
+ candev->flags |= CANDEV_PROGRAMMABLE_IRQ;
+
+ return 0;
+}
+
+#define CHIP_TYPE "sja1000p"
+/**
+ * template_init_chip_data - Initialize chips
+ * @candev: Pointer to candevice/board structure
+ * @chipnr: Number of the CAN chip on the hardware card
+ *
+ * The function template_init_chip_data() is used to initialize the hardware
+ * structure containing information about the CAN chips.
+ * %CHIP_TYPE represents the type of CAN chip. %CHIP_TYPE can be "i82527" or
+ * "sja1000".
+ * The @chip_base_addr entry represents the start of the 'official' memory map
+ * of the installed chip. It's likely that this is the same as the @io_addr
+ * argument supplied at module loading time.
+ * The @clock entry holds the chip clock value in Hz.
+ * The entry @sja_cdr_reg holds hardware specific options for the Clock Divider
+ * register. Options defined in the %sja1000.h file:
+ * %CDR_CLKOUT_MASK, %CDR_CLK_OFF, %CDR_RXINPEN, %CDR_CBP, %CDR_PELICAN
+ * The entry @sja_ocr_reg holds hardware specific options for the Output Control
+ * register. Options defined in the %sja1000.h file:
+ * %OCR_MODE_BIPHASE, %OCR_MODE_TEST, %OCR_MODE_NORMAL, %OCR_MODE_CLOCK,
+ * %OCR_TX0_LH, %OCR_TX1_ZZ.
+ * The entry @int_clk_reg holds hardware specific options for the Clock Out
+ * register. Options defined in the %i82527.h file:
+ * %iCLK_CD0, %iCLK_CD1, %iCLK_CD2, %iCLK_CD3, %iCLK_SL0, %iCLK_SL1.
+ * The entry @int_bus_reg holds hardware specific options for the Bus
+ * Configuration register. Options defined in the %i82527.h file:
+ * %iBUS_DR0, %iBUS_DR1, %iBUS_DT1, %iBUS_POL, %iBUS_CBY.
+ * Return Value: The function always returns zero
+ * File: src/template.c
+ */
+int pcan_dongle_init_chip_data(struct candevice_t *candev, int chipnr)
+{
+// if (chipnr == 0)
+ {
+ /* initialize common routines for the SJA1000 chip */
+ sja1000p_fill_chipspecops(candev->chip[chipnr]);
+
+
+ candev->chip[chipnr]->chip_type=CHIP_TYPE;
+ candev->chip[chipnr]->chip_base_addr=candev->io_addr;
+ candev->chip[chipnr]->clock = 16000000;
+ candev->chip[chipnr]->int_clk_reg = 0x0;
+ candev->chip[chipnr]->int_bus_reg = 0x0;
+ candev->chip[chipnr]->sja_cdr_reg = sjaCDR_CBP | sjaCDR_CLK_OFF;
+ candev->chip[chipnr]->sja_ocr_reg = sjaOCR_MODE_NORMAL | sjaOCR_TX0_LH;
+
+ candev->chip[chipnr]->flags |= CHIP_IRQ_VME; // I don't want setup call request_irq
+ // I'm going to do it through parport_register_device
+
+ }
+
+ return 0;
+}
+
+/**
+ * template_init_obj_data - Initialize message buffers
+ * @chip: Pointer to chip specific structure
+ * @objnr: Number of the message buffer
+ *
+ * The function template_init_obj_data() is used to initialize the hardware
+ * structure containing information about the different message objects on the
+ * CAN chip. In case of the sja1000 there's only one message object but on the
+ * i82527 chip there are 15.
+ * The code below is for a i82527 chip and initializes the object base addresses
+ * The entry @obj_base_addr represents the first memory address of the message
+ * object. In case of the sja1000 @obj_base_addr is taken the same as the chips
+ * base address.
+ * Unless the hardware uses a segmented memory map, flags can be set zero.
+ * Return Value: The function always returns zero
+ * File: src/template.c
+ */
+int pcan_dongle_init_obj_data(struct chip_t *chip, int objnr)
+{
+ chip->msgobj[objnr]->obj_base_addr=chip->chip_base_addr;
+ chip->msgobj[objnr]->obj_flags=0;
+
+ return 0;
+}
+
+/**
+ * template_program_irq - program interrupts
+ * @candev: Pointer to candevice/board structure
+ *
+ * The function template_program_irq() is used for hardware that uses
+ * programmable interrupts. If your hardware doesn't use programmable interrupts
+ * you should not set the @candevices_t->flags entry to %CANDEV_PROGRAMMABLE_IRQ and
+ * leave this function unedited. Again this function is hardware specific so
+ * there's no example code.
+ * Return value: The function returns zero on success or %-ENODEV on failure
+ * File: src/template.c
+ */
+int pcan_dongle_program_irq(struct candevice_t *candev)
+{
+ int ret_open;
+
+ pcan_dongle_req_irq(&dongle_port);
+ ret_open = pcan_dongle_open(&dongle_port);
+
+ return ret_open;
+}
+
+
+/**
+ * template_write_register - Low level write register routine
+ * @data: data to be written
+ * @address: memory address to write to
+ *
+ * The function template_write_register() is used to write to hardware registers
+ * on the CAN chip. You should only have to edit this function if your hardware
+ * uses some specific write process.
+ * Return Value: The function does not return a value
+ * File: src/template.c
+ */
+void pcan_dongle_write_register(unsigned data, unsigned long address)
+{
+ address -= dongle_port.chip->chip_base_addr; // it's in mutiplexed mode
+
+ pcan_dongle_writereg(&dongle_port, (u8) address, (u8) data); // write a register
+
+// DEBUGMSG("Write Reg at: 0x%lx data 0x%x \n", address, (unsigned) data);
+}
+
+/**
+ * template_read_register - Low level read register routine
+ * @address: memory address to read from
+ *
+ * The function template_read_register() is used to read from hardware registers
+ * on the CAN chip. You should only have to edit this function if your hardware
+ * uses some specific read process.
+ * Return Value: The function returns the value stored in @address
+ * File: src/template.c
+ */
+unsigned pcan_dongle_read_register(unsigned long address)
+{
+ u8 val;
+
+ address -= dongle_port.chip->chip_base_addr; // it's in mutiplexed mode
+
+ if (dongle_port.wType == HW_DONGLE_SJA)
+ val = pcan_dongle_sp_readreg(&dongle_port, (u8) address); // functions for SP port
+ else
+ val = pcan_dongle_epp_readreg(&dongle_port, (u8) address); // functions for EPP port
+
+// DEBUGMSG("Read Reg at: 0x%lx data 0x%x \n", address, val);
+
+ return ((unsigned)val);
+}
+
+/* !!! Don't change this function !!! */
+int pcan_dongle_register(struct hwspecops_t *hwspecops)
+{
+ hwspecops->request_io = pcan_dongle_request_io;
+ hwspecops->release_io = pcan_dongle_release_io;
+ hwspecops->reset = pcan_dongle_reset;
+ hwspecops->init_hw_data = pcan_dongle_init_hw_data;
+ hwspecops->init_chip_data = pcan_dongle_init_chip_data;
+ hwspecops->init_obj_data = pcan_dongle_init_obj_data;
+ hwspecops->write_register = pcan_dongle_write_register;
+ hwspecops->read_register = pcan_dongle_read_register;
+ hwspecops->program_irq = pcan_dongle_program_irq;
+ return 0;
+}
+
+
projects / lincan.git / commitdiff