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