summaryrefslogtreecommitdiff
path: root/drivers/staging/cpc-usb/cpc.h
blob: ed8cb34d4763fed17e78e86edca29beca63a6acd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
/*
 * CPC CAN Interface Definitions
 *
 * Copyright (C) 2000-2008 EMS Dr. Thomas Wuensche
 *
 * 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.
 */
#ifndef CPC_HEADER
#define CPC_HEADER

// the maximum length of the union members within a CPC_MSG
// this value can be defined by the customer, but has to be
// >= 64 bytes
// however, if not defined before, we set a length of 64 byte
#if !defined(CPC_MSG_LEN) || (CPC_MSG_LEN < 64)
#undef CPC_MSG_LEN
#define CPC_MSG_LEN 64
#endif

// check the operating system used
#ifdef _WIN32 // running a Windows OS

// define basic types on Windows platforms
#ifdef _MSC_VER // Visual Studio
	typedef unsigned __int8 u8;
	typedef unsigned __int16 u16;
	typedef unsigned __int32 u32;
#else // Borland Compiler
	typedef unsigned char u8;
	typedef unsigned short u16;
	typedef unsigned int u32;
#endif
	// on Windows OS we use a byte alignment of 1
	#pragma pack(push, 1)

	// set the calling conventions for the library function calls
	#define CALL_CONV __stdcall
#else
	// Kernel headers already define this types
	#ifndef __KERNEL__
		// define basic types
		typedef unsigned char u8;
		typedef unsigned short u16;
		typedef unsigned int u32;
	#endif

	// Linux does not use this calling convention
	#define CALL_CONV
#endif

// Transmission of events from CPC interfaces to PC can be individually
// controlled per event type. Default state is: don't transmit
// Control values are constructed by bit-or of Subject and Action
// and passed to CPC_Control()

// Control-Values for CPC_Control() Command Subject Selection
#define CONTR_CAN_Message 0x04
#define CONTR_Busload	  0x08
#define	CONTR_CAN_State	  0x0C
#define	CONTR_SendAck	  0x10
#define	CONTR_Filter	  0x14
#define CONTR_CmdQueue    0x18	// reserved, do not use
#define CONTR_BusError    0x1C

// Control Command Actions
#define CONTR_CONT_OFF    0
#define CONTR_CONT_ON     1
#define CONTR_SING_ON     2
// CONTR_SING_ON doesn't change CONTR_CONT_ON state, so it should be
// read as: transmit at least once

// defines for confirmed request
#define DO_NOT_CONFIRM 0
#define DO_CONFIRM     1

// event flags
#define EVENT_READ 0x01
#define EVENT_WRITE 0x02

// Messages from CPC to PC contain a message object type field.
// The following message types are sent by CPC and can be used in
// handlers, others should be ignored.
#define CPC_MSG_T_RESYNC        0 // Normally to be ignored
#define CPC_MSG_T_CAN           1 // CAN data frame
#define CPC_MSG_T_BUSLOAD       2 // Busload message
#define CPC_MSG_T_STRING        3 // Normally to be ignored
#define CPC_MSG_T_CONTI         4 // Normally to be ignored
#define CPC_MSG_T_MEM           7 // Normally not to be handled
#define	CPC_MSG_T_RTR           8 // CAN remote frame
#define CPC_MSG_T_TXACK	        9 // Send acknowledge
#define CPC_MSG_T_POWERUP      10 // Power-up message
#define	CPC_MSG_T_CMD_NO       11 // Normally to be ignored
#define	CPC_MSG_T_CAN_PRMS     12 // Actual CAN parameters
#define	CPC_MSG_T_ABORTED      13 // Command aborted message
#define	CPC_MSG_T_CANSTATE     14 // CAN state message
#define CPC_MSG_T_RESET        15 // used to reset CAN-Controller
#define	CPC_MSG_T_XCAN         16 // XCAN data frame
#define CPC_MSG_T_XRTR         17 // XCAN remote frame
#define CPC_MSG_T_INFO         18 // information strings
#define CPC_MSG_T_CONTROL      19 // used for control of interface/driver behaviour
#define CPC_MSG_T_CONFIRM      20 // response type for confirmed requests
#define CPC_MSG_T_OVERRUN      21 // response type for overrun conditions
#define CPC_MSG_T_KEEPALIVE    22 // response type for keep alive conditions
#define CPC_MSG_T_CANERROR     23 // response type for bus error conditions
#define CPC_MSG_T_DISCONNECTED 24 // response type for a disconnected interface
#define CPC_MSG_T_ERR_COUNTER  25 // RX/TX error counter of CAN controller

