irda update 5/7:
[opensuse:kernel.git] / net / irda / irda_device.c
1 /*********************************************************************
2  *                
3  * Filename:      irda_device.c
4  * Version:       0.9
5  * Description:   Utility functions used by the device drivers
6  * Status:        Experimental.
7  * Author:        Dag Brattli <dagb@cs.uit.no>
8  * Created at:    Sat Oct  9 09:22:27 1999
9  * Modified at:   Sun Jan 23 17:41:24 2000
10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
11  * 
12  *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
13  *     Copyright (c) 2000-2001 Jean Tourrilhes <jt@hpl.hp.com>
14  *     
15  *     This program is free software; you can redistribute it and/or 
16  *     modify it under the terms of the GNU General Public License as 
17  *     published by the Free Software Foundation; either version 2 of 
18  *     the License, or (at your option) any later version.
19  * 
20  *     This program is distributed in the hope that it will be useful,
21  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
22  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23  *     GNU General Public License for more details.
24  * 
25  *     You should have received a copy of the GNU General Public License 
26  *     along with this program; if not, write to the Free Software 
27  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
28  *     MA 02111-1307 USA
29  *     
30  ********************************************************************/
31
32 #include <linux/config.h>
33 #include <linux/string.h>
34 #include <linux/proc_fs.h>
35 #include <linux/skbuff.h>
36 #include <linux/if.h>
37 #include <linux/if_ether.h>
38 #include <linux/if_arp.h>
39 #include <linux/netdevice.h>
40 #include <linux/init.h>
41 #include <linux/tty.h>
42 #include <linux/kmod.h>
43 #include <linux/wireless.h>
44 #include <linux/spinlock.h>
45
46 #include <asm/ioctls.h>
47 #include <asm/uaccess.h>
48 #include <asm/dma.h>
49 #include <asm/io.h>
50
51 #include <net/pkt_sched.h>
52
53 #include <net/irda/irda_device.h>
54 #include <net/irda/irlap.h>
55 #include <net/irda/timer.h>
56 #include <net/irda/wrapper.h>
57
58 extern int irtty_init(void);
59 extern int nsc_ircc_init(void);
60 extern int ircc_init(void);
61 extern int toshoboe_init(void);
62 extern int litelink_init(void);
63 extern int w83977af_init(void);
64 extern int esi_init(void);
65 extern int tekram_init(void);
66 extern int actisys_init(void);
67 extern int girbil_init(void);
68 extern int sa1100_irda_init(void);
69 extern int ep7211_ir_init(void);
70
71 static void __irda_task_delete(struct irda_task *task);
72
73 static hashbin_t *dongles = NULL;
74 static hashbin_t *tasks = NULL;
75
76 const char *infrared_mode[] = {
77         "IRDA_IRLAP",
78         "IRDA_RAW",
79         "SHARP_ASK",
80         "TV_REMOTE",
81 };
82
83 #ifdef CONFIG_IRDA_DEBUG
84 static const char *task_state[] = {
85         "IRDA_TASK_INIT",
86         "IRDA_TASK_DONE", 
87         "IRDA_TASK_WAIT",
88         "IRDA_TASK_WAIT1",
89         "IRDA_TASK_WAIT2",
90         "IRDA_TASK_WAIT3",
91         "IRDA_TASK_CHILD_INIT",
92         "IRDA_TASK_CHILD_WAIT",
93         "IRDA_TASK_CHILD_DONE",
94 };
95 #endif  /* CONFIG_IRDA_DEBUG */
96
97 static void irda_task_timer_expired(void *data);
98
99 #ifdef CONFIG_PROC_FS
100 int irda_device_proc_read(char *buf, char **start, off_t offset, int len, 
101                           int unused);
102
103 #endif /* CONFIG_PROC_FS */
104
105 int __init irda_device_init( void)
106 {
107         dongles = hashbin_new(HB_GLOBAL);
108         if (dongles == NULL) {
109                 printk(KERN_WARNING 
110                        "IrDA: Can't allocate dongles hashbin!\n");
111                 return -ENOMEM;
112         }
113
114         tasks = hashbin_new(HB_GLOBAL);
115         if (tasks == NULL) {
116                 printk(KERN_WARNING 
117                        "IrDA: Can't allocate tasks hashbin!\n");
118                 return -ENOMEM;
119         }
120
121         /* 
122          * Call the init function of the device drivers that has not been
123          * compiled as a module 
124          */
125 #ifdef CONFIG_IRTTY_SIR
126         irtty_init();
127 #endif
128 #ifdef CONFIG_WINBOND_FIR
129         w83977af_init();
130 #endif
131 #ifdef CONFIG_SA1100_FIR
132         sa1100_irda_init();
133 #endif
134 #ifdef CONFIG_NSC_FIR
135         nsc_ircc_init();
136 #endif
137 #ifdef CONFIG_TOSHIBA_FIR
138         toshoboe_init();
139 #endif
140 #ifdef CONFIG_SMC_IRCC_FIR
141         ircc_init();
142 #endif
143 #ifdef CONFIG_ESI_DONGLE
144         esi_init();
145 #endif
146 #ifdef CONFIG_TEKRAM_DONGLE
147         tekram_init();
148 #endif
149 #ifdef CONFIG_ACTISYS_DONGLE
150         actisys_init();
151 #endif
152 #ifdef CONFIG_GIRBIL_DONGLE
153         girbil_init();
154 #endif
155 #ifdef CONFIG_LITELINK_DONGLE
156         litelink_init();
157 #endif
158 #ifdef CONFIG_OLD_BELKIN
159         old_belkin_init();
160 #endif
161 #ifdef CONFIG_EP7211_IR
162         ep7211_ir_init();
163 #endif
164         return 0;
165 }
166
167 void irda_device_cleanup(void)
168 {
169         IRDA_DEBUG(4, __FUNCTION__ "()\n");
170
171         hashbin_delete(tasks, (FREE_FUNC) __irda_task_delete);
172         hashbin_delete(dongles, NULL);
173 }
174
175 /*
176  * Function irda_device_set_media_busy (self, status)
177  *
178  *    Called when we have detected that another station is transmiting
179  *    in contention mode.
180  */
181 void irda_device_set_media_busy(struct net_device *dev, int status) 
182 {
183         struct irlap_cb *self;
184
185         IRDA_DEBUG(4, __FUNCTION__ "(%s)\n", status ? "TRUE" : "FALSE");
186
187         self = (struct irlap_cb *) dev->atalk_ptr;
188
189         ASSERT(self != NULL, return;);
190         ASSERT(self->magic == LAP_MAGIC, return;);
191
192         if (status) {
193                 self->media_busy = TRUE;
194                 if (status == SMALL)
195                         irlap_start_mbusy_timer(self, SMALLBUSY_TIMEOUT);
196                 else
197                         irlap_start_mbusy_timer(self, MEDIABUSY_TIMEOUT);
198                 IRDA_DEBUG( 4, "Media busy!\n");
199         } else {
200                 self->media_busy = FALSE;
201                 irlap_stop_mbusy_timer(self);
202         }
203 }
204
205 int irda_device_set_dtr_rts(struct net_device *dev, int dtr, int rts)
206 {       
207         struct if_irda_req req;
208         int ret;
209
210         IRDA_DEBUG(2, __FUNCTION__ "()\n");
211
212         if (!dev->do_ioctl) {
213                 ERROR(__FUNCTION__ "(), do_ioctl not impl. by "
214                       "device driver\n");
215                 return -1;
216         }
217
218         req.ifr_dtr = dtr;
219         req.ifr_rts = rts;
220
221         ret = dev->do_ioctl(dev, (struct ifreq *) &req, SIOCSDTRRTS);
222
223         return ret;
224 }
225
226 int irda_device_change_speed(struct net_device *dev, __u32 speed)
227 {       
228         struct if_irda_req req;
229         int ret;
230
231         IRDA_DEBUG(2, __FUNCTION__ "()\n");
232
233         if (!dev->do_ioctl) {
234                 ERROR(__FUNCTION__ "(), do_ioctl not impl. by "
235                       "device driver\n");
236                 return -1;
237         }
238
239         req.ifr_baudrate = speed;
240
241         ret = dev->do_ioctl(dev, (struct ifreq *) &req, SIOCSBANDWIDTH);
242
243         return ret;
244 }
245
246 /*
247  * Function irda_device_is_receiving (dev)
248  *
249  *    Check if the device driver is currently receiving data
250  *
251  */
252 int irda_device_is_receiving(struct net_device *dev)
253 {
254         struct if_irda_req req;
255         int ret;
256
257         IRDA_DEBUG(2, __FUNCTION__ "()\n");
258
259         if (!dev->do_ioctl) {
260                 ERROR(__FUNCTION__ "(), do_ioctl not impl. by "
261                       "device driver\n");
262                 return -1;
263         }
264
265         ret = dev->do_ioctl(dev, (struct ifreq *) &req, SIOCGRECEIVING);
266         if (ret < 0)
267                 return ret;
268
269         return req.ifr_receiving;
270 }
271
272 void irda_task_next_state(struct irda_task *task, IRDA_TASK_STATE state)
273 {
274         IRDA_DEBUG(2, __FUNCTION__ "(), state = %s\n", task_state[state]);
275
276         task->state = state;
277 }
278
279 static void __irda_task_delete(struct irda_task *task)
280 {
281         del_timer(&task->timer);
282         
283         kfree(task);
284 }
285
286 void irda_task_delete(struct irda_task *task)
287 {
288         /* Unregister task */
289         hashbin_remove(tasks, (int) task, NULL);
290
291         __irda_task_delete(task);
292 }
293
294 /*
295  * Function irda_task_kick (task)
296  *
297  *    Tries to execute a task possible multiple times until the task is either
298  *    finished, or askes for a timeout. When a task is finished, we do post
299  *    processing, and notify the parent task, that is waiting for this task
300  *    to complete.
301  */
302 int irda_task_kick(struct irda_task *task)
303 {
304         int finished = TRUE;
305         int count = 0;
306         int timeout;
307
308         IRDA_DEBUG(2, __FUNCTION__ "()\n");
309
310         ASSERT(task != NULL, return -1;);
311         ASSERT(task->magic == IRDA_TASK_MAGIC, return -1;);
312
313         /* Execute task until it's finished, or askes for a timeout */
314         do {
315                 timeout = task->function(task);
316                 if (count++ > 100) {
317                         ERROR(__FUNCTION__ "(), error in task handler!\n");
318                         irda_task_delete(task);
319                         return TRUE;
320                 }                       
321         } while ((timeout == 0) && (task->state != IRDA_TASK_DONE));
322
323         if (timeout < 0) {
324                 ERROR(__FUNCTION__ "(), Error executing task!\n");
325                 irda_task_delete(task);
326                 return TRUE;
327         }
328
329         /* Check if we are finished */
330         if (task->state == IRDA_TASK_DONE) {
331                 del_timer(&task->timer);
332
333                 /* Do post processing */
334                 if (task->finished)
335                         task->finished(task);
336
337                 /* Notify parent */
338                 if (task->parent) {
339                         /* Check if parent is waiting for us to complete */
340                         if (task->parent->state == IRDA_TASK_CHILD_WAIT) {
341                                 task->parent->state = IRDA_TASK_CHILD_DONE;
342
343                                 /* Stop timer now that we are here */
344                                 del_timer(&task->parent->timer);
345
346                                 /* Kick parent task */
347                                 irda_task_kick(task->parent);
348                         }
349                 }               
350                 irda_task_delete(task);
351         } else if (timeout > 0) {
352                 irda_start_timer(&task->timer, timeout, (void *) task, 
353                                  irda_task_timer_expired);
354                 finished = FALSE;
355         } else {
356                 IRDA_DEBUG(0, __FUNCTION__ 
357                            "(), not finished, and no timeout!\n");
358                 finished = FALSE;
359         }
360
361         return finished;
362 }
363
364 /*
365  * Function irda_task_execute (instance, function, finished)
366  *
367  *    This function registers and tries to execute tasks that may take some
368  *    time to complete. We do it this hairy way since we may have been
369  *    called from interrupt context, so it's not possible to use
370  *    schedule_timeout() 
371  * Two important notes :
372  *      o Make sure you irda_task_delete(task); in case you delete the
373  *        calling instance.
374  *      o No real need to lock when calling this function, but you may
375  *        want to lock within the task handler.
376  * Jean II
377  */
378 struct irda_task *irda_task_execute(void *instance, 
379                                     IRDA_TASK_CALLBACK function, 
380                                     IRDA_TASK_CALLBACK finished, 
381                                     struct irda_task *parent, void *param)
382 {
383         struct irda_task *task;
384         int ret;
385
386         IRDA_DEBUG(2, __FUNCTION__ "()\n");
387
388         task = kmalloc(sizeof(struct irda_task), GFP_ATOMIC);
389         if (!task)
390                 return NULL;
391
392         task->state    = IRDA_TASK_INIT;
393         task->instance = instance;
394         task->function = function;
395         task->finished = finished;
396         task->parent   = parent;
397         task->param    = param; 
398         task->magic    = IRDA_TASK_MAGIC;
399
400         init_timer(&task->timer);
401
402         /* Register task */
403         hashbin_insert(tasks, (irda_queue_t *) task, (int) task, NULL);
404
405         /* No time to waste, so lets get going! */
406         ret = irda_task_kick(task);
407         if (ret)
408                 return NULL;
409         else
410                 return task;
411 }
412
413 /*
414  * Function irda_task_timer_expired (data)
415  *
416  *    Task time has expired. We now try to execute task (again), and restart
417  *    the timer if the task has not finished yet
418  */
419 static void irda_task_timer_expired(void *data)
420 {
421         struct irda_task *task;
422
423         IRDA_DEBUG(2, __FUNCTION__ "()\n");
424
425         task = (struct irda_task *) data;
426
427         irda_task_kick(task);
428 }
429
430 /*
431  * Function irda_device_setup (dev)
432  *
433  *    This function should be used by low level device drivers in a similar way
434  *    as ether_setup() is used by normal network device drivers
435  */
436 int irda_device_setup(struct net_device *dev) 
437 {
438         ASSERT(dev != NULL, return -1;);
439
440         dev->hard_header_len = 0;
441         dev->addr_len        = 0;
442
443         dev->features        |= NETIF_F_DYNALLOC;
444         /* dev->destructor      = irda_device_destructor; */
445
446         dev->type            = ARPHRD_IRDA;
447         dev->tx_queue_len    = 8; /* Window size + 1 s-frame */
448  
449         memset(dev->broadcast, 0xff, 4);
450
451         dev->mtu = 2048;
452         dev->flags = IFF_NOARP;
453         return 0;
454 }
455
456 /*
457  * Function irda_device_txqueue_empty (dev)
458  *
459  *    Check if there is still some frames in the transmit queue for this
460  *    device. Maybe we should use: q->q.qlen == 0.
461  *
462  */
463 int irda_device_txqueue_empty(struct net_device *dev)
464 {
465         if (skb_queue_len(&dev->qdisc->q))
466                 return FALSE;
467
468         return TRUE;
469 }
470
471 /*
472  * Function irda_device_init_dongle (self, type, qos)
473  *
474  *    Initialize attached dongle.
475  *
476  * Important : request_module require us to call this function with
477  * a process context and irq enabled. - Jean II
478  */
479 dongle_t *irda_device_dongle_init(struct net_device *dev, int type)
480 {
481         struct dongle_reg *reg;
482         dongle_t *dongle;
483
484         ASSERT(dev != NULL, return NULL;);
485
486 #ifdef CONFIG_KMOD
487         {
488         char modname[32];
489         ASSERT(!in_interrupt(), return NULL;);
490         /* Try to load the module needed */
491         sprintf(modname, "irda-dongle-%d", type);
492         request_module(modname);
493         }
494 #endif /* CONFIG_KMOD */
495
496         if (!(reg = hashbin_find(dongles, type, NULL))) {
497                 ERROR("IrDA: Unable to find requested dongle\n");
498                 return NULL;
499         }
500
501         /* Allocate dongle info for this instance */
502         dongle = kmalloc(sizeof(dongle_t), GFP_KERNEL);
503         if (!dongle)
504                 return NULL;
505
506         memset(dongle, 0, sizeof(dongle_t));
507
508         /* Bind the registration info to this particular instance */
509         dongle->issue = reg;
510         dongle->dev = dev;
511
512         return dongle;
513 }
514
515 /*
516  * Function irda_device_dongle_cleanup (dongle)
517  *
518  *    
519  *
520  */
521 int irda_device_dongle_cleanup(dongle_t *dongle)
522 {
523         ASSERT(dongle != NULL, return -1;);
524
525         dongle->issue->close(dongle);
526
527         kfree(dongle);
528
529         return 0;
530 }
531
532 /*
533  * Function irda_device_register_dongle (dongle)
534  *
535  *    
536  *
537  */
538 int irda_device_register_dongle(struct dongle_reg *new)
539 {
540         /* Check if this dongle has been registred before */
541         if (hashbin_find(dongles, new->type, NULL)) {
542                 MESSAGE(__FUNCTION__ "(), Dongle already registered\n");
543                 return 0;
544         }
545         
546         /* Insert IrDA dongle into hashbin */
547         hashbin_insert(dongles, (irda_queue_t *) new, new->type, NULL);
548         
549         return 0;
550 }
551
552 /*
553  * Function irda_device_unregister_dongle (dongle)
554  *
555  *    Unregister dongle, and remove dongle from list of registred dongles
556  *
557  */
558 void irda_device_unregister_dongle(struct dongle_reg *dongle)
559 {
560         struct dongle *node;
561
562         node = hashbin_remove(dongles, dongle->type, NULL);
563         if (!node) {
564                 ERROR(__FUNCTION__ "(), dongle not found!\n");
565                 return;
566         }
567 }
568
569 /*
570  * Function irda_device_set_mode (self, mode)
571  *
572  *    Set the Infrared device driver into mode where it sends and receives
573  *    data without using IrLAP framing. Check out the particular device
574  *    driver to find out which modes it support.
575  */
576 int irda_device_set_mode(struct net_device* dev, int mode)
577 {       
578         struct if_irda_req req;
579         int ret;
580
581         IRDA_DEBUG(0, __FUNCTION__ "()\n");
582
583         if (!dev->do_ioctl) {
584                 ERROR(__FUNCTION__ "(), set_raw_mode not impl. by "
585                       "device driver\n");
586                 return -1;
587         }
588         
589         req.ifr_mode = mode;
590
591         ret = dev->do_ioctl(dev, (struct ifreq *) &req, SIOCSMODE);
592         
593         return ret;
594 }
595
596 /*
597  * Function setup_dma (idev, buffer, count, mode)
598  *
599  *    Setup the DMA channel. Commonly used by ISA FIR drivers
600  *
601  */
602 void setup_dma(int channel, char *buffer, int count, int mode)
603 {
604         unsigned long flags;
605         
606         flags = claim_dma_lock();
607         
608         disable_dma(channel);
609         clear_dma_ff(channel);
610         set_dma_mode(channel, mode);
611         set_dma_addr(channel, isa_virt_to_bus(buffer));
612         set_dma_count(channel, count);
613         enable_dma(channel);
614
615         release_dma_lock(flags);
616 }