198b12064SDario Binacchi /* 298b12064SDario Binacchi * slcan.c - serial line CAN interface driver (using tty line discipline) 398b12064SDario Binacchi * 498b12064SDario Binacchi * This file is derived from linux/drivers/net/slip/slip.c 598b12064SDario Binacchi * 698b12064SDario Binacchi * slip.c Authors : Laurence Culhane <loz@holmes.demon.co.uk> 798b12064SDario Binacchi * Fred N. van Kempen <waltje@uwalt.nl.mugnet.org> 898b12064SDario Binacchi * slcan.c Author : Oliver Hartkopp <socketcan@hartkopp.net> 998b12064SDario Binacchi * 1098b12064SDario Binacchi * This program is free software; you can redistribute it and/or modify it 1198b12064SDario Binacchi * under the terms of the GNU General Public License as published by the 1298b12064SDario Binacchi * Free Software Foundation; either version 2 of the License, or (at your 1398b12064SDario Binacchi * option) any later version. 1498b12064SDario Binacchi * 1598b12064SDario Binacchi * This program is distributed in the hope that it will be useful, but 1698b12064SDario Binacchi * WITHOUT ANY WARRANTY; without even the implied warranty of 1798b12064SDario Binacchi * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 1898b12064SDario Binacchi * General Public License for more details. 1998b12064SDario Binacchi * 2098b12064SDario Binacchi * You should have received a copy of the GNU General Public License along 2198b12064SDario Binacchi * with this program; if not, see http://www.gnu.org/licenses/gpl.html 2298b12064SDario Binacchi * 2398b12064SDario Binacchi * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 2498b12064SDario Binacchi * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2598b12064SDario Binacchi * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2698b12064SDario Binacchi * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2798b12064SDario Binacchi * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2898b12064SDario Binacchi * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2998b12064SDario Binacchi * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 3098b12064SDario Binacchi * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 3198b12064SDario Binacchi * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 3298b12064SDario Binacchi * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 3398b12064SDario Binacchi * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 3498b12064SDario Binacchi * DAMAGE. 3598b12064SDario Binacchi * 3698b12064SDario Binacchi */ 3798b12064SDario Binacchi 3898b12064SDario Binacchi #include <linux/module.h> 3998b12064SDario Binacchi #include <linux/moduleparam.h> 4098b12064SDario Binacchi 4198b12064SDario Binacchi #include <linux/uaccess.h> 4298b12064SDario Binacchi #include <linux/bitops.h> 4398b12064SDario Binacchi #include <linux/string.h> 4498b12064SDario Binacchi #include <linux/tty.h> 4598b12064SDario Binacchi #include <linux/errno.h> 4698b12064SDario Binacchi #include <linux/netdevice.h> 4798b12064SDario Binacchi #include <linux/skbuff.h> 4898b12064SDario Binacchi #include <linux/rtnetlink.h> 4998b12064SDario Binacchi #include <linux/if_arp.h> 5098b12064SDario Binacchi #include <linux/if_ether.h> 5198b12064SDario Binacchi #include <linux/sched.h> 5298b12064SDario Binacchi #include <linux/delay.h> 5398b12064SDario Binacchi #include <linux/init.h> 5498b12064SDario Binacchi #include <linux/kernel.h> 5598b12064SDario Binacchi #include <linux/workqueue.h> 5698b12064SDario Binacchi #include <linux/can.h> 5798b12064SDario Binacchi #include <linux/can/dev.h> 5898b12064SDario Binacchi #include <linux/can/skb.h> 5998b12064SDario Binacchi 604de0e8efSDario Binacchi #include "slcan.h" 614de0e8efSDario Binacchi 6298b12064SDario Binacchi MODULE_ALIAS_LDISC(N_SLCAN); 6398b12064SDario Binacchi MODULE_DESCRIPTION("serial line CAN interface"); 6498b12064SDario Binacchi MODULE_LICENSE("GPL"); 6598b12064SDario Binacchi MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>"); 6698b12064SDario Binacchi 6798b12064SDario Binacchi #define SLCAN_MAGIC 0x53CA 6898b12064SDario Binacchi 6998b12064SDario Binacchi static int maxdev = 10; /* MAX number of SLCAN channels; 7098b12064SDario Binacchi This can be overridden with 7198b12064SDario Binacchi insmod slcan.ko maxdev=nnn */ 7298b12064SDario Binacchi module_param(maxdev, int, 0); 7398b12064SDario Binacchi MODULE_PARM_DESC(maxdev, "Maximum number of slcan interfaces"); 7498b12064SDario Binacchi 7598b12064SDario Binacchi /* maximum rx buffer len: extended CAN frame with timestamp */ 7698b12064SDario Binacchi #define SLC_MTU (sizeof("T1111222281122334455667788EA5F\r")+1) 7798b12064SDario Binacchi 7898b12064SDario Binacchi #define SLC_CMD_LEN 1 7998b12064SDario Binacchi #define SLC_SFF_ID_LEN 3 8098b12064SDario Binacchi #define SLC_EFF_ID_LEN 8 8198b12064SDario Binacchi 8298b12064SDario Binacchi struct slcan { 8398b12064SDario Binacchi struct can_priv can; 8498b12064SDario Binacchi int magic; 8598b12064SDario Binacchi 8698b12064SDario Binacchi /* Various fields. */ 8798b12064SDario Binacchi struct tty_struct *tty; /* ptr to TTY structure */ 8898b12064SDario Binacchi struct net_device *dev; /* easy for intr handling */ 8998b12064SDario Binacchi spinlock_t lock; 9098b12064SDario Binacchi struct work_struct tx_work; /* Flushes transmit buffer */ 9198b12064SDario Binacchi 9298b12064SDario Binacchi /* These are pointers to the malloc()ed frame buffers. */ 9398b12064SDario Binacchi unsigned char rbuff[SLC_MTU]; /* receiver buffer */ 9498b12064SDario Binacchi int rcount; /* received chars counter */ 9598b12064SDario Binacchi unsigned char xbuff[SLC_MTU]; /* transmitter buffer */ 9698b12064SDario Binacchi unsigned char *xhead; /* pointer to next XMIT byte */ 9798b12064SDario Binacchi int xleft; /* bytes left in XMIT queue */ 9898b12064SDario Binacchi 9998b12064SDario Binacchi unsigned long flags; /* Flag values/ mode etc */ 10098b12064SDario Binacchi #define SLF_INUSE 0 /* Channel in use */ 10198b12064SDario Binacchi #define SLF_ERROR 1 /* Parity, etc. error */ 10298b12064SDario Binacchi #define SLF_XCMD 2 /* Command transmission */ 1034de0e8efSDario Binacchi unsigned long cmd_flags; /* Command flags */ 1044de0e8efSDario Binacchi #define CF_ERR_RST 0 /* Reset errors on open */ 10598b12064SDario Binacchi wait_queue_head_t xcmd_wait; /* Wait queue for commands */ 10698b12064SDario Binacchi /* transmission */ 10798b12064SDario Binacchi }; 10898b12064SDario Binacchi 10998b12064SDario Binacchi static struct net_device **slcan_devs; 11098b12064SDario Binacchi 11198b12064SDario Binacchi static const u32 slcan_bitrate_const[] = { 11298b12064SDario Binacchi 10000, 20000, 50000, 100000, 125000, 11398b12064SDario Binacchi 250000, 500000, 800000, 1000000 11498b12064SDario Binacchi }; 11598b12064SDario Binacchi 1164de0e8efSDario Binacchi bool slcan_err_rst_on_open(struct net_device *ndev) 1174de0e8efSDario Binacchi { 1184de0e8efSDario Binacchi struct slcan *sl = netdev_priv(ndev); 1194de0e8efSDario Binacchi 1204de0e8efSDario Binacchi return !!test_bit(CF_ERR_RST, &sl->cmd_flags); 1214de0e8efSDario Binacchi } 1224de0e8efSDario Binacchi 1234de0e8efSDario Binacchi int slcan_enable_err_rst_on_open(struct net_device *ndev, bool on) 1244de0e8efSDario Binacchi { 1254de0e8efSDario Binacchi struct slcan *sl = netdev_priv(ndev); 1264de0e8efSDario Binacchi 1274de0e8efSDario Binacchi if (netif_running(ndev)) 1284de0e8efSDario Binacchi return -EBUSY; 1294de0e8efSDario Binacchi 1304de0e8efSDario Binacchi if (on) 1314de0e8efSDario Binacchi set_bit(CF_ERR_RST, &sl->cmd_flags); 1324de0e8efSDario Binacchi else 1334de0e8efSDario Binacchi clear_bit(CF_ERR_RST, &sl->cmd_flags); 1344de0e8efSDario Binacchi 1354de0e8efSDario Binacchi return 0; 1364de0e8efSDario Binacchi } 1374de0e8efSDario Binacchi 13898b12064SDario Binacchi /************************************************************************ 13998b12064SDario Binacchi * SLCAN ENCAPSULATION FORMAT * 14098b12064SDario Binacchi ************************************************************************/ 14198b12064SDario Binacchi 14298b12064SDario Binacchi /* 14398b12064SDario Binacchi * A CAN frame has a can_id (11 bit standard frame format OR 29 bit extended 14498b12064SDario Binacchi * frame format) a data length code (len) which can be from 0 to 8 14598b12064SDario Binacchi * and up to <len> data bytes as payload. 14698b12064SDario Binacchi * Additionally a CAN frame may become a remote transmission frame if the 14798b12064SDario Binacchi * RTR-bit is set. This causes another ECU to send a CAN frame with the 14898b12064SDario Binacchi * given can_id. 14998b12064SDario Binacchi * 15098b12064SDario Binacchi * The SLCAN ASCII representation of these different frame types is: 15198b12064SDario Binacchi * <type> <id> <dlc> <data>* 15298b12064SDario Binacchi * 15398b12064SDario Binacchi * Extended frames (29 bit) are defined by capital characters in the type. 15498b12064SDario Binacchi * RTR frames are defined as 'r' types - normal frames have 't' type: 15598b12064SDario Binacchi * t => 11 bit data frame 15698b12064SDario Binacchi * r => 11 bit RTR frame 15798b12064SDario Binacchi * T => 29 bit data frame 15898b12064SDario Binacchi * R => 29 bit RTR frame 15998b12064SDario Binacchi * 16098b12064SDario Binacchi * The <id> is 3 (standard) or 8 (extended) bytes in ASCII Hex (base64). 16198b12064SDario Binacchi * The <dlc> is a one byte ASCII number ('0' - '8') 16298b12064SDario Binacchi * The <data> section has at much ASCII Hex bytes as defined by the <dlc> 16398b12064SDario Binacchi * 16498b12064SDario Binacchi * Examples: 16598b12064SDario Binacchi * 16698b12064SDario Binacchi * t1230 : can_id 0x123, len 0, no data 16798b12064SDario Binacchi * t4563112233 : can_id 0x456, len 3, data 0x11 0x22 0x33 16898b12064SDario Binacchi * T12ABCDEF2AA55 : extended can_id 0x12ABCDEF, len 2, data 0xAA 0x55 16998b12064SDario Binacchi * r1230 : can_id 0x123, len 0, no data, remote transmission request 17098b12064SDario Binacchi * 17198b12064SDario Binacchi */ 17298b12064SDario Binacchi 17398b12064SDario Binacchi /************************************************************************ 17498b12064SDario Binacchi * STANDARD SLCAN DECAPSULATION * 17598b12064SDario Binacchi ************************************************************************/ 17698b12064SDario Binacchi 17798b12064SDario Binacchi /* Send one completely decapsulated can_frame to the network layer */ 178*b32ff466SDario Binacchi static void slc_bump_frame(struct slcan *sl) 17998b12064SDario Binacchi { 18098b12064SDario Binacchi struct sk_buff *skb; 18198b12064SDario Binacchi struct can_frame *cf; 18298b12064SDario Binacchi int i, tmp; 18398b12064SDario Binacchi u32 tmpid; 18498b12064SDario Binacchi char *cmd = sl->rbuff; 18598b12064SDario Binacchi 18698b12064SDario Binacchi skb = alloc_can_skb(sl->dev, &cf); 18798b12064SDario Binacchi if (unlikely(!skb)) { 18898b12064SDario Binacchi sl->dev->stats.rx_dropped++; 18998b12064SDario Binacchi return; 19098b12064SDario Binacchi } 19198b12064SDario Binacchi 19298b12064SDario Binacchi switch (*cmd) { 19398b12064SDario Binacchi case 'r': 19498b12064SDario Binacchi cf->can_id = CAN_RTR_FLAG; 19598b12064SDario Binacchi fallthrough; 19698b12064SDario Binacchi case 't': 19798b12064SDario Binacchi /* store dlc ASCII value and terminate SFF CAN ID string */ 19898b12064SDario Binacchi cf->len = sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN]; 19998b12064SDario Binacchi sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN] = 0; 20098b12064SDario Binacchi /* point to payload data behind the dlc */ 20198b12064SDario Binacchi cmd += SLC_CMD_LEN + SLC_SFF_ID_LEN + 1; 20298b12064SDario Binacchi break; 20398b12064SDario Binacchi case 'R': 20498b12064SDario Binacchi cf->can_id = CAN_RTR_FLAG; 20598b12064SDario Binacchi fallthrough; 20698b12064SDario Binacchi case 'T': 20798b12064SDario Binacchi cf->can_id |= CAN_EFF_FLAG; 20898b12064SDario Binacchi /* store dlc ASCII value and terminate EFF CAN ID string */ 20998b12064SDario Binacchi cf->len = sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN]; 21098b12064SDario Binacchi sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN] = 0; 21198b12064SDario Binacchi /* point to payload data behind the dlc */ 21298b12064SDario Binacchi cmd += SLC_CMD_LEN + SLC_EFF_ID_LEN + 1; 21398b12064SDario Binacchi break; 21498b12064SDario Binacchi default: 21598b12064SDario Binacchi goto decode_failed; 21698b12064SDario Binacchi } 21798b12064SDario Binacchi 21898b12064SDario Binacchi if (kstrtou32(sl->rbuff + SLC_CMD_LEN, 16, &tmpid)) 21998b12064SDario Binacchi goto decode_failed; 22098b12064SDario Binacchi 22198b12064SDario Binacchi cf->can_id |= tmpid; 22298b12064SDario Binacchi 22398b12064SDario Binacchi /* get len from sanitized ASCII value */ 22498b12064SDario Binacchi if (cf->len >= '0' && cf->len < '9') 22598b12064SDario Binacchi cf->len -= '0'; 22698b12064SDario Binacchi else 22798b12064SDario Binacchi goto decode_failed; 22898b12064SDario Binacchi 22998b12064SDario Binacchi /* RTR frames may have a dlc > 0 but they never have any data bytes */ 23098b12064SDario Binacchi if (!(cf->can_id & CAN_RTR_FLAG)) { 23198b12064SDario Binacchi for (i = 0; i < cf->len; i++) { 23298b12064SDario Binacchi tmp = hex_to_bin(*cmd++); 23398b12064SDario Binacchi if (tmp < 0) 23498b12064SDario Binacchi goto decode_failed; 23598b12064SDario Binacchi 23698b12064SDario Binacchi cf->data[i] = (tmp << 4); 23798b12064SDario Binacchi tmp = hex_to_bin(*cmd++); 23898b12064SDario Binacchi if (tmp < 0) 23998b12064SDario Binacchi goto decode_failed; 24098b12064SDario Binacchi 24198b12064SDario Binacchi cf->data[i] |= tmp; 24298b12064SDario Binacchi } 24398b12064SDario Binacchi } 24498b12064SDario Binacchi 24598b12064SDario Binacchi sl->dev->stats.rx_packets++; 24698b12064SDario Binacchi if (!(cf->can_id & CAN_RTR_FLAG)) 24798b12064SDario Binacchi sl->dev->stats.rx_bytes += cf->len; 24898b12064SDario Binacchi 24998b12064SDario Binacchi netif_rx(skb); 25098b12064SDario Binacchi return; 25198b12064SDario Binacchi 25298b12064SDario Binacchi decode_failed: 25398b12064SDario Binacchi sl->dev->stats.rx_errors++; 25498b12064SDario Binacchi dev_kfree_skb(skb); 25598b12064SDario Binacchi } 25698b12064SDario Binacchi 257*b32ff466SDario Binacchi /* An error frame can contain more than one type of error. 258*b32ff466SDario Binacchi * 259*b32ff466SDario Binacchi * Examples: 260*b32ff466SDario Binacchi * 261*b32ff466SDario Binacchi * e1a : len 1, errors: ACK error 262*b32ff466SDario Binacchi * e3bcO: len 3, errors: Bit0 error, CRC error, Tx overrun error 263*b32ff466SDario Binacchi */ 264*b32ff466SDario Binacchi static void slc_bump_err(struct slcan *sl) 265*b32ff466SDario Binacchi { 266*b32ff466SDario Binacchi struct net_device *dev = sl->dev; 267*b32ff466SDario Binacchi struct sk_buff *skb; 268*b32ff466SDario Binacchi struct can_frame *cf; 269*b32ff466SDario Binacchi char *cmd = sl->rbuff; 270*b32ff466SDario Binacchi bool rx_errors = false, tx_errors = false, rx_over_errors = false; 271*b32ff466SDario Binacchi int i, len; 272*b32ff466SDario Binacchi 273*b32ff466SDario Binacchi /* get len from sanitized ASCII value */ 274*b32ff466SDario Binacchi len = cmd[1]; 275*b32ff466SDario Binacchi if (len >= '0' && len < '9') 276*b32ff466SDario Binacchi len -= '0'; 277*b32ff466SDario Binacchi else 278*b32ff466SDario Binacchi return; 279*b32ff466SDario Binacchi 280*b32ff466SDario Binacchi if ((len + SLC_CMD_LEN + 1) > sl->rcount) 281*b32ff466SDario Binacchi return; 282*b32ff466SDario Binacchi 283*b32ff466SDario Binacchi skb = alloc_can_err_skb(dev, &cf); 284*b32ff466SDario Binacchi 285*b32ff466SDario Binacchi if (skb) 286*b32ff466SDario Binacchi cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 287*b32ff466SDario Binacchi 288*b32ff466SDario Binacchi cmd += SLC_CMD_LEN + 1; 289*b32ff466SDario Binacchi for (i = 0; i < len; i++, cmd++) { 290*b32ff466SDario Binacchi switch (*cmd) { 291*b32ff466SDario Binacchi case 'a': 292*b32ff466SDario Binacchi netdev_dbg(dev, "ACK error\n"); 293*b32ff466SDario Binacchi tx_errors = true; 294*b32ff466SDario Binacchi if (skb) { 295*b32ff466SDario Binacchi cf->can_id |= CAN_ERR_ACK; 296*b32ff466SDario Binacchi cf->data[3] = CAN_ERR_PROT_LOC_ACK; 297*b32ff466SDario Binacchi } 298*b32ff466SDario Binacchi 299*b32ff466SDario Binacchi break; 300*b32ff466SDario Binacchi case 'b': 301*b32ff466SDario Binacchi netdev_dbg(dev, "Bit0 error\n"); 302*b32ff466SDario Binacchi tx_errors = true; 303*b32ff466SDario Binacchi if (skb) 304*b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_BIT0; 305*b32ff466SDario Binacchi 306*b32ff466SDario Binacchi break; 307*b32ff466SDario Binacchi case 'B': 308*b32ff466SDario Binacchi netdev_dbg(dev, "Bit1 error\n"); 309*b32ff466SDario Binacchi tx_errors = true; 310*b32ff466SDario Binacchi if (skb) 311*b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_BIT1; 312*b32ff466SDario Binacchi 313*b32ff466SDario Binacchi break; 314*b32ff466SDario Binacchi case 'c': 315*b32ff466SDario Binacchi netdev_dbg(dev, "CRC error\n"); 316*b32ff466SDario Binacchi rx_errors = true; 317*b32ff466SDario Binacchi if (skb) { 318*b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_BIT; 319*b32ff466SDario Binacchi cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 320*b32ff466SDario Binacchi } 321*b32ff466SDario Binacchi 322*b32ff466SDario Binacchi break; 323*b32ff466SDario Binacchi case 'f': 324*b32ff466SDario Binacchi netdev_dbg(dev, "Form Error\n"); 325*b32ff466SDario Binacchi rx_errors = true; 326*b32ff466SDario Binacchi if (skb) 327*b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_FORM; 328*b32ff466SDario Binacchi 329*b32ff466SDario Binacchi break; 330*b32ff466SDario Binacchi case 'o': 331*b32ff466SDario Binacchi netdev_dbg(dev, "Rx overrun error\n"); 332*b32ff466SDario Binacchi rx_over_errors = true; 333*b32ff466SDario Binacchi rx_errors = true; 334*b32ff466SDario Binacchi if (skb) { 335*b32ff466SDario Binacchi cf->can_id |= CAN_ERR_CRTL; 336*b32ff466SDario Binacchi cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 337*b32ff466SDario Binacchi } 338*b32ff466SDario Binacchi 339*b32ff466SDario Binacchi break; 340*b32ff466SDario Binacchi case 'O': 341*b32ff466SDario Binacchi netdev_dbg(dev, "Tx overrun error\n"); 342*b32ff466SDario Binacchi tx_errors = true; 343*b32ff466SDario Binacchi if (skb) { 344*b32ff466SDario Binacchi cf->can_id |= CAN_ERR_CRTL; 345*b32ff466SDario Binacchi cf->data[1] = CAN_ERR_CRTL_TX_OVERFLOW; 346*b32ff466SDario Binacchi } 347*b32ff466SDario Binacchi 348*b32ff466SDario Binacchi break; 349*b32ff466SDario Binacchi case 's': 350*b32ff466SDario Binacchi netdev_dbg(dev, "Stuff error\n"); 351*b32ff466SDario Binacchi rx_errors = true; 352*b32ff466SDario Binacchi if (skb) 353*b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_STUFF; 354*b32ff466SDario Binacchi 355*b32ff466SDario Binacchi break; 356*b32ff466SDario Binacchi default: 357*b32ff466SDario Binacchi if (skb) 358*b32ff466SDario Binacchi dev_kfree_skb(skb); 359*b32ff466SDario Binacchi 360*b32ff466SDario Binacchi return; 361*b32ff466SDario Binacchi } 362*b32ff466SDario Binacchi } 363*b32ff466SDario Binacchi 364*b32ff466SDario Binacchi if (rx_errors) 365*b32ff466SDario Binacchi dev->stats.rx_errors++; 366*b32ff466SDario Binacchi 367*b32ff466SDario Binacchi if (rx_over_errors) 368*b32ff466SDario Binacchi dev->stats.rx_over_errors++; 369*b32ff466SDario Binacchi 370*b32ff466SDario Binacchi if (tx_errors) 371*b32ff466SDario Binacchi dev->stats.tx_errors++; 372*b32ff466SDario Binacchi 373*b32ff466SDario Binacchi if (skb) 374*b32ff466SDario Binacchi netif_rx(skb); 375*b32ff466SDario Binacchi } 376*b32ff466SDario Binacchi 377*b32ff466SDario Binacchi static void slc_bump(struct slcan *sl) 378*b32ff466SDario Binacchi { 379*b32ff466SDario Binacchi switch (sl->rbuff[0]) { 380*b32ff466SDario Binacchi case 'r': 381*b32ff466SDario Binacchi fallthrough; 382*b32ff466SDario Binacchi case 't': 383*b32ff466SDario Binacchi fallthrough; 384*b32ff466SDario Binacchi case 'R': 385*b32ff466SDario Binacchi fallthrough; 386*b32ff466SDario Binacchi case 'T': 387*b32ff466SDario Binacchi return slc_bump_frame(sl); 388*b32ff466SDario Binacchi case 'e': 389*b32ff466SDario Binacchi return slc_bump_err(sl); 390*b32ff466SDario Binacchi default: 391*b32ff466SDario Binacchi return; 392*b32ff466SDario Binacchi } 393*b32ff466SDario Binacchi } 394*b32ff466SDario Binacchi 39598b12064SDario Binacchi /* parse tty input stream */ 39698b12064SDario Binacchi static void slcan_unesc(struct slcan *sl, unsigned char s) 39798b12064SDario Binacchi { 39898b12064SDario Binacchi if ((s == '\r') || (s == '\a')) { /* CR or BEL ends the pdu */ 39998b12064SDario Binacchi if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && 40098b12064SDario Binacchi (sl->rcount > 4)) { 40198b12064SDario Binacchi slc_bump(sl); 40298b12064SDario Binacchi } 40398b12064SDario Binacchi sl->rcount = 0; 40498b12064SDario Binacchi } else { 40598b12064SDario Binacchi if (!test_bit(SLF_ERROR, &sl->flags)) { 40698b12064SDario Binacchi if (sl->rcount < SLC_MTU) { 40798b12064SDario Binacchi sl->rbuff[sl->rcount++] = s; 40898b12064SDario Binacchi return; 40998b12064SDario Binacchi } else { 41098b12064SDario Binacchi sl->dev->stats.rx_over_errors++; 41198b12064SDario Binacchi set_bit(SLF_ERROR, &sl->flags); 41298b12064SDario Binacchi } 41398b12064SDario Binacchi } 41498b12064SDario Binacchi } 41598b12064SDario Binacchi } 41698b12064SDario Binacchi 41798b12064SDario Binacchi /************************************************************************ 41898b12064SDario Binacchi * STANDARD SLCAN ENCAPSULATION * 41998b12064SDario Binacchi ************************************************************************/ 42098b12064SDario Binacchi 42198b12064SDario Binacchi /* Encapsulate one can_frame and stuff into a TTY queue. */ 42298b12064SDario Binacchi static void slc_encaps(struct slcan *sl, struct can_frame *cf) 42398b12064SDario Binacchi { 42498b12064SDario Binacchi int actual, i; 42598b12064SDario Binacchi unsigned char *pos; 42698b12064SDario Binacchi unsigned char *endpos; 42798b12064SDario Binacchi canid_t id = cf->can_id; 42898b12064SDario Binacchi 42998b12064SDario Binacchi pos = sl->xbuff; 43098b12064SDario Binacchi 43198b12064SDario Binacchi if (cf->can_id & CAN_RTR_FLAG) 43298b12064SDario Binacchi *pos = 'R'; /* becomes 'r' in standard frame format (SFF) */ 43398b12064SDario Binacchi else 43498b12064SDario Binacchi *pos = 'T'; /* becomes 't' in standard frame format (SSF) */ 43598b12064SDario Binacchi 43698b12064SDario Binacchi /* determine number of chars for the CAN-identifier */ 43798b12064SDario Binacchi if (cf->can_id & CAN_EFF_FLAG) { 43898b12064SDario Binacchi id &= CAN_EFF_MASK; 43998b12064SDario Binacchi endpos = pos + SLC_EFF_ID_LEN; 44098b12064SDario Binacchi } else { 44198b12064SDario Binacchi *pos |= 0x20; /* convert R/T to lower case for SFF */ 44298b12064SDario Binacchi id &= CAN_SFF_MASK; 44398b12064SDario Binacchi endpos = pos + SLC_SFF_ID_LEN; 44498b12064SDario Binacchi } 44598b12064SDario Binacchi 44698b12064SDario Binacchi /* build 3 (SFF) or 8 (EFF) digit CAN identifier */ 44798b12064SDario Binacchi pos++; 44898b12064SDario Binacchi while (endpos >= pos) { 44998b12064SDario Binacchi *endpos-- = hex_asc_upper[id & 0xf]; 45098b12064SDario Binacchi id >>= 4; 45198b12064SDario Binacchi } 45298b12064SDario Binacchi 45398b12064SDario Binacchi pos += (cf->can_id & CAN_EFF_FLAG) ? SLC_EFF_ID_LEN : SLC_SFF_ID_LEN; 45498b12064SDario Binacchi 45598b12064SDario Binacchi *pos++ = cf->len + '0'; 45698b12064SDario Binacchi 45798b12064SDario Binacchi /* RTR frames may have a dlc > 0 but they never have any data bytes */ 45898b12064SDario Binacchi if (!(cf->can_id & CAN_RTR_FLAG)) { 45998b12064SDario Binacchi for (i = 0; i < cf->len; i++) 46098b12064SDario Binacchi pos = hex_byte_pack_upper(pos, cf->data[i]); 46198b12064SDario Binacchi 46298b12064SDario Binacchi sl->dev->stats.tx_bytes += cf->len; 46398b12064SDario Binacchi } 46498b12064SDario Binacchi 46598b12064SDario Binacchi *pos++ = '\r'; 46698b12064SDario Binacchi 46798b12064SDario Binacchi /* Order of next two lines is *very* important. 46898b12064SDario Binacchi * When we are sending a little amount of data, 46998b12064SDario Binacchi * the transfer may be completed inside the ops->write() 47098b12064SDario Binacchi * routine, because it's running with interrupts enabled. 47198b12064SDario Binacchi * In this case we *never* got WRITE_WAKEUP event, 47298b12064SDario Binacchi * if we did not request it before write operation. 47398b12064SDario Binacchi * 14 Oct 1994 Dmitry Gorodchanin. 47498b12064SDario Binacchi */ 47598b12064SDario Binacchi set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 47698b12064SDario Binacchi actual = sl->tty->ops->write(sl->tty, sl->xbuff, pos - sl->xbuff); 47798b12064SDario Binacchi sl->xleft = (pos - sl->xbuff) - actual; 47898b12064SDario Binacchi sl->xhead = sl->xbuff + actual; 47998b12064SDario Binacchi } 48098b12064SDario Binacchi 48198b12064SDario Binacchi /* Write out any remaining transmit buffer. Scheduled when tty is writable */ 48298b12064SDario Binacchi static void slcan_transmit(struct work_struct *work) 48398b12064SDario Binacchi { 48498b12064SDario Binacchi struct slcan *sl = container_of(work, struct slcan, tx_work); 48598b12064SDario Binacchi int actual; 48698b12064SDario Binacchi 48798b12064SDario Binacchi spin_lock_bh(&sl->lock); 48898b12064SDario Binacchi /* First make sure we're connected. */ 48998b12064SDario Binacchi if (!sl->tty || sl->magic != SLCAN_MAGIC || 49098b12064SDario Binacchi (unlikely(!netif_running(sl->dev)) && 49198b12064SDario Binacchi likely(!test_bit(SLF_XCMD, &sl->flags)))) { 49298b12064SDario Binacchi spin_unlock_bh(&sl->lock); 49398b12064SDario Binacchi return; 49498b12064SDario Binacchi } 49598b12064SDario Binacchi 49698b12064SDario Binacchi if (sl->xleft <= 0) { 49798b12064SDario Binacchi if (unlikely(test_bit(SLF_XCMD, &sl->flags))) { 49898b12064SDario Binacchi clear_bit(SLF_XCMD, &sl->flags); 49998b12064SDario Binacchi clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 50098b12064SDario Binacchi spin_unlock_bh(&sl->lock); 50198b12064SDario Binacchi wake_up(&sl->xcmd_wait); 50298b12064SDario Binacchi return; 50398b12064SDario Binacchi } 50498b12064SDario Binacchi 50598b12064SDario Binacchi /* Now serial buffer is almost free & we can start 50698b12064SDario Binacchi * transmission of another packet */ 50798b12064SDario Binacchi sl->dev->stats.tx_packets++; 50898b12064SDario Binacchi clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 50998b12064SDario Binacchi spin_unlock_bh(&sl->lock); 51098b12064SDario Binacchi netif_wake_queue(sl->dev); 51198b12064SDario Binacchi return; 51298b12064SDario Binacchi } 51398b12064SDario Binacchi 51498b12064SDario Binacchi actual = sl->tty->ops->write(sl->tty, sl->xhead, sl->xleft); 51598b12064SDario Binacchi sl->xleft -= actual; 51698b12064SDario Binacchi sl->xhead += actual; 51798b12064SDario Binacchi spin_unlock_bh(&sl->lock); 51898b12064SDario Binacchi } 51998b12064SDario Binacchi 52098b12064SDario Binacchi /* 52198b12064SDario Binacchi * Called by the driver when there's room for more data. 52298b12064SDario Binacchi * Schedule the transmit. 52398b12064SDario Binacchi */ 52498b12064SDario Binacchi static void slcan_write_wakeup(struct tty_struct *tty) 52598b12064SDario Binacchi { 52698b12064SDario Binacchi struct slcan *sl; 52798b12064SDario Binacchi 52898b12064SDario Binacchi rcu_read_lock(); 52998b12064SDario Binacchi sl = rcu_dereference(tty->disc_data); 53098b12064SDario Binacchi if (sl) 53198b12064SDario Binacchi schedule_work(&sl->tx_work); 53298b12064SDario Binacchi rcu_read_unlock(); 53398b12064SDario Binacchi } 53498b12064SDario Binacchi 53598b12064SDario Binacchi /* Send a can_frame to a TTY queue. */ 53698b12064SDario Binacchi static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev) 53798b12064SDario Binacchi { 53898b12064SDario Binacchi struct slcan *sl = netdev_priv(dev); 53998b12064SDario Binacchi 54098b12064SDario Binacchi if (can_dropped_invalid_skb(dev, skb)) 54198b12064SDario Binacchi return NETDEV_TX_OK; 54298b12064SDario Binacchi 54398b12064SDario Binacchi spin_lock(&sl->lock); 54498b12064SDario Binacchi if (!netif_running(dev)) { 54598b12064SDario Binacchi spin_unlock(&sl->lock); 54698b12064SDario Binacchi netdev_warn(dev, "xmit: iface is down\n"); 54798b12064SDario Binacchi goto out; 54898b12064SDario Binacchi } 54998b12064SDario Binacchi if (sl->tty == NULL) { 55098b12064SDario Binacchi spin_unlock(&sl->lock); 55198b12064SDario Binacchi goto out; 55298b12064SDario Binacchi } 55398b12064SDario Binacchi 55498b12064SDario Binacchi netif_stop_queue(sl->dev); 55598b12064SDario Binacchi slc_encaps(sl, (struct can_frame *) skb->data); /* encaps & send */ 55698b12064SDario Binacchi spin_unlock(&sl->lock); 55798b12064SDario Binacchi 55898b12064SDario Binacchi out: 55998b12064SDario Binacchi kfree_skb(skb); 56098b12064SDario Binacchi return NETDEV_TX_OK; 56198b12064SDario Binacchi } 56298b12064SDario Binacchi 56398b12064SDario Binacchi 56498b12064SDario Binacchi /****************************************** 56598b12064SDario Binacchi * Routines looking at netdevice side. 56698b12064SDario Binacchi ******************************************/ 56798b12064SDario Binacchi 56898b12064SDario Binacchi static int slcan_transmit_cmd(struct slcan *sl, const unsigned char *cmd) 56998b12064SDario Binacchi { 57098b12064SDario Binacchi int ret, actual, n; 57198b12064SDario Binacchi 57298b12064SDario Binacchi spin_lock(&sl->lock); 57398b12064SDario Binacchi if (!sl->tty) { 57498b12064SDario Binacchi spin_unlock(&sl->lock); 57598b12064SDario Binacchi return -ENODEV; 57698b12064SDario Binacchi } 57798b12064SDario Binacchi 57898b12064SDario Binacchi n = snprintf(sl->xbuff, sizeof(sl->xbuff), "%s", cmd); 57998b12064SDario Binacchi set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 58098b12064SDario Binacchi actual = sl->tty->ops->write(sl->tty, sl->xbuff, n); 58198b12064SDario Binacchi sl->xleft = n - actual; 58298b12064SDario Binacchi sl->xhead = sl->xbuff + actual; 58398b12064SDario Binacchi set_bit(SLF_XCMD, &sl->flags); 58498b12064SDario Binacchi spin_unlock(&sl->lock); 58598b12064SDario Binacchi ret = wait_event_interruptible_timeout(sl->xcmd_wait, 58698b12064SDario Binacchi !test_bit(SLF_XCMD, &sl->flags), 58798b12064SDario Binacchi HZ); 58898b12064SDario Binacchi clear_bit(SLF_XCMD, &sl->flags); 58998b12064SDario Binacchi if (ret == -ERESTARTSYS) 59098b12064SDario Binacchi return ret; 59198b12064SDario Binacchi 59298b12064SDario Binacchi if (ret == 0) 59398b12064SDario Binacchi return -ETIMEDOUT; 59498b12064SDario Binacchi 59598b12064SDario Binacchi return 0; 59698b12064SDario Binacchi } 59798b12064SDario Binacchi 59898b12064SDario Binacchi /* Netdevice UP -> DOWN routine */ 59998b12064SDario Binacchi static int slc_close(struct net_device *dev) 60098b12064SDario Binacchi { 60198b12064SDario Binacchi struct slcan *sl = netdev_priv(dev); 60298b12064SDario Binacchi int err; 60398b12064SDario Binacchi 60498b12064SDario Binacchi spin_lock_bh(&sl->lock); 60598b12064SDario Binacchi if (sl->tty) { 60698b12064SDario Binacchi if (sl->can.bittiming.bitrate && 60798b12064SDario Binacchi sl->can.bittiming.bitrate != CAN_BITRATE_UNKNOWN) { 60898b12064SDario Binacchi spin_unlock_bh(&sl->lock); 60998b12064SDario Binacchi err = slcan_transmit_cmd(sl, "C\r"); 61098b12064SDario Binacchi spin_lock_bh(&sl->lock); 61198b12064SDario Binacchi if (err) 61298b12064SDario Binacchi netdev_warn(dev, 61398b12064SDario Binacchi "failed to send close command 'C\\r'\n"); 61498b12064SDario Binacchi } 61598b12064SDario Binacchi 61698b12064SDario Binacchi /* TTY discipline is running. */ 61798b12064SDario Binacchi clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 61898b12064SDario Binacchi } 61998b12064SDario Binacchi netif_stop_queue(dev); 62098b12064SDario Binacchi close_candev(dev); 62198b12064SDario Binacchi sl->can.state = CAN_STATE_STOPPED; 62298b12064SDario Binacchi if (sl->can.bittiming.bitrate == CAN_BITRATE_UNKNOWN) 62398b12064SDario Binacchi sl->can.bittiming.bitrate = CAN_BITRATE_UNSET; 62498b12064SDario Binacchi 62598b12064SDario Binacchi sl->rcount = 0; 62698b12064SDario Binacchi sl->xleft = 0; 62798b12064SDario Binacchi spin_unlock_bh(&sl->lock); 62898b12064SDario Binacchi 62998b12064SDario Binacchi return 0; 63098b12064SDario Binacchi } 63198b12064SDario Binacchi 63298b12064SDario Binacchi /* Netdevice DOWN -> UP routine */ 63398b12064SDario Binacchi static int slc_open(struct net_device *dev) 63498b12064SDario Binacchi { 63598b12064SDario Binacchi struct slcan *sl = netdev_priv(dev); 63698b12064SDario Binacchi unsigned char cmd[SLC_MTU]; 63798b12064SDario Binacchi int err, s; 63898b12064SDario Binacchi 63998b12064SDario Binacchi if (sl->tty == NULL) 64098b12064SDario Binacchi return -ENODEV; 64198b12064SDario Binacchi 64298b12064SDario Binacchi /* The baud rate is not set with the command 64398b12064SDario Binacchi * `ip link set <iface> type can bitrate <baud>' and therefore 64498b12064SDario Binacchi * can.bittiming.bitrate is CAN_BITRATE_UNSET (0), causing 64598b12064SDario Binacchi * open_candev() to fail. So let's set to a fake value. 64698b12064SDario Binacchi */ 64798b12064SDario Binacchi if (sl->can.bittiming.bitrate == CAN_BITRATE_UNSET) 64898b12064SDario Binacchi sl->can.bittiming.bitrate = CAN_BITRATE_UNKNOWN; 64998b12064SDario Binacchi 65098b12064SDario Binacchi err = open_candev(dev); 65198b12064SDario Binacchi if (err) { 65298b12064SDario Binacchi netdev_err(dev, "failed to open can device\n"); 65398b12064SDario Binacchi return err; 65498b12064SDario Binacchi } 65598b12064SDario Binacchi 65698b12064SDario Binacchi sl->flags &= BIT(SLF_INUSE); 65798b12064SDario Binacchi 65898b12064SDario Binacchi if (sl->can.bittiming.bitrate != CAN_BITRATE_UNKNOWN) { 65998b12064SDario Binacchi for (s = 0; s < ARRAY_SIZE(slcan_bitrate_const); s++) { 66098b12064SDario Binacchi if (sl->can.bittiming.bitrate == slcan_bitrate_const[s]) 66198b12064SDario Binacchi break; 66298b12064SDario Binacchi } 66398b12064SDario Binacchi 66498b12064SDario Binacchi /* The CAN framework has already validate the bitrate value, 66598b12064SDario Binacchi * so we can avoid to check if `s' has been properly set. 66698b12064SDario Binacchi */ 66798b12064SDario Binacchi 66898b12064SDario Binacchi snprintf(cmd, sizeof(cmd), "C\rS%d\r", s); 66998b12064SDario Binacchi err = slcan_transmit_cmd(sl, cmd); 67098b12064SDario Binacchi if (err) { 67198b12064SDario Binacchi netdev_err(dev, 67298b12064SDario Binacchi "failed to send bitrate command 'C\\rS%d\\r'\n", 67398b12064SDario Binacchi s); 67498b12064SDario Binacchi goto cmd_transmit_failed; 67598b12064SDario Binacchi } 67698b12064SDario Binacchi 6774de0e8efSDario Binacchi if (test_bit(CF_ERR_RST, &sl->cmd_flags)) { 6784de0e8efSDario Binacchi err = slcan_transmit_cmd(sl, "F\r"); 6794de0e8efSDario Binacchi if (err) { 6804de0e8efSDario Binacchi netdev_err(dev, 6814de0e8efSDario Binacchi "failed to send error command 'F\\r'\n"); 6824de0e8efSDario Binacchi goto cmd_transmit_failed; 6834de0e8efSDario Binacchi } 6844de0e8efSDario Binacchi } 6854de0e8efSDario Binacchi 68698b12064SDario Binacchi err = slcan_transmit_cmd(sl, "O\r"); 68798b12064SDario Binacchi if (err) { 68898b12064SDario Binacchi netdev_err(dev, "failed to send open command 'O\\r'\n"); 68998b12064SDario Binacchi goto cmd_transmit_failed; 69098b12064SDario Binacchi } 69198b12064SDario Binacchi } 69298b12064SDario Binacchi 69398b12064SDario Binacchi sl->can.state = CAN_STATE_ERROR_ACTIVE; 69498b12064SDario Binacchi netif_start_queue(dev); 69598b12064SDario Binacchi return 0; 69698b12064SDario Binacchi 69798b12064SDario Binacchi cmd_transmit_failed: 69898b12064SDario Binacchi close_candev(dev); 69998b12064SDario Binacchi return err; 70098b12064SDario Binacchi } 70198b12064SDario Binacchi 70298b12064SDario Binacchi static void slc_dealloc(struct slcan *sl) 70398b12064SDario Binacchi { 70498b12064SDario Binacchi int i = sl->dev->base_addr; 70598b12064SDario Binacchi 70698b12064SDario Binacchi free_candev(sl->dev); 70798b12064SDario Binacchi slcan_devs[i] = NULL; 70898b12064SDario Binacchi } 70998b12064SDario Binacchi 71098b12064SDario Binacchi static int slcan_change_mtu(struct net_device *dev, int new_mtu) 71198b12064SDario Binacchi { 71298b12064SDario Binacchi return -EINVAL; 71398b12064SDario Binacchi } 71498b12064SDario Binacchi 71598b12064SDario Binacchi static const struct net_device_ops slc_netdev_ops = { 71698b12064SDario Binacchi .ndo_open = slc_open, 71798b12064SDario Binacchi .ndo_stop = slc_close, 71898b12064SDario Binacchi .ndo_start_xmit = slc_xmit, 71998b12064SDario Binacchi .ndo_change_mtu = slcan_change_mtu, 72098b12064SDario Binacchi }; 72198b12064SDario Binacchi 72298b12064SDario Binacchi /****************************************** 72398b12064SDario Binacchi Routines looking at TTY side. 72498b12064SDario Binacchi ******************************************/ 72598b12064SDario Binacchi 72698b12064SDario Binacchi /* 72798b12064SDario Binacchi * Handle the 'receiver data ready' interrupt. 72898b12064SDario Binacchi * This function is called by the 'tty_io' module in the kernel when 72998b12064SDario Binacchi * a block of SLCAN data has been received, which can now be decapsulated 73098b12064SDario Binacchi * and sent on to some IP layer for further processing. This will not 73198b12064SDario Binacchi * be re-entered while running but other ldisc functions may be called 73298b12064SDario Binacchi * in parallel 73398b12064SDario Binacchi */ 73498b12064SDario Binacchi 73598b12064SDario Binacchi static void slcan_receive_buf(struct tty_struct *tty, 73698b12064SDario Binacchi const unsigned char *cp, const char *fp, 73798b12064SDario Binacchi int count) 73898b12064SDario Binacchi { 73998b12064SDario Binacchi struct slcan *sl = (struct slcan *) tty->disc_data; 74098b12064SDario Binacchi 74198b12064SDario Binacchi if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev)) 74298b12064SDario Binacchi return; 74398b12064SDario Binacchi 74498b12064SDario Binacchi /* Read the characters out of the buffer */ 74598b12064SDario Binacchi while (count--) { 74698b12064SDario Binacchi if (fp && *fp++) { 74798b12064SDario Binacchi if (!test_and_set_bit(SLF_ERROR, &sl->flags)) 74898b12064SDario Binacchi sl->dev->stats.rx_errors++; 74998b12064SDario Binacchi cp++; 75098b12064SDario Binacchi continue; 75198b12064SDario Binacchi } 75298b12064SDario Binacchi slcan_unesc(sl, *cp++); 75398b12064SDario Binacchi } 75498b12064SDario Binacchi } 75598b12064SDario Binacchi 75698b12064SDario Binacchi /************************************ 75798b12064SDario Binacchi * slcan_open helper routines. 75898b12064SDario Binacchi ************************************/ 75998b12064SDario Binacchi 76098b12064SDario Binacchi /* Collect hanged up channels */ 76198b12064SDario Binacchi static void slc_sync(void) 76298b12064SDario Binacchi { 76398b12064SDario Binacchi int i; 76498b12064SDario Binacchi struct net_device *dev; 76598b12064SDario Binacchi struct slcan *sl; 76698b12064SDario Binacchi 76798b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 76898b12064SDario Binacchi dev = slcan_devs[i]; 76998b12064SDario Binacchi if (dev == NULL) 77098b12064SDario Binacchi break; 77198b12064SDario Binacchi 77298b12064SDario Binacchi sl = netdev_priv(dev); 77398b12064SDario Binacchi if (sl->tty) 77498b12064SDario Binacchi continue; 77598b12064SDario Binacchi if (dev->flags & IFF_UP) 77698b12064SDario Binacchi dev_close(dev); 77798b12064SDario Binacchi } 77898b12064SDario Binacchi } 77998b12064SDario Binacchi 78098b12064SDario Binacchi /* Find a free SLCAN channel, and link in this `tty' line. */ 78198b12064SDario Binacchi static struct slcan *slc_alloc(void) 78298b12064SDario Binacchi { 78398b12064SDario Binacchi int i; 78498b12064SDario Binacchi struct net_device *dev = NULL; 78598b12064SDario Binacchi struct slcan *sl; 78698b12064SDario Binacchi 78798b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 78898b12064SDario Binacchi dev = slcan_devs[i]; 78998b12064SDario Binacchi if (dev == NULL) 79098b12064SDario Binacchi break; 79198b12064SDario Binacchi 79298b12064SDario Binacchi } 79398b12064SDario Binacchi 79498b12064SDario Binacchi /* Sorry, too many, all slots in use */ 79598b12064SDario Binacchi if (i >= maxdev) 79698b12064SDario Binacchi return NULL; 79798b12064SDario Binacchi 79898b12064SDario Binacchi dev = alloc_candev(sizeof(*sl), 1); 79998b12064SDario Binacchi if (!dev) 80098b12064SDario Binacchi return NULL; 80198b12064SDario Binacchi 80298b12064SDario Binacchi snprintf(dev->name, sizeof(dev->name), "slcan%d", i); 80398b12064SDario Binacchi dev->netdev_ops = &slc_netdev_ops; 80498b12064SDario Binacchi dev->base_addr = i; 8054de0e8efSDario Binacchi slcan_set_ethtool_ops(dev); 80698b12064SDario Binacchi sl = netdev_priv(dev); 80798b12064SDario Binacchi 80898b12064SDario Binacchi /* Initialize channel control data */ 80998b12064SDario Binacchi sl->magic = SLCAN_MAGIC; 81098b12064SDario Binacchi sl->dev = dev; 81198b12064SDario Binacchi sl->can.bitrate_const = slcan_bitrate_const; 81298b12064SDario Binacchi sl->can.bitrate_const_cnt = ARRAY_SIZE(slcan_bitrate_const); 81398b12064SDario Binacchi spin_lock_init(&sl->lock); 81498b12064SDario Binacchi INIT_WORK(&sl->tx_work, slcan_transmit); 81598b12064SDario Binacchi init_waitqueue_head(&sl->xcmd_wait); 81698b12064SDario Binacchi slcan_devs[i] = dev; 81798b12064SDario Binacchi 81898b12064SDario Binacchi return sl; 81998b12064SDario Binacchi } 82098b12064SDario Binacchi 82198b12064SDario Binacchi /* 82298b12064SDario Binacchi * Open the high-level part of the SLCAN channel. 82398b12064SDario Binacchi * This function is called by the TTY module when the 82498b12064SDario Binacchi * SLCAN line discipline is called for. Because we are 82598b12064SDario Binacchi * sure the tty line exists, we only have to link it to 82698b12064SDario Binacchi * a free SLCAN channel... 82798b12064SDario Binacchi * 82898b12064SDario Binacchi * Called in process context serialized from other ldisc calls. 82998b12064SDario Binacchi */ 83098b12064SDario Binacchi 83198b12064SDario Binacchi static int slcan_open(struct tty_struct *tty) 83298b12064SDario Binacchi { 83398b12064SDario Binacchi struct slcan *sl; 83498b12064SDario Binacchi int err; 83598b12064SDario Binacchi 83698b12064SDario Binacchi if (!capable(CAP_NET_ADMIN)) 83798b12064SDario Binacchi return -EPERM; 83898b12064SDario Binacchi 83998b12064SDario Binacchi if (tty->ops->write == NULL) 84098b12064SDario Binacchi return -EOPNOTSUPP; 84198b12064SDario Binacchi 84298b12064SDario Binacchi /* RTnetlink lock is misused here to serialize concurrent 84398b12064SDario Binacchi opens of slcan channels. There are better ways, but it is 84498b12064SDario Binacchi the simplest one. 84598b12064SDario Binacchi */ 84698b12064SDario Binacchi rtnl_lock(); 84798b12064SDario Binacchi 84898b12064SDario Binacchi /* Collect hanged up channels. */ 84998b12064SDario Binacchi slc_sync(); 85098b12064SDario Binacchi 85198b12064SDario Binacchi sl = tty->disc_data; 85298b12064SDario Binacchi 85398b12064SDario Binacchi err = -EEXIST; 85498b12064SDario Binacchi /* First make sure we're not already connected. */ 85598b12064SDario Binacchi if (sl && sl->magic == SLCAN_MAGIC) 85698b12064SDario Binacchi goto err_exit; 85798b12064SDario Binacchi 85898b12064SDario Binacchi /* OK. Find a free SLCAN channel to use. */ 85998b12064SDario Binacchi err = -ENFILE; 86098b12064SDario Binacchi sl = slc_alloc(); 86198b12064SDario Binacchi if (sl == NULL) 86298b12064SDario Binacchi goto err_exit; 86398b12064SDario Binacchi 86498b12064SDario Binacchi sl->tty = tty; 86598b12064SDario Binacchi tty->disc_data = sl; 86698b12064SDario Binacchi 86798b12064SDario Binacchi if (!test_bit(SLF_INUSE, &sl->flags)) { 86898b12064SDario Binacchi /* Perform the low-level SLCAN initialization. */ 86998b12064SDario Binacchi sl->rcount = 0; 87098b12064SDario Binacchi sl->xleft = 0; 87198b12064SDario Binacchi 87298b12064SDario Binacchi set_bit(SLF_INUSE, &sl->flags); 87398b12064SDario Binacchi 87498b12064SDario Binacchi rtnl_unlock(); 87598b12064SDario Binacchi err = register_candev(sl->dev); 87698b12064SDario Binacchi if (err) { 87798b12064SDario Binacchi pr_err("slcan: can't register candev\n"); 87898b12064SDario Binacchi goto err_free_chan; 87998b12064SDario Binacchi } 88098b12064SDario Binacchi } else { 88198b12064SDario Binacchi rtnl_unlock(); 88298b12064SDario Binacchi } 88398b12064SDario Binacchi 88498b12064SDario Binacchi tty->receive_room = 65536; /* We don't flow control */ 88598b12064SDario Binacchi 88698b12064SDario Binacchi /* TTY layer expects 0 on success */ 88798b12064SDario Binacchi return 0; 88898b12064SDario Binacchi 88998b12064SDario Binacchi err_free_chan: 89098b12064SDario Binacchi rtnl_lock(); 89198b12064SDario Binacchi sl->tty = NULL; 89298b12064SDario Binacchi tty->disc_data = NULL; 89398b12064SDario Binacchi clear_bit(SLF_INUSE, &sl->flags); 89498b12064SDario Binacchi slc_dealloc(sl); 89598b12064SDario Binacchi rtnl_unlock(); 89698b12064SDario Binacchi return err; 89798b12064SDario Binacchi 89898b12064SDario Binacchi err_exit: 89998b12064SDario Binacchi rtnl_unlock(); 90098b12064SDario Binacchi 90198b12064SDario Binacchi /* Count references from TTY module */ 90298b12064SDario Binacchi return err; 90398b12064SDario Binacchi } 90498b12064SDario Binacchi 90598b12064SDario Binacchi /* 90698b12064SDario Binacchi * Close down a SLCAN channel. 90798b12064SDario Binacchi * This means flushing out any pending queues, and then returning. This 90898b12064SDario Binacchi * call is serialized against other ldisc functions. 90998b12064SDario Binacchi * 91098b12064SDario Binacchi * We also use this method for a hangup event. 91198b12064SDario Binacchi */ 91298b12064SDario Binacchi 91398b12064SDario Binacchi static void slcan_close(struct tty_struct *tty) 91498b12064SDario Binacchi { 91598b12064SDario Binacchi struct slcan *sl = (struct slcan *) tty->disc_data; 91698b12064SDario Binacchi 91798b12064SDario Binacchi /* First make sure we're connected. */ 91898b12064SDario Binacchi if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty) 91998b12064SDario Binacchi return; 92098b12064SDario Binacchi 92198b12064SDario Binacchi spin_lock_bh(&sl->lock); 92298b12064SDario Binacchi rcu_assign_pointer(tty->disc_data, NULL); 92398b12064SDario Binacchi sl->tty = NULL; 92498b12064SDario Binacchi spin_unlock_bh(&sl->lock); 92598b12064SDario Binacchi 92698b12064SDario Binacchi synchronize_rcu(); 92798b12064SDario Binacchi flush_work(&sl->tx_work); 92898b12064SDario Binacchi 92998b12064SDario Binacchi slc_close(sl->dev); 93098b12064SDario Binacchi unregister_candev(sl->dev); 93198b12064SDario Binacchi rtnl_lock(); 93298b12064SDario Binacchi slc_dealloc(sl); 93398b12064SDario Binacchi rtnl_unlock(); 93498b12064SDario Binacchi } 93598b12064SDario Binacchi 93698b12064SDario Binacchi static void slcan_hangup(struct tty_struct *tty) 93798b12064SDario Binacchi { 93898b12064SDario Binacchi slcan_close(tty); 93998b12064SDario Binacchi } 94098b12064SDario Binacchi 94198b12064SDario Binacchi /* Perform I/O control on an active SLCAN channel. */ 94298b12064SDario Binacchi static int slcan_ioctl(struct tty_struct *tty, unsigned int cmd, 94398b12064SDario Binacchi unsigned long arg) 94498b12064SDario Binacchi { 94598b12064SDario Binacchi struct slcan *sl = (struct slcan *) tty->disc_data; 94698b12064SDario Binacchi unsigned int tmp; 94798b12064SDario Binacchi 94898b12064SDario Binacchi /* First make sure we're connected. */ 94998b12064SDario Binacchi if (!sl || sl->magic != SLCAN_MAGIC) 95098b12064SDario Binacchi return -EINVAL; 95198b12064SDario Binacchi 95298b12064SDario Binacchi switch (cmd) { 95398b12064SDario Binacchi case SIOCGIFNAME: 95498b12064SDario Binacchi tmp = strlen(sl->dev->name) + 1; 95598b12064SDario Binacchi if (copy_to_user((void __user *)arg, sl->dev->name, tmp)) 95698b12064SDario Binacchi return -EFAULT; 95798b12064SDario Binacchi return 0; 95898b12064SDario Binacchi 95998b12064SDario Binacchi case SIOCSIFHWADDR: 96098b12064SDario Binacchi return -EINVAL; 96198b12064SDario Binacchi 96298b12064SDario Binacchi default: 96398b12064SDario Binacchi return tty_mode_ioctl(tty, cmd, arg); 96498b12064SDario Binacchi } 96598b12064SDario Binacchi } 96698b12064SDario Binacchi 96798b12064SDario Binacchi static struct tty_ldisc_ops slc_ldisc = { 96898b12064SDario Binacchi .owner = THIS_MODULE, 96998b12064SDario Binacchi .num = N_SLCAN, 97098b12064SDario Binacchi .name = "slcan", 97198b12064SDario Binacchi .open = slcan_open, 97298b12064SDario Binacchi .close = slcan_close, 97398b12064SDario Binacchi .hangup = slcan_hangup, 97498b12064SDario Binacchi .ioctl = slcan_ioctl, 97598b12064SDario Binacchi .receive_buf = slcan_receive_buf, 97698b12064SDario Binacchi .write_wakeup = slcan_write_wakeup, 97798b12064SDario Binacchi }; 97898b12064SDario Binacchi 97998b12064SDario Binacchi static int __init slcan_init(void) 98098b12064SDario Binacchi { 98198b12064SDario Binacchi int status; 98298b12064SDario Binacchi 98398b12064SDario Binacchi if (maxdev < 4) 98498b12064SDario Binacchi maxdev = 4; /* Sanity */ 98598b12064SDario Binacchi 98698b12064SDario Binacchi pr_info("slcan: serial line CAN interface driver\n"); 98798b12064SDario Binacchi pr_info("slcan: %d dynamic interface channels.\n", maxdev); 98898b12064SDario Binacchi 98998b12064SDario Binacchi slcan_devs = kcalloc(maxdev, sizeof(struct net_device *), GFP_KERNEL); 99098b12064SDario Binacchi if (!slcan_devs) 99198b12064SDario Binacchi return -ENOMEM; 99298b12064SDario Binacchi 99398b12064SDario Binacchi /* Fill in our line protocol discipline, and register it */ 99498b12064SDario Binacchi status = tty_register_ldisc(&slc_ldisc); 99598b12064SDario Binacchi if (status) { 99698b12064SDario Binacchi printk(KERN_ERR "slcan: can't register line discipline\n"); 99798b12064SDario Binacchi kfree(slcan_devs); 99898b12064SDario Binacchi } 99998b12064SDario Binacchi return status; 100098b12064SDario Binacchi } 100198b12064SDario Binacchi 100298b12064SDario Binacchi static void __exit slcan_exit(void) 100398b12064SDario Binacchi { 100498b12064SDario Binacchi int i; 100598b12064SDario Binacchi struct net_device *dev; 100698b12064SDario Binacchi struct slcan *sl; 100798b12064SDario Binacchi unsigned long timeout = jiffies + HZ; 100898b12064SDario Binacchi int busy = 0; 100998b12064SDario Binacchi 101098b12064SDario Binacchi if (slcan_devs == NULL) 101198b12064SDario Binacchi return; 101298b12064SDario Binacchi 101398b12064SDario Binacchi /* First of all: check for active disciplines and hangup them. 101498b12064SDario Binacchi */ 101598b12064SDario Binacchi do { 101698b12064SDario Binacchi if (busy) 101798b12064SDario Binacchi msleep_interruptible(100); 101898b12064SDario Binacchi 101998b12064SDario Binacchi busy = 0; 102098b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 102198b12064SDario Binacchi dev = slcan_devs[i]; 102298b12064SDario Binacchi if (!dev) 102398b12064SDario Binacchi continue; 102498b12064SDario Binacchi sl = netdev_priv(dev); 102598b12064SDario Binacchi spin_lock_bh(&sl->lock); 102698b12064SDario Binacchi if (sl->tty) { 102798b12064SDario Binacchi busy++; 102898b12064SDario Binacchi tty_hangup(sl->tty); 102998b12064SDario Binacchi } 103098b12064SDario Binacchi spin_unlock_bh(&sl->lock); 103198b12064SDario Binacchi } 103298b12064SDario Binacchi } while (busy && time_before(jiffies, timeout)); 103398b12064SDario Binacchi 103498b12064SDario Binacchi /* FIXME: hangup is async so we should wait when doing this second 103598b12064SDario Binacchi phase */ 103698b12064SDario Binacchi 103798b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 103898b12064SDario Binacchi dev = slcan_devs[i]; 103998b12064SDario Binacchi if (!dev) 104098b12064SDario Binacchi continue; 104198b12064SDario Binacchi 104298b12064SDario Binacchi sl = netdev_priv(dev); 104398b12064SDario Binacchi if (sl->tty) { 104498b12064SDario Binacchi netdev_err(dev, "tty discipline still running\n"); 104598b12064SDario Binacchi } 104698b12064SDario Binacchi 104798b12064SDario Binacchi slc_close(dev); 104898b12064SDario Binacchi unregister_candev(dev); 104998b12064SDario Binacchi slc_dealloc(sl); 105098b12064SDario Binacchi } 105198b12064SDario Binacchi 105298b12064SDario Binacchi kfree(slcan_devs); 105398b12064SDario Binacchi slcan_devs = NULL; 105498b12064SDario Binacchi 105598b12064SDario Binacchi tty_unregister_ldisc(&slc_ldisc); 105698b12064SDario Binacchi } 105798b12064SDario Binacchi 105898b12064SDario Binacchi module_init(slcan_init); 105998b12064SDario Binacchi module_exit(slcan_exit); 1060