8314d28562296c685af7519339917620df229796
[lincan.git] / embedded / app / usbcan / ul_usb1.c
1 /**************************************************************************/
2 /* File: ul_usb1.c - UL_USB1 board specific part of USB<->CAN converter   */
3 /*                                                                        */
4 /* LinCAN - (Not only) Linux CAN bus driver                               */
5 /* Copyright (C) 2002-2011 DCE FEE CTU Prague <http://dce.felk.cvut.cz>   */
6 /* Copyright (C) 2008 Jan Kriz email:johen@post.cz                        */
7 /*                                                                        */
8 /* LinCAN is free software; you can redistribute it and/or modify it      */
9 /* under terms of the GNU General Public License as published by the      */
10 /* Free Software Foundation; either version 2, or (at your option) any    */
11 /* later version.  LinCAN is distributed in the hope that it will be      */
12 /* useful, but WITHOUT ANY WARRANTY; without even the implied warranty    */
13 /* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    */
14 /* General Public License for more details. You should have received a    */
15 /* copy of the GNU General Public License along with LinCAN; see file     */
16 /* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave,  */
17 /* Cambridge, MA 02139, USA.                                              */
18 /*                                                                        */
19 /* To allow use of LinCAN in the compact embedded systems firmware        */
20 /* and RT-executives (RTEMS for example), main authors agree with next    */
21 /* special exception:                                                     */
22 /*                                                                        */
23 /* Including LinCAN header files in a file, instantiating LinCAN generics */
24 /* or templates, or linking other files with LinCAN objects to produce    */
25 /* an application image/executable, does not by itself cause the          */
26 /* resulting application image/executable to be covered by                */
27 /* the GNU General Public License.                                        */
28 /* This exception does not however invalidate any other reasons           */
29 /* why the executable file might be covered by the GNU Public License.    */
30 /* Publication of enhanced or derived LinCAN files is required although.  */
31 /**************************************************************************/
32
33 #include "./can/can.h"
34 #include "./can/can_sysdep.h"
35 #include "./can/main.h"
36 #include "./can/devcommon.h"
37 #include "./can/setup.h"
38 // #include "./can/finish.h"
39 #include "./can/i82527.h"
40 //#include "../include/sja1000.h"
41 #include "./can/sja1000p.h"
42
43 #include "./can/errno.h"
44
45 #include "./can/ul_usb1.h"
46
47 /* Get a minor range for your devices from the usb maintainer */
48 #define USB_SKEL_MINOR_BASE     192
49
50 #define CAN_OP_MASK 0x80
51 #define CAN_OP_READ 0x80
52 #define CAN_OP_WRITE 0x00
53
54
55         /* our private defines. if this grows any larger, use your own .h file */
56 #define MAX_TRANSFER            (PAGE_SIZE - 512)
57 /* MAX_TRANSFER is chosen so that the VM is not stressed by
58    allocations > PAGE_SIZE and the number of packets in a page
59    is an integer 512 is the largest possible packet on EHCI */
60 #define WRITES_IN_FLIGHT        8
61 /* arbitrarily chosen */
62
63 /* Define these values to match your devices */
64 #define USB_SKEL_VENDOR_ID      0xDEAD
65 #define USB_SKEL_PRODUCT_ID     0x1001
66
67
68 /*
69  * IO_RANGE is the io-memory range that gets reserved, please adjust according
70  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
71  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
72  */
73 #define IO_RANGE 0x100
74
75 /** ul_usb1_request_io
76  * ul_usb1_request_io: - reserve io or memory range for can board
77  * @candev: pointer to candevice/board which asks for io. Field @io_addr
78  *      of @candev is used in most cases to define start of the range
79  *
80  * The function ul_usb1_request_io() is used to reserve the io-memory. If your
81  * hardware uses a dedicated memory range as hardware control registers you
82  * will have to add the code to reserve this memory as well.
83  * %IO_RANGE is the io-memory range that gets reserved, please adjust according
84  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
85  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
86  * Return Value: The function returns zero on success or %-ENODEV on failure
87  * File: src/ul_usb1.c
88  */
89 int ul_usb1_request_io(struct candevice_t *candev)
90 {
91         return 0;
92 }
93
94 /** ul_usb1_release_io
95  * ul_usb1_release_io - free reserved io memory range
96  * @candev: pointer to candevice/board which releases io
97  *
98  * The function ul_usb1_release_io() is used to free reserved io-memory.
99  * In case you have reserved more io memory, don't forget to free it here.
100  * IO_RANGE is the io-memory range that gets released, please adjust according
101  * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
102  * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
103  * Return Value: The function always returns zero
104  * File: src/ul_usb1.c
105  */
106 int ul_usb1_release_io(struct candevice_t *candev)
107 {
108         return 0;
109 }
110
111 /** ul_usb1_reset
112  * ul_usb1_reset - hardware reset routine
113  * @candev: Pointer to candevice/board structure
114  *
115  * The function ul_usb1_reset() is used to give a hardware reset. This is
116  * rather hardware specific so I haven't included example code. Don't forget to
117  * check the reset status of the chip before returning.
118  * Return Value: The function returns zero on success or %-ENODEV on failure
119  * File: src/ul_usb1.c
120  */
121 int ul_usb1_reset(struct candevice_t *candev)
122 {
123         return 0;
124 }
125
126 #define RESET_ADDR 0x0
127 #define NR_82527 0
128 #define NR_SJA1000 1
129
130 /** ul_usb1_init_hw_data
131  * ul_usb1_init_hw_data - Initialize hardware cards
132  * @candev: Pointer to candevice/board structure
133  *
134  * The function ul_usb1_init_hw_data() is used to initialize the hardware
135  * structure containing information about the installed CAN-board.
136  * %RESET_ADDR represents the io-address of the hardware reset register.
137  * %NR_82527 represents the number of Intel 82527 chips on the board.
138  * %NR_SJA1000 represents the number of Philips sja1000 chips on the board.
139  * The flags entry can currently only be %CANDEV_PROGRAMMABLE_IRQ to indicate that
140  * the hardware uses programmable interrupts.
141  * Return Value: The function always returns zero
142  * File: src/ul_usb1.c
143  */
144 int ul_usb1_init_hw_data(struct candevice_t *candev)
145 {
146         candev->res_addr=RESET_ADDR;
147         candev->nr_82527_chips=NR_82527;
148         candev->nr_sja1000_chips=NR_SJA1000;
149         candev->nr_all_chips=NR_82527+NR_SJA1000;
150         candev->flags |= CANDEV_PROGRAMMABLE_IRQ*0;
151
152         return 0;
153 }
154
155 /** ul_usb1_init_chip_data
156  * ul_usb1_init_chip_data - Initialize chips
157  * @candev: Pointer to candevice/board structure
158  * @chipnr: Number of the CAN chip on the hardware card
159  *
160  * The function ul_usb1_init_chip_data() is used to initialize the hardware
161  * structure containing information about the CAN chips.
162  * %CHIP_TYPE represents the type of CAN chip. %CHIP_TYPE can be "i82527" or
163  * "sja1000".
164  * The @chip_base_addr entry represents the start of the 'official' memory map
165  * of the installed chip. It's likely that this is the same as the @io_addr
166  * argument supplied at module loading time.
167  * The @clock entry holds the chip clock value in Hz.
168  * The entry @sja_cdr_reg holds hardware specific options for the Clock Divider
169  * register. Options defined in the %sja1000.h file:
170  * %sjaCDR_CLKOUT_MASK, %sjaCDR_CLK_OFF, %sjaCDR_RXINPEN, %sjaCDR_CBP, %sjaCDR_PELICAN
171  * The entry @sja_ocr_reg holds hardware specific options for the Output Control
172  * register. Options defined in the %sja1000.h file:
173  * %sjaOCR_MODE_BIPHASE, %sjaOCR_MODE_TEST, %sjaOCR_MODE_NORMAL, %sjaOCR_MODE_CLOCK,
174  * %sjaOCR_TX0_LH, %sjaOCR_TX1_ZZ.
175  * The entry @int_clk_reg holds hardware specific options for the Clock Out
176  * register. Options defined in the %i82527.h file:
177  * %iCLK_CD0, %iCLK_CD1, %iCLK_CD2, %iCLK_CD3, %iCLK_SL0, %iCLK_SL1.
178  * The entry @int_bus_reg holds hardware specific options for the Bus
179  * Configuration register. Options defined in the %i82527.h file:
180  * %iBUS_DR0, %iBUS_DR1, %iBUS_DT1, %iBUS_POL, %iBUS_CBY.
181  * The entry @int_cpu_reg holds hardware specific options for the cpu interface
182  * register. Options defined in the %i82527.h file:
183  * %iCPU_CEN, %iCPU_MUX, %iCPU_SLP, %iCPU_PWD, %iCPU_DMC, %iCPU_DSC, %iCPU_RST.
184  * Return Value: The function always returns zero
185  * File: src/ul_usb1.c
186  */
187 int ul_usb1_init_chip_data(struct candevice_t *candev, int chipnr)
188 {
189         /*i82527_fill_chipspecops(candev->chip[chipnr]);*/
190         /*sja1000_fill_chipspecops(candev->chip[chipnr]);*/
191         sja1000p_fill_chipspecops(candev->chip[chipnr]);
192
193         candev->chip[chipnr]->flags|= CHIP_IRQ_CUSTOM;
194
195         candev->chip[chipnr]->chip_base_addr=0;
196         candev->chip[chipnr]->clock = 24000000;
197         candev->chip[chipnr]->int_cpu_reg = iCPU_DSC;
198         candev->chip[chipnr]->int_clk_reg = iCLK_SL1;
199         candev->chip[chipnr]->int_bus_reg = iBUS_CBY;
200         candev->chip[chipnr]->sja_cdr_reg = sjaCDR_CBP | sjaCDR_CLK_OFF;
201         candev->chip[chipnr]->sja_ocr_reg = sjaOCR_MODE_NORMAL |
202                                                                 sjaOCR_TX0_LH;
203
204         candev->chip[chipnr]->chip_data=(void *)malloc(sizeof(struct ul_usb1_chip_data));
205         if (candev->chip[chipnr]->chip_data==NULL)
206                 return -ENOMEM;
207         return 0;
208 }
209
210 /** ul_usb1_init_obj_data
211  * ul_usb1_init_obj_data - Initialize message buffers
212  * @chip: Pointer to chip specific structure
213  * @objnr: Number of the message buffer
214  *
215  * The function ul_usb1_init_obj_data() is used to initialize the hardware
216  * structure containing information about the different message objects on the
217  * CAN chip. In case of the sja1000 there's only one message object but on the
218  * i82527 chip there are 15.
219  * The code below is for a i82527 chip and initializes the object base addresses
220  * The entry @obj_base_addr represents the first memory address of the message
221  * object. In case of the sja1000 @obj_base_addr is taken the same as the chips
222  * base address.
223  * Unless the hardware uses a segmented memory map, flags can be set zero.
224  * Return Value: The function always returns zero
225  * File: src/ul_usb1.c
226  */
227 int ul_usb1_init_obj_data(struct canchip_t *chip, int objnr)
228 {
229         chip->msgobj[objnr]->obj_base_addr=chip->chip_base_addr+(objnr+1)*0x10;
230
231         return 0;
232 }
233
234 /** ul_usb1_program_irq
235  * ul_usb1_program_irq - program interrupts
236  * @candev: Pointer to candevice/board structure
237  *
238  * The function ul_usb1_program_irq() is used for hardware that uses
239  * programmable interrupts. If your hardware doesn't use programmable interrupts
240  * you should not set the @candevices_t->flags entry to %CANDEV_PROGRAMMABLE_IRQ and
241  * leave this function unedited. Again this function is hardware specific so
242  * there's no example code.
243  * Return value: The function returns zero on success or %-ENODEV on failure
244  * File: src/ul_usb1.c
245  */
246 int ul_usb1_program_irq(struct candevice_t *candev)
247 {
248         return 0;
249 }
250
251 /** ul_usb1_write_register
252  * ul_usb1_write_register - Low level write register routine
253  * @data: data to be written
254  * @address: memory address to write to
255  *
256  * The function ul_usb1_write_register() is used to write to hardware registers
257  * on the CAN chip. You should only have to edit this function if your hardware
258  * uses some specific write process.
259  * Return Value: The function does not return a value
260  * File: src/ul_usb1.c
261  */
262 void ul_usb1_write_register(unsigned data, unsigned long address)
263 {
264         can_write(data, address & 0xFF);
265 }
266
267 /** ul_usb1_read_register
268  * ul_usb1_read_register - Low level read register routine
269  * @address: memory address to read from
270  *
271  * The function ul_usb1_read_register() is used to read from hardware registers
272  * on the CAN chip. You should only have to edit this function if your hardware
273  * uses some specific read process.
274  * Return Value: The function returns the value stored in @address
275  * File: src/ul_usb1.c
276  */
277 unsigned ul_usb1_read_register(unsigned long address)
278 {
279         uint8_t data;
280         data = can_read(address & 0xFF);
281         return data;
282 }
283
284 /* !!! Don't change this function !!! */
285 int ul_usb1_register(struct hwspecops_t *hwspecops)
286 {
287         hwspecops->request_io = ul_usb1_request_io;
288         hwspecops->release_io = ul_usb1_release_io;
289         hwspecops->reset = ul_usb1_reset;
290         hwspecops->init_hw_data = ul_usb1_init_hw_data;
291         hwspecops->init_chip_data = ul_usb1_init_chip_data;
292         hwspecops->init_obj_data = ul_usb1_init_obj_data;
293         hwspecops->write_register = ul_usb1_write_register;
294         hwspecops->read_register = ul_usb1_read_register;
295         hwspecops->program_irq = ul_usb1_program_irq;
296         return 0;
297 }
298