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 810a9cdcf0SDario Binacchi #define SLC_STATE_LEN 1 820a9cdcf0SDario Binacchi #define SLC_STATE_BE_RXCNT_LEN 3 830a9cdcf0SDario Binacchi #define SLC_STATE_BE_TXCNT_LEN 3 840a9cdcf0SDario Binacchi #define SLC_STATE_FRAME_LEN (1 + SLC_CMD_LEN + SLC_STATE_BE_RXCNT_LEN + \ 850a9cdcf0SDario Binacchi SLC_STATE_BE_TXCNT_LEN) 8698b12064SDario Binacchi struct slcan { 8798b12064SDario Binacchi struct can_priv can; 8898b12064SDario Binacchi int magic; 8998b12064SDario Binacchi 9098b12064SDario Binacchi /* Various fields. */ 9198b12064SDario Binacchi struct tty_struct *tty; /* ptr to TTY structure */ 9298b12064SDario Binacchi struct net_device *dev; /* easy for intr handling */ 9398b12064SDario Binacchi spinlock_t lock; 9498b12064SDario Binacchi struct work_struct tx_work; /* Flushes transmit buffer */ 9598b12064SDario Binacchi 9698b12064SDario Binacchi /* These are pointers to the malloc()ed frame buffers. */ 9798b12064SDario Binacchi unsigned char rbuff[SLC_MTU]; /* receiver buffer */ 9898b12064SDario Binacchi int rcount; /* received chars counter */ 9998b12064SDario Binacchi unsigned char xbuff[SLC_MTU]; /* transmitter buffer */ 10098b12064SDario Binacchi unsigned char *xhead; /* pointer to next XMIT byte */ 10198b12064SDario Binacchi int xleft; /* bytes left in XMIT queue */ 10298b12064SDario Binacchi 10398b12064SDario Binacchi unsigned long flags; /* Flag values/ mode etc */ 10498b12064SDario Binacchi #define SLF_INUSE 0 /* Channel in use */ 10598b12064SDario Binacchi #define SLF_ERROR 1 /* Parity, etc. error */ 10698b12064SDario Binacchi #define SLF_XCMD 2 /* Command transmission */ 1074de0e8efSDario Binacchi unsigned long cmd_flags; /* Command flags */ 1084de0e8efSDario Binacchi #define CF_ERR_RST 0 /* Reset errors on open */ 10998b12064SDario Binacchi wait_queue_head_t xcmd_wait; /* Wait queue for commands */ 11098b12064SDario Binacchi /* transmission */ 11198b12064SDario Binacchi }; 11298b12064SDario Binacchi 11398b12064SDario Binacchi static struct net_device **slcan_devs; 11498b12064SDario Binacchi 11598b12064SDario Binacchi static const u32 slcan_bitrate_const[] = { 11698b12064SDario Binacchi 10000, 20000, 50000, 100000, 125000, 11798b12064SDario Binacchi 250000, 500000, 800000, 1000000 11898b12064SDario Binacchi }; 11998b12064SDario Binacchi 1204de0e8efSDario Binacchi bool slcan_err_rst_on_open(struct net_device *ndev) 1214de0e8efSDario Binacchi { 1224de0e8efSDario Binacchi struct slcan *sl = netdev_priv(ndev); 1234de0e8efSDario Binacchi 1244de0e8efSDario Binacchi return !!test_bit(CF_ERR_RST, &sl->cmd_flags); 1254de0e8efSDario Binacchi } 1264de0e8efSDario Binacchi 1274de0e8efSDario Binacchi int slcan_enable_err_rst_on_open(struct net_device *ndev, bool on) 1284de0e8efSDario Binacchi { 1294de0e8efSDario Binacchi struct slcan *sl = netdev_priv(ndev); 1304de0e8efSDario Binacchi 1314de0e8efSDario Binacchi if (netif_running(ndev)) 1324de0e8efSDario Binacchi return -EBUSY; 1334de0e8efSDario Binacchi 1344de0e8efSDario Binacchi if (on) 1354de0e8efSDario Binacchi set_bit(CF_ERR_RST, &sl->cmd_flags); 1364de0e8efSDario Binacchi else 1374de0e8efSDario Binacchi clear_bit(CF_ERR_RST, &sl->cmd_flags); 1384de0e8efSDario Binacchi 1394de0e8efSDario Binacchi return 0; 1404de0e8efSDario Binacchi } 1414de0e8efSDario Binacchi 14298b12064SDario Binacchi /************************************************************************ 14398b12064SDario Binacchi * SLCAN ENCAPSULATION FORMAT * 14498b12064SDario Binacchi ************************************************************************/ 14598b12064SDario Binacchi 14698b12064SDario Binacchi /* 14798b12064SDario Binacchi * A CAN frame has a can_id (11 bit standard frame format OR 29 bit extended 14898b12064SDario Binacchi * frame format) a data length code (len) which can be from 0 to 8 14998b12064SDario Binacchi * and up to <len> data bytes as payload. 15098b12064SDario Binacchi * Additionally a CAN frame may become a remote transmission frame if the 15198b12064SDario Binacchi * RTR-bit is set. This causes another ECU to send a CAN frame with the 15298b12064SDario Binacchi * given can_id. 15398b12064SDario Binacchi * 15498b12064SDario Binacchi * The SLCAN ASCII representation of these different frame types is: 15598b12064SDario Binacchi * <type> <id> <dlc> <data>* 15698b12064SDario Binacchi * 15798b12064SDario Binacchi * Extended frames (29 bit) are defined by capital characters in the type. 15898b12064SDario Binacchi * RTR frames are defined as 'r' types - normal frames have 't' type: 15998b12064SDario Binacchi * t => 11 bit data frame 16098b12064SDario Binacchi * r => 11 bit RTR frame 16198b12064SDario Binacchi * T => 29 bit data frame 16298b12064SDario Binacchi * R => 29 bit RTR frame 16398b12064SDario Binacchi * 16498b12064SDario Binacchi * The <id> is 3 (standard) or 8 (extended) bytes in ASCII Hex (base64). 16598b12064SDario Binacchi * The <dlc> is a one byte ASCII number ('0' - '8') 16698b12064SDario Binacchi * The <data> section has at much ASCII Hex bytes as defined by the <dlc> 16798b12064SDario Binacchi * 16898b12064SDario Binacchi * Examples: 16998b12064SDario Binacchi * 17098b12064SDario Binacchi * t1230 : can_id 0x123, len 0, no data 17198b12064SDario Binacchi * t4563112233 : can_id 0x456, len 3, data 0x11 0x22 0x33 17298b12064SDario Binacchi * T12ABCDEF2AA55 : extended can_id 0x12ABCDEF, len 2, data 0xAA 0x55 17398b12064SDario Binacchi * r1230 : can_id 0x123, len 0, no data, remote transmission request 17498b12064SDario Binacchi * 17598b12064SDario Binacchi */ 17698b12064SDario Binacchi 17798b12064SDario Binacchi /************************************************************************ 17898b12064SDario Binacchi * STANDARD SLCAN DECAPSULATION * 17998b12064SDario Binacchi ************************************************************************/ 18098b12064SDario Binacchi 18198b12064SDario Binacchi /* Send one completely decapsulated can_frame to the network layer */ 182b32ff466SDario Binacchi static void slc_bump_frame(struct slcan *sl) 18398b12064SDario Binacchi { 18498b12064SDario Binacchi struct sk_buff *skb; 18598b12064SDario Binacchi struct can_frame *cf; 18698b12064SDario Binacchi int i, tmp; 18798b12064SDario Binacchi u32 tmpid; 18898b12064SDario Binacchi char *cmd = sl->rbuff; 18998b12064SDario Binacchi 19098b12064SDario Binacchi skb = alloc_can_skb(sl->dev, &cf); 19198b12064SDario Binacchi if (unlikely(!skb)) { 19298b12064SDario Binacchi sl->dev->stats.rx_dropped++; 19398b12064SDario Binacchi return; 19498b12064SDario Binacchi } 19598b12064SDario Binacchi 19698b12064SDario Binacchi switch (*cmd) { 19798b12064SDario Binacchi case 'r': 19898b12064SDario Binacchi cf->can_id = CAN_RTR_FLAG; 19998b12064SDario Binacchi fallthrough; 20098b12064SDario Binacchi case 't': 20198b12064SDario Binacchi /* store dlc ASCII value and terminate SFF CAN ID string */ 20298b12064SDario Binacchi cf->len = sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN]; 20398b12064SDario Binacchi sl->rbuff[SLC_CMD_LEN + SLC_SFF_ID_LEN] = 0; 20498b12064SDario Binacchi /* point to payload data behind the dlc */ 20598b12064SDario Binacchi cmd += SLC_CMD_LEN + SLC_SFF_ID_LEN + 1; 20698b12064SDario Binacchi break; 20798b12064SDario Binacchi case 'R': 20898b12064SDario Binacchi cf->can_id = CAN_RTR_FLAG; 20998b12064SDario Binacchi fallthrough; 21098b12064SDario Binacchi case 'T': 21198b12064SDario Binacchi cf->can_id |= CAN_EFF_FLAG; 21298b12064SDario Binacchi /* store dlc ASCII value and terminate EFF CAN ID string */ 21398b12064SDario Binacchi cf->len = sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN]; 21498b12064SDario Binacchi sl->rbuff[SLC_CMD_LEN + SLC_EFF_ID_LEN] = 0; 21598b12064SDario Binacchi /* point to payload data behind the dlc */ 21698b12064SDario Binacchi cmd += SLC_CMD_LEN + SLC_EFF_ID_LEN + 1; 21798b12064SDario Binacchi break; 21898b12064SDario Binacchi default: 21998b12064SDario Binacchi goto decode_failed; 22098b12064SDario Binacchi } 22198b12064SDario Binacchi 22298b12064SDario Binacchi if (kstrtou32(sl->rbuff + SLC_CMD_LEN, 16, &tmpid)) 22398b12064SDario Binacchi goto decode_failed; 22498b12064SDario Binacchi 22598b12064SDario Binacchi cf->can_id |= tmpid; 22698b12064SDario Binacchi 22798b12064SDario Binacchi /* get len from sanitized ASCII value */ 22898b12064SDario Binacchi if (cf->len >= '0' && cf->len < '9') 22998b12064SDario Binacchi cf->len -= '0'; 23098b12064SDario Binacchi else 23198b12064SDario Binacchi goto decode_failed; 23298b12064SDario Binacchi 23398b12064SDario Binacchi /* RTR frames may have a dlc > 0 but they never have any data bytes */ 23498b12064SDario Binacchi if (!(cf->can_id & CAN_RTR_FLAG)) { 23598b12064SDario Binacchi for (i = 0; i < cf->len; i++) { 23698b12064SDario Binacchi tmp = hex_to_bin(*cmd++); 23798b12064SDario Binacchi if (tmp < 0) 23898b12064SDario Binacchi goto decode_failed; 23998b12064SDario Binacchi 24098b12064SDario Binacchi cf->data[i] = (tmp << 4); 24198b12064SDario Binacchi tmp = hex_to_bin(*cmd++); 24298b12064SDario Binacchi if (tmp < 0) 24398b12064SDario Binacchi goto decode_failed; 24498b12064SDario Binacchi 24598b12064SDario Binacchi cf->data[i] |= tmp; 24698b12064SDario Binacchi } 24798b12064SDario Binacchi } 24898b12064SDario Binacchi 24998b12064SDario Binacchi sl->dev->stats.rx_packets++; 25098b12064SDario Binacchi if (!(cf->can_id & CAN_RTR_FLAG)) 25198b12064SDario Binacchi sl->dev->stats.rx_bytes += cf->len; 25298b12064SDario Binacchi 25398b12064SDario Binacchi netif_rx(skb); 25498b12064SDario Binacchi return; 25598b12064SDario Binacchi 25698b12064SDario Binacchi decode_failed: 25798b12064SDario Binacchi sl->dev->stats.rx_errors++; 25898b12064SDario Binacchi dev_kfree_skb(skb); 25998b12064SDario Binacchi } 26098b12064SDario Binacchi 2610a9cdcf0SDario Binacchi /* A change state frame must contain state info and receive and transmit 2620a9cdcf0SDario Binacchi * error counters. 2630a9cdcf0SDario Binacchi * 2640a9cdcf0SDario Binacchi * Examples: 2650a9cdcf0SDario Binacchi * 2660a9cdcf0SDario Binacchi * sb256256 : state bus-off: rx counter 256, tx counter 256 2670a9cdcf0SDario Binacchi * sa057033 : state active, rx counter 57, tx counter 33 2680a9cdcf0SDario Binacchi */ 2690a9cdcf0SDario Binacchi static void slc_bump_state(struct slcan *sl) 2700a9cdcf0SDario Binacchi { 2710a9cdcf0SDario Binacchi struct net_device *dev = sl->dev; 2720a9cdcf0SDario Binacchi struct sk_buff *skb; 2730a9cdcf0SDario Binacchi struct can_frame *cf; 2740a9cdcf0SDario Binacchi char *cmd = sl->rbuff; 2750a9cdcf0SDario Binacchi u32 rxerr, txerr; 2760a9cdcf0SDario Binacchi enum can_state state, rx_state, tx_state; 2770a9cdcf0SDario Binacchi 2780a9cdcf0SDario Binacchi switch (cmd[1]) { 2790a9cdcf0SDario Binacchi case 'a': 2800a9cdcf0SDario Binacchi state = CAN_STATE_ERROR_ACTIVE; 2810a9cdcf0SDario Binacchi break; 2820a9cdcf0SDario Binacchi case 'w': 2830a9cdcf0SDario Binacchi state = CAN_STATE_ERROR_WARNING; 2840a9cdcf0SDario Binacchi break; 2850a9cdcf0SDario Binacchi case 'p': 2860a9cdcf0SDario Binacchi state = CAN_STATE_ERROR_PASSIVE; 2870a9cdcf0SDario Binacchi break; 2880a9cdcf0SDario Binacchi case 'b': 2890a9cdcf0SDario Binacchi state = CAN_STATE_BUS_OFF; 2900a9cdcf0SDario Binacchi break; 2910a9cdcf0SDario Binacchi default: 2920a9cdcf0SDario Binacchi return; 2930a9cdcf0SDario Binacchi } 2940a9cdcf0SDario Binacchi 2950a9cdcf0SDario Binacchi if (state == sl->can.state || sl->rcount < SLC_STATE_FRAME_LEN) 2960a9cdcf0SDario Binacchi return; 2970a9cdcf0SDario Binacchi 2980a9cdcf0SDario Binacchi cmd += SLC_STATE_BE_RXCNT_LEN + SLC_CMD_LEN + 1; 2990a9cdcf0SDario Binacchi cmd[SLC_STATE_BE_TXCNT_LEN] = 0; 3000a9cdcf0SDario Binacchi if (kstrtou32(cmd, 10, &txerr)) 3010a9cdcf0SDario Binacchi return; 3020a9cdcf0SDario Binacchi 3030a9cdcf0SDario Binacchi *cmd = 0; 3040a9cdcf0SDario Binacchi cmd -= SLC_STATE_BE_RXCNT_LEN; 3050a9cdcf0SDario Binacchi if (kstrtou32(cmd, 10, &rxerr)) 3060a9cdcf0SDario Binacchi return; 3070a9cdcf0SDario Binacchi 3080a9cdcf0SDario Binacchi skb = alloc_can_err_skb(dev, &cf); 3090a9cdcf0SDario Binacchi if (skb) { 3100a9cdcf0SDario Binacchi cf->data[6] = txerr; 3110a9cdcf0SDario Binacchi cf->data[7] = rxerr; 3120a9cdcf0SDario Binacchi } else { 3130a9cdcf0SDario Binacchi cf = NULL; 3140a9cdcf0SDario Binacchi } 3150a9cdcf0SDario Binacchi 3160a9cdcf0SDario Binacchi tx_state = txerr >= rxerr ? state : 0; 3170a9cdcf0SDario Binacchi rx_state = txerr <= rxerr ? state : 0; 3180a9cdcf0SDario Binacchi can_change_state(dev, cf, tx_state, rx_state); 3190a9cdcf0SDario Binacchi 3200a9cdcf0SDario Binacchi if (state == CAN_STATE_BUS_OFF) 3210a9cdcf0SDario Binacchi can_bus_off(dev); 3220a9cdcf0SDario Binacchi 3230a9cdcf0SDario Binacchi if (skb) 3240a9cdcf0SDario Binacchi netif_rx(skb); 3250a9cdcf0SDario Binacchi } 3260a9cdcf0SDario Binacchi 327b32ff466SDario Binacchi /* An error frame can contain more than one type of error. 328b32ff466SDario Binacchi * 329b32ff466SDario Binacchi * Examples: 330b32ff466SDario Binacchi * 331b32ff466SDario Binacchi * e1a : len 1, errors: ACK error 332b32ff466SDario Binacchi * e3bcO: len 3, errors: Bit0 error, CRC error, Tx overrun error 333b32ff466SDario Binacchi */ 334b32ff466SDario Binacchi static void slc_bump_err(struct slcan *sl) 335b32ff466SDario Binacchi { 336b32ff466SDario Binacchi struct net_device *dev = sl->dev; 337b32ff466SDario Binacchi struct sk_buff *skb; 338b32ff466SDario Binacchi struct can_frame *cf; 339b32ff466SDario Binacchi char *cmd = sl->rbuff; 340b32ff466SDario Binacchi bool rx_errors = false, tx_errors = false, rx_over_errors = false; 341b32ff466SDario Binacchi int i, len; 342b32ff466SDario Binacchi 343b32ff466SDario Binacchi /* get len from sanitized ASCII value */ 344b32ff466SDario Binacchi len = cmd[1]; 345b32ff466SDario Binacchi if (len >= '0' && len < '9') 346b32ff466SDario Binacchi len -= '0'; 347b32ff466SDario Binacchi else 348b32ff466SDario Binacchi return; 349b32ff466SDario Binacchi 350b32ff466SDario Binacchi if ((len + SLC_CMD_LEN + 1) > sl->rcount) 351b32ff466SDario Binacchi return; 352b32ff466SDario Binacchi 353b32ff466SDario Binacchi skb = alloc_can_err_skb(dev, &cf); 354b32ff466SDario Binacchi 355b32ff466SDario Binacchi if (skb) 356b32ff466SDario Binacchi cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR; 357b32ff466SDario Binacchi 358b32ff466SDario Binacchi cmd += SLC_CMD_LEN + 1; 359b32ff466SDario Binacchi for (i = 0; i < len; i++, cmd++) { 360b32ff466SDario Binacchi switch (*cmd) { 361b32ff466SDario Binacchi case 'a': 362b32ff466SDario Binacchi netdev_dbg(dev, "ACK error\n"); 363b32ff466SDario Binacchi tx_errors = true; 364b32ff466SDario Binacchi if (skb) { 365b32ff466SDario Binacchi cf->can_id |= CAN_ERR_ACK; 366b32ff466SDario Binacchi cf->data[3] = CAN_ERR_PROT_LOC_ACK; 367b32ff466SDario Binacchi } 368b32ff466SDario Binacchi 369b32ff466SDario Binacchi break; 370b32ff466SDario Binacchi case 'b': 371b32ff466SDario Binacchi netdev_dbg(dev, "Bit0 error\n"); 372b32ff466SDario Binacchi tx_errors = true; 373b32ff466SDario Binacchi if (skb) 374b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_BIT0; 375b32ff466SDario Binacchi 376b32ff466SDario Binacchi break; 377b32ff466SDario Binacchi case 'B': 378b32ff466SDario Binacchi netdev_dbg(dev, "Bit1 error\n"); 379b32ff466SDario Binacchi tx_errors = true; 380b32ff466SDario Binacchi if (skb) 381b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_BIT1; 382b32ff466SDario Binacchi 383b32ff466SDario Binacchi break; 384b32ff466SDario Binacchi case 'c': 385b32ff466SDario Binacchi netdev_dbg(dev, "CRC error\n"); 386b32ff466SDario Binacchi rx_errors = true; 387b32ff466SDario Binacchi if (skb) { 388b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_BIT; 389b32ff466SDario Binacchi cf->data[3] = CAN_ERR_PROT_LOC_CRC_SEQ; 390b32ff466SDario Binacchi } 391b32ff466SDario Binacchi 392b32ff466SDario Binacchi break; 393b32ff466SDario Binacchi case 'f': 394b32ff466SDario Binacchi netdev_dbg(dev, "Form Error\n"); 395b32ff466SDario Binacchi rx_errors = true; 396b32ff466SDario Binacchi if (skb) 397b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_FORM; 398b32ff466SDario Binacchi 399b32ff466SDario Binacchi break; 400b32ff466SDario Binacchi case 'o': 401b32ff466SDario Binacchi netdev_dbg(dev, "Rx overrun error\n"); 402b32ff466SDario Binacchi rx_over_errors = true; 403b32ff466SDario Binacchi rx_errors = true; 404b32ff466SDario Binacchi if (skb) { 405b32ff466SDario Binacchi cf->can_id |= CAN_ERR_CRTL; 406b32ff466SDario Binacchi cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; 407b32ff466SDario Binacchi } 408b32ff466SDario Binacchi 409b32ff466SDario Binacchi break; 410b32ff466SDario Binacchi case 'O': 411b32ff466SDario Binacchi netdev_dbg(dev, "Tx overrun error\n"); 412b32ff466SDario Binacchi tx_errors = true; 413b32ff466SDario Binacchi if (skb) { 414b32ff466SDario Binacchi cf->can_id |= CAN_ERR_CRTL; 415b32ff466SDario Binacchi cf->data[1] = CAN_ERR_CRTL_TX_OVERFLOW; 416b32ff466SDario Binacchi } 417b32ff466SDario Binacchi 418b32ff466SDario Binacchi break; 419b32ff466SDario Binacchi case 's': 420b32ff466SDario Binacchi netdev_dbg(dev, "Stuff error\n"); 421b32ff466SDario Binacchi rx_errors = true; 422b32ff466SDario Binacchi if (skb) 423b32ff466SDario Binacchi cf->data[2] |= CAN_ERR_PROT_STUFF; 424b32ff466SDario Binacchi 425b32ff466SDario Binacchi break; 426b32ff466SDario Binacchi default: 427b32ff466SDario Binacchi if (skb) 428b32ff466SDario Binacchi dev_kfree_skb(skb); 429b32ff466SDario Binacchi 430b32ff466SDario Binacchi return; 431b32ff466SDario Binacchi } 432b32ff466SDario Binacchi } 433b32ff466SDario Binacchi 434b32ff466SDario Binacchi if (rx_errors) 435b32ff466SDario Binacchi dev->stats.rx_errors++; 436b32ff466SDario Binacchi 437b32ff466SDario Binacchi if (rx_over_errors) 438b32ff466SDario Binacchi dev->stats.rx_over_errors++; 439b32ff466SDario Binacchi 440b32ff466SDario Binacchi if (tx_errors) 441b32ff466SDario Binacchi dev->stats.tx_errors++; 442b32ff466SDario Binacchi 443b32ff466SDario Binacchi if (skb) 444b32ff466SDario Binacchi netif_rx(skb); 445b32ff466SDario Binacchi } 446b32ff466SDario Binacchi 447b32ff466SDario Binacchi static void slc_bump(struct slcan *sl) 448b32ff466SDario Binacchi { 449b32ff466SDario Binacchi switch (sl->rbuff[0]) { 450b32ff466SDario Binacchi case 'r': 451b32ff466SDario Binacchi fallthrough; 452b32ff466SDario Binacchi case 't': 453b32ff466SDario Binacchi fallthrough; 454b32ff466SDario Binacchi case 'R': 455b32ff466SDario Binacchi fallthrough; 456b32ff466SDario Binacchi case 'T': 457b32ff466SDario Binacchi return slc_bump_frame(sl); 458b32ff466SDario Binacchi case 'e': 459b32ff466SDario Binacchi return slc_bump_err(sl); 4600a9cdcf0SDario Binacchi case 's': 4610a9cdcf0SDario Binacchi return slc_bump_state(sl); 462b32ff466SDario Binacchi default: 463b32ff466SDario Binacchi return; 464b32ff466SDario Binacchi } 465b32ff466SDario Binacchi } 466b32ff466SDario Binacchi 46798b12064SDario Binacchi /* parse tty input stream */ 46898b12064SDario Binacchi static void slcan_unesc(struct slcan *sl, unsigned char s) 46998b12064SDario Binacchi { 47098b12064SDario Binacchi if ((s == '\r') || (s == '\a')) { /* CR or BEL ends the pdu */ 47198b12064SDario Binacchi if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && 47298b12064SDario Binacchi (sl->rcount > 4)) { 47398b12064SDario Binacchi slc_bump(sl); 47498b12064SDario Binacchi } 47598b12064SDario Binacchi sl->rcount = 0; 47698b12064SDario Binacchi } else { 47798b12064SDario Binacchi if (!test_bit(SLF_ERROR, &sl->flags)) { 47898b12064SDario Binacchi if (sl->rcount < SLC_MTU) { 47998b12064SDario Binacchi sl->rbuff[sl->rcount++] = s; 48098b12064SDario Binacchi return; 48198b12064SDario Binacchi } else { 48298b12064SDario Binacchi sl->dev->stats.rx_over_errors++; 48398b12064SDario Binacchi set_bit(SLF_ERROR, &sl->flags); 48498b12064SDario Binacchi } 48598b12064SDario Binacchi } 48698b12064SDario Binacchi } 48798b12064SDario Binacchi } 48898b12064SDario Binacchi 48998b12064SDario Binacchi /************************************************************************ 49098b12064SDario Binacchi * STANDARD SLCAN ENCAPSULATION * 49198b12064SDario Binacchi ************************************************************************/ 49298b12064SDario Binacchi 49398b12064SDario Binacchi /* Encapsulate one can_frame and stuff into a TTY queue. */ 49498b12064SDario Binacchi static void slc_encaps(struct slcan *sl, struct can_frame *cf) 49598b12064SDario Binacchi { 49698b12064SDario Binacchi int actual, i; 49798b12064SDario Binacchi unsigned char *pos; 49898b12064SDario Binacchi unsigned char *endpos; 49998b12064SDario Binacchi canid_t id = cf->can_id; 50098b12064SDario Binacchi 50198b12064SDario Binacchi pos = sl->xbuff; 50298b12064SDario Binacchi 50398b12064SDario Binacchi if (cf->can_id & CAN_RTR_FLAG) 50498b12064SDario Binacchi *pos = 'R'; /* becomes 'r' in standard frame format (SFF) */ 50598b12064SDario Binacchi else 50698b12064SDario Binacchi *pos = 'T'; /* becomes 't' in standard frame format (SSF) */ 50798b12064SDario Binacchi 50898b12064SDario Binacchi /* determine number of chars for the CAN-identifier */ 50998b12064SDario Binacchi if (cf->can_id & CAN_EFF_FLAG) { 51098b12064SDario Binacchi id &= CAN_EFF_MASK; 51198b12064SDario Binacchi endpos = pos + SLC_EFF_ID_LEN; 51298b12064SDario Binacchi } else { 51398b12064SDario Binacchi *pos |= 0x20; /* convert R/T to lower case for SFF */ 51498b12064SDario Binacchi id &= CAN_SFF_MASK; 51598b12064SDario Binacchi endpos = pos + SLC_SFF_ID_LEN; 51698b12064SDario Binacchi } 51798b12064SDario Binacchi 51898b12064SDario Binacchi /* build 3 (SFF) or 8 (EFF) digit CAN identifier */ 51998b12064SDario Binacchi pos++; 52098b12064SDario Binacchi while (endpos >= pos) { 52198b12064SDario Binacchi *endpos-- = hex_asc_upper[id & 0xf]; 52298b12064SDario Binacchi id >>= 4; 52398b12064SDario Binacchi } 52498b12064SDario Binacchi 52598b12064SDario Binacchi pos += (cf->can_id & CAN_EFF_FLAG) ? SLC_EFF_ID_LEN : SLC_SFF_ID_LEN; 52698b12064SDario Binacchi 52798b12064SDario Binacchi *pos++ = cf->len + '0'; 52898b12064SDario Binacchi 52998b12064SDario Binacchi /* RTR frames may have a dlc > 0 but they never have any data bytes */ 53098b12064SDario Binacchi if (!(cf->can_id & CAN_RTR_FLAG)) { 53198b12064SDario Binacchi for (i = 0; i < cf->len; i++) 53298b12064SDario Binacchi pos = hex_byte_pack_upper(pos, cf->data[i]); 53398b12064SDario Binacchi 53498b12064SDario Binacchi sl->dev->stats.tx_bytes += cf->len; 53598b12064SDario Binacchi } 53698b12064SDario Binacchi 53798b12064SDario Binacchi *pos++ = '\r'; 53898b12064SDario Binacchi 53998b12064SDario Binacchi /* Order of next two lines is *very* important. 54098b12064SDario Binacchi * When we are sending a little amount of data, 54198b12064SDario Binacchi * the transfer may be completed inside the ops->write() 54298b12064SDario Binacchi * routine, because it's running with interrupts enabled. 54398b12064SDario Binacchi * In this case we *never* got WRITE_WAKEUP event, 54498b12064SDario Binacchi * if we did not request it before write operation. 54598b12064SDario Binacchi * 14 Oct 1994 Dmitry Gorodchanin. 54698b12064SDario Binacchi */ 54798b12064SDario Binacchi set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 54898b12064SDario Binacchi actual = sl->tty->ops->write(sl->tty, sl->xbuff, pos - sl->xbuff); 54998b12064SDario Binacchi sl->xleft = (pos - sl->xbuff) - actual; 55098b12064SDario Binacchi sl->xhead = sl->xbuff + actual; 55198b12064SDario Binacchi } 55298b12064SDario Binacchi 55398b12064SDario Binacchi /* Write out any remaining transmit buffer. Scheduled when tty is writable */ 55498b12064SDario Binacchi static void slcan_transmit(struct work_struct *work) 55598b12064SDario Binacchi { 55698b12064SDario Binacchi struct slcan *sl = container_of(work, struct slcan, tx_work); 55798b12064SDario Binacchi int actual; 55898b12064SDario Binacchi 55998b12064SDario Binacchi spin_lock_bh(&sl->lock); 56098b12064SDario Binacchi /* First make sure we're connected. */ 56198b12064SDario Binacchi if (!sl->tty || sl->magic != SLCAN_MAGIC || 56298b12064SDario Binacchi (unlikely(!netif_running(sl->dev)) && 56398b12064SDario Binacchi likely(!test_bit(SLF_XCMD, &sl->flags)))) { 56498b12064SDario Binacchi spin_unlock_bh(&sl->lock); 56598b12064SDario Binacchi return; 56698b12064SDario Binacchi } 56798b12064SDario Binacchi 56898b12064SDario Binacchi if (sl->xleft <= 0) { 56998b12064SDario Binacchi if (unlikely(test_bit(SLF_XCMD, &sl->flags))) { 57098b12064SDario Binacchi clear_bit(SLF_XCMD, &sl->flags); 57198b12064SDario Binacchi clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 57298b12064SDario Binacchi spin_unlock_bh(&sl->lock); 57398b12064SDario Binacchi wake_up(&sl->xcmd_wait); 57498b12064SDario Binacchi return; 57598b12064SDario Binacchi } 57698b12064SDario Binacchi 57798b12064SDario Binacchi /* Now serial buffer is almost free & we can start 57898b12064SDario Binacchi * transmission of another packet */ 57998b12064SDario Binacchi sl->dev->stats.tx_packets++; 58098b12064SDario Binacchi clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 58198b12064SDario Binacchi spin_unlock_bh(&sl->lock); 58298b12064SDario Binacchi netif_wake_queue(sl->dev); 58398b12064SDario Binacchi return; 58498b12064SDario Binacchi } 58598b12064SDario Binacchi 58698b12064SDario Binacchi actual = sl->tty->ops->write(sl->tty, sl->xhead, sl->xleft); 58798b12064SDario Binacchi sl->xleft -= actual; 58898b12064SDario Binacchi sl->xhead += actual; 58998b12064SDario Binacchi spin_unlock_bh(&sl->lock); 59098b12064SDario Binacchi } 59198b12064SDario Binacchi 59298b12064SDario Binacchi /* 59398b12064SDario Binacchi * Called by the driver when there's room for more data. 59498b12064SDario Binacchi * Schedule the transmit. 59598b12064SDario Binacchi */ 59698b12064SDario Binacchi static void slcan_write_wakeup(struct tty_struct *tty) 59798b12064SDario Binacchi { 59898b12064SDario Binacchi struct slcan *sl; 59998b12064SDario Binacchi 60098b12064SDario Binacchi rcu_read_lock(); 60198b12064SDario Binacchi sl = rcu_dereference(tty->disc_data); 60298b12064SDario Binacchi if (sl) 60398b12064SDario Binacchi schedule_work(&sl->tx_work); 60498b12064SDario Binacchi rcu_read_unlock(); 60598b12064SDario Binacchi } 60698b12064SDario Binacchi 60798b12064SDario Binacchi /* Send a can_frame to a TTY queue. */ 60898b12064SDario Binacchi static netdev_tx_t slc_xmit(struct sk_buff *skb, struct net_device *dev) 60998b12064SDario Binacchi { 61098b12064SDario Binacchi struct slcan *sl = netdev_priv(dev); 61198b12064SDario Binacchi 61298b12064SDario Binacchi if (can_dropped_invalid_skb(dev, skb)) 61398b12064SDario Binacchi return NETDEV_TX_OK; 61498b12064SDario Binacchi 61598b12064SDario Binacchi spin_lock(&sl->lock); 61698b12064SDario Binacchi if (!netif_running(dev)) { 61798b12064SDario Binacchi spin_unlock(&sl->lock); 61898b12064SDario Binacchi netdev_warn(dev, "xmit: iface is down\n"); 61998b12064SDario Binacchi goto out; 62098b12064SDario Binacchi } 62198b12064SDario Binacchi if (sl->tty == NULL) { 62298b12064SDario Binacchi spin_unlock(&sl->lock); 62398b12064SDario Binacchi goto out; 62498b12064SDario Binacchi } 62598b12064SDario Binacchi 62698b12064SDario Binacchi netif_stop_queue(sl->dev); 62798b12064SDario Binacchi slc_encaps(sl, (struct can_frame *) skb->data); /* encaps & send */ 62898b12064SDario Binacchi spin_unlock(&sl->lock); 62998b12064SDario Binacchi 63098b12064SDario Binacchi out: 63198b12064SDario Binacchi kfree_skb(skb); 63298b12064SDario Binacchi return NETDEV_TX_OK; 63398b12064SDario Binacchi } 63498b12064SDario Binacchi 63598b12064SDario Binacchi 63698b12064SDario Binacchi /****************************************** 63798b12064SDario Binacchi * Routines looking at netdevice side. 63898b12064SDario Binacchi ******************************************/ 63998b12064SDario Binacchi 64098b12064SDario Binacchi static int slcan_transmit_cmd(struct slcan *sl, const unsigned char *cmd) 64198b12064SDario Binacchi { 64298b12064SDario Binacchi int ret, actual, n; 64398b12064SDario Binacchi 64498b12064SDario Binacchi spin_lock(&sl->lock); 64598b12064SDario Binacchi if (!sl->tty) { 64698b12064SDario Binacchi spin_unlock(&sl->lock); 64798b12064SDario Binacchi return -ENODEV; 64898b12064SDario Binacchi } 64998b12064SDario Binacchi 650*0159a930SDan Carpenter n = scnprintf(sl->xbuff, sizeof(sl->xbuff), "%s", cmd); 65198b12064SDario Binacchi set_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 65298b12064SDario Binacchi actual = sl->tty->ops->write(sl->tty, sl->xbuff, n); 65398b12064SDario Binacchi sl->xleft = n - actual; 65498b12064SDario Binacchi sl->xhead = sl->xbuff + actual; 65598b12064SDario Binacchi set_bit(SLF_XCMD, &sl->flags); 65698b12064SDario Binacchi spin_unlock(&sl->lock); 65798b12064SDario Binacchi ret = wait_event_interruptible_timeout(sl->xcmd_wait, 65898b12064SDario Binacchi !test_bit(SLF_XCMD, &sl->flags), 65998b12064SDario Binacchi HZ); 66098b12064SDario Binacchi clear_bit(SLF_XCMD, &sl->flags); 66198b12064SDario Binacchi if (ret == -ERESTARTSYS) 66298b12064SDario Binacchi return ret; 66398b12064SDario Binacchi 66498b12064SDario Binacchi if (ret == 0) 66598b12064SDario Binacchi return -ETIMEDOUT; 66698b12064SDario Binacchi 66798b12064SDario Binacchi return 0; 66898b12064SDario Binacchi } 66998b12064SDario Binacchi 67098b12064SDario Binacchi /* Netdevice UP -> DOWN routine */ 67198b12064SDario Binacchi static int slc_close(struct net_device *dev) 67298b12064SDario Binacchi { 67398b12064SDario Binacchi struct slcan *sl = netdev_priv(dev); 67498b12064SDario Binacchi int err; 67598b12064SDario Binacchi 67698b12064SDario Binacchi spin_lock_bh(&sl->lock); 67798b12064SDario Binacchi if (sl->tty) { 67898b12064SDario Binacchi if (sl->can.bittiming.bitrate && 67998b12064SDario Binacchi sl->can.bittiming.bitrate != CAN_BITRATE_UNKNOWN) { 68098b12064SDario Binacchi spin_unlock_bh(&sl->lock); 68198b12064SDario Binacchi err = slcan_transmit_cmd(sl, "C\r"); 68298b12064SDario Binacchi spin_lock_bh(&sl->lock); 68398b12064SDario Binacchi if (err) 68498b12064SDario Binacchi netdev_warn(dev, 68598b12064SDario Binacchi "failed to send close command 'C\\r'\n"); 68698b12064SDario Binacchi } 68798b12064SDario Binacchi 68898b12064SDario Binacchi /* TTY discipline is running. */ 68998b12064SDario Binacchi clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 69098b12064SDario Binacchi } 69198b12064SDario Binacchi netif_stop_queue(dev); 69298b12064SDario Binacchi close_candev(dev); 69398b12064SDario Binacchi sl->can.state = CAN_STATE_STOPPED; 69498b12064SDario Binacchi if (sl->can.bittiming.bitrate == CAN_BITRATE_UNKNOWN) 69598b12064SDario Binacchi sl->can.bittiming.bitrate = CAN_BITRATE_UNSET; 69698b12064SDario Binacchi 69798b12064SDario Binacchi sl->rcount = 0; 69898b12064SDario Binacchi sl->xleft = 0; 69998b12064SDario Binacchi spin_unlock_bh(&sl->lock); 70098b12064SDario Binacchi 70198b12064SDario Binacchi return 0; 70298b12064SDario Binacchi } 70398b12064SDario Binacchi 70498b12064SDario Binacchi /* Netdevice DOWN -> UP routine */ 70598b12064SDario Binacchi static int slc_open(struct net_device *dev) 70698b12064SDario Binacchi { 70798b12064SDario Binacchi struct slcan *sl = netdev_priv(dev); 70898b12064SDario Binacchi unsigned char cmd[SLC_MTU]; 70998b12064SDario Binacchi int err, s; 71098b12064SDario Binacchi 71198b12064SDario Binacchi if (sl->tty == NULL) 71298b12064SDario Binacchi return -ENODEV; 71398b12064SDario Binacchi 71498b12064SDario Binacchi /* The baud rate is not set with the command 71598b12064SDario Binacchi * `ip link set <iface> type can bitrate <baud>' and therefore 71698b12064SDario Binacchi * can.bittiming.bitrate is CAN_BITRATE_UNSET (0), causing 71798b12064SDario Binacchi * open_candev() to fail. So let's set to a fake value. 71898b12064SDario Binacchi */ 71998b12064SDario Binacchi if (sl->can.bittiming.bitrate == CAN_BITRATE_UNSET) 72098b12064SDario Binacchi sl->can.bittiming.bitrate = CAN_BITRATE_UNKNOWN; 72198b12064SDario Binacchi 72298b12064SDario Binacchi err = open_candev(dev); 72398b12064SDario Binacchi if (err) { 72498b12064SDario Binacchi netdev_err(dev, "failed to open can device\n"); 72598b12064SDario Binacchi return err; 72698b12064SDario Binacchi } 72798b12064SDario Binacchi 72898b12064SDario Binacchi sl->flags &= BIT(SLF_INUSE); 72998b12064SDario Binacchi 73098b12064SDario Binacchi if (sl->can.bittiming.bitrate != CAN_BITRATE_UNKNOWN) { 73198b12064SDario Binacchi for (s = 0; s < ARRAY_SIZE(slcan_bitrate_const); s++) { 73298b12064SDario Binacchi if (sl->can.bittiming.bitrate == slcan_bitrate_const[s]) 73398b12064SDario Binacchi break; 73498b12064SDario Binacchi } 73598b12064SDario Binacchi 73698b12064SDario Binacchi /* The CAN framework has already validate the bitrate value, 73798b12064SDario Binacchi * so we can avoid to check if `s' has been properly set. 73898b12064SDario Binacchi */ 73998b12064SDario Binacchi 74098b12064SDario Binacchi snprintf(cmd, sizeof(cmd), "C\rS%d\r", s); 74198b12064SDario Binacchi err = slcan_transmit_cmd(sl, cmd); 74298b12064SDario Binacchi if (err) { 74398b12064SDario Binacchi netdev_err(dev, 74498b12064SDario Binacchi "failed to send bitrate command 'C\\rS%d\\r'\n", 74598b12064SDario Binacchi s); 74698b12064SDario Binacchi goto cmd_transmit_failed; 74798b12064SDario Binacchi } 74898b12064SDario Binacchi 7494de0e8efSDario Binacchi if (test_bit(CF_ERR_RST, &sl->cmd_flags)) { 7504de0e8efSDario Binacchi err = slcan_transmit_cmd(sl, "F\r"); 7514de0e8efSDario Binacchi if (err) { 7524de0e8efSDario Binacchi netdev_err(dev, 7534de0e8efSDario Binacchi "failed to send error command 'F\\r'\n"); 7544de0e8efSDario Binacchi goto cmd_transmit_failed; 7554de0e8efSDario Binacchi } 7564de0e8efSDario Binacchi } 7574de0e8efSDario Binacchi 75898b12064SDario Binacchi err = slcan_transmit_cmd(sl, "O\r"); 75998b12064SDario Binacchi if (err) { 76098b12064SDario Binacchi netdev_err(dev, "failed to send open command 'O\\r'\n"); 76198b12064SDario Binacchi goto cmd_transmit_failed; 76298b12064SDario Binacchi } 76398b12064SDario Binacchi } 76498b12064SDario Binacchi 76598b12064SDario Binacchi sl->can.state = CAN_STATE_ERROR_ACTIVE; 76698b12064SDario Binacchi netif_start_queue(dev); 76798b12064SDario Binacchi return 0; 76898b12064SDario Binacchi 76998b12064SDario Binacchi cmd_transmit_failed: 77098b12064SDario Binacchi close_candev(dev); 77198b12064SDario Binacchi return err; 77298b12064SDario Binacchi } 77398b12064SDario Binacchi 77498b12064SDario Binacchi static void slc_dealloc(struct slcan *sl) 77598b12064SDario Binacchi { 77698b12064SDario Binacchi int i = sl->dev->base_addr; 77798b12064SDario Binacchi 77898b12064SDario Binacchi free_candev(sl->dev); 77998b12064SDario Binacchi slcan_devs[i] = NULL; 78098b12064SDario Binacchi } 78198b12064SDario Binacchi 78298b12064SDario Binacchi static int slcan_change_mtu(struct net_device *dev, int new_mtu) 78398b12064SDario Binacchi { 78498b12064SDario Binacchi return -EINVAL; 78598b12064SDario Binacchi } 78698b12064SDario Binacchi 78798b12064SDario Binacchi static const struct net_device_ops slc_netdev_ops = { 78898b12064SDario Binacchi .ndo_open = slc_open, 78998b12064SDario Binacchi .ndo_stop = slc_close, 79098b12064SDario Binacchi .ndo_start_xmit = slc_xmit, 79198b12064SDario Binacchi .ndo_change_mtu = slcan_change_mtu, 79298b12064SDario Binacchi }; 79398b12064SDario Binacchi 79498b12064SDario Binacchi /****************************************** 79598b12064SDario Binacchi Routines looking at TTY side. 79698b12064SDario Binacchi ******************************************/ 79798b12064SDario Binacchi 79898b12064SDario Binacchi /* 79998b12064SDario Binacchi * Handle the 'receiver data ready' interrupt. 80098b12064SDario Binacchi * This function is called by the 'tty_io' module in the kernel when 80198b12064SDario Binacchi * a block of SLCAN data has been received, which can now be decapsulated 80298b12064SDario Binacchi * and sent on to some IP layer for further processing. This will not 80398b12064SDario Binacchi * be re-entered while running but other ldisc functions may be called 80498b12064SDario Binacchi * in parallel 80598b12064SDario Binacchi */ 80698b12064SDario Binacchi 80798b12064SDario Binacchi static void slcan_receive_buf(struct tty_struct *tty, 80898b12064SDario Binacchi const unsigned char *cp, const char *fp, 80998b12064SDario Binacchi int count) 81098b12064SDario Binacchi { 81198b12064SDario Binacchi struct slcan *sl = (struct slcan *) tty->disc_data; 81298b12064SDario Binacchi 81398b12064SDario Binacchi if (!sl || sl->magic != SLCAN_MAGIC || !netif_running(sl->dev)) 81498b12064SDario Binacchi return; 81598b12064SDario Binacchi 81698b12064SDario Binacchi /* Read the characters out of the buffer */ 81798b12064SDario Binacchi while (count--) { 81898b12064SDario Binacchi if (fp && *fp++) { 81998b12064SDario Binacchi if (!test_and_set_bit(SLF_ERROR, &sl->flags)) 82098b12064SDario Binacchi sl->dev->stats.rx_errors++; 82198b12064SDario Binacchi cp++; 82298b12064SDario Binacchi continue; 82398b12064SDario Binacchi } 82498b12064SDario Binacchi slcan_unesc(sl, *cp++); 82598b12064SDario Binacchi } 82698b12064SDario Binacchi } 82798b12064SDario Binacchi 82898b12064SDario Binacchi /************************************ 82998b12064SDario Binacchi * slcan_open helper routines. 83098b12064SDario Binacchi ************************************/ 83198b12064SDario Binacchi 83298b12064SDario Binacchi /* Collect hanged up channels */ 83398b12064SDario Binacchi static void slc_sync(void) 83498b12064SDario Binacchi { 83598b12064SDario Binacchi int i; 83698b12064SDario Binacchi struct net_device *dev; 83798b12064SDario Binacchi struct slcan *sl; 83898b12064SDario Binacchi 83998b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 84098b12064SDario Binacchi dev = slcan_devs[i]; 84198b12064SDario Binacchi if (dev == NULL) 84298b12064SDario Binacchi break; 84398b12064SDario Binacchi 84498b12064SDario Binacchi sl = netdev_priv(dev); 84598b12064SDario Binacchi if (sl->tty) 84698b12064SDario Binacchi continue; 84798b12064SDario Binacchi if (dev->flags & IFF_UP) 84898b12064SDario Binacchi dev_close(dev); 84998b12064SDario Binacchi } 85098b12064SDario Binacchi } 85198b12064SDario Binacchi 85298b12064SDario Binacchi /* Find a free SLCAN channel, and link in this `tty' line. */ 85398b12064SDario Binacchi static struct slcan *slc_alloc(void) 85498b12064SDario Binacchi { 85598b12064SDario Binacchi int i; 85698b12064SDario Binacchi struct net_device *dev = NULL; 85798b12064SDario Binacchi struct slcan *sl; 85898b12064SDario Binacchi 85998b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 86098b12064SDario Binacchi dev = slcan_devs[i]; 86198b12064SDario Binacchi if (dev == NULL) 86298b12064SDario Binacchi break; 86398b12064SDario Binacchi 86498b12064SDario Binacchi } 86598b12064SDario Binacchi 86698b12064SDario Binacchi /* Sorry, too many, all slots in use */ 86798b12064SDario Binacchi if (i >= maxdev) 86898b12064SDario Binacchi return NULL; 86998b12064SDario Binacchi 87098b12064SDario Binacchi dev = alloc_candev(sizeof(*sl), 1); 87198b12064SDario Binacchi if (!dev) 87298b12064SDario Binacchi return NULL; 87398b12064SDario Binacchi 87498b12064SDario Binacchi snprintf(dev->name, sizeof(dev->name), "slcan%d", i); 87598b12064SDario Binacchi dev->netdev_ops = &slc_netdev_ops; 87698b12064SDario Binacchi dev->base_addr = i; 8774de0e8efSDario Binacchi slcan_set_ethtool_ops(dev); 87898b12064SDario Binacchi sl = netdev_priv(dev); 87998b12064SDario Binacchi 88098b12064SDario Binacchi /* Initialize channel control data */ 88198b12064SDario Binacchi sl->magic = SLCAN_MAGIC; 88298b12064SDario Binacchi sl->dev = dev; 88398b12064SDario Binacchi sl->can.bitrate_const = slcan_bitrate_const; 88498b12064SDario Binacchi sl->can.bitrate_const_cnt = ARRAY_SIZE(slcan_bitrate_const); 88598b12064SDario Binacchi spin_lock_init(&sl->lock); 88698b12064SDario Binacchi INIT_WORK(&sl->tx_work, slcan_transmit); 88798b12064SDario Binacchi init_waitqueue_head(&sl->xcmd_wait); 88898b12064SDario Binacchi slcan_devs[i] = dev; 88998b12064SDario Binacchi 89098b12064SDario Binacchi return sl; 89198b12064SDario Binacchi } 89298b12064SDario Binacchi 89398b12064SDario Binacchi /* 89498b12064SDario Binacchi * Open the high-level part of the SLCAN channel. 89598b12064SDario Binacchi * This function is called by the TTY module when the 89698b12064SDario Binacchi * SLCAN line discipline is called for. Because we are 89798b12064SDario Binacchi * sure the tty line exists, we only have to link it to 89898b12064SDario Binacchi * a free SLCAN channel... 89998b12064SDario Binacchi * 90098b12064SDario Binacchi * Called in process context serialized from other ldisc calls. 90198b12064SDario Binacchi */ 90298b12064SDario Binacchi 90398b12064SDario Binacchi static int slcan_open(struct tty_struct *tty) 90498b12064SDario Binacchi { 90598b12064SDario Binacchi struct slcan *sl; 90698b12064SDario Binacchi int err; 90798b12064SDario Binacchi 90898b12064SDario Binacchi if (!capable(CAP_NET_ADMIN)) 90998b12064SDario Binacchi return -EPERM; 91098b12064SDario Binacchi 91198b12064SDario Binacchi if (tty->ops->write == NULL) 91298b12064SDario Binacchi return -EOPNOTSUPP; 91398b12064SDario Binacchi 91498b12064SDario Binacchi /* RTnetlink lock is misused here to serialize concurrent 91598b12064SDario Binacchi opens of slcan channels. There are better ways, but it is 91698b12064SDario Binacchi the simplest one. 91798b12064SDario Binacchi */ 91898b12064SDario Binacchi rtnl_lock(); 91998b12064SDario Binacchi 92098b12064SDario Binacchi /* Collect hanged up channels. */ 92198b12064SDario Binacchi slc_sync(); 92298b12064SDario Binacchi 92398b12064SDario Binacchi sl = tty->disc_data; 92498b12064SDario Binacchi 92598b12064SDario Binacchi err = -EEXIST; 92698b12064SDario Binacchi /* First make sure we're not already connected. */ 92798b12064SDario Binacchi if (sl && sl->magic == SLCAN_MAGIC) 92898b12064SDario Binacchi goto err_exit; 92998b12064SDario Binacchi 93098b12064SDario Binacchi /* OK. Find a free SLCAN channel to use. */ 93198b12064SDario Binacchi err = -ENFILE; 93298b12064SDario Binacchi sl = slc_alloc(); 93398b12064SDario Binacchi if (sl == NULL) 93498b12064SDario Binacchi goto err_exit; 93598b12064SDario Binacchi 93698b12064SDario Binacchi sl->tty = tty; 93798b12064SDario Binacchi tty->disc_data = sl; 93898b12064SDario Binacchi 93998b12064SDario Binacchi if (!test_bit(SLF_INUSE, &sl->flags)) { 94098b12064SDario Binacchi /* Perform the low-level SLCAN initialization. */ 94198b12064SDario Binacchi sl->rcount = 0; 94298b12064SDario Binacchi sl->xleft = 0; 94398b12064SDario Binacchi 94498b12064SDario Binacchi set_bit(SLF_INUSE, &sl->flags); 94598b12064SDario Binacchi 94698b12064SDario Binacchi rtnl_unlock(); 94798b12064SDario Binacchi err = register_candev(sl->dev); 94898b12064SDario Binacchi if (err) { 94998b12064SDario Binacchi pr_err("slcan: can't register candev\n"); 95098b12064SDario Binacchi goto err_free_chan; 95198b12064SDario Binacchi } 95298b12064SDario Binacchi } else { 95398b12064SDario Binacchi rtnl_unlock(); 95498b12064SDario Binacchi } 95598b12064SDario Binacchi 95698b12064SDario Binacchi tty->receive_room = 65536; /* We don't flow control */ 95798b12064SDario Binacchi 95898b12064SDario Binacchi /* TTY layer expects 0 on success */ 95998b12064SDario Binacchi return 0; 96098b12064SDario Binacchi 96198b12064SDario Binacchi err_free_chan: 96298b12064SDario Binacchi rtnl_lock(); 96398b12064SDario Binacchi sl->tty = NULL; 96498b12064SDario Binacchi tty->disc_data = NULL; 96598b12064SDario Binacchi clear_bit(SLF_INUSE, &sl->flags); 96698b12064SDario Binacchi slc_dealloc(sl); 96798b12064SDario Binacchi rtnl_unlock(); 96898b12064SDario Binacchi return err; 96998b12064SDario Binacchi 97098b12064SDario Binacchi err_exit: 97198b12064SDario Binacchi rtnl_unlock(); 97298b12064SDario Binacchi 97398b12064SDario Binacchi /* Count references from TTY module */ 97498b12064SDario Binacchi return err; 97598b12064SDario Binacchi } 97698b12064SDario Binacchi 97798b12064SDario Binacchi /* 97898b12064SDario Binacchi * Close down a SLCAN channel. 97998b12064SDario Binacchi * This means flushing out any pending queues, and then returning. This 98098b12064SDario Binacchi * call is serialized against other ldisc functions. 98198b12064SDario Binacchi * 98298b12064SDario Binacchi * We also use this method for a hangup event. 98398b12064SDario Binacchi */ 98498b12064SDario Binacchi 98598b12064SDario Binacchi static void slcan_close(struct tty_struct *tty) 98698b12064SDario Binacchi { 98798b12064SDario Binacchi struct slcan *sl = (struct slcan *) tty->disc_data; 98898b12064SDario Binacchi 98998b12064SDario Binacchi /* First make sure we're connected. */ 99098b12064SDario Binacchi if (!sl || sl->magic != SLCAN_MAGIC || sl->tty != tty) 99198b12064SDario Binacchi return; 99298b12064SDario Binacchi 99398b12064SDario Binacchi spin_lock_bh(&sl->lock); 99498b12064SDario Binacchi rcu_assign_pointer(tty->disc_data, NULL); 99598b12064SDario Binacchi sl->tty = NULL; 99698b12064SDario Binacchi spin_unlock_bh(&sl->lock); 99798b12064SDario Binacchi 99898b12064SDario Binacchi synchronize_rcu(); 99998b12064SDario Binacchi flush_work(&sl->tx_work); 100098b12064SDario Binacchi 100198b12064SDario Binacchi slc_close(sl->dev); 100298b12064SDario Binacchi unregister_candev(sl->dev); 100398b12064SDario Binacchi rtnl_lock(); 100498b12064SDario Binacchi slc_dealloc(sl); 100598b12064SDario Binacchi rtnl_unlock(); 100698b12064SDario Binacchi } 100798b12064SDario Binacchi 100898b12064SDario Binacchi static void slcan_hangup(struct tty_struct *tty) 100998b12064SDario Binacchi { 101098b12064SDario Binacchi slcan_close(tty); 101198b12064SDario Binacchi } 101298b12064SDario Binacchi 101398b12064SDario Binacchi /* Perform I/O control on an active SLCAN channel. */ 101498b12064SDario Binacchi static int slcan_ioctl(struct tty_struct *tty, unsigned int cmd, 101598b12064SDario Binacchi unsigned long arg) 101698b12064SDario Binacchi { 101798b12064SDario Binacchi struct slcan *sl = (struct slcan *) tty->disc_data; 101898b12064SDario Binacchi unsigned int tmp; 101998b12064SDario Binacchi 102098b12064SDario Binacchi /* First make sure we're connected. */ 102198b12064SDario Binacchi if (!sl || sl->magic != SLCAN_MAGIC) 102298b12064SDario Binacchi return -EINVAL; 102398b12064SDario Binacchi 102498b12064SDario Binacchi switch (cmd) { 102598b12064SDario Binacchi case SIOCGIFNAME: 102698b12064SDario Binacchi tmp = strlen(sl->dev->name) + 1; 102798b12064SDario Binacchi if (copy_to_user((void __user *)arg, sl->dev->name, tmp)) 102898b12064SDario Binacchi return -EFAULT; 102998b12064SDario Binacchi return 0; 103098b12064SDario Binacchi 103198b12064SDario Binacchi case SIOCSIFHWADDR: 103298b12064SDario Binacchi return -EINVAL; 103398b12064SDario Binacchi 103498b12064SDario Binacchi default: 103598b12064SDario Binacchi return tty_mode_ioctl(tty, cmd, arg); 103698b12064SDario Binacchi } 103798b12064SDario Binacchi } 103898b12064SDario Binacchi 103998b12064SDario Binacchi static struct tty_ldisc_ops slc_ldisc = { 104098b12064SDario Binacchi .owner = THIS_MODULE, 104198b12064SDario Binacchi .num = N_SLCAN, 104298b12064SDario Binacchi .name = "slcan", 104398b12064SDario Binacchi .open = slcan_open, 104498b12064SDario Binacchi .close = slcan_close, 104598b12064SDario Binacchi .hangup = slcan_hangup, 104698b12064SDario Binacchi .ioctl = slcan_ioctl, 104798b12064SDario Binacchi .receive_buf = slcan_receive_buf, 104898b12064SDario Binacchi .write_wakeup = slcan_write_wakeup, 104998b12064SDario Binacchi }; 105098b12064SDario Binacchi 105198b12064SDario Binacchi static int __init slcan_init(void) 105298b12064SDario Binacchi { 105398b12064SDario Binacchi int status; 105498b12064SDario Binacchi 105598b12064SDario Binacchi if (maxdev < 4) 105698b12064SDario Binacchi maxdev = 4; /* Sanity */ 105798b12064SDario Binacchi 105898b12064SDario Binacchi pr_info("slcan: serial line CAN interface driver\n"); 105998b12064SDario Binacchi pr_info("slcan: %d dynamic interface channels.\n", maxdev); 106098b12064SDario Binacchi 106198b12064SDario Binacchi slcan_devs = kcalloc(maxdev, sizeof(struct net_device *), GFP_KERNEL); 106298b12064SDario Binacchi if (!slcan_devs) 106398b12064SDario Binacchi return -ENOMEM; 106498b12064SDario Binacchi 106598b12064SDario Binacchi /* Fill in our line protocol discipline, and register it */ 106698b12064SDario Binacchi status = tty_register_ldisc(&slc_ldisc); 106798b12064SDario Binacchi if (status) { 106898b12064SDario Binacchi printk(KERN_ERR "slcan: can't register line discipline\n"); 106998b12064SDario Binacchi kfree(slcan_devs); 107098b12064SDario Binacchi } 107198b12064SDario Binacchi return status; 107298b12064SDario Binacchi } 107398b12064SDario Binacchi 107498b12064SDario Binacchi static void __exit slcan_exit(void) 107598b12064SDario Binacchi { 107698b12064SDario Binacchi int i; 107798b12064SDario Binacchi struct net_device *dev; 107898b12064SDario Binacchi struct slcan *sl; 107998b12064SDario Binacchi unsigned long timeout = jiffies + HZ; 108098b12064SDario Binacchi int busy = 0; 108198b12064SDario Binacchi 108298b12064SDario Binacchi if (slcan_devs == NULL) 108398b12064SDario Binacchi return; 108498b12064SDario Binacchi 108598b12064SDario Binacchi /* First of all: check for active disciplines and hangup them. 108698b12064SDario Binacchi */ 108798b12064SDario Binacchi do { 108898b12064SDario Binacchi if (busy) 108998b12064SDario Binacchi msleep_interruptible(100); 109098b12064SDario Binacchi 109198b12064SDario Binacchi busy = 0; 109298b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 109398b12064SDario Binacchi dev = slcan_devs[i]; 109498b12064SDario Binacchi if (!dev) 109598b12064SDario Binacchi continue; 109698b12064SDario Binacchi sl = netdev_priv(dev); 109798b12064SDario Binacchi spin_lock_bh(&sl->lock); 109898b12064SDario Binacchi if (sl->tty) { 109998b12064SDario Binacchi busy++; 110098b12064SDario Binacchi tty_hangup(sl->tty); 110198b12064SDario Binacchi } 110298b12064SDario Binacchi spin_unlock_bh(&sl->lock); 110398b12064SDario Binacchi } 110498b12064SDario Binacchi } while (busy && time_before(jiffies, timeout)); 110598b12064SDario Binacchi 110698b12064SDario Binacchi /* FIXME: hangup is async so we should wait when doing this second 110798b12064SDario Binacchi phase */ 110898b12064SDario Binacchi 110998b12064SDario Binacchi for (i = 0; i < maxdev; i++) { 111098b12064SDario Binacchi dev = slcan_devs[i]; 111198b12064SDario Binacchi if (!dev) 111298b12064SDario Binacchi continue; 111398b12064SDario Binacchi 111498b12064SDario Binacchi sl = netdev_priv(dev); 111598b12064SDario Binacchi if (sl->tty) { 111698b12064SDario Binacchi netdev_err(dev, "tty discipline still running\n"); 111798b12064SDario Binacchi } 111898b12064SDario Binacchi 111998b12064SDario Binacchi slc_close(dev); 112098b12064SDario Binacchi unregister_candev(dev); 112198b12064SDario Binacchi slc_dealloc(sl); 112298b12064SDario Binacchi } 112398b12064SDario Binacchi 112498b12064SDario Binacchi kfree(slcan_devs); 112598b12064SDario Binacchi slcan_devs = NULL; 112698b12064SDario Binacchi 112798b12064SDario Binacchi tty_unregister_ldisc(&slc_ldisc); 112898b12064SDario Binacchi } 112998b12064SDario Binacchi 113098b12064SDario Binacchi module_init(slcan_init); 113198b12064SDario Binacchi module_exit(slcan_exit); 1132