embedded/app/usbcan/can/sja1000p.h

   1 /**************************************************************************/
   2 /* File: sja1000p.h - Philips/NXP SJA1000 chip PeliCanCAN mode 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) 2004-2005 Tomasz Motylewski (BFAD GmbH)                  */
   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 #ifndef _CAN_SJA1000P_H
  37 #define _CAN_SJA1000P_H
  38
  39 int sja1000p_chip_config(struct canchip_t *chip);
  40 int sja1000p_extended_mask(struct canchip_t *chip, unsigned long code, unsigned long mask);
  41 int sja1000p_baud_rate(struct canchip_t *chip, int rate, int clock, int sjw,
  42                 int sampl_pt, int flags);
  43 int sja1000p_pre_read_config(struct canchip_t *chip, struct msgobj_t *obj);
  44 int sja1000p_pre_write_config(struct canchip_t *chip, struct msgobj_t *obj,
  45                 struct canmsg_t *msg);
  46 int sja1000p_send_msg(struct canchip_t *chip, struct msgobj_t *obj,
  47                 struct canmsg_t *msg);
  48 int sja1000p_fill_chipspecops(struct canchip_t *chip);
  49 int sja1000p_irq_handler(int irq, struct canchip_t *chip);
  50
  51
  52 /* PeliCAN mode */
  53 enum SJA1000_PeliCAN_regs {
  54         SJAMOD  = 0x00,
  55 /// Command register
  56         SJACMR  = 0x01,
  57 /// Status register
  58         SJASR   = 0x02,
  59 /// Interrupt register
  60         SJAIR   = 0x03,
  61 /// Interrupt Enable
  62         SJAIER  = 0x04,
  63 /// Bus Timing register 0
  64         SJABTR0 = 0x06,
  65 /// Bus Timing register 1
  66         SJABTR1 = 0x07,
  67 /// Output Control register
  68         SJAOCR  = 0x08,
  69 /// Arbitration Lost Capture
  70         SJAALC  = 0x0b,
  71 /// Error Code Capture
  72         SJAECC  = 0x0c,
  73 /// Error Warning Limit
  74         SJAEWLR = 0x0d,
  75 /// RX Error Counter
  76         SJARXERR = 0x0e,
  77 /// TX Error Counter
  78         SJATXERR0 = 0x0e,
  79         SJATXERR1 = 0x0f,
  80 /// Rx Message Counter (number of msgs. in RX FIFO
  81         SJARMC  = 0x1d,
  82 /// Rx Buffer Start Addr. (address of current MSG)
  83         SJARBSA = 0x1e,
  84 /// Transmit Buffer (write) Receive Buffer (read) Frame Information
  85         SJAFRM = 0x10,
  86 /// ID bytes (11 bits in 0 and 1 or 16 bits in 0,1 and 13 bits in 2,3 (extended))
  87         SJAID0 = 0x11, SJAID1 = 0x12,
  88 /// ID cont. for extended frames
  89         SJAID2 = 0x13, SJAID3 = 0x14,
  90 /// Data start standard frame
  91         SJADATS = 0x13,
  92 /// Data start extended frame
  93         SJADATE = 0x15,
  94 /// Acceptance Code (4 bytes) in RESET mode
  95         SJAACR0 = 0x10,
  96 /// Acceptance Mask (4 bytes) in RESET mode
  97         SJAAMR0 = 0x14,
  98 /// 4 bytes
  99         SJA_PeliCAN_AC_LEN = 4,
 100 /// Clock Divider
 101         SJACDR = 0x1f
 102 };
 103
 104 /** Mode Register 0x00 */
 105 enum sja1000_PeliCAN_MOD {
 106         sjaMOD_SM = 1<<4,  // Sleep Mode (writable only in OPERATING mode)
 107         sjaMOD_AFM= 1<<3,  // Acceptance Filter Mode (writable only in RESET)
 108         sjaMOD_STM= 1<<2,  // Self Test Mode (writable only in RESET)
 109         sjaMOD_LOM= 1<<1,  // Listen Only Mode (writable only in RESET)
 110         sjaMOD_RM = 1      // Reset Mode
 111 };
 112
 113 /** Command Register 0x01 */
 114 enum sja1000_PeliCAN_CMR {
 115         sjaCMR_SRR= 1<<4,  // Self Reception Request (GoToSleep in BASIC mode)
 116         sjaCMR_CDO= 1<<3,  // Clear Data Overrun
 117         sjaCMR_RRB= 1<<2,  // Release Receive Buffer
 118         sjaCMR_AT = 1<<1,  // Abort Transmission
 119         sjaCMR_TR = 1 };   // Transmission Request
 120
 121 /** Status Register 0x02 */
 122 enum sja1000_SR {
 123         sjaSR_BS  = 1<<7,  // Bus Status
 124         sjaSR_ES  = 1<<6,  // Error Status
 125         sjaSR_TS  = 1<<5,  // Transmit Status
 126         sjaSR_RS  = 1<<4,  // Receive Status
 127         sjaSR_TCS = 1<<3,  // Transmission Complete Status
 128         sjaSR_TBS = 1<<2,  // Transmit Buffer Status
 129         sjaSR_DOS = 1<<1,  // Data Overrun Status
 130         sjaSR_RBS = 1 };   // Receive Buffer Status
 131
 132 /** Interrupt Enable Register 0x04 */
 133 enum sja1000_PeliCAN_IER {
 134         sjaIER_BEIE= 1<<7, // Bus Error Interrupt Enable
 135         sjaIER_ALIE= 1<<6, // Arbitration Lost Interrupt Enable
 136         sjaIER_EPIE= 1<<5, // Error Passive Interrupt Enable
 137         sjaIER_WUIE= 1<<4, // Wake-Up Interrupt Enable
 138         sjaIER_DOIE= 1<<3, // Data Overrun Interrupt Enable
 139         sjaIER_EIE = 1<<2, // Error Warning Interrupt Enable
 140         sjaIER_TIE = 1<<1, // Transmit Interrupt Enable
 141         sjaIER_RIE = 1,    // Receive Interrupt Enable
 142         sjaENABLE_INTERRUPTS = sjaIER_BEIE|sjaIER_EPIE|sjaIER_DOIE|sjaIER_EIE|sjaIER_TIE|sjaIER_RIE,
 143         sjaDISABLE_INTERRUPTS = 0
 144 // WARNING: the chip automatically enters RESET (bus off) mode when
 145         // error counter > 255
 146 };
 147
 148 /** Arbitration Lost Capture Register 0x0b.
 149  * Counting starts from 0 (bit1 of ID). Bits 5-7 reserved*/
 150 enum sja1000_PeliCAN_ALC {
 151         sjaALC_SRTR = 0x0b,// Arbitration lost in bit SRTR
 152         sjaALC_IDE  = 0x1c, // Arbitration lost in bit IDE
 153         sjaALC_RTR  = 0x1f, // Arbitration lost in RTR
 154 };
 155
 156 /** Error Code Capture Register 0x0c*/
 157 enum sja1000_PeliCAN_ECC {
 158         sjaECC_ERCC1 = 1<<7,
 159         sjaECC_ERCC0 = 1<<6,
 160         sjaECC_BIT   = 0,
 161         sjaECC_FORM  = sjaECC_ERCC0,
 162         sjaECC_STUFF = sjaECC_ERCC1,
 163         sjaECC_OTHER = sjaECC_ERCC0 | sjaECC_ERCC1,
 164         sjaECC_DIR   = 1<<5,    // 1 == RX, 0 == TX
 165         sjaECC_SEG_M = (1<<5) -1 // Segment mask, see page 37 of SJA1000 Data Sheet
 166 };
 167
 168 /** Frame format information 0x10 */
 169 enum sja1000_PeliCAN_FRM {
 170         sjaFRM_FF = 1<<7, // Frame Format 1 == extended, 0 == standard
 171         sjaFRM_RTR = 1<<6, // Remote request
 172         sjaFRM_DLC_M = (1<<4)-1 // Length Mask
 173 };
 174
 175
 176 /** Interrupt (status) Register 0x03 */
 177 enum sja1000_PeliCAN_IR {
 178         sjaIR_BEI = 1<<7,  // Bus Error Interrupt
 179         sjaIR_ALI = 1<<6,  // Arbitration Lost Interrupt
 180         sjaIR_EPI = 1<<5,  // Error Passive Interrupt (entered error passive state or error active state)
 181         sjaIR_WUI = 1<<4,  // Wake-Up Interrupt
 182         sjaIR_DOI = 1<<3,  // Data Overrun Interrupt
 183         sjaIR_EI  = 1<<2,  // Error Interrupt
 184         sjaIR_TI  = 1<<1,  // Transmit Interrupt
 185         sjaIR_RI  = 1      // Receive Interrupt
 186 };
 187
 188 /** Bus Timing 1 Register 0x07 */
 189 enum sja1000_BTR1 {
 190         sjaMAX_TSEG1 = 15,
 191         sjaMAX_TSEG2 = 7
 192 };
 193
 194 /** Output Control Register 0x08 */
 195 enum sja1000_OCR {
 196         sjaOCR_MODE_BIPHASE = 0,
 197         sjaOCR_MODE_TEST = 1,
 198         sjaOCR_MODE_NORMAL = 2,
 199         sjaOCR_MODE_CLOCK = 3,
 200 /// TX0 push-pull not inverted
 201         sjaOCR_TX0_LH = 0x18,
 202 /// TX1 floating (off)
 203         sjaOCR_TX1_ZZ = 0
 204 };
 205
 206 /** Clock Divider register 0x1f */
 207 enum sja1000_CDR {
 208         sjaCDR_PELICAN = 1<<7,
 209 /// bypass input comparator
 210         sjaCDR_CBP = 1<<6,
 211 /// switch TX1 to generate RX INT
 212         sjaCDR_RXINPEN = 1<<5,
 213         sjaCDR_CLK_OFF = 1<<3,
 214 /// f_out = f_osc/(2*(CDR[2:0]+1)) or f_osc if CDR[2:0]==7
 215         sjaCDR_CLKOUT_DIV1 = 7,
 216         sjaCDR_CLKOUT_DIV2 = 0,
 217         sjaCDR_CLKOUT_DIV4 = 1,
 218         sjaCDR_CLKOUT_DIV6 = 2,
 219         sjaCDR_CLKOUT_DIV8 = 3,
 220         sjaCDR_CLKOUT_DIV10 = 4,
 221         sjaCDR_CLKOUT_DIV12 = 5,
 222         sjaCDR_CLKOUT_DIV14 = 6,
 223         sjaCDR_CLKOUT_MASK = 7
 224 };
 225
 226 /** flags for sja1000_baud_rate */
 227 #define BTR1_SAM (1<<1)
 228
 229 #endif /* _CAN_SJA1000P_H */