#define CPC_MSG_T_FIRMWARE    100 // response type for USB firmware download

// Messages from the PC to the CPC interface contain a command field
// Most of the command types are wrapped by the library functions and have therefore
// normally not to be used.
// However, programmers who wish to circumvent the library and talk directly
// to the drivers (mainly Linux programmers) can use the following
// command types:

#define CPC_CMD_T_CAN                 1	// CAN data frame
#define CPC_CMD_T_CONTROL             3	// used for control of interface/driver behaviour
#define	CPC_CMD_T_CAN_PRMS            6	// set CAN parameters
#define	CPC_CMD_T_CLEARBUF            8	// clears input queue; this is depricated, use CPC_CMD_T_CLEAR_MSG_QUEUE instead
#define	CPC_CMD_T_INQ_CAN_PARMS      11	// inquire actual CAN parameters
#define	CPC_CMD_T_FILTER_PRMS        12	// set filter parameter
#define	CPC_CMD_T_RTR                13	// CAN remote frame
#define	CPC_CMD_T_CANSTATE           14	// CAN state message
#define	CPC_CMD_T_XCAN               15	// XCAN data frame
#define CPC_CMD_T_XRTR               16	// XCAN remote frame
#define CPC_CMD_T_RESET              17	// used to reset CAN-Controller
#define CPC_CMD_T_INQ_INFO           18	// miscellanous information strings
#define CPC_CMD_T_OPEN_CHAN          19	// open a channel
#define CPC_CMD_T_CLOSE_CHAN         20	// close a channel
#define CPC_CMD_T_CNTBUF             21	// this is depricated, use CPC_CMD_T_INQ_MSG_QUEUE_CNT instead
#define CPC_CMD_T_CAN_EXIT          200 // exit the CAN (disable interrupts; reset bootrate; reset output_cntr; mode = 1)

#define CPC_CMD_T_INQ_MSG_QUEUE_CNT  CPC_CMD_T_CNTBUF   // inquires the count of elements in the message queue
#define CPC_CMD_T_INQ_ERR_COUNTER    25	                // request the CAN controllers error counter
#define	CPC_CMD_T_CLEAR_MSG_QUEUE    CPC_CMD_T_CLEARBUF // clear CPC_MSG queue
#define	CPC_CMD_T_CLEAR_CMD_QUEUE    28	                // clear CPC_CMD queue
#define CPC_CMD_T_FIRMWARE          100                 // reserved, must not be used
#define CPC_CMD_T_USB_RESET         101                 // reserved, must not be used
#define CPC_CMD_T_WAIT_NOTIFY       102                 // reserved, must not be used
#define CPC_CMD_T_WAIT_SETUP        103                 // reserved, must not be used
#define	CPC_CMD_T_ABORT             255                 // Normally not to be used

// definitions for CPC_MSG_T_INFO
// information sources
#define CPC_INFOMSG_T_UNKNOWN_SOURCE 0
#define CPC_INFOMSG_T_INTERFACE      1
#define CPC_INFOMSG_T_DRIVER         2
#define CPC_INFOMSG_T_LIBRARY        3

// information types
#define CPC_INFOMSG_T_UNKNOWN_TYPE   0
#define CPC_INFOMSG_T_VERSION        1
#define CPC_INFOMSG_T_SERIAL         2

