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         kfree(chips_addr);
 111
 112         return 0;
 113 }
 114
 115 int mpc5200_reset(struct candevice_t *candev)
 116 {
 117         int i;
 118         DEBUGMSG("Resetting MSCAN chips ...\n");
 119
 120         for (i = 0; i < candev->nr_all_chips; i++)
 121         {
 122             /* !!! Assuming this card has ONLY MSCAN chips !!! */
 123             if (mscan_reset_chip(candev->chip[i]))
 124                 return -ENODEV;
 125         }
 126
 127         return 0;
 128 }
 129
 130 int mpc5200_init_hw_data(struct candevice_t *candev)
 131 {
 132         /* candev->res_addr = RESET_ADDR; */
 133         candev->nr_82527_chips = NR_82527;
 134         candev->nr_sja1000_chips = NR_SJA1000;
 135         candev->nr_all_chips = NR_ALL;
 136         /* candev->flags |= CANDEV_PROGRAMMABLE_IRQ; */
 137
 138         return 0;
 139 }
 140 int mpc5200_init_chip_data(struct candevice_t *candev, int chipnr)
 141 {
 142         mscan_fill_chipspecops(candev->chip[chipnr]);
 143
 144         candev->chip[chipnr]->clock = MPC5200_CLK_FREQ;
 145         candev->chip[chipnr]->hostdevice = candev;
 146
 147 /*
 148         candev->chip[chipnr]->chip_base_addr = can_ioport2ioptr(candev->io_addr) + chipnr * MPC5200_CAN_CHIP_OFFSET;  one chip with 2 interfaces
 149         candev->chip[chipnr]->chip_irq = MPC5200_CAN_IRQ + chipnr;
 150 */
 151         DEBUGMSG("mpc5200_init_chip_data\n");
 152
 153         return 0;
 154 }
 155
 156 int mpc5200_init_obj_data(struct canchip_t *chip, int objnr)
 157 {
 158         /* we have only two chips with only one mailbox each */
 159         chip->msgobj[objnr]->obj_base_addr = (can_ioptr_t) MSCAN_CTL0 + MPC5200_CAN_CHIP_OFFSET * objnr;
 160
 161         return 0;
 162 }
 163
 164 int mpc5200_program_irq(struct candevice_t *candev)
 165 {
 166         /* we  don't use programmable interrupt on MPC5200 */
 167         return 0;
 168 }
 169
 170
 171 void mpc5200_write_register(unsigned data, can_ioptr_t address)
 172 {
 173         /* address is an absolute address */
 174         /* DEBUGMSG("write register\n"); */
 175         writeb(data, address);          /* regs in PowerPC (5200) are one-byte length */
 176 }
 177
 178 unsigned mpc5200_read_register(can_ioptr_t address)
 179 {
 180         /* address is an absolute address */
 181         /* DEBUGMSG("read register\n"); */
 182         return readb(address);          /* regs in PowerPC (5200) are one-byte length */
 183 }
 184
 185 int mpc5200_register(struct hwspecops_t *hwspecops)
 186 {
 187         hwspecops->request_io = mpc5200_request_io;
 188         hwspecops->release_io = mpc5200_release_io;
 189         hwspecops->reset = mpc5200_reset;
 190         hwspecops->init_hw_data = mpc5200_init_hw_data;
 191         hwspecops->init_chip_data = mpc5200_init_chip_data;
 192         hwspecops->init_obj_data = mpc5200_init_obj_data;
 193         hwspecops->program_irq = NULL; /* mpc5200_program_irq; */
 194         hwspecops->write_register = mpc5200_write_register;
 195         hwspecops->read_register = mpc5200_read_register;
 196         return 0;
 197 }
 198
 199
 200 int mpc5200_init_device_node(struct canchip_t * chip, struct device_node * devnode)
 201 {
 202         chip->chip_base_addr = of_iomap(devnode, 0);
 203         if (!chip->chip_base_addr)
 204         {
 205                 DEBUGMSG("\tcannot map IO - of_iomap\n");
 206                 return -ENODEV;
 207         }
 208
 209         chip->chip_irq = irq_of_parse_and_map(devnode, 0);
 210         if (!chip->chip_irq)
 211         {
 212                 DEBUGMSG("\tcannot map IRQ\n");
 213                 iounmap(chip->chip_base_addr);
 214                 return -ENODEV;
 215         }
 216
 217         DEBUGMSG("Bound to io-addr: 0x%08x IRQ: %d\n", (unsigned int)chip->chip_base_addr, chip->chip_irq);
 218
 219         return 0;
 220 }