lincan/src/mpc5200.c

   1 /**************************************************************************/
   2 /* File: mpc5200.c - Freescale MPC5200 MSCAN controller support           */
   3 /*                                                                        */
   4 /* LinCAN - (Not only) Linux CAN bus driver                               */
   5 /* Copyright (C) 2002-2009 DCE FEE CTU Prague <http://dce.felk.cvut.cz>   */
   6 /* Copyright (C) 2002-2009 Pavel Pisa <pisa@cmp.felk.cvut.cz>             */
   7 /* Copyright (C) 2007-2008 Martin Petera <peterm4@fel.cvut.cz>            */
   8 /* Funded by OCERA and FRESCOR IST projects                               */
   9 /* Based on CAN driver code by Arnaud Westenberg <arnaud@wanadoo.nl>      */
  10 /*                                                                        */
  11 /* LinCAN is free software; you can redistribute it and/or modify it      */
  12 /* under terms of the GNU General Public License as published by the      */
  13 /* Free Software Foundation; either version 2, or (at your option) any    */
  14 /* later version.  LinCAN is distributed in the hope that it will be      */
  15 /* useful, but WITHOUT ANY WARRANTY; without even the implied warranty    */
  16 /* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    */
  17 /* General Public License for more details. You should have received a    */
  18 /* copy of the GNU General Public License along with LinCAN; see file     */
  19 /* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave,  */
  20 /* Cambridge, MA 02139, USA.                                              */
  21 /*                                                                        */
  22 /* To allow use of LinCAN in the compact embedded systems firmware        */
  23 /* and RT-executives (RTEMS for example), main authors agree with next    */
  24 /* special exception:                                                     */
  25 /*                                                                        */
  26 /* Including LinCAN header files in a file, instantiating LinCAN generics */
  27 /* or templates, or linking other files with LinCAN objects to produce    */
  28 /* an application image/executable, does not by itself cause the          */
  29 /* resulting application image/executable to be covered by                */
  30 /* the GNU General Public License.                                        */
  31 /* This exception does not however invalidate any other reasons           */
  32 /* why the executable file might be covered by the GNU Public License.    */
  33 /* Publication of enhanced or derived LinCAN files is required although.  */
  34 /**************************************************************************/
  35
  36 #include "../include/can.h"
  37 #include "../include/can_sysdep.h"
  38 #include "../include/main.h"
  39 #include "../include/mpc5200.h"
  40 #include "../include/mscan.h"
  41 #include "linux/of.h"
  42 #include "linux/of_platform.h"
  43
  44 int mpc5200_init_device_node(struct canchip_t * chip, struct device_node * devnode);
  45
  46 /* in time when release_io should take place, we dont know the
  47  * base addresses that has to be free.
  48  * This variable keeps those addresses
  49  */
  50 unsigned long * chips_addr;
  51
  52
  53 int mpc5200_request_io(struct candevice_t *candev)
  54 {
  55         int chipnr;
  56         struct device_node * dn;
  57         const char * of_devname = "can";
  58
  59         /* Workaround for OpenFormware */
  60
  61         /* Select device by chipnr:
  62          *  first dev is @ 900
  63          *  second dev is @ 980
  64          *
  65          * There are only two devices on MPC5200 */
  66
  67         /* initialize internal address storage */
  68         chips_addr = (unsigned long*)kmalloc(candev->nr_all_chips * sizeof(unsigned long), GFP_KERNEL);
  69
  70         /* DEBUGMSG("Looking for device node '%s'\n", of_devname); */
  71
  72         chipnr = 0;
  73         for_each_node_by_name(dn, of_devname)
  74         {
  75                 /* DEBUGMSG(" got OF node (%s)...\n", of_devname); */
  76
  77                 if (!of_device_is_available(dn))
  78                 {
  79                         DEBUGMSG("\tdevice not available\n");
  80                         continue;
  81                 }
  82
  83
  84                 if (mpc5200_init_device_node(candev->chip[chipnr], dn))
  85                         return -ENODEV;
  86
  87                 /* fill received address to internal storage */
  88                 chips_addr[chipnr] = (unsigned long)candev->chip[chipnr]->chip_base_addr;
  89
  90                 /* original MIDAM Shark board use only one CAN chip - this handles similar cases */
  91                 if (++chipnr >= candev->nr_all_chips)
  92                         break;
  93         }
  94
  95
  96         DEBUGMSG("Succesfully mapped %d can devices\n", chipnr);
  97         return 0;
  98 }
  99
 100 int mpc5200_release_io(struct candevice_t *candev)
 101 {
 102         int i;
 103
 104         /*can_release_io_region(candev->io_addr, candev->nr_all_chips * IO_RANGE);*/
 105
 106         /* free all chips memorey space - using internal address storage */
 107         for (i = 0; i < candev->nr_all_chips; i++)
 108                 iounmap((void*)chips_addr[i]);
 109
 110         return 0;
 111 }
 112
 113 int mpc5200_reset(struct candevice_t *candev)
 114 {
 115         int i;
 116         DEBUGMSG("Resetting MSCAN chips ...\n");
 117
 118         for (i = 0; i < candev->nr_all_chips; i++)
 119         {
 120             /* !!! Assuming this card has ONLY MSCAN chips !!! */
 121             if (mscan_reset_chip(candev->chip[i]))
 122                 return -ENODEV;
 123         }
 124
 125         return 0;
 126 }
 127
 128 int mpc5200_init_hw_data(struct candevice_t *candev)
 129 {
 130         /* candev->res_addr = RESET_ADDR; */
 131         candev->nr_82527_chips = NR_82527;
 132         candev->nr_sja1000_chips = NR_SJA1000;
 133         candev->nr_all_chips = NR_ALL;
 134         /* candev->flags |= CANDEV_PROGRAMMABLE_IRQ; */
 135
 136         return 0;
 137 }
 138 int mpc5200_init_chip_data(struct candevice_t *candev, int chipnr)
 139 {
 140         mscan_fill_chipspecops(candev->chip[chipnr]);
 141
 142         candev->chip[chipnr]->clock = MPC5200_CLK_FREQ;
 143         candev->chip[chipnr]->hostdevice = candev;
 144
 145 /*
 146         candev->chip[chipnr]->chip_base_addr = can_ioport2ioptr(candev->io_addr) + chipnr * MPC5200_CAN_CHIP_OFFSET;  one chip with 2 interfaces
 147         candev->chip[chipnr]->chip_irq = MPC5200_CAN_IRQ + chipnr;
 148 */
 149         DEBUGMSG("mpc5200_init_chip_data\n");
 150
 151         return 0;
 152 }
 153
 154 int mpc5200_init_obj_data(struct canchip_t *chip, int objnr)
 155 {
 156         /* we have only two chips with only one mailbox each */
 157         chip->msgobj[objnr]->obj_base_addr = (can_ioptr_t) MSCAN_CTL0 + MPC5200_CAN_CHIP_OFFSET * objnr;
 158
 159         return 0;
 160 }
 161
 162 int mpc5200_program_irq(struct candevice_t *candev)
 163 {
 164         /* we  don't use programmable interrupt on MPC5200 */
 165         return 0;
 166 }
 167
 168
 169 void mpc5200_write_register(unsigned data, can_ioptr_t address)
 170 {
 171         /* address is an absolute address */
 172         /* DEBUGMSG("write register\n"); */
 173         writeb(data, address);          /* regs in PowerPC (5200) are one-byte length */
 174 }
 175
 176 unsigned mpc5200_read_register(can_ioptr_t address)
 177 {
 178         /* address is an absolute address */
 179         /* DEBUGMSG("read register\n"); */
 180         return readb(address);          /* regs in PowerPC (5200) are one-byte length */
 181 }
 182
 183 int mpc5200_register(struct hwspecops_t *hwspecops)
 184 {
 185         hwspecops->request_io = mpc5200_request_io;
 186         hwspecops->release_io = mpc5200_release_io;
 187         hwspecops->reset = mpc5200_reset;
 188         hwspecops->init_hw_data = mpc5200_init_hw_data;
 189         hwspecops->init_chip_data = mpc5200_init_chip_data;
 190         hwspecops->init_obj_data = mpc5200_init_obj_data;
 191         hwspecops->program_irq = NULL; /* mpc5200_program_irq; */
 192         hwspecops->write_register = mpc5200_write_register;
 193         hwspecops->read_register = mpc5200_read_register;
 194         return 0;
 195 }
 196
 197
 198 int mpc5200_init_device_node(struct canchip_t * chip, struct device_node * devnode)
 199 {
 200         chip->chip_base_addr = of_iomap(devnode, 0);
 201         if (!chip->chip_base_addr)
 202         {
 203                 DEBUGMSG("\tcannot map IO - of_iomap\n");
 204                 return -ENODEV;
 205         }
 206
 207         chip->chip_irq = irq_of_parse_and_map(devnode, 0);
 208         if (!chip->chip_irq)
 209         {
 210                 DEBUGMSG("\tcannot map IRQ\n");
 211                 iounmap(chip->chip_base_addr);
 212                 return -ENODEV;
 213         }
 214
 215         DEBUGMSG("Bound to io-addr: 0x%08x IRQ: %d\n", (unsigned int)chip->chip_base_addr, chip->chip_irq);
 216
 217         return 0;
 218 }