// definitions for controller types
#define PCA82C200   1 // Philips basic CAN controller, replaced by SJA1000
#define SJA1000     2 // Philips basic CAN controller
#define AN82527     3 // Intel full CAN controller
#define M16C_BASIC  4 // M16C controller running in basic CAN (not full CAN) mode

// channel open error codes
#define CPC_ERR_NO_FREE_CHANNEL            -1	// no more free space within the channel array
#define CPC_ERR_CHANNEL_ALREADY_OPEN       -2	// the channel is already open
#define CPC_ERR_CHANNEL_NOT_ACTIVE         -3	// access to a channel not active failed
#define CPC_ERR_NO_DRIVER_PRESENT          -4	// no driver at the location searched by the library
#define CPC_ERR_NO_INIFILE_PRESENT         -5	// the library could not find the inifile
#define CPC_ERR_WRONG_PARAMETERS           -6	// wrong parameters in the inifile
#define CPC_ERR_NO_INTERFACE_PRESENT       -7	// 1. The specified interface is not connected
						// 2. The interface (mostly CPC-USB) was disconnected upon operation
#define CPC_ERR_NO_MATCHING_CHANNEL        -8	// the driver couldn't find a matching channel
#define CPC_ERR_NO_BUFFER_AVAILABLE        -9	// the driver couldn't allocate buffer for messages
#define CPC_ERR_NO_INTERRUPT               -10	// the requested interrupt couldn't be claimed
#define CPC_ERR_NO_MATCHING_INTERFACE      -11	// no interface type related to this channel was found
#define CPC_ERR_NO_RESOURCES               -12	// the requested resources could not be claimed
#define CPC_ERR_SOCKET                     -13	// error concerning TCP sockets

// init error codes
#define CPC_ERR_WRONG_CONTROLLER_TYPE      -14	// wrong CAN controller type within initialization
#define CPC_ERR_NO_RESET_MODE              -15	// the controller could not be set into reset mode
#define CPC_ERR_NO_CAN_ACCESS              -16	// the CAN controller could not be accessed

// transmit error codes
#define CPC_ERR_CAN_WRONG_ID               -20	// the provided CAN id is too big
#define CPC_ERR_CAN_WRONG_LENGTH           -21	// the provided CAN length is too long
#define CPC_ERR_CAN_NO_TRANSMIT_BUF        -22	// the transmit buffer was occupied
#define CPC_ERR_CAN_TRANSMIT_TIMEOUT       -23	// The message could not be sent within a
						// specified time

// other error codes
#define CPC_ERR_SERVICE_NOT_SUPPORTED      -30	// the requested service is not supported by the interface
#define CPC_ERR_IO_TRANSFER                -31	// a transmission error down to the driver occurred
#define CPC_ERR_TRANSMISSION_FAILED        -32	// a transmission error down to the interface occurred
#define CPC_ERR_TRANSMISSION_TIMEOUT       -33	// a timeout occurred within transmission to the interface
#define CPC_ERR_OP_SYS_NOT_SUPPORTED       -35	// the operating system is not supported
#define CPC_ERR_UNKNOWN                    -40	// an unknown error ocurred (mostly IOCTL errors)

#define CPC_ERR_LOADING_DLL                -50	// the library 'cpcwin.dll' could not be loaded
#define CPC_ERR_ASSIGNING_FUNCTION         -51	// the specified function could not be assigned
#define CPC_ERR_DLL_INITIALIZATION         -52	// the DLL was not initialized correctly
#define CPC_ERR_MISSING_LICFILE            -55	// the file containing the licenses does not exist
#define CPC_ERR_MISSING_LICENSE            -56	// a required license was not found

// CAN state bit values. Ignore any bits not listed
#define CPC_CAN_STATE_BUSOFF     0x80
#define CPC_CAN_STATE_ERROR      0x40

// Mask to help ignore undefined bits
#define CPC_CAN_STATE_MASK       0xc0

