~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/irda/irda_device.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/string.h>
 33 #include <linux/proc_fs.h>
 34 #include <linux/skbuff.h>
 35 #include <linux/capability.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 static void irda_task_timer_expired(void *data);
 61 
 62 int __init irda_device_init( void)
 63 {
 64         dongles = hashbin_new(HB_NOLOCK);
 65         if (dongles == NULL) {
 66                 IRDA_WARNING("IrDA: Can't allocate dongles hashbin!\n");
 67                 return -ENOMEM;
 68         }
 69         spin_lock_init(&dongles->hb_spinlock);
 70 
 71         tasks = hashbin_new(HB_LOCK);
 72         if (tasks == NULL) {
 73                 IRDA_WARNING("IrDA: Can't allocate tasks hashbin!\n");
 74                 hashbin_delete(dongles, NULL);
 75                 return -ENOMEM;
 76         }
 77 
 78         /* We no longer initialise the driver ourselves here, we let
 79          * the system do it for us... - Jean II */
 80 
 81         return 0;
 82 }
 83 
 84 static void leftover_dongle(void *arg)
 85 {
 86         struct dongle_reg *reg = arg;
 87         IRDA_WARNING("IrDA: Dongle type %x not unregistered\n",
 88                      reg->type);
 89 }
 90 
 91 void irda_device_cleanup(void)
 92 {
 93         IRDA_DEBUG(4, "%s()\n", __func__);
 94 
 95         hashbin_delete(tasks, (FREE_FUNC) __irda_task_delete);
 96 
 97         hashbin_delete(dongles, leftover_dongle);
 98 }
 99 
