]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /********************************************************************* |
2 | * | |
3 | * Filename: irtty-sir.c | |
4 | * Version: 2.0 | |
5 | * Description: IrDA line discipline implementation | |
6 | * Status: Experimental. | |
7 | * Author: Dag Brattli <dagb@cs.uit.no> | |
8 | * Created at: Tue Dec 9 21:18:38 1997 | |
9 | * Modified at: Sun Oct 27 22:13:30 2002 | |
10 | * Modified by: Martin Diehl <mad@mdiehl.de> | |
11 | * Sources: slip.c by Laurence Culhane, <loz@holmes.demon.co.uk> | |
12 | * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org> | |
13 | * | |
14 | * Copyright (c) 1998-2000 Dag Brattli, | |
15 | * Copyright (c) 2002 Martin Diehl, | |
16 | * All Rights Reserved. | |
17 | * | |
18 | * This program is free software; you can redistribute it and/or | |
19 | * modify it under the terms of the GNU General Public License as | |
20 | * published by the Free Software Foundation; either version 2 of | |
21 | * the License, or (at your option) any later version. | |
22 | * | |
96de0e25 | 23 | * Neither Dag Brattli nor University of Tromsø admit liability nor |
1da177e4 LT |
24 | * provide warranty for any of this software. This material is |
25 | * provided "AS-IS" and at no charge. | |
26 | * | |
27 | ********************************************************************/ | |
28 | ||
29 | #include <linux/module.h> | |
30 | #include <linux/kernel.h> | |
5a0e3ad6 | 31 | #include <linux/slab.h> |
1da177e4 LT |
32 | #include <linux/tty.h> |
33 | #include <linux/init.h> | |
34 | #include <asm/uaccess.h> | |
1da177e4 | 35 | #include <linux/delay.h> |
d4ccd08c | 36 | #include <linux/mutex.h> |
1da177e4 LT |
37 | |
38 | #include <net/irda/irda.h> | |
39 | #include <net/irda/irda_device.h> | |
40 | ||
41 | #include "sir-dev.h" | |
42 | #include "irtty-sir.h" | |
43 | ||
44 | static int qos_mtt_bits = 0x03; /* 5 ms or more */ | |
45 | ||
46 | module_param(qos_mtt_bits, int, 0); | |
47 | MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time"); | |
48 | ||
49 | /* ------------------------------------------------------- */ | |
50 | ||
51 | /* device configuration callbacks always invoked with irda-thread context */ | |
52 | ||
53 | /* find out, how many chars we have in buffers below us | |
54 | * this is allowed to lie, i.e. return less chars than we | |
55 | * actually have. The returned value is used to determine | |
56 | * how long the irdathread should wait before doing the | |
57 | * real blocking wait_until_sent() | |
58 | */ | |
59 | ||
60 | static int irtty_chars_in_buffer(struct sir_dev *dev) | |
61 | { | |
62 | struct sirtty_cb *priv = dev->priv; | |
63 | ||
64 | IRDA_ASSERT(priv != NULL, return -1;); | |
65 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;); | |
66 | ||
f34d7a5b | 67 | return tty_chars_in_buffer(priv->tty); |
1da177e4 LT |
68 | } |
69 | ||
70 | /* Wait (sleep) until underlaying hardware finished transmission | |
71 | * i.e. hardware buffers are drained | |
72 | * this must block and not return before all characters are really sent | |
73 | * | |
74 | * If the tty sits on top of a 16550A-like uart, there are typically | |
75 | * up to 16 bytes in the fifo - f.e. 9600 bps 8N1 needs 16.7 msec | |
76 | * | |
77 | * With usbserial the uart-fifo is basically replaced by the converter's | |
78 | * outgoing endpoint buffer, which can usually hold 64 bytes (at least). | |
79 | * With pl2303 it appears we are safe with 60msec here. | |
80 | * | |
81 | * I really wish all serial drivers would provide | |
82 | * correct implementation of wait_until_sent() | |
83 | */ | |
84 | ||
85 | #define USBSERIAL_TX_DONE_DELAY 60 | |
86 | ||
87 | static void irtty_wait_until_sent(struct sir_dev *dev) | |
88 | { | |
89 | struct sirtty_cb *priv = dev->priv; | |
90 | struct tty_struct *tty; | |
91 | ||
92 | IRDA_ASSERT(priv != NULL, return;); | |
93 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;); | |
94 | ||
95 | tty = priv->tty; | |
f34d7a5b AC |
96 | if (tty->ops->wait_until_sent) { |
97 | tty->ops->wait_until_sent(tty, msecs_to_jiffies(100)); | |
1da177e4 LT |
98 | } |
99 | else { | |
100 | msleep(USBSERIAL_TX_DONE_DELAY); | |
101 | } | |
102 | } | |
103 | ||
104 | /* | |
105 | * Function irtty_change_speed (dev, speed) | |
106 | * | |
107 | * Change the speed of the serial port. | |
108 | * | |
109 | * This may sleep in set_termios (usbserial driver f.e.) and must | |
110 | * not be called from interrupt/timer/tasklet therefore. | |
111 | * All such invocations are deferred to kIrDAd now so we can sleep there. | |
112 | */ | |
113 | ||
114 | static int irtty_change_speed(struct sir_dev *dev, unsigned speed) | |
115 | { | |
116 | struct sirtty_cb *priv = dev->priv; | |
117 | struct tty_struct *tty; | |
606d099c | 118 | struct ktermios old_termios; |
1da177e4 LT |
119 | int cflag; |
120 | ||
121 | IRDA_ASSERT(priv != NULL, return -1;); | |
122 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;); | |
123 | ||
124 | tty = priv->tty; | |
125 | ||
6a1c0680 | 126 | down_write(&tty->termios_rwsem); |
adc8d746 AC |
127 | old_termios = tty->termios; |
128 | cflag = tty->termios.c_cflag; | |
f34d7a5b AC |
129 | tty_encode_baud_rate(tty, speed, speed); |
130 | if (tty->ops->set_termios) | |
131 | tty->ops->set_termios(tty, &old_termios); | |
1da177e4 | 132 | priv->io.speed = speed; |
6a1c0680 | 133 | up_write(&tty->termios_rwsem); |
1da177e4 LT |
134 | |
135 | return 0; | |
136 | } | |
137 | ||
138 | /* | |
139 | * Function irtty_set_dtr_rts (dev, dtr, rts) | |
140 | * | |
141 | * This function can be used by dongles etc. to set or reset the status | |
142 | * of the dtr and rts lines | |
143 | */ | |
144 | ||
145 | static int irtty_set_dtr_rts(struct sir_dev *dev, int dtr, int rts) | |
146 | { | |
147 | struct sirtty_cb *priv = dev->priv; | |
148 | int set = 0; | |
149 | int clear = 0; | |
150 | ||
151 | IRDA_ASSERT(priv != NULL, return -1;); | |
152 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;); | |
153 | ||
154 | if (rts) | |
155 | set |= TIOCM_RTS; | |
156 | else | |
157 | clear |= TIOCM_RTS; | |
158 | if (dtr) | |
159 | set |= TIOCM_DTR; | |
160 | else | |
161 | clear |= TIOCM_DTR; | |
162 | ||
163 | /* | |
164 | * We can't use ioctl() because it expects a non-null file structure, | |
165 | * and we don't have that here. | |
166 | * This function is not yet defined for all tty driver, so | |
167 | * let's be careful... Jean II | |
168 | */ | |
f34d7a5b | 169 | IRDA_ASSERT(priv->tty->ops->tiocmset != NULL, return -1;); |
20b9d177 | 170 | priv->tty->ops->tiocmset(priv->tty, set, clear); |
1da177e4 LT |
171 | |
172 | return 0; | |
173 | } | |
174 | ||
175 | /* ------------------------------------------------------- */ | |
176 | ||
177 | /* called from sir_dev when there is more data to send | |
178 | * context is either netdev->hard_xmit or some transmit-completion bh | |
179 | * i.e. we are under spinlock here and must not sleep. | |
180 | */ | |
181 | ||
182 | static int irtty_do_write(struct sir_dev *dev, const unsigned char *ptr, size_t len) | |
183 | { | |
184 | struct sirtty_cb *priv = dev->priv; | |
185 | struct tty_struct *tty; | |
186 | int writelen; | |
187 | ||
188 | IRDA_ASSERT(priv != NULL, return -1;); | |
189 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;); | |
190 | ||
191 | tty = priv->tty; | |
f34d7a5b | 192 | if (!tty->ops->write) |
1da177e4 | 193 | return 0; |
8a1ec21e | 194 | set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); |
f34d7a5b AC |
195 | writelen = tty_write_room(tty); |
196 | if (writelen > len) | |
1da177e4 | 197 | writelen = len; |
f34d7a5b | 198 | return tty->ops->write(tty, ptr, writelen); |
1da177e4 LT |
199 | } |
200 | ||
201 | /* ------------------------------------------------------- */ | |
202 | ||
203 | /* irda line discipline callbacks */ | |
204 | ||
205 | /* | |
206 | * Function irtty_receive_buf( tty, cp, count) | |
207 | * | |
208 | * Handle the 'receiver data ready' interrupt. This function is called | |
209 | * by the 'tty_io' module in the kernel when a block of IrDA data has | |
210 | * been received, which can now be decapsulated and delivered for | |
211 | * further processing | |
212 | * | |
d6c53c0e | 213 | * calling context depends on underlying driver and tty->port->low_latency! |
1da177e4 LT |
214 | * for example (low_latency: 1 / 0): |
215 | * serial.c: uart-interrupt / softint | |
216 | * usbserial: urb-complete-interrupt / softint | |
217 | */ | |
218 | ||
55db4c64 LT |
219 | static void irtty_receive_buf(struct tty_struct *tty, const unsigned char *cp, |
220 | char *fp, int count) | |
1da177e4 LT |
221 | { |
222 | struct sir_dev *dev; | |
223 | struct sirtty_cb *priv = tty->disc_data; | |
224 | int i; | |
225 | ||
55db4c64 LT |
226 | IRDA_ASSERT(priv != NULL, return;); |
227 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;); | |
1da177e4 LT |
228 | |
229 | if (unlikely(count==0)) /* yes, this happens */ | |
55db4c64 | 230 | return; |
1da177e4 LT |
231 | |
232 | dev = priv->dev; | |
233 | if (!dev) { | |
6c91023d | 234 | net_warn_ratelimited("%s(), not ready yet!\n", __func__); |
55db4c64 | 235 | return; |
1da177e4 LT |
236 | } |
237 | ||
238 | for (i = 0; i < count; i++) { | |
239 | /* | |
240 | * Characters received with a parity error, etc? | |
241 | */ | |
242 | if (fp && *fp++) { | |
955a9d20 | 243 | pr_debug("Framing or parity error!\n"); |
1da177e4 | 244 | sirdev_receive(dev, NULL, 0); /* notify sir_dev (updating stats) */ |
55db4c64 | 245 | return; |
1da177e4 LT |
246 | } |
247 | } | |
248 | ||
249 | sirdev_receive(dev, cp, count); | |
250 | } | |
251 | ||
1da177e4 LT |
252 | /* |
253 | * Function irtty_write_wakeup (tty) | |
254 | * | |
255 | * Called by the driver when there's room for more data. If we have | |
256 | * more packets to send, we send them here. | |
257 | * | |
258 | */ | |
259 | static void irtty_write_wakeup(struct tty_struct *tty) | |
260 | { | |
261 | struct sirtty_cb *priv = tty->disc_data; | |
262 | ||
263 | IRDA_ASSERT(priv != NULL, return;); | |
264 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;); | |
265 | ||
8a1ec21e | 266 | clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); |
1da177e4 LT |
267 | if (priv->dev) |
268 | sirdev_write_complete(priv->dev); | |
269 | } | |
270 | ||
271 | /* ------------------------------------------------------- */ | |
272 | ||
273 | /* | |
274 | * Function irtty_stop_receiver (tty, stop) | |
275 | * | |
276 | */ | |
277 | ||
278 | static inline void irtty_stop_receiver(struct tty_struct *tty, int stop) | |
279 | { | |
606d099c | 280 | struct ktermios old_termios; |
1da177e4 LT |
281 | int cflag; |
282 | ||
6a1c0680 | 283 | down_write(&tty->termios_rwsem); |
adc8d746 AC |
284 | old_termios = tty->termios; |
285 | cflag = tty->termios.c_cflag; | |
1da177e4 LT |
286 | |
287 | if (stop) | |
288 | cflag &= ~CREAD; | |
289 | else | |
290 | cflag |= CREAD; | |
291 | ||
adc8d746 | 292 | tty->termios.c_cflag = cflag; |
f34d7a5b AC |
293 | if (tty->ops->set_termios) |
294 | tty->ops->set_termios(tty, &old_termios); | |
6a1c0680 | 295 | up_write(&tty->termios_rwsem); |
1da177e4 LT |
296 | } |
297 | ||
298 | /*****************************************************************/ | |
299 | ||
300 | /* serialize ldisc open/close with sir_dev */ | |
d4ccd08c | 301 | static DEFINE_MUTEX(irtty_mutex); |
1da177e4 LT |
302 | |
303 | /* notifier from sir_dev when irda% device gets opened (ifup) */ | |
304 | ||
305 | static int irtty_start_dev(struct sir_dev *dev) | |
306 | { | |
307 | struct sirtty_cb *priv; | |
308 | struct tty_struct *tty; | |
309 | ||
310 | /* serialize with ldisc open/close */ | |
d4ccd08c | 311 | mutex_lock(&irtty_mutex); |
1da177e4 LT |
312 | |
313 | priv = dev->priv; | |
314 | if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) { | |
d4ccd08c | 315 | mutex_unlock(&irtty_mutex); |
1da177e4 LT |
316 | return -ESTALE; |
317 | } | |
318 | ||
319 | tty = priv->tty; | |
320 | ||
f34d7a5b AC |
321 | if (tty->ops->start) |
322 | tty->ops->start(tty); | |
1da177e4 LT |
323 | /* Make sure we can receive more data */ |
324 | irtty_stop_receiver(tty, FALSE); | |
325 | ||
d4ccd08c | 326 | mutex_unlock(&irtty_mutex); |
1da177e4 LT |
327 | return 0; |
328 | } | |
329 | ||
330 | /* notifier from sir_dev when irda% device gets closed (ifdown) */ | |
331 | ||
332 | static int irtty_stop_dev(struct sir_dev *dev) | |
333 | { | |
334 | struct sirtty_cb *priv; | |
335 | struct tty_struct *tty; | |
336 | ||
337 | /* serialize with ldisc open/close */ | |
d4ccd08c | 338 | mutex_lock(&irtty_mutex); |
1da177e4 LT |
339 | |
340 | priv = dev->priv; | |
341 | if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) { | |
d4ccd08c | 342 | mutex_unlock(&irtty_mutex); |
1da177e4 LT |
343 | return -ESTALE; |
344 | } | |
345 | ||
346 | tty = priv->tty; | |
347 | ||
348 | /* Make sure we don't receive more data */ | |
349 | irtty_stop_receiver(tty, TRUE); | |
f34d7a5b AC |
350 | if (tty->ops->stop) |
351 | tty->ops->stop(tty); | |
1da177e4 | 352 | |
d4ccd08c | 353 | mutex_unlock(&irtty_mutex); |
1da177e4 LT |
354 | |
355 | return 0; | |
356 | } | |
357 | ||
358 | /* ------------------------------------------------------- */ | |
359 | ||
360 | static struct sir_driver sir_tty_drv = { | |
361 | .owner = THIS_MODULE, | |
362 | .driver_name = "sir_tty", | |
363 | .start_dev = irtty_start_dev, | |
364 | .stop_dev = irtty_stop_dev, | |
365 | .do_write = irtty_do_write, | |
366 | .chars_in_buffer = irtty_chars_in_buffer, | |
367 | .wait_until_sent = irtty_wait_until_sent, | |
368 | .set_speed = irtty_change_speed, | |
369 | .set_dtr_rts = irtty_set_dtr_rts, | |
370 | }; | |
371 | ||
372 | /* ------------------------------------------------------- */ | |
373 | ||
374 | /* | |
375 | * Function irtty_ioctl (tty, file, cmd, arg) | |
376 | * | |
377 | * The Swiss army knife of system calls :-) | |
378 | * | |
379 | */ | |
380 | static int irtty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg) | |
381 | { | |
382 | struct irtty_info { char name[6]; } info; | |
383 | struct sir_dev *dev; | |
384 | struct sirtty_cb *priv = tty->disc_data; | |
385 | int err = 0; | |
386 | ||
387 | IRDA_ASSERT(priv != NULL, return -ENODEV;); | |
388 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -EBADR;); | |
389 | ||
955a9d20 | 390 | pr_debug("%s(cmd=0x%X)\n", __func__, cmd); |
1da177e4 LT |
391 | |
392 | dev = priv->dev; | |
393 | IRDA_ASSERT(dev != NULL, return -1;); | |
394 | ||
395 | switch (cmd) { | |
1da177e4 LT |
396 | case IRTTY_IOCTDONGLE: |
397 | /* this call blocks for completion */ | |
398 | err = sirdev_set_dongle(dev, (IRDA_DONGLE) arg); | |
399 | break; | |
400 | ||
401 | case IRTTY_IOCGET: | |
402 | IRDA_ASSERT(dev->netdev != NULL, return -1;); | |
403 | ||
404 | memset(&info, 0, sizeof(info)); | |
405 | strncpy(info.name, dev->netdev->name, sizeof(info.name)-1); | |
406 | ||
407 | if (copy_to_user((void __user *)arg, &info, sizeof(info))) | |
408 | err = -EFAULT; | |
409 | break; | |
410 | default: | |
d0127539 | 411 | err = tty_mode_ioctl(tty, file, cmd, arg); |
1da177e4 LT |
412 | break; |
413 | } | |
414 | return err; | |
415 | } | |
416 | ||
417 | ||
418 | /* | |
419 | * Function irtty_open(tty) | |
420 | * | |
421 | * This function is called by the TTY module when the IrDA line | |
422 | * discipline is called for. Because we are sure the tty line exists, | |
423 | * we only have to link it to a free IrDA channel. | |
424 | */ | |
425 | static int irtty_open(struct tty_struct *tty) | |
426 | { | |
427 | struct sir_dev *dev; | |
428 | struct sirtty_cb *priv; | |
429 | int ret = 0; | |
430 | ||
431 | /* Module stuff handled via irda_ldisc.owner - Jean II */ | |
432 | ||
1da177e4 LT |
433 | /* stop the underlying driver */ |
434 | irtty_stop_receiver(tty, TRUE); | |
f34d7a5b AC |
435 | if (tty->ops->stop) |
436 | tty->ops->stop(tty); | |
1da177e4 | 437 | |
f34d7a5b | 438 | tty_driver_flush_buffer(tty); |
1da177e4 LT |
439 | |
440 | /* apply mtt override */ | |
441 | sir_tty_drv.qos_mtt_bits = qos_mtt_bits; | |
442 | ||
443 | /* get a sir device instance for this driver */ | |
444 | dev = sirdev_get_instance(&sir_tty_drv, tty->name); | |
445 | if (!dev) { | |
446 | ret = -ENODEV; | |
447 | goto out; | |
448 | } | |
449 | ||
450 | /* allocate private device info block */ | |
dd00cc48 | 451 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); |
87286477 PST |
452 | if (!priv) { |
453 | ret = -ENOMEM; | |
1da177e4 | 454 | goto out_put; |
87286477 | 455 | } |
1da177e4 LT |
456 | |
457 | priv->magic = IRTTY_MAGIC; | |
458 | priv->tty = tty; | |
459 | priv->dev = dev; | |
460 | ||
461 | /* serialize with start_dev - in case we were racing with ifup */ | |
d4ccd08c | 462 | mutex_lock(&irtty_mutex); |
1da177e4 LT |
463 | |
464 | dev->priv = priv; | |
465 | tty->disc_data = priv; | |
33f0f88f | 466 | tty->receive_room = 65536; |
1da177e4 | 467 | |
d4ccd08c | 468 | mutex_unlock(&irtty_mutex); |
1da177e4 | 469 | |
955a9d20 | 470 | pr_debug("%s - %s: irda line discipline opened\n", __func__, tty->name); |
1da177e4 LT |
471 | |
472 | return 0; | |
473 | ||
474 | out_put: | |
475 | sirdev_put_instance(dev); | |
476 | out: | |
477 | return ret; | |
478 | } | |
479 | ||
480 | /* | |
481 | * Function irtty_close (tty) | |
482 | * | |
483 | * Close down a IrDA channel. This means flushing out any pending queues, | |
484 | * and then restoring the TTY line discipline to what it was before it got | |
485 | * hooked to IrDA (which usually is TTY again). | |
486 | */ | |
487 | static void irtty_close(struct tty_struct *tty) | |
488 | { | |
489 | struct sirtty_cb *priv = tty->disc_data; | |
490 | ||
491 | IRDA_ASSERT(priv != NULL, return;); | |
492 | IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;); | |
493 | ||
494 | /* Hm, with a dongle attached the dongle driver wants | |
495 | * to close the dongle - which requires the use of | |
496 | * some tty write and/or termios or ioctl operations. | |
497 | * Are we allowed to call those when already requested | |
498 | * to shutdown the ldisc? | |
499 | * If not, we should somehow mark the dev being staled. | |
500 | * Question remains, how to close the dongle in this case... | |
501 | * For now let's assume we are granted to issue tty driver calls | |
502 | * until we return here from the ldisc close. I'm just wondering | |
503 | * how this behaves with hotpluggable serial hardware like | |
504 | * rs232-pcmcia card or usb-serial... | |
505 | * | |
506 | * priv->tty = NULL?; | |
507 | */ | |
508 | ||
509 | /* we are dead now */ | |
510 | tty->disc_data = NULL; | |
511 | ||
512 | sirdev_put_instance(priv->dev); | |
513 | ||
514 | /* Stop tty */ | |
8a1ec21e | 515 | clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); |
f34d7a5b AC |
516 | if (tty->ops->stop) |
517 | tty->ops->stop(tty); | |
1da177e4 LT |
518 | |
519 | kfree(priv); | |
520 | ||
955a9d20 | 521 | pr_debug("%s - %s: irda line discipline closed\n", __func__, tty->name); |
1da177e4 LT |
522 | } |
523 | ||
524 | /* ------------------------------------------------------- */ | |
525 | ||
a352def2 | 526 | static struct tty_ldisc_ops irda_ldisc = { |
1da177e4 LT |
527 | .magic = TTY_LDISC_MAGIC, |
528 | .name = "irda", | |
529 | .flags = 0, | |
530 | .open = irtty_open, | |
531 | .close = irtty_close, | |
532 | .read = NULL, | |
533 | .write = NULL, | |
534 | .ioctl = irtty_ioctl, | |
535 | .poll = NULL, | |
536 | .receive_buf = irtty_receive_buf, | |
1da177e4 LT |
537 | .write_wakeup = irtty_write_wakeup, |
538 | .owner = THIS_MODULE, | |
539 | }; | |
540 | ||
541 | /* ------------------------------------------------------- */ | |
542 | ||
543 | static int __init irtty_sir_init(void) | |
544 | { | |
545 | int err; | |
546 | ||
547 | if ((err = tty_register_ldisc(N_IRDA, &irda_ldisc)) != 0) | |
6c91023d JP |
548 | net_err_ratelimited("IrDA: can't register line discipline (err = %d)\n", |
549 | err); | |
1da177e4 LT |
550 | return err; |
551 | } | |
552 | ||
553 | static void __exit irtty_sir_cleanup(void) | |
554 | { | |
555 | int err; | |
556 | ||
64ccd715 | 557 | if ((err = tty_unregister_ldisc(N_IRDA))) { |
6c91023d JP |
558 | net_err_ratelimited("%s(), can't unregister line discipline (err = %d)\n", |
559 | __func__, err); | |
1da177e4 LT |
560 | } |
561 | } | |
562 | ||
563 | module_init(irtty_sir_init); | |
564 | module_exit(irtty_sir_cleanup); | |
565 | ||
566 | MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>"); | |
567 | MODULE_DESCRIPTION("IrDA TTY device driver"); | |
568 | MODULE_ALIAS_LDISC(N_IRDA); | |
569 | MODULE_LICENSE("GPL"); | |
570 |