// CAN-Message representation in a CPC_MSG
// Message object type is CPC_MSG_T_CAN or CPC_MSG_T_RTR
// or CPC_MSG_T_XCAN or CPC_MSG_T_XRTR
typedef struct CPC_CAN_MSG {
	u32 id;
	u8 length;
	u8 msg[8];
} CPC_CAN_MSG_T;


// representation of the CAN parameters for the PCA82C200 controller
typedef struct CPC_PCA82C200_PARAMS {
	u8 acc_code;	// Acceptance-code for receive, Standard: 0
	u8 acc_mask;	// Acceptance-mask for receive, Standard: 0xff (everything)
	u8 btr0;	// Bus-timing register 0
	u8 btr1;	// Bus-timing register 1
	u8 outp_contr;	// Output-control register
} CPC_PCA82C200_PARAMS_T;

// representation of the CAN parameters for the SJA1000 controller
typedef struct CPC_SJA1000_PARAMS {
	u8 mode;	// enables single or dual acceptance filtering
	u8 acc_code0;	// Acceptance-code for receive, Standard: 0
	u8 acc_code1;
	u8 acc_code2;
	u8 acc_code3;
	u8 acc_mask0;	// Acceptance-mask for receive, Standard: 0xff (everything)
	u8 acc_mask1;
	u8 acc_mask2;
	u8 acc_mask3;
	u8 btr0;	// Bus-timing register 0
	u8 btr1;	// Bus-timing register 1
	u8 outp_contr;	// Output-control register
} CPC_SJA1000_PARAMS_T;

// representation of the CAN parameters for the M16C controller
// in basic CAN mode (means no full CAN)
typedef struct CPC_M16C_BASIC_PARAMS {
	u8 con0;
	u8 con1;
	u8 ctlr0;
	u8 ctlr1;
	u8 clk;
	u8 acc_std_code0;
	u8 acc_std_code1;
	u8 acc_ext_code0;
	u8 acc_ext_code1;
	u8 acc_ext_code2;
	u8 acc_ext_code3;
	u8 acc_std_mask0;
	u8 acc_std_mask1;
	u8 acc_ext_mask0;
	u8 acc_ext_mask1;
	u8 acc_ext_mask2;
	u8 acc_ext_mask3;
} CPC_M16C_BASIC_PARAMS_T;

// CAN params message representation
typedef struct CPC_CAN_PARAMS {
	u8 cc_type;	// represents the controller type
	union {
		CPC_M16C_BASIC_PARAMS_T m16c_basic;
		CPC_SJA1000_PARAMS_T sja1000;
		CPC_PCA82C200_PARAMS_T pca82c200;
	} cc_params;
} CPC_CAN_PARAMS_T;

// the following structures are slightly different for Windows and Linux
// To be able to use the 'Select' mechanism with Linux the application
// needs to know the devices file desciptor.
// This mechanism is not implemented within Windows and the file descriptor
// is therefore not needed
#ifdef _WIN32

// CAN init params message representation
typedef struct CPC_INIT_PARAMS {
	CPC_CAN_PARAMS_T canparams;
} CPC_INIT_PARAMS_T;

#else// Linux

// CHAN init params representation
typedef struct CPC_CHAN_PARAMS {
	int fd;
} CPC_CHAN_PARAMS_T;

// CAN init params message representation
typedef struct CPC_INIT_PARAMS {
	CPC_CHAN_PARAMS_T chanparams;
	CPC_CAN_PARAMS_T canparams;
} CPC_INIT_PARAMS_T;

#endif

// structure for confirmed message handling
typedef struct CPC_CONFIRM {
	u8 result; // error code
} CPC_CONFIRM_T;

// structure for information requests
typedef struct CPC_INFO {
	u8 source;                 // interface, driver or library
	u8 type;                   // version or serial number
	char msg[CPC_MSG_LEN - 2]; // string holding the requested information
} CPC_INFO_T;

// OVERRUN ///////////////////////////////////////
// In general two types of overrun may occur.
// A hardware overrun, where the CAN controller
// lost a message, because the interrupt was
// not handled before the next messgae comes in.
// Or a software overrun, where i.e. a received
// message could not be stored in the CPC_MSG
// buffer.

