]> nv-tegra.nvidia Code Review - linux-3.10.git/blob - net/irda/irda_device.c
[PATCH] x86_64: Make IRDA devices are not really ISA devices not depend on CONFIG_ISA
[linux-3.10.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/spinlock.h>
44
45 #include <asm/ioctls.h>
46 #include <asm/uaccess.h>
47 #include <asm/dma.h>
48 #include <asm/io.h>
49
50 #include <net/irda/irda_device.h>
51 #include <net/irda/irlap.h>
52 #include <net/irda/timer.h>
53 #include <net/irda/wrapper.h>
54
55 static void __irda_task_delete(struct irda_task *task);
56
57 static hashbin_t *dongles = NULL;
58 static hashbin_t *tasks = NULL;
59
60 #ifdef CONFIG_IRDA_DEBUG
61 static const char *task_state[] = {
62         "IRDA_TASK_INIT",
63         "IRDA_TASK_DONE",
64         "IRDA_TASK_WAIT",
65         "IRDA_TASK_WAIT1",
66         "IRDA_TASK_WAIT2",
67         "IRDA_TASK_WAIT3",
68         "IRDA_TASK_CHILD_INIT",
69         "IRDA_TASK_CHILD_WAIT",
70         "IRDA_TASK_CHILD_DONE",
71 };
72 #endif  /* CONFIG_IRDA_DEBUG */
73
74 static void irda_task_timer_expired(void *data);
75
76 int __init irda_device_init( void)
77 {
78         dongles = hashbin_new(HB_NOLOCK);
79         if (dongles == NULL) {
80                 IRDA_WARNING("IrDA: Can't allocate dongles hashbin!\n");
81                 return -ENOMEM;
82         }
83         spin_lock_init(&dongles->hb_spinlock);
84
85         tasks = hashbin_new(HB_LOCK);
86         if (tasks == NULL) {
87                 IRDA_WARNING("IrDA: Can't allocate tasks hashbin!\n");
88                 hashbin_delete(dongles, NULL);
89                 return -ENOMEM;
90         }
91
92         /* We no longer initialise the driver ourselves here, we let
93          * the system do it for us... - Jean II */
94
95         return 0;
96 }
97
98 static void __exit leftover_dongle(void *arg)
99 {
100         struct dongle_reg *reg = arg;
101         IRDA_WARNING("IrDA: Dongle type %x not unregistered\n",
102                      reg->type);
103 }
104
105 void __exit irda_device_cleanup(void)
106 {
107         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
108
109         hashbin_delete(tasks, (FREE_FUNC) __irda_task_delete);
110
111         hashbin_delete(dongles, leftover_dongle);
112 }
113
114 /*
115  * Function irda_device_set_media_busy (self, status)
116  *
117  *    Called when we have detected that another station is transmitting
118  *    in contention mode.
119  */
120 void irda_device_set_media_busy(struct net_device *dev, int status)
121 {
122         struct irlap_cb *self;
123
124         IRDA_DEBUG(4, "%s(%s)\n", __FUNCTION__, status ? "TRUE" : "FALSE");
125
126         self = (struct irlap_cb *) dev->atalk_ptr;
127
128         /* Some drivers may enable the receive interrupt before calling
129          * irlap_open(), or they may disable the receive interrupt
130          * after calling irlap_close().
131          * The IrDA stack is protected from this in irlap_driver_rcv().
132          * However, the driver calls directly the wrapper, that calls
133          * us directly. Make sure we protect ourselves.
134          * Jean II */
135         if (!self || self->magic != LAP_MAGIC)
136                 return;
137
138         if (status) {
139                 self->media_busy = TRUE;
140                 if (status == SMALL)
141                         irlap_start_mbusy_timer(self, SMALLBUSY_TIMEOUT);
142                 else
143                         irlap_start_mbusy_timer(self, MEDIABUSY_TIMEOUT);
144                 IRDA_DEBUG( 4, "Media busy!\n");
145         } else {
146                 self->media_busy = FALSE;
147                 irlap_stop_mbusy_timer(self);
148         }
149 }
150 EXPORT_SYMBOL(irda_device_set_media_busy);
151
152
153 /*
154  * Function irda_device_is_receiving (dev)
155  *
156  *    Check if the device driver is currently receiving data
157  *
158  */
159 int irda_device_is_receiving(struct net_device *dev)
160 {
161         struct if_irda_req req;
162         int ret;
163
164         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
165
166         if (!dev->do_ioctl) {
167                 IRDA_ERROR("%s: do_ioctl not impl. by device driver\n",
168                            __FUNCTION__);
169                 return -1;
170         }
171
172         ret = dev->do_ioctl(dev, (struct ifreq *) &req, SIOCGRECEIVING);
173         if (ret < 0)
174                 return ret;
175
176         return req.ifr_receiving;
177 }
178
179 void irda_task_next_state(struct irda_task *task, IRDA_TASK_STATE state)
180 {
181         IRDA_DEBUG(2, "%s(), state = %s\n", __FUNCTION__, task_state[state]);
182
183         task->state = state;
184 }
185 EXPORT_SYMBOL(irda_task_next_state);
186
187 static void __irda_task_delete(struct irda_task *task)
188 {
189         del_timer(&task->timer);
190
191         kfree(task);
192 }
193
194 void irda_task_delete(struct irda_task *task)
195 {
196         /* Unregister task */
197         hashbin_remove(tasks, (long) task, NULL);
198
199         __irda_task_delete(task);
200 }
201 EXPORT_SYMBOL(irda_task_delete);
202
203 /*
204  * Function irda_task_kick (task)
205  *
206  *    Tries to execute a task possible multiple times until the task is either
207  *    finished, or askes for a timeout. When a task is finished, we do post
208  *    processing, and notify the parent task, that is waiting for this task
209  *    to complete.
210  */
211 static int irda_task_kick(struct irda_task *task)
212 {
213         int finished = TRUE;
214         int count = 0;
215         int timeout;
216
217         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
218
219         IRDA_ASSERT(task != NULL, return -1;);
220         IRDA_ASSERT(task->magic == IRDA_TASK_MAGIC, return -1;);
221
222         /* Execute task until it's finished, or askes for a timeout */
223         do {
224                 timeout = task->function(task);
225                 if (count++ > 100) {
226                         IRDA_ERROR("%s: error in task handler!\n",
227                                    __FUNCTION__);
228                         irda_task_delete(task);
229                         return TRUE;
230                 }
231         } while ((timeout == 0) && (task->state != IRDA_TASK_DONE));
232
233         if (timeout < 0) {
234                 IRDA_ERROR("%s: Error executing task!\n", __FUNCTION__);
235                 irda_task_delete(task);
236                 return TRUE;
237         }
238
239         /* Check if we are finished */
240         if (task->state == IRDA_TASK_DONE) {
241                 del_timer(&task->timer);
242
243                 /* Do post processing */
244                 if (task->finished)
245                         task->finished(task);
246
247                 /* Notify parent */
248                 if (task->parent) {
249                         /* Check if parent is waiting for us to complete */
250                         if (task->parent->state == IRDA_TASK_CHILD_WAIT) {
251                                 task->parent->state = IRDA_TASK_CHILD_DONE;
252
253                                 /* Stop timer now that we are here */
254                                 del_timer(&task->parent->timer);
255
256                                 /* Kick parent task */
257                                 irda_task_kick(task->parent);
258                         }
259                 }
260                 irda_task_delete(task);
261         } else if (timeout > 0) {
262                 irda_start_timer(&task->timer, timeout, (void *) task,
263                                  irda_task_timer_expired);
264                 finished = FALSE;
265         } else {
266                 IRDA_DEBUG(0, "%s(), not finished, and no timeout!\n",
267                            __FUNCTION__);
268                 finished = FALSE;
269         }
270
271         return finished;
272 }
273
274 /*
275  * Function irda_task_execute (instance, function, finished)
276  *
277  *    This function registers and tries to execute tasks that may take some
278  *    time to complete. We do it this hairy way since we may have been
279  *    called from interrupt context, so it's not possible to use
280  *    schedule_timeout()
281  * Two important notes :
282  *      o Make sure you irda_task_delete(task); in case you delete the
283  *        calling instance.
284  *      o No real need to lock when calling this function, but you may
285  *        want to lock within the task handler.
286  * Jean II
287  */
288 struct irda_task *irda_task_execute(void *instance,
289                                     IRDA_TASK_CALLBACK function,
290                                     IRDA_TASK_CALLBACK finished,
291                                     struct irda_task *parent, void *param)
292 {
293         struct irda_task *task;
294
295         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
296
297         task = kmalloc(sizeof(struct irda_task), GFP_ATOMIC);
298         if (!task)
299                 return NULL;
300
301         task->state    = IRDA_TASK_INIT;
302         task->instance = instance;
303         task->function = function;
304         task->finished = finished;
305         task->parent   = parent;
306         task->param    = param;
307         task->magic    = IRDA_TASK_MAGIC;
308
309         init_timer(&task->timer);
310
311         /* Register task */
312         hashbin_insert(tasks, (irda_queue_t *) task, (long) task, NULL);
313
314         /* No time to waste, so lets get going! */
315         return irda_task_kick(task) ? NULL : task;
316 }
317 EXPORT_SYMBOL(irda_task_execute);
318
319 /*
320  * Function irda_task_timer_expired (data)
321  *
322  *    Task time has expired. We now try to execute task (again), and restart
323  *    the timer if the task has not finished yet
324  */
325 static void irda_task_timer_expired(void *data)
326 {
327         struct irda_task *task;
328
329         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
330
331         task = (struct irda_task *) data;
332
333         irda_task_kick(task);
334 }
335
336 /*
337  * Function irda_device_setup (dev)
338  *
339  *    This function should be used by low level device drivers in a similar way
340  *    as ether_setup() is used by normal network device drivers
341  */
342 static void irda_device_setup(struct net_device *dev)
343 {
344         dev->hard_header_len = 0;
345         dev->addr_len        = 0;
346
347         dev->type            = ARPHRD_IRDA;
348         dev->tx_queue_len    = 8; /* Window size + 1 s-frame */
349
350         memset(dev->broadcast, 0xff, 4);
351
352         dev->mtu = 2048;
353         dev->flags = IFF_NOARP;
354 }
355
356 /*
357  * Funciton  alloc_irdadev 
358  *      Allocates and sets up an IRDA device in a manner similar to
359  *      alloc_etherdev.
360  */
361 struct net_device *alloc_irdadev(int sizeof_priv)
362 {
363         return alloc_netdev(sizeof_priv, "irda%d", irda_device_setup);
364 }
365 EXPORT_SYMBOL(alloc_irdadev);
366
367 /*
368  * Function irda_device_init_dongle (self, type, qos)
369  *
370  *    Initialize attached dongle.
371  *
372  * Important : request_module require us to call this function with
373  * a process context and irq enabled. - Jean II
374  */
375 dongle_t *irda_device_dongle_init(struct net_device *dev, int type)
376 {
377         struct dongle_reg *reg;
378         dongle_t *dongle = NULL;
379
380         might_sleep();
381
382         spin_lock(&dongles->hb_spinlock);
383         reg = hashbin_find(dongles, type, NULL);
384
385 #ifdef CONFIG_KMOD
386         /* Try to load the module needed */
387         if (!reg && capable(CAP_SYS_MODULE)) {
388                 spin_unlock(&dongles->hb_spinlock);
389         
390                 request_module("irda-dongle-%d", type);
391                 
392                 spin_lock(&dongles->hb_spinlock);
393                 reg = hashbin_find(dongles, type, NULL);
394         }
395 #endif
396
397         if (!reg || !try_module_get(reg->owner) ) {
398                 IRDA_ERROR("IrDA: Unable to find requested dongle type %x\n",
399                            type);
400                 goto out;
401         }
402
403         /* Allocate dongle info for this instance */
404         dongle = kmalloc(sizeof(dongle_t), GFP_KERNEL);
405         if (!dongle)
406                 goto out;
407
408         memset(dongle, 0, sizeof(dongle_t));
409
410         /* Bind the registration info to this particular instance */
411         dongle->issue = reg;
412         dongle->dev = dev;
413
414  out:
415         spin_unlock(&dongles->hb_spinlock);
416         return dongle;
417 }
418 EXPORT_SYMBOL(irda_device_dongle_init);
419
420 /*
421  * Function irda_device_dongle_cleanup (dongle)
422  */
423 int irda_device_dongle_cleanup(dongle_t *dongle)
424 {
425         IRDA_ASSERT(dongle != NULL, return -1;);
426
427         dongle->issue->close(dongle);
428         module_put(dongle->issue->owner);
429         kfree(dongle);
430
431         return 0;
432 }
433 EXPORT_SYMBOL(irda_device_dongle_cleanup);
434
435 /*
436  * Function irda_device_register_dongle (dongle)
437  */
438 int irda_device_register_dongle(struct dongle_reg *new)
439 {
440         spin_lock(&dongles->hb_spinlock);
441         /* Check if this dongle has been registered before */
442         if (hashbin_find(dongles, new->type, NULL)) {
443                 IRDA_MESSAGE("%s: Dongle type %x already registered\n", 
444                              __FUNCTION__, new->type);
445         } else {
446                 /* Insert IrDA dongle into hashbin */
447                 hashbin_insert(dongles, (irda_queue_t *) new, new->type, NULL);
448         }
449         spin_unlock(&dongles->hb_spinlock);
450
451         return 0;
452 }
453 EXPORT_SYMBOL(irda_device_register_dongle);
454
455 /*
456  * Function irda_device_unregister_dongle (dongle)
457  *
458  *    Unregister dongle, and remove dongle from list of registered dongles
459  *
460  */
461 void irda_device_unregister_dongle(struct dongle_reg *dongle)
462 {
463         struct dongle *node;
464
465         spin_lock(&dongles->hb_spinlock);
466         node = hashbin_remove(dongles, dongle->type, NULL);
467         if (!node) 
468                 IRDA_ERROR("%s: dongle not found!\n", __FUNCTION__);
469         spin_unlock(&dongles->hb_spinlock);
470 }
471 EXPORT_SYMBOL(irda_device_unregister_dongle);
472
473 /*
474  * Function setup_dma (idev, buffer, count, mode)
475  *
476  *    Setup the DMA channel. Commonly used by LPC FIR drivers
477  *
478  */
479 void irda_setup_dma(int channel, dma_addr_t buffer, int count, int mode)
480 {
481         unsigned long flags;
482
483         flags = claim_dma_lock();
484
485         disable_dma(channel);
486         clear_dma_ff(channel);
487         set_dma_mode(channel, mode);
488         set_dma_addr(channel, buffer);
489         set_dma_count(channel, count);
490         enable_dma(channel);
491
492         release_dma_lock(flags);
493 }
494 EXPORT_SYMBOL(irda_setup_dma);