Merge branch 'master' into can-usb1
[lincan.git] / lincan / src / setup.c
1 /* setup.c
2  * Linux CAN-bus device driver.
3  * Written by Arnaud Westenberg email:arnaud@wanadoo.nl
4  * Rewritten for new CAN queues by Pavel Pisa - OCERA team member
5  * email:pisa@cmp.felk.cvut.cz
6  * This software is released under the GPL-License.
7  * Version lincan-0.3  17 Jun 2004
8  */
9
10 #include "../include/can.h"
11 #include "../include/can_sysdep.h"
12 #include "../include/main.h"
13 #include "../include/devcommon.h"
14 #include "../include/setup.h"
15 #include "../include/finish.h"
16
17 int init_hwspecops(struct candevice_t *candev, int *irqnum_p);
18 int init_device_struct(int card, int *chan_param_idx_p, int *irq_param_idx_p);
19 int init_chip_struct(struct candevice_t *candev, int chipnr, int irq, long baudrate, long clock);
20 int init_obj_struct(struct candevice_t *candev, struct canchip_t *hostchip, int objnr);
21
22 int next_minor=0;
23
24 /**
25  * can_base_addr_fixup - relocates board physical memory addresses to the CPU accessible ones
26  * @candev: pointer to the previously filled device/board, chips and message objects structures
27  * @new_base: @candev new base address
28  *
29  * This function adapts base addresses of all structures of one board
30  * to the new board base address.
31  * It is required for translation between physical and virtual address mappings.
32  * This function is prepared to simplify board specific xxx_request_io() function
33  * for memory mapped devices.
34  */
35 int can_base_addr_fixup(struct candevice_t *candev, can_ioptr_t new_base)
36 {
37         long offs;
38         int i, j;
39
40         offs=new_base-candev->dev_base_addr;
41         candev->dev_base_addr=new_base;
42         for(i=0;i<candev->nr_all_chips;i++){
43                 candev->chip[i]->chip_base_addr += offs;
44                 for(j=0;j<candev->chip[i]->max_objects;j++)
45                         candev->chip[i]->msgobj[j]->obj_base_addr += offs;
46         }
47         return 0;
48 }
49
50 /**
51  * can_check_dev_taken - checks if bus device description is already taken by driver
52  * @anydev:     pointer to bus specific Linux device description
53  *
54  * Returns: Returns 1 if device is already used by LinCAN driver, 0 otherwise.
55  */
56 int can_check_dev_taken(void *anydev)
57 {
58         int board_nr;
59         struct candevice_t *candev;
60         void *boarddev;
61
62         for (board_nr=hardware_p->nr_boards; board_nr--; ) {
63                 if((candev=hardware_p->candevice[board_nr])==NULL)
64                         continue;
65                 boarddev=candev->sysdevptr.anydev;
66                 if(boarddev == anydev)
67                         return 1;
68         }
69
70         return 0;
71 }
72
73
74 /**
75  * register_obj_struct - registers message object into global array
76  * @obj: the initialized message object being registered
77  * @minorbase: wanted minor number, if (-1) automatically selected
78  *
79  * Return Value: returns negative number in the case of fail
80  */
81 int register_obj_struct(struct msgobj_t *obj, int minorbase)
82 {
83         int i;
84
85         if(minorbase>=0)
86                 next_minor=minorbase;
87         if(next_minor>=MAX_TOT_MSGOBJS)
88                 next_minor=0;
89         i=next_minor;
90         do{
91                 if(objects_p[i]==NULL){
92                         objects_p[i]=obj;
93                         obj->minor=i;
94                         next_minor=i+1;
95                         return 0;
96                 }
97                 if(++i >= MAX_TOT_MSGOBJS) i=0;
98         }while(i!=next_minor);
99         obj->minor=-1;
100         return -1;
101 }
102
103
104 /**
105  * register_chip_struct - registers chip into global array
106  * @chip: the initialized chip structure being registered
107  * @minorbase: wanted minor number base, if (-1) automatically selected
108  *
109  * Return Value: returns negative number in the case of fail
110  */
111 int register_chip_struct(struct canchip_t *chip, int minorbase)
112 {
113         static int next_chip_slot=0;
114         int i;
115
116         if(next_chip_slot>=MAX_TOT_CHIPS)
117                 next_chip_slot=0;
118         i=next_chip_slot;
119         do{
120                 if(chips_p[i]==NULL){
121                         chips_p[i]=chip;
122
123                         next_chip_slot=i+1;
124                         return 0;
125                 }
126                 if(++i >= MAX_TOT_CHIPS) i=0;
127         }while(i!=next_chip_slot);
128         return -1;
129 }
130
131
132
133 /**
134  * init_hw_struct - initializes driver hardware description structures
135  *
136  * The function init_hw_struct() is used to initialize the hardware structure.
137  *
138  * Return Value: returns negative number in the case of fail
139  */
140 int init_hw_struct(void)
141 {
142         int i=0;
143         int irq_param_idx=0;
144         int chan_param_idx=0;
145
146         hardware_p->nr_boards=0;
147         while ( (hw[i] != NULL) & (i < MAX_HW_CARDS) ) {
148                 hardware_p->nr_boards++;
149
150                 if (init_device_struct(i, &chan_param_idx, &irq_param_idx)) {
151                         CANMSG("Error initializing candevice_t structures.\n");
152                         return -ENODEV;
153                 }
154                 i++;
155         }
156
157         return 0;
158 }
159
160 /**
161  * init_new_hw_struct - initializes driver description structures for new hardware
162  *
163  * The function init_new_hw_struct() is used to initialize the hardware structure.
164  *
165  * Return Value: returns negative number in the case of fail
166  */
167 int init_new_hw_struct(int devnr)
168 {
169         int irq_param_idx=0;
170         int chan_param_idx=0;
171
172         if ( (hw[devnr] != NULL) & (devnr < MAX_HW_CARDS) ) {
173                 hardware_p->nr_boards++;
174
175                 if (init_device_struct(devnr, &chan_param_idx, &irq_param_idx)) {
176                         CANMSG("Error initializing candevice_t structures.\n");
177                         return -ENODEV;
178                 }
179         }
180
181         return 0;
182 }
183
184 /**
185  * init_device_struct - initializes single CAN device/board
186  * @card: index into @hardware_p HW description
187  * @chan_param_idx_p: pointer to the index into arrays of the CAN channel parameters
188  * @irq_param_idx_p: pointer to the index into arrays of the per CAN channel IRQ parameters
189  *
190  * The function builds representation of the one board from parameters provided
191  * in the module parameters arrays:
192  *      @hw[card] .. hardware type,
193  *      @io[card] .. base IO address,
194  *      @baudrate[chan_param_idx] .. per channel baudrate,
195  *      @minor[chan_param_idx] .. optional specification of requested channel minor base,
196  *      @irq[irq_param_idx] .. one or more board/chips IRQ parameters.
197  * The indexes are advanced after consumed parameters if the registration is successful.
198  *
199  * The hardware specific operations of the device/board are initialized by call to
200  * init_hwspecops() function. Then board data are initialized by board specific
201  * init_hw_data() function. Then chips and objects representation is build by
202  * init_chip_struct() function. If all above steps are successful, chips and
203  * message objects are registered into global arrays.
204  *
205  * Return Value: returns negative number in the case of fail
206  */
207 int init_device_struct(int card, int *chan_param_idx_p, int *irq_param_idx_p)
208 {
209         struct candevice_t *candev;
210         int ret;
211         int irqnum;
212         int chipnr;
213         long bd;
214         int irqsig=-1;
215         long clock;
216
217         candev=(struct candevice_t *)can_checked_malloc(sizeof(struct candevice_t));
218         if (candev==NULL)
219                 return -ENOMEM;
220
221         memset(candev, 0, sizeof(struct candevice_t));
222
223         hardware_p->candevice[card]=candev;
224         candev->candev_idx=card;
225
226         candev=candev;
227
228         candev->hwname=hw[card];
229         candev->io_addr=io[card];
230         candev->dev_base_addr=io[card];
231         clock=clockfreq[card];
232
233         candev->hwspecops=(struct hwspecops_t *)can_checked_malloc(sizeof(struct hwspecops_t));
234         if (candev->hwspecops==NULL)
235                 goto error_nomem;
236
237         memset(candev->hwspecops, 0, sizeof(struct hwspecops_t));
238
239         if (init_hwspecops(candev, &irqnum))
240                 goto error_nodev;
241
242         if (candev->hwspecops->init_hw_data(candev))
243                 goto error_nodev;
244
245         /* Alocate and initialize the chip structures */
246         for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {
247
248                 if(chipnr<irqnum)
249                         irqsig=irq[*irq_param_idx_p+chipnr];
250
251                 bd=baudrate[*chan_param_idx_p+chipnr];
252                 if(!bd) bd=baudrate[0];
253
254                 if ((ret=init_chip_struct(candev, chipnr, irqsig, bd*1000, clock*1000)))
255                         goto error_chip;
256         }
257
258
259
260         for (chipnr=0; chipnr < candev->nr_all_chips; chipnr++) {
261                 int m=minor[*chan_param_idx_p+chipnr];
262                 struct canchip_t *chip=candev->chip[chipnr];
263                 int objnr;
264
265                 register_chip_struct(chip, m);
266
267                 for (objnr=0; objnr<chip->max_objects; objnr++) {
268                         register_obj_struct(chip->msgobj[objnr], m);
269                         if(m>=0) m++;
270                 }
271         }
272
273         *irq_param_idx_p += irqnum;
274         *chan_param_idx_p += candev->nr_all_chips;
275
276         return 0;
277
278     error_nodev:
279         ret=-ENODEV;
280     error_chip:
281         candevice_done(candev);
282         goto error_both;
283
284     error_nomem:
285         ret=-ENOMEM;
286
287     error_both:
288         hardware_p->candevice[card]=NULL;
289         can_checked_free(candev);
290         return ret;
291
292 }
293
294 /**
295  * init_chip_struct - initializes one CAN chip structure
296  * @candev: pointer to the corresponding CAN device/board
297  * @chipnr: index of the chip in the corresponding device/board structure
298  * @irq: chip IRQ number or (-1) if not appropriate
299  * @baudrate: baudrate in the units of 1Bd
300  * @clock: optional chip base clock frequency in 1Hz step
301  *
302  * Chip structure is allocated and chip specific operations are filled by
303  * call to board specific init_chip_data() which calls chip specific
304  * fill_chipspecops(). The message objects are generated by
305  * calls to init_obj_struct() function.
306  *
307  * Return Value: returns negative number in the case of fail
308  */
309 int init_chip_struct(struct candevice_t *candev, int chipnr, int irq, long baudrate, long clock)
310 {
311         struct canchip_t *chip;
312         int objnr;
313         int ret;
314
315         candev->chip[chipnr]=(struct canchip_t *)can_checked_malloc(sizeof(struct canchip_t));
316         if ((chip=candev->chip[chipnr])==NULL)
317                 return -ENOMEM;
318
319         memset(chip, 0, sizeof(struct canchip_t));
320
321         chip->write_register=candev->hwspecops->write_register;
322         chip->read_register=candev->hwspecops->read_register;
323
324         chip->chipspecops=can_checked_malloc(sizeof(struct chipspecops_t));
325         if (chip->chipspecops==NULL)
326                 return -ENOMEM;
327         memset(chip->chipspecops,0,sizeof(struct chipspecops_t));
328
329         chip->chip_idx=chipnr;
330         chip->hostdevice=candev;
331         chip->chip_irq=irq;
332         chip->baudrate=baudrate;
333         chip->clock=clock;
334         chip->flags=0x0;
335
336         if(candev->hwspecops->init_chip_data(candev,chipnr)<0)
337                 return -ENODEV;
338
339         for (objnr=0; objnr<chip->max_objects; objnr++) {
340                 ret=init_obj_struct(candev, chip, objnr);
341                 if(ret<0) return ret;
342         }
343
344         return 0;
345 }
346
347
348 /**
349  * init_obj_struct - initializes one CAN message object structure
350  * @candev: pointer to the corresponding CAN device/board
351  * @hostchip: pointer to the chip containing this object
352  * @objnr: index of the builded object in the chip structure
353  *
354  * The function initializes message object structure and allocates and initializes
355  * CAN queue chip ends structure.
356  *
357  * Return Value: returns negative number in the case of fail
358  */
359 int init_obj_struct(struct candevice_t *candev, struct canchip_t *hostchip, int objnr)
360 {
361         struct canque_ends_t *qends;
362         struct msgobj_t *obj;
363         int ret;
364
365         obj=(struct msgobj_t *)can_checked_malloc(sizeof(struct msgobj_t));
366         hostchip->msgobj[objnr]=obj;
367         if (obj == NULL)
368                 return -ENOMEM;
369
370         memset(obj, 0, sizeof(struct msgobj_t));
371         obj->minor=-1;
372
373         atomic_set(&obj->obj_used,0);
374         INIT_LIST_HEAD(&obj->obj_users);
375         init_timer(&obj->tx_timeout);
376
377         qends = (struct canque_ends_t *)can_checked_malloc(sizeof(struct canque_ends_t));
378         if(qends == NULL) return -ENOMEM;
379         memset(qends, 0, sizeof(struct canque_ends_t));
380         obj->hostchip=hostchip;
381         obj->object=objnr+1;
382         obj->qends=qends;
383         obj->tx_qedge=NULL;
384         obj->tx_slot=NULL;
385         obj->obj_flags = 0x0;
386
387         ret=canqueue_ends_init_chip(qends, hostchip, obj);
388         if(ret<0) return ret;
389
390         ret=candev->hwspecops->init_obj_data(hostchip,objnr);
391         if(ret<0) return ret;
392
393         return 0;
394 }
395
396
397 /**
398  * init_hwspecops - finds and initializes board/device specific operations
399  * @candev: pointer to the corresponding CAN device/board
400  * @irqnum_p: optional pointer to the number of interrupts required by board
401  *
402  * The function searches board @hwname in the list of supported boards types.
403  * The board type specific board_register() function is used to initialize
404  * @hwspecops operations.
405  *
406  * Return Value: returns negative number in the case of fail
407  */
408 int init_hwspecops(struct candevice_t *candev, int *irqnum_p)
409 {
410         const struct boardtype_t *brp;
411
412         brp = boardtype_find(candev->hwname);
413
414         if(!brp) {
415                 CANMSG("Sorry, hardware \"%s\" is currently not supported.\n",candev->hwname);
416                 return -EINVAL;
417         }
418
419         if(irqnum_p)
420                 *irqnum_p=brp->irqnum;
421         brp->board_register(candev->hwspecops);
422
423         return 0;
424 }