// After a software overrun has occurred
// we wait until we have CPC_OVR_GAP slots
// free in the CPC_MSG buffer.
#define CPC_OVR_GAP               10

// Two types of software overrun may occur.
// A received CAN message or a CAN state event
// can cause an overrun.
// Note: A CPC_CMD which would normally store
// its result immediately in the CPC_MSG
// queue may fail, because the message queue is full.
// This will not generate an overrun message, but
// will halt command execution, until this command
// is able to store its message in the message queue.
#define CPC_OVR_EVENT_CAN       0x01
#define CPC_OVR_EVENT_CANSTATE  0x02
#define CPC_OVR_EVENT_BUSERROR  0x04

// If the CAN controller lost a message
// we indicate it with the highest bit
// set in the count field.
#define CPC_OVR_HW              0x80

// structure for overrun conditions
typedef struct {
	u8 event;
	u8 count;
} CPC_OVERRUN_T;

// CAN errors ////////////////////////////////////
// Each CAN controller type has different
// registers to record errors.
// Therefor a structure containing the specific
// errors is set up for each controller here

// SJA1000 error structure
// see the SJA1000 datasheet for detailed
// explanation of the registers
typedef struct CPC_SJA1000_CAN_ERROR {
	u8 ecc;   // error capture code register
	u8 rxerr; // RX error counter register
	u8 txerr; // TX error counter register
} CPC_SJA1000_CAN_ERROR_T;

// M16C error structure
// see the M16C datasheet for detailed
// explanation of the registers
typedef struct CPC_M16C_CAN_ERROR {
	u8 tbd;	// to be defined
} CPC_M16C_CAN_ERROR_T;

// structure for CAN error conditions
#define  CPC_CAN_ECODE_ERRFRAME   0x01
typedef struct CPC_CAN_ERROR {
	u8 ecode;
	struct {
		u8 cc_type; // CAN controller type
		union {
			CPC_SJA1000_CAN_ERROR_T sja1000;
			CPC_M16C_CAN_ERROR_T m16c;
		} regs;
	} cc;
} CPC_CAN_ERROR_T;

// Structure containing RX/TX error counter.
// This structure is used to request the
// values of the CAN controllers TX and RX
// error counter.
typedef struct CPC_CAN_ERR_COUNTER {
	u8 rx;
	u8 tx;
} CPC_CAN_ERR_COUNTER_T;

// If this flag is set, transmissions from PC to CPC are protected against loss
#define CPC_SECURE_TO_CPC	0x01

// If this flag is set, transmissions from CPC to PC are protected against loss
#define CPC_SECURE_TO_PC	0x02

// If this flag is set, the CAN-transmit buffer is checked to be free before sending a message
#define CPC_SECURE_SEND		0x04

// If this flag is set, the transmission complete flag is checked
// after sending a message
// THIS IS CURRENTLY ONLY IMPLEMENTED IN THE PASSIVE INTERFACE DRIVERS
#define CPC_SECURE_TRANSMIT	0x08

// main message type used between library and application
typedef struct CPC_MSG {
	u8 type;	// type of message
	u8 length;	// length of data within union 'msg'
	u8 msgid;	// confirmation handle
	u32 ts_sec;	// timestamp in seconds
	u32 ts_nsec;	// timestamp in nano seconds
	union {
		u8 generic[CPC_MSG_LEN];
		CPC_CAN_MSG_T canmsg;
		CPC_CAN_PARAMS_T canparams;
		CPC_CONFIRM_T confirmation;
		CPC_INFO_T info;
		CPC_OVERRUN_T overrun;
		CPC_CAN_ERROR_T error;
		CPC_CAN_ERR_COUNTER_T err_counter;
		u8 busload;
		u8 canstate;
	} msg;
} CPC_MSG_T;

#ifdef _WIN32
#pragma pack(pop)		// reset the byte alignment
#endif

#endif				// CPC_HEADER