slcan.c revision a8e83b17536aad603fbeae4c460f2da0ee9fe6ed 
1/*
2 * slcan.c - serial line CAN interface driver (using tty line discipline)
3 *
4 * This file is derived from linux/drivers/net/slip/slip.c
5 *
6 * slip.c Authors  : Laurence Culhane <loz@holmes.demon.co.uk>
7 *                   Fred N. van Kempen <waltje@uwalt.nl.mugnet.org>
8 * slcan.c Author  : Oliver Hartkopp <socketcan@hartkopp.net>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, see http://www.gnu.org/licenses/gpl.html
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
34 * DAMAGE.
35 *
36 */
37
38#include <linux/module.h>
39#include <linux/moduleparam.h>
40
41#include <linux/uaccess.h>
42#include <linux/bitops.h>
43#include <linux/string.h>
44#include <linux/tty.h>
45#include <linux/errno.h>
46#include <linux/netdevice.h>
47#include <linux/skbuff.h>
48#include <linux/rtnetlink.h>
49#include <linux/if_arp.h>
50#include <linux/if_ether.h>
51#include <linux/sched.h>
52#include <linux/delay.h>
53#include <linux/init.h>
54#include <linux/kernel.h>
55#include <linux/workqueue.h>
56#include <linux/can.h>
57#include <linux/can/skb.h>
58
59static __initconst const char banner[] =
60	KERN_INFO "slcan: serial line CAN interface driver\n";
61
62MODULE_ALIAS_LDISC(N_SLCAN);
63MODULE_DESCRIPTION("serial line CAN interface");
64MODULE_LICENSE("GPL");
65MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>");
66
67#define SLCAN_MAGIC 0x53CA
68
69static int maxdev = 10;		/* MAX number of SLCAN channels;
70				   This can be overridden with
71				   insmod slcan.ko maxdev=nnn	*/
72module_param(maxdev, int, 0);
73MODULE_PARM_DESC(maxdev, "Maximum number of slcan interfaces");
74
75/* maximum rx buffer len: extended CAN frame with timestamp */
76#define SLC_MTU (sizeof("T1111222281122334455667788EA5F\r")+1)
77
78#define SLC_CMD_LEN 1
79#define SLC_SFF_ID_LEN 3
80#define SLC_EFF_ID_LEN 8
81
82struct slcan {
83	int			magic;
84
85	/* Various fields. */
86	struct tty_struct	*tty;		/* ptr to TTY structure	     */
87	struct net_device	*dev;		/* easy for intr handling    */
88	spinlock_t		lock;
89	struct work_struct	tx_work;	/* Flushes transmit buffer   */
90
91	/* These are pointers to the malloc()ed frame buffers. */
92	unsigned char		rbuff[SLC_MTU];	/* receiver buffer	     */
93	int			rcount;         /* received chars counter    */
94	unsigned char		xbuff[SLC_MTU];	/* transmitter buffer	     */
95	unsigned char		*xhead;         /* pointer to next XMIT byte */
96	int			xleft;          /* bytes left in XMIT queue  */
97
98	unsigned long		flags;		/* Flag values/ mode etc     */
99#define SLF_INUSE		0		/* Channel in use            */
100#define SLF_ERROR		1               /* Parity, etc. error        */
101};
102
103static struct net_device **slcan_devs;
104
105 /************************************************************************
106  *			SLCAN ENCAPSULATION FORMAT			 *
107  ************************************************************************/
108
109/*
110 * A CAN frame has a can_id (11 bit standard frame format OR 29 bit extended
111 * frame format) a data length code (can_dlc) which can be from 0 to 8
112 * and up to <can_dlc> data bytes as payload.
113 * Additionally a CAN frame may become a remote transmission frame if the
114 * RTR-bit is set. This causes another ECU to send a CAN frame with the
115 * given can_id.
116 *
117 * The SLCAN ASCII representation of these different frame types is:
118 * <type> <id> <dlc> <data>*
119 *
120 * Extended frames (29 bit) are defined by capital characters in the type.
121 * RTR frames are defined as 'r' types - normal frames have 't' type:
122 * t => 11 bit data frame
123 * r => 11 bit RTR frame
124 * T => 29 bit data frame
125 * R => 29 bit RTR frame
126 *
127 * The <id> is 3 (standard) or 8 (extended) bytes in ASCII Hex (base64).
128 * The <dlc> is a one byte ASCII number ('0' - '8')
129 * The <data> section has at much ASCII Hex bytes as defined by the <dlc>
130 *
131 * Examples:
132 *
133 * t1230 : can_id 0x123, can_dlc 0, no data
134 * t4563112233 : can_id 0x456, can_dlc 3, data 0x11 0x22 0x33
135 * T12ABCDEF2AA55 : extended can_id 0x12ABCDEF, can_dlc 2, data 0xAA 0x55
136 * r1230 : can_id 0x123, can_dlc 0, no data, remote transmission request
137 *
138 */
139
140 /************************************************************************
141  *			STANDARD SLCAN DECAPSULATION			 *
142  ************************************************************************/
143
144/* Send one completely decapsulated can_frame to the network layer */
145static void slc_bump(struct slcan *sl)
146{
147	struct sk_buff *skb;
148	struct can_frame cf;
149	int i, tmp;
150	u32 tmpid;
151	char *cmd = sl->rbuff;
152
153	cf.can_id = 0;
154
155	switch (*cmd) {
156	case 'r':
157		cf.can_id = CAN_RTR_FLAG;
158		/* fallthrough */
159	case 't':
160		/* store dlc ASCII value and terminate SFF CAN ID string */
161		cf.can_dlc = sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN];
162		sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN] = 0;
163		/* point to payload data behind the dlc */
164		cmd += SLC_CMD_LEN + SLC_SFF_ID_LEN + 1;
165		break;
166	case 'R':
167		cf.can_id = CAN_RTR_FLAG;
168		/* fallthrough */
169	case 'T':
170		cf.can_id |= CAN_EFF_FLAG;
171		/* store dlc ASCII value and terminate EFF CAN ID string */
172		cf.can_dlc = sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN];
173		sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN] = 0;
174		/* point to payload data behind the dlc */
175		cmd += SLC_CMD_LEN + SLC_EFF_ID_LEN + 1;
176		break;
177	default:
178		return;
179	}
180
181	if (kstrtou32(sl->rbuff + SLC_CMD_LEN, 16, &tmpid))
182		return;
183
184	cf.can_id |= tmpid;
185
186	/* get can_dlc from sanitized ASCII value */
187	if (cf.can_dlc >= '0' && cf.can_dlc < '9')
188		cf.can_dlc -= '0';
189	else
190		return;
191
192	*(u64 *) (&cf.data) = 0; /* clear payload */
193
194	/* RTR frames may have a dlc > 0 but they never have any data bytes */
195	if (!(cf.can_id & CAN_RTR_FLAG)) {
196		for (i = 0; i < cf.can_dlc; i++) {
197			tmp = hex_to_bin(*cmd++);
198			if (tmp < 0)
199				return;
200			cf.data[i] = (tmp << 4);
201			tmp = hex_to_bin(*cmd++);
202			if (tmp < 0)
203				return;
204			cf.data[i] |= tmp;
205		}
206	}
207
208	skb = dev_alloc_skb(sizeof(struct can_frame) +
209			    sizeof(struct can_skb_priv));
210	if (!skb)
211		return;
212
213	skb->dev = sl->dev;
214	skb->protocol = htons(ETH_P_CAN);
215	skb->pkt_type = PACKET_BROADCAST;
216	skb->ip_summed = CHECKSUM_UNNECESSARY;
217
218	can_skb_reserve(skb);
219	can_skb_prv(skb)->ifindex = sl->dev->ifindex;
220
221	memcpy(skb_put(skb, sizeof(struct can_frame)),
222	       &cf, sizeof(struct can_frame));
223	netif_rx_ni(skb);
224
225	sl->dev->stats.rx_packets++;
226	sl->dev->stats.rx_bytes += cf.can_dlc;
227}
228
229/* parse tty input stream */
230static void slcan_unesc(struct slcan *sl, unsigned char s)
231{
232	if ((s == '\r') || (s == '\a')) { /* CR or BEL ends the pdu */
233		if (!test_and_clear_bit(SLF_ERROR, &sl->flags) &&
234		    (sl->rcount > 4))  {
235			slc_bump(sl);
236		}
237		sl->rcount = 0;
238	} else {
239		if (!test_bit(SLF_ERROR, &sl->flags))  {
240			if (sl->rcount < SLC_MTU)  {
241				sl->rbuff[sl->rcount++] = s;
242				return;
243			} else {
244				sl->dev->stats.rx_over_errors++;
245				set_bit(SLF_ERROR, &sl->flags);
246			}
247		}
248	}
249}
250
251 /************************************************************************
252  *			STANDARD SLCAN ENCAPSULATION			 *
253  ************************************************************************/
254
255/* Encapsulate one can_frame and stuff into a TTY queue. */
256static void slc_encaps(struct slcan *sl, struct can_frame *cf)
257{
258	int actual, i;
259	unsigned char *pos;
260	unsigned char *endpos;
261	canid_t id = cf->can_id;
262
263	pos = sl->xbuff;
264
265	if (cf->can_id & CAN_RTR_FLAG)
266		*pos = 'R'; /* becomes 'r' in standard frame format (SFF) */
267	else
268		*pos = 'T'; /* becomes 't' in standard frame format (SSF) */
269
270	/* determine number of chars for the CAN-identifier */
271	if (cf->can_id & CAN_EFF_FLAG) {
272		id &= CAN_EFF_MASK;
273		endpos = pos + SLC_EFF_ID_LEN;
274	} else {
275		*pos |= 0x20; /* convert R/T to lower case for SFF */
276		id &= CAN_SFF_MASK;
277		endpos = pos + SLC_SFF_ID_LEN;
278	}
279
280	/* build 3 (SFF) or 8 (EFF) digit CAN identifier */
281	pos++;
282	while (endpos >= pos) {
283		*endpos-- = hex_asc_upper[id & 0xf];
284		id >>= 4;
285	}
286
287	pos += (cf->can_id & CAN_EFF_FLAG) ? SLC_EFF_ID_LEN : SLC_SFF_ID_LEN;
288
289	*pos++ = cf->can_dlc + '0';
290
291	/* RTR frames may have a dlc > 0 but they never have any data bytes */
292	if (!(cf->can_id & CAN_RTR_FLAG)) {
293		for (i = 0; i < cf->can_dlc; i++)
294			pos = hex_byte_pack_upper(pos, cf->data[i]);
295	}
296
297	*pos++ = '\r';
298
299	/* Order of next two lines is *very* important.
300	 * When we are sending a little amount of data,
301	 * the transfer may be completed inside the ops->write()
302	 * routine, because it's running with interrupts enabled.
303	 * In this case we *never* got WRITE_WAKEUP event,
304	 * if we did not request it before write operation.
305	 *       14 Oct 1994  Dmitry Gorodchanin.
306	 */
307	set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
308	actual = sl->tty->ops->write(sl->tty, sl->xbuff, pos - sl->xbuff);
309	sl->xleft = (pos - sl->xbuff) - actual;
310	sl->xhead = sl->xbuff + actual;
311	sl->dev->stats.tx_bytes += cf->can_dlc;
312}
313
314/* Write out any remaining transmit buffer. Scheduled when tty is writable */
315static void slcan_transmit(struct work_struct *work)
316{
317	struct slcan *sl = container_of(work, struct slcan, tx_work);
318	int actual;
319
320	spin_lock_bh(&sl->lock);
321	/* First make sure we're connected. */
322	if (!sl->tty || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev)) {
323		spin_unlock_bh(&sl->lock);
324		return;
325	}
326
327	if (sl->xleft <= 0)  {
328		/* Now serial buffer is almost free & we can start
329		 * transmission of another packet */
330		sl->dev->stats.tx_packets++;
331		clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
332		spin_unlock_bh(&sl->lock);
333		netif_wake_queue(sl->dev);
334		return;
335	}
336
337	actual = sl->tty->ops->write(sl->tty, sl->xhead, sl->xleft);
338	sl->xleft -= actual;
339	sl->xhead += actual;
340	spin_unlock_bh(&sl->lock);
341}
342
343/*
344 * Called by the driver when there's room for more data.
345 * Schedule the transmit.
346 */
347static void slcan_write_wakeup(struct tty_struct *tty)
348{
349	struct slcan *sl = tty->disc_data;
350
351	schedule_work(&sl->tx_work);
352}
353
354/* Send a can_frame to a TTY queue. */
355static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev)
356{
357	struct slcan *sl = netdev_priv(dev);
358
359	if (skb->len != sizeof(struct can_frame))
360		goto out;
361
362	spin_lock(&sl->lock);
363	if (!netif_running(dev))  {
364		spin_unlock(&sl->lock);
365		printk(KERN_WARNING "%s: xmit: iface is down\n", dev->name);
366		goto out;
367	}
368	if (sl->tty == NULL) {
369		spin_unlock(&sl->lock);
370		goto out;
371	}
372
373	netif_stop_queue(sl->dev);
374	slc_encaps(sl, (struct can_frame *) skb->data); /* encaps & send */
375	spin_unlock(&sl->lock);
376
377out:
378	kfree_skb(skb);
379	return NETDEV_TX_OK;
380}
381
382
383/******************************************
384 *   Routines looking at netdevice side.
385 ******************************************/
386
387/* Netdevice UP -> DOWN routine */
388static int slc_close(struct net_device *dev)
389{
390	struct slcan *sl = netdev_priv(dev);
391
392	spin_lock_bh(&sl->lock);
393	if (sl->tty) {
394		/* TTY discipline is running. */
395		clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags);
396	}
397	netif_stop_queue(dev);
398	sl->rcount   = 0;
399	sl->xleft    = 0;
400	spin_unlock_bh(&sl->lock);
401
402	return 0;
403}
404
405/* Netdevice DOWN -> UP routine */
406static int slc_open(struct net_device *dev)
407{
408	struct slcan *sl = netdev_priv(dev);
409
410	if (sl->tty == NULL)
411		return -ENODEV;
412
413	sl->flags &= (1 << SLF_INUSE);
414	netif_start_queue(dev);
415	return 0;
416}
417
418/* Hook the destructor so we can free slcan devs at the right point in time */
419static void slc_free_netdev(struct net_device *dev)
420{
421	int i = dev->base_addr;
422	free_netdev(dev);
423	slcan_devs[i] = NULL;
424}
425
426static int slcan_change_mtu(struct net_device *dev, int new_mtu)
427{
428	return -EINVAL;
429}
430
431static const struct net_device_ops slc_netdev_ops = {
432	.ndo_open               = slc_open,
433	.ndo_stop               = slc_close,
434	.ndo_start_xmit         = slc_xmit,
435	.ndo_change_mtu         = slcan_change_mtu,
436};
437
438static void slc_setup(struct net_device *dev)
439{
440	dev->netdev_ops		= &slc_netdev_ops;
441	dev->destructor		= slc_free_netdev;
442
443	dev->hard_header_len	= 0;
444	dev->addr_len		= 0;
445	dev->tx_queue_len	= 10;
446
447	dev->mtu		= sizeof(struct can_frame);
448	dev->type		= ARPHRD_CAN;
449
450	/* New-style flags. */
451	dev->flags		= IFF_NOARP;
452	dev->features           = NETIF_F_HW_CSUM;
453}
454
455/******************************************
456  Routines looking at TTY side.
457 ******************************************/
458
459/*
460 * Handle the 'receiver data ready' interrupt.
461 * This function is called by the 'tty_io' module in the kernel when
462 * a block of SLCAN data has been received, which can now be decapsulated
463 * and sent on to some IP layer for further processing. This will not
464 * be re-entered while running but other ldisc functions may be called
465 * in parallel
466 */
467
468static void slcan_receive_buf(struct tty_struct *tty,
469			      const unsigned char *cp, char *fp, int count)
470{
471	struct slcan *sl = (struct slcan *) tty->disc_data;
472
473	if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev))
474		return;
475
476	/* Read the characters out of the buffer */
477	while (count--) {
478		if (fp && *fp++) {
479			if (!test_and_set_bit(SLF_ERROR, &sl->flags))
480				sl->dev->stats.rx_errors++;
481			cp++;
482			continue;
483		}
484		slcan_unesc(sl, *cp++);
485	}
486}
487
488/************************************
489 *  slcan_open helper routines.
490 ************************************/
491
492/* Collect hanged up channels */
493static void slc_sync(void)
494{
495	int i;
496	struct net_device *dev;
497	struct slcan	  *sl;
498
499	for (i = 0; i < maxdev; i++) {
500		dev = slcan_devs[i];
501		if (dev == NULL)
502			break;
503
504		sl = netdev_priv(dev);
505		if (sl->tty)
506			continue;
507		if (dev->flags & IFF_UP)
508			dev_close(dev);
509	}
510}
511
512/* Find a free SLCAN channel, and link in this `tty' line. */
513static struct slcan *slc_alloc(dev_t line)
514{
515	int i;
516	char name[IFNAMSIZ];
517	struct net_device *dev = NULL;
518	struct slcan       *sl;
519
520	for (i = 0; i < maxdev; i++) {
521		dev = slcan_devs[i];
522		if (dev == NULL)
523			break;
524
525	}
526
527	/* Sorry, too many, all slots in use */
528	if (i >= maxdev)
529		return NULL;
530
531	sprintf(name, "slcan%d", i);
532	dev = alloc_netdev(sizeof(*sl), name, slc_setup);
533	if (!dev)
534		return NULL;
535
536	dev->base_addr  = i;
537	sl = netdev_priv(dev);
538
539	/* Initialize channel control data */
540	sl->magic = SLCAN_MAGIC;
541	sl->dev	= dev;
542	spin_lock_init(&sl->lock);
543	INIT_WORK(&sl->tx_work, slcan_transmit);
544	slcan_devs[i] = dev;
545
546	return sl;
547}
548
549/*
550 * Open the high-level part of the SLCAN channel.
551 * This function is called by the TTY module when the
552 * SLCAN line discipline is called for.  Because we are
553 * sure the tty line exists, we only have to link it to
554 * a free SLCAN channel...
555 *
556 * Called in process context serialized from other ldisc calls.
557 */
558
559static int slcan_open(struct tty_struct *tty)
560{
561	struct slcan *sl;
562	int err;
563
564	if (!capable(CAP_NET_ADMIN))
565		return -EPERM;
566
567	if (tty->ops->write == NULL)
568		return -EOPNOTSUPP;
569
570	/* RTnetlink lock is misused here to serialize concurrent
571	   opens of slcan channels. There are better ways, but it is
572	   the simplest one.
573	 */
574	rtnl_lock();
575
576	/* Collect hanged up channels. */
577	slc_sync();
578
579	sl = tty->disc_data;
580
581	err = -EEXIST;
582	/* First make sure we're not already connected. */
583	if (sl && sl->magic == SLCAN_MAGIC)
584		goto err_exit;
585
586	/* OK.  Find a free SLCAN channel to use. */
587	err = -ENFILE;
588	sl = slc_alloc(tty_devnum(tty));
589	if (sl == NULL)
590		goto err_exit;
591
592	sl->tty = tty;
593	tty->disc_data = sl;
594
595	if (!test_bit(SLF_INUSE, &sl->flags)) {
596		/* Perform the low-level SLCAN initialization. */
597		sl->rcount   = 0;
598		sl->xleft    = 0;
599
600		set_bit(SLF_INUSE, &sl->flags);
601
602		err = register_netdevice(sl->dev);
603		if (err)
604			goto err_free_chan;
605	}
606
607	/* Done.  We have linked the TTY line to a channel. */
608	rtnl_unlock();
609	tty->receive_room = 65536;	/* We don't flow control */
610
611	/* TTY layer expects 0 on success */
612	return 0;
613
614err_free_chan:
615	sl->tty = NULL;
616	tty->disc_data = NULL;
617	clear_bit(SLF_INUSE, &sl->flags);
618
619err_exit:
620	rtnl_unlock();
621
622	/* Count references from TTY module */
623	return err;
624}
625
626/*
627 * Close down a SLCAN channel.
628 * This means flushing out any pending queues, and then returning. This
629 * call is serialized against other ldisc functions.
630 *
631 * We also use this method for a hangup event.
632 */
633
634static void slcan_close(struct tty_struct *tty)
635{
636	struct slcan *sl = (struct slcan *) tty->disc_data;
637
638	/* First make sure we're connected. */
639	if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty)
640		return;
641
642	spin_lock_bh(&sl->lock);
643	tty->disc_data = NULL;
644	sl->tty = NULL;
645	spin_unlock_bh(&sl->lock);
646
647	flush_work(&sl->tx_work);
648
649	/* Flush network side */
650	unregister_netdev(sl->dev);
651	/* This will complete via sl_free_netdev */
652}
653
654static int slcan_hangup(struct tty_struct *tty)
655{
656	slcan_close(tty);
657	return 0;
658}
659
660/* Perform I/O control on an active SLCAN channel. */
661static int slcan_ioctl(struct tty_struct *tty, struct file *file,
662		       unsigned int cmd, unsigned long arg)
663{
664	struct slcan *sl = (struct slcan *) tty->disc_data;
665	unsigned int tmp;
666
667	/* First make sure we're connected. */
668	if (!sl || sl->magic != SLCAN_MAGIC)
669		return -EINVAL;
670
671	switch (cmd) {
672	case SIOCGIFNAME:
673		tmp = strlen(sl->dev->name) + 1;
674		if (copy_to_user((void __user *)arg, sl->dev->name, tmp))
675			return -EFAULT;
676		return 0;
677
678	case SIOCSIFHWADDR:
679		return -EINVAL;
680
681	default:
682		return tty_mode_ioctl(tty, file, cmd, arg);
683	}
684}
685
686static struct tty_ldisc_ops slc_ldisc = {
687	.owner		= THIS_MODULE,
688	.magic		= TTY_LDISC_MAGIC,
689	.name		= "slcan",
690	.open		= slcan_open,
691	.close		= slcan_close,
692	.hangup		= slcan_hangup,
693	.ioctl		= slcan_ioctl,
694	.receive_buf	= slcan_receive_buf,
695	.write_wakeup	= slcan_write_wakeup,
696};
697
698static int __init slcan_init(void)
699{
700	int status;
701
702	if (maxdev < 4)
703		maxdev = 4; /* Sanity */
704
705	printk(banner);
706	printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev);
707
708	slcan_devs = kzalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
709	if (!slcan_devs)
710		return -ENOMEM;
711
712	/* Fill in our line protocol discipline, and register it */
713	status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
714	if (status)  {
715		printk(KERN_ERR "slcan: can't register line discipline\n");
716		kfree(slcan_devs);
717	}
718	return status;
719}
720
721static void __exit slcan_exit(void)
722{
723	int i;
724	struct net_device *dev;
725	struct slcan *sl;
726	unsigned long timeout = jiffies + HZ;
727	int busy = 0;
728
729	if (slcan_devs == NULL)
730		return;
731
732	/* First of all: check for active disciplines and hangup them.
733	 */
734	do {
735		if (busy)
736			msleep_interruptible(100);
737
738		busy = 0;
739		for (i = 0; i < maxdev; i++) {
740			dev = slcan_devs[i];
741			if (!dev)
742				continue;
743			sl = netdev_priv(dev);
744			spin_lock_bh(&sl->lock);
745			if (sl->tty) {
746				busy++;
747				tty_hangup(sl->tty);
748			}
749			spin_unlock_bh(&sl->lock);
750		}
751	} while (busy && time_before(jiffies, timeout));
752
753	/* FIXME: hangup is async so we should wait when doing this second
754	   phase */
755
756	for (i = 0; i < maxdev; i++) {
757		dev = slcan_devs[i];
758		if (!dev)
759			continue;
760		slcan_devs[i] = NULL;
761
762		sl = netdev_priv(dev);
763		if (sl->tty) {
764			printk(KERN_ERR "%s: tty discipline still running\n",
765			       dev->name);
766			/* Intentionally leak the control block. */
767			dev->destructor = NULL;
768		}
769
770		unregister_netdev(dev);
771	}
772
773	kfree(slcan_devs);
774	slcan_devs = NULL;
775
776	i = tty_unregister_ldisc(N_SLCAN);
777	if (i)
778		printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
779}
780
781module_init(slcan_init);
782module_exit(slcan_exit);
783