lincan/include/mscan.h

   1 /**************************************************************************/
   2 /* File: mscan.h - 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
  37 #define reg_t uint8_t
  38
  39 int mscan_chip_config(struct canchip_t *chip);
  40 int mscan_enable_configuration(struct canchip_t *chip);
  41 int mscan_disable_configuration(struct canchip_t *chip);
  42
  43 int mscan_baud_rate(struct canchip_t *chip, int rate, int clock, int sjw, int sampl_pt, int flags);
  44 int mscan_set_btregs(struct canchip_t *chip, unsigned short bcr0, unsigned short bcr1);
  45
  46 int mscan_start_chip(struct canchip_t *chip);
  47 int mscan_stop_chip(struct canchip_t *chip);
  48 int mscan_attach_to_chip(struct canchip_t *chip);
  49 int mscan_release_chip(struct canchip_t *chip);
  50
  51 int mscan_standard_mask(struct canchip_t *chip, unsigned short code, unsigned short mask);
  52 int mscan_extended_mask(struct canchip_t *chip, unsigned long code, unsigned long mask);
  53 /* int mscan_message15_mask(int irq, struct canchip_t *chip); */
  54
  55 int mscan_pre_read_config(struct canchip_t *chip, struct msgobj_t *obj);
  56 int mscan_pre_write_config(struct canchip_t *chip, struct msgobj_t *obj, struct canmsg_t *msg);
  57 int mscan_send_msg(struct canchip_t *chip, struct msgobj_t *obj, struct canmsg_t *msg);
  58 int mscan_remote_request(struct canchip_t *chip, struct msgobj_t *obj);
  59
  60 int mscan_irq_handler(int irq, struct canchip_t *chip);
  61 /* int mscan_irq_accept(int irq, struct canchip_t *chip); */
  62 int mscan_config_irqs(struct canchip_t *chip, short irqs);
  63
  64 int mscan_clear_objects(struct canchip_t *chip);
  65 int mscan_check_tx_stat(struct canchip_t *chip);
  66 int mscan_wakeup_tx(struct canchip_t *chip, struct msgobj_t *obj);
  67 int mscan_filtch_rq(struct canchip_t *chip, struct msgobj_t * obj);
  68
  69 int mscan_register(struct chipspecops_t *chipspecops);
  70 int mscan_fill_chipspecops(struct canchip_t *chip);
  71
  72 int mscan_reset_chip(struct canchip_t * chip);
  73
  74 extern inline void can_write_reg_w(const struct canchip_t *pchip, uint16_t data, unsigned reg)
  75 {
  76         can_ioptr_t address = pchip->chip_base_addr + reg;
  77     #ifndef CONFIG_OC_LINCAN_DYNAMICIO
  78         writew(data,address);
  79     #else /*CONFIG_OC_LINCAN_DYNAMICIO*/
  80         pchip->write_register(data, address);
  81     #endif /*CONFIG_OC_LINCAN_DYNAMICIO*/
  82 }
  83
  84 extern inline uint16_t can_read_reg_w(const struct canchip_t *pchip, unsigned reg)
  85 {
  86         can_ioptr_t address = pchip->chip_base_addr + reg;
  87     #ifndef CONFIG_OC_LINCAN_DYNAMICIO
  88         return readw(address);
  89     #else /*CONFIG_OC_LINCAN_DYNAMICIO*/
  90         return pchip->read_register(address);
  91     #endif /*CONFIG_OC_LINCAN_DYNAMICIO*/
  92 }
  93
  94
  95 /* BasicCAN mode address map */
  96 #define MSCAN_CTL0      0x00            /* Control Register 0 */
  97 #define MSCAN_CTL1      0x01            /* Control Register 1 */
  98 #define MSCAN_BTR0      0x04            /* Bus Timing Register 0 */
  99 #define MSCAN_BTR1      0x05            /* Bus Timing Register 1 */
 100 #define MSCAN_RFLG      0x08            /* Receive Flag Register */
 101 #define MSCAN_RIER      0x09            /* Receiver Interrupt Enable Register */
 102 #define MSCAN_TFLG      0x0c            /* Transmitter Flag Register */
 103 #define MSCAN_TIER      0x0d            /* Transmitter Interrupt Enable Register */
 104 #define MSCAN_TARG      0x10            /* Transmitter Message Abort Request Register */
 105 #define MSCAN_TAAK      0x11            /* Transmitter Message Abort Acknowledge Register */
 106 #define MSCAN_TBSEL     0x14            /* Transmitter Buffer Selection */
 107 #define MSCAN_IDAC      0x15            /* Identifier Acceptance Control Register */
 108 /* Reserved 0x18, 0x19 */
 109 #define MSCAN_RXERR     0x1c            /* Receive Error Counter Register */
 110 #define MSCAN_TXERR     0x1d            /* Transmitt Error Counter Register */
 111
 112 /* Acceptance Filters */
 113 #define MSCAN_IDAR0     0x20            /* Identifier Acceptance Register 0 */
 114 #define MSCAN_IDAR1     0x21            /* Identifier Acceptance Register 1 */
 115 #define MSCAN_IDAR2     0x24            /* Identifier Acceptance Register 2 */
 116 #define MSCAN_IDAR3     0x25            /* Identifier Acceptance Register 3 */
 117 #define MSCAN_IDMR0     0x28            /* Identifier Mask Register 0 */
 118 #define MSCAN_IDMR1     0x29            /* Identifier Mask Register 1 */
 119 #define MSCAN_IDMR2     0x2c            /* Identifier Mask Register 2 */
 120 #define MSCAN_IDMR3     0x2d            /* Identifier Mask Register 3 */
 121
 122 #define MSCAN_IDAR4     0x30            /* Identifier Acceptance Register 4 */
 123 #define MSCAN_IDAR5     0x31            /* Identifier Acceptance Register 5 */
 124 #define MSCAN_IDAR6     0x34            /* Identifier Acceptance Register 6 */
 125 #define MSCAN_IDAR7     0x35            /* Identifier Acceptance Register 7 */
 126 #define MSCAN_IDMR4     0x38            /* Identifier Mask Register 4 */
 127 #define MSCAN_IDMR5     0x39            /* Identifier Mask Register 5 */
 128 #define MSCAN_IDMR6     0x3c            /* Identifier Mask Register 6 */
 129 #define MSCAN_IDMR7     0x3d            /* Identifier Mask Register 7 */
 130
 131 /* Buffers */
 132 #define MSCAN_RXFG      0x40            /* Foregroung Receive Buffer 0x40-0x5f */
 133 #define MSCAN_TXFG      0x60            /* Foregroung Receive Buffer 0x60-0x7f */
 134
 135
 136 /* BaudRate minimal and maximal TSEG values */
 137 #define MSCAN_TSEG1_MIN         4               /* means 1 Tq clock cycle */
 138 #define MSCAN_TSEG1_MAX         16              /* means 16 Tq clock cycles */
 139 #define MSCAN_TSEG2_MIN         2               /* means 1 Tq clock cycle */
 140 #define MSCAN_TSEG2_MAX         8               /* means 8 Tq clock cycles */
 141 #define MSCAN_TSEG_MIN          (MSCAN_TSEG1_MIN + MSCAN_TSEG2_MIN)
 142 #define MSCAN_TSEG_MAX          (MSCAN_TSEG1_MAX + MSCAN_TSEG2_MAX)
 143
 144 #define MSCAN_BRP_MIN           1
 145 #define MSCAN_BRP_MAX           64
 146
 147 enum mscan_ctl0 {
 148         MSCAN_CTL0_RXFRM        = 1 << 7,               /* Received Frame Flag - rw */
 149         MSCAN_CTL0_RXACT        = 1 << 6,               /* Receiver Active Status - ro */
 150         MSCAN_CTL0_CSWAI        = 1 << 5,               /* CAN Stops in Wait Mode - rw */
 151         MSCAN_CTL0_SYNCH        = 1 << 4,               /* Synchronized Status - ro */
 152         MSCAN_CTL0_TIME         = 1 << 3,               /* Timer Enable - rw */
 153         MSCAN_CTL0_WUPE         = 1 << 2,               /* WakeUp Enable - rw */
 154         MSCAN_CTL0_SLPRQ        = 1 << 1,               /* Sleep Request - rw */
 155         MSCAN_CTL0_INITRQ       = 1 << 0,               /* Initialization Mode Request - rw */
 156 };
 157
 158 enum mscan_ctl1 {
 159         MSCAN_CTL1_CANE         = 1 << 7,               /* MSCAN Enable rw */
 160         MSCAN_CTL1_CLKSRC       = 1 << 6,               /* MSCAN Clock Source rw */
 161         MSCAN_CTL1_LOOPB        = 1 << 5,               /* Loob-Back Self Test Mode rw */
 162         MSCAN_CTL1_LISTEN       = 1 << 4,               /* Listen-Only Mode rw */
 163         MSCAN_CTL1_WUPM         = 1 << 2,               /* WakeUp Mode rw */
 164         MSCAN_CTL1_SLPAK        = 1 << 1,               /* Sleep Mode Acknowledge - ro */
 165         MSCAN_CTL1_INITAK       = 1 << 0,               /* Initialization Mode Acknowledge - ro */
 166
 167         MSCAN_CTL1_RSVD         = 1 << 3,               /* Reserved */
 168 };
 169
 170 enum mscan_btr0 {
 171         MSCAN_BTR0_SJW          = 0xa0,                 /* Synchronization Jump Width: 0 to 3 (1 to 4 Tq) */
 172         MSCAN_BTR0_BRP          = 0x3f,                 /* Baud Rate Prescaler: 0 to 63 (1 to 64) */
 173 };
 174
 175 enum mscan_btr1 {
 176         MSCAN_BTR1_SAMP         = 1 << 7,               /* Sampling: 0-One sample, 1-Three samples per bit */
 177         MSCAN_BTR1_TSEG2        = 0x70,                 /* TSEG2: 3 bits */
 178         MSCAN_BTR1_TSEG1        = 0x0f,                 /* TSEG1: 4 bits */
 179 };
 180
 181 /* Interupt & Interrupt Enable Registers */
 182 enum mscan_rflg {
 183         MSCAN_RFLG_WUPIF        = 1 << 7,               /* WakeUp Interrupt Flag - rw */
 184         MSCAN_RFLG_CSCIF        = 1 << 6,               /* CAN Status Change Interrupt Flag - rw */
 185         MSCAN_RFLG_RSTAT        = 0x30,                 /* Receiver Status Bits: 0-RxOK, 1-RxWRN, 2-RxERR, 3-BusOff - ro */
 186         MSCAN_RFLG_TSTAT        = 0x0a,                 /* Transmitter Status Bits: 0-TxOK, 1-TxWRN, 2-TxErr, 3-BusOff - ro */
 187         MSCAN_RFLG_OVRIF        = 1 << 1,               /* Overrun Interrupt Flag - rw */
 188         MSCAN_RFLG_RXF          = 1 << 0,               /* Receive Buffer Full - rw */
 189 };
 190
 191 enum mscan_rier {
 192         MSCAN_RIER_WUPIE        = 1 << 7,               /* WakeUp Interrupt Enable - rw */
 193         MSCAN_RIER_CSCIE        = 1 << 6,               /* CAN Status Change Interrupt Enable - rw */
 194         MSCAN_RIER_RSTATE       = 0x30,                 /* Receiver Status Change Enable: 0-Never, 1-BusOff, 2-BusOff+RxErr, 3-All - rw */
 195         MSCAN_RIER_TSTATE       = 0x0a,                 /* Transmitter Status Change Enable: 0-Never, 1-BusOff, 2-BusOff+TxErr, 3-All - rw */
 196         MSCAN_RIER_OVRIE        = 1 << 1,               /* Overrun Interrupt Enable - rw */
 197         MSCAN_RIER_RXFIE        = 1 << 0,               /* Receive Buffer Full Interrupt Enable - rw */
 198 };
 199
 200 enum mscan_tflg {
 201         MSCAN_TFLG_TXE          = 0x07,                 /* Transmitter Buffer Empty */
 202
 203         MSCAN_TFLG_RSVD         = 0xf8,                 /* Reserved */
 204 };
 205
 206 enum mscan_tier {
 207         MSCAN_TIER_TXE          = 0x07,                 /* Transmitter Empty Interrupt Enable */
 208
 209         MSCAN_TIER_RSVD         = 0xf8,                 /* Reserved */
 210 };
 211 /* IRQ end */
 212
 213 enum mscan_tarq {
 214         MSCAN_TARQ_ABTRQ        = 0x07,                 /* Abort Request */
 215
 216         MSCAN_TARQ_RSVD         = 0xf8,                 /* Reserved */
 217 };
 218
 219 enum mscan_taak {
 220         MSCAN_TAAK_ABTAK        = 0x07,                 /* Abort Acknowledge */
 221
 222         MSCAN_TAAK_RSVD         = 0xf8,                 /* Reserved */
 223 };
 224
 225 enum mscan_tbsel {
 226         MSCAN_TBSEL_TX          = 0x07,                 /* Transmitt Buffer Select - prioritize lower */
 227
 228         MSCAN_TBSEL_RSVD        = 0xf8,                 /* Reserved */
 229 };
 230
 231 enum mscan_idac {
 232         MSCAN_IDAC_IDAM         = 0x30,                 /* Identifier Acceptance Mode: 0-Two 32bit, 1-Four 16-bit. 2-Eight 8bit, 3-Closed */
 233         MSCAN_IDAC_IDHIT        = 0x07,                 /* Identifier Acceptance Hit Indicator */
 234
 235         MSCAN_IDAC_RSVD         = 0xa8,                 /* Reserved */
 236 };
 237
 238 /* Message Buffer Organization */
 239 #define MSCAN_MSGBUFF_ID0       0x00                    /* Identifier Register 0 */
 240 #define MSCAN_MSGBUFF_ID1       0x01                    /* Identifier Register 1 */
 241 #define MSCAN_MSGBUFF_ID2       0x04                    /* Identifier Register 2 */
 242 #define MSCAN_MSGBUFF_ID3       0x05                    /* Identifier Register 3 */
 243
 244 #define MSCAN_MSGBUFF_DATA0     0x08                    /* Data Segment Register 0 */
 245 #define MSCAN_MSGBUFF_DATA1     0x09                    /* Data Segment Register 1 */
 246 #define MSCAN_MSGBUFF_DATA2     0x0c                    /* Data Segment Register 2 */
 247 #define MSCAN_MSGBUFF_DATA3     0x0d                    /* Data Segment Register 3 */
 248 #define MSCAN_MSGBUFF_DATA4     0x10                    /* Data Segment Register 4 */
 249 #define MSCAN_MSGBUFF_DATA5     0x11                    /* Data Segment Register 5 */
 250 #define MSCAN_MSGBUFF_DATA6     0x14                    /* Data Segment Register 6 */
 251 #define MSCAN_MSGBUFF_DATA7     0x15                    /* Data Segment Register 7 */
 252
 253 #define MSCAN_MSGBUFF_DLEN      0x18                    /* Data Length Register */
 254 #define MSCAN_MSGBUFF_TXPRIO    0x19                    /* Transmitt Buffer Priority - Not Applicable for Rx buffers */
 255 #define MSCAN_MSGBUFF_TSH       0x1c                    /* Time Stamp Register High */
 256 #define MSCAN_MSGBUFF_TSL       0x1d                    /* Time Stamp Register Low */
 257
 258 struct mscan_msg_buffer{
 259
 260         uint8_t         id_0;                   /* CAN identifier:  ID_EXT {28:21} OR ID_STD {10:3} */
 261         uint8_t         id_1;                   /* CAN identifier:  ID_EXT {20:18},SRR,IDE,ID_EXT{17:15} OR ID_STD{2:0},RTR,IDE, reserved */
 262         uint16_t        spacer_0;               /* spacer for compatibility */
 263         uint8_t         id_2;                   /* CAN identifier:  IDE_EXT{14:7} OR reserved for ID_STD */
 264         uint8_t         id_3;                   /* CAN identifier:  ID_EXT{6:0},RTR OR reserved for ID_STD */
 265         uint16_t        spacer_1;               /* spacer for compatibility */
 266         uint8_t         data_0;                 /* CAN data byte 0 */
 267         uint8_t         data_1;                 /* CAN data byte 1 */
 268         uint16_t        spacer_2;               /* spacer for compatibility */
 269         uint8_t         data_2;                 /* CAN data byte 2 */
 270         uint8_t         data_3;                 /* CAN data byte 3 */
 271         uint16_t        spacer_3;               /* spacer for compatibility */
 272         uint8_t         data_4;                 /* CAN data byte 4 */
 273         uint8_t         data_5;                 /* CAN data byte 5 */
 274         uint16_t        spacer_4;               /* spacer for compatibility */
 275         uint8_t         data_6;                 /* CAN data byte 6 */
 276         uint8_t         data_7;                 /* CAN data byte 7 */
 277         uint16_t        spacer_5;               /* spacer for compatibility */
 278         uint8_t         data_len;               /* CAN data length: 0xf0 reserved, DLC{3:0} */
 279         uint8_t         local_prio;             /* MSCAN TX local priority - unused fro TX buffer */
 280         uint16_t        spacer_6;               /* spacer for compatibility */
 281         uint8_t         timestamp_h;            /* local timestamp - High byte - Read Only */
 282         uint8_t         timestamp_l;            /* local timestamp - Low byte - Read Only */
 283 };