100 /*
101  * Function irda_device_set_media_busy (self, status)
102  *
103  *    Called when we have detected that another station is transmitting
104  *    in contention mode.
105  */
106 void irda_device_set_media_busy(struct net_device *dev, int status)
107 {
108         struct irlap_cb *self;
109 
110         IRDA_DEBUG(4, "%s(%s)\n", __func__, status ? "TRUE" : "FALSE");
111 
112         self = (struct irlap_cb *) dev->atalk_ptr;
113 
114         /* Some drivers may enable the receive interrupt before calling
115          * irlap_open(), or they may disable the receive interrupt
116          * after calling irlap_close().
117          * The IrDA stack is protected from this in irlap_driver_rcv().
118          * However, the driver calls directly the wrapper, that calls
119          * us directly. Make sure we protect ourselves.
120          * Jean II */
121         if (!self || self->magic != LAP_MAGIC)
122                 return;
123 
124         if (status) {
125                 self->media_busy = TRUE;
126                 if (status == SMALL)
127                         irlap_start_mbusy_timer(self, SMALLBUSY_TIMEOUT);
128                 else
129                         irlap_start_mbusy_timer(self, MEDIABUSY_TIMEOUT);
130                 IRDA_DEBUG( 4, "Media busy!\n");
131         } else {
132                 self->media_busy = FALSE;
133                 irlap_stop_mbusy_timer(self);
134         }
135 }
136 EXPORT_SYMBOL(irda_device_set_media_busy);
137 
138 
139 /*
140  * Function irda_device_is_receiving (dev)
141  *
142  *    Check if the device driver is currently receiving data
143  *
144  */
145 int irda_device_is_receiving(struct net_device *dev)
146 {
147         struct if_irda_req req;
148         int ret;
149 
150         IRDA_DEBUG(2, "%s()\n", __func__);
151 
152         if (!dev->netdev_ops->ndo_do_ioctl) {
153                 IRDA_ERROR("%s: do_ioctl not impl. by device driver\n",
154                            __func__);
155                 return -1;
156         }
157 
158         ret = (dev->netdev_ops->ndo_do_ioctl)(dev, (struct ifreq *) &req,
159                                               SIOCGRECEIVING);
160         if (ret < 0)
161                 return ret;
162 
163         return req.ifr_receiving;
164 }
165 
166 static void __irda_task_delete(struct irda_task *task)
167 {
168         del_timer(&task->timer);
169 
170         kfree(task);
171 }
172 
173 static void irda_task_delete(struct irda_task *task)
174 {
175         /* Unregister task */
176         hashbin_remove(tasks, (long) task, NULL);
177 
178         __irda_task_delete(task);
179 }
180 
181 /*
182  * Function irda_task_kick (task)
183  *
184  *    Tries to execute a task possible multiple times until the task is either
185  *    finished, or askes for a timeout. When a task is finished, we do post
186  *    processing, and notify the parent task, that is waiting for this task
187  *    to complete.
188  */
189 static int irda_task_kick(struct irda_task *task)
190 {
191         int finished = TRUE;
192         int count = 0;
193         int timeout;
194 
195         IRDA_DEBUG(2, "%s()\n", __func__);
196 
197         IRDA_ASSERT(task != NULL, return -1;);
198         IRDA_ASSERT(task->magic == IRDA_TASK_MAGIC, return -1;);
199 
200         /* Execute task until it's finished, or askes for a timeout */
201         do {
202                 timeout = task->function(task);
203                 if (count++ > 100) {
204                         IRDA_ERROR("%s: error in task handler!\n",
205                                    __func__);
206                         irda_task_delete(task);
207                         return TRUE;
208                 }
209         } while ((timeout == 0) && (task->state != IRDA_TASK_DONE));
210 
211         if (timeout < 0) {
212                 IRDA_ERROR("%s: Error executing task!\n", __func__);
213                 irda_task_delete(task);
214                 return TRUE;
215         }
216 
217         /* Check if we are finished */
218         if (task->state == IRDA_TASK_DONE) {
219                 del_timer(&task->timer);
220 
221                 /* Do post processing */
222                 if (task->finished)
223                         task->finished(task);
224 
225                 /* Notify parent */
226                 if (task->parent) {
227                         /* Check if parent is waiting for us to complete */
228                         if (task->parent->state == IRDA_TASK_CHILD_WAIT) {
229                                 task->parent->state = IRDA_TASK_CHILD_DONE;
230 
231                                 /* Stop timer now that we are here */
232                                 del_timer(&task->parent->timer);
233 
234                                 /* Kick parent task */
235                                 irda_task_kick(task->parent);
236                         }
237                 }
238                 irda_task_delete(task);
239         } else if (timeout > 0) {
240                 irda_start_timer(&task->timer, timeout, (void *) task,
241                                  irda_task_timer_expired);
242                 finished = FALSE;
243         } else {
244                 IRDA_DEBUG(0, "%s(), not finished, and no timeout!\n",
245                            __func__);
246                 finished = FALSE;
247         }
248 
249         return finished;
250 }
251 
252 /*
253  * Function irda_task_timer_expired (data)
254  *
255  *    Task time has expired. We now try to execute task (again), and restart
256  *    the timer if the task has not finished yet
257  */
258 static void irda_task_timer_expired(void *data)
259 {
260         struct irda_task *task;
261 
262         IRDA_DEBUG(2, "%s()\n", __func__);
263 
264         task = (struct irda_task *) data;
265 
266         irda_task_kick(task);
267 }
268 
269 /*
270  * Function irda_device_setup (dev)
271  *
272  *    This function should be used by low level device drivers in a similar way
273  *    as ether_setup() is used by normal network device drivers
274  */
275 static void irda_device_setup(struct net_device *dev)
276 {
277         dev->hard_header_len = 0;
278         dev->addr_len        = LAP_ALEN;
279 
280         dev->type            = ARPHRD_IRDA;
281         dev->tx_queue_len    = 8; /* Window size + 1 s-frame */
282 
283         memset(dev->broadcast, 0xff, LAP_ALEN);
284 
285         dev->mtu = 2048;
286         dev->flags = IFF_NOARP;
287 }
288 
289 /*
290  * Funciton  alloc_irdadev
291  *      Allocates and sets up an IRDA device in a manner similar to
292  *      alloc_etherdev.
293  */
294 struct net_device *alloc_irdadev(int sizeof_priv)
295 {
296         return alloc_netdev(sizeof_priv, "irda%d", irda_device_setup);
297 }
298 EXPORT_SYMBOL(alloc_irdadev);
299 
300 #ifdef CONFIG_ISA_DMA_API
301 /*
302  * Function setup_dma (idev, buffer, count, mode)
303  *
304  *    Setup the DMA channel. Commonly used by LPC FIR drivers
305  *
306  */
307 void irda_setup_dma(int channel, dma_addr_t buffer, int count, int mode)
308 {
309         unsigned long flags;
310 
311         flags = claim_dma_lock();
312 
313         disable_dma(channel);
314         clear_dma_ff(channel);
315         set_dma_mode(channel, mode);
316         set_dma_addr(channel, buffer);
317         set_dma_count(channel, count);
318         enable_dma(channel);
319 
320         release_dma_lock(flags);
321 }
322 EXPORT_SYMBOL(irda_setup_dma);
323 #endif
324 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp