-138

Documentation/networking/caif/caif.rst

reviewed

··· 1 1 - .. SPDX-License-Identifier: GPL-2.0 2 2 - .. include:: <isonum.txt> 3 3 - 4 4 - 5 5 - ================ 6 6 - Using Linux CAIF 7 7 - ================ 8 8 - 9 9 - 10 10 - :Copyright: |copy| ST-Ericsson AB 2010 11 11 - 12 12 - :Author: Sjur Brendeland/ sjur.brandeland@stericsson.com 13 13 - 14 14 - Start 15 15 - ===== 16 16 - 17 17 - If you have compiled CAIF for modules do:: 18 18 - 19 19 - $modprobe crc_ccitt 20 20 - $modprobe caif 21 21 - $modprobe caif_socket 22 22 - $modprobe chnl_net 23 23 - 24 24 - 25 25 - Preparing the setup with a STE modem 26 26 - ==================================== 27 27 - 28 28 - If you are working on integration of CAIF you should make sure 29 29 - that the kernel is built with module support. 30 30 - 31 31 - There are some things that need to be tweaked to get the host TTY correctly 32 32 - set up to talk to the modem. 33 33 - Since the CAIF stack is running in the kernel and we want to use the existing 34 34 - TTY, we are installing our physical serial driver as a line discipline above 35 35 - the TTY device. 36 36 - 37 37 - To achieve this we need to install the N_CAIF ldisc from user space. 38 38 - The benefit is that we can hook up to any TTY. 39 39 - 40 40 - The use of Start-of-frame-extension (STX) must also be set as 41 41 - module parameter "ser_use_stx". 42 42 - 43 43 - Normally Frame Checksum is always used on UART, but this is also provided as a 44 44 - module parameter "ser_use_fcs". 45 45 - 46 46 - :: 47 47 - 48 48 - $ modprobe caif_serial ser_ttyname=/dev/ttyS0 ser_use_stx=yes 49 49 - $ ifconfig caif_ttyS0 up 50 50 - 51 51 - PLEASE NOTE: 52 52 - There is a limitation in Android shell. 53 53 - It only accepts one argument to insmod/modprobe! 54 54 - 55 55 - Trouble shooting 56 56 - ================ 57 57 - 58 58 - There are debugfs parameters provided for serial communication. 59 59 - /sys/kernel/debug/caif_serial/<tty-name>/ 60 60 - 61 61 - * ser_state: Prints the bit-mask status where 62 62 - 63 63 - - 0x02 means SENDING, this is a transient state. 64 64 - - 0x10 means FLOW_OFF_SENT, i.e. the previous frame has not been sent 65 65 - and is blocking further send operation. Flow OFF has been propagated 66 66 - to all CAIF Channels using this TTY. 67 67 - 68 68 - * tty_status: Prints the bit-mask tty status information 69 69 - 70 70 - - 0x01 - tty->warned is on. 71 71 - - 0x04 - tty->packed is on. 72 72 - - 0x08 - tty->flow.tco_stopped is on. 73 73 - - 0x10 - tty->hw_stopped is on. 74 74 - - 0x20 - tty->flow.stopped is on. 75 75 - 76 76 - * last_tx_msg: Binary blob Prints the last transmitted frame. 77 77 - 78 78 - This can be printed with:: 79 79 - 80 80 - $od --format=x1 /sys/kernel/debug/caif_serial/<tty>/last_rx_msg. 81 81 - 82 82 - The first two tx messages sent look like this. Note: The initial 83 83 - byte 02 is start of frame extension (STX) used for re-syncing 84 84 - upon errors. 85 85 - 86 86 - - Enumeration:: 87 87 - 88 88 - 0000000 02 05 00 00 03 01 d2 02 89 89 - | | | | | | 90 90 - STX(1) | | | | 91 91 - Length(2)| | | 92 92 - Control Channel(1) 93 93 - Command:Enumeration(1) 94 94 - Link-ID(1) 95 95 - Checksum(2) 96 96 - 97 97 - - Channel Setup:: 98 98 - 99 99 - 0000000 02 07 00 00 00 21 a1 00 48 df 100 100 - | | | | | | | | 101 101 - STX(1) | | | | | | 102 102 - Length(2)| | | | | 103 103 - Control Channel(1) 104 104 - Command:Channel Setup(1) 105 105 - Channel Type(1) 106 106 - Priority and Link-ID(1) 107 107 - Endpoint(1) 108 108 - Checksum(2) 109 109 - 110 110 - * last_rx_msg: Prints the last transmitted frame. 111 111 - 112 112 - The RX messages for LinkSetup look almost identical but they have the 113 113 - bit 0x20 set in the command bit, and Channel Setup has added one byte 114 114 - before Checksum containing Channel ID. 115 115 - 116 116 - NOTE: 117 117 - Several CAIF Messages might be concatenated. The maximum debug 118 118 - buffer size is 128 bytes. 119 119 - 120 120 - Error Scenarios 121 121 - =============== 122 122 - 123 123 - - last_tx_msg contains channel setup message and last_rx_msg is empty -> 124 124 - The host seems to be able to send over the UART, at least the CAIF ldisc get 125 125 - notified that sending is completed. 126 126 - 127 127 - - last_tx_msg contains enumeration message and last_rx_msg is empty -> 128 128 - The host is not able to send the message from UART, the tty has not been 129 129 - able to complete the transmit operation. 130 130 - 131 131 - - if /sys/kernel/debug/caif_serial/<tty>/tty_status is non-zero there 132 132 - might be problems transmitting over UART. 133 133 - 134 134 - E.g. host and modem wiring is not correct you will typically see 135 135 - tty_status = 0x10 (hw_stopped) and ser_state = 0x10 (FLOW_OFF_SENT). 136 136 - 137 137 - You will probably see the enumeration message in last_tx_message 138 138 - and empty last_rx_message.

-12

Documentation/networking/caif/index.rst

reviewed

··· 1 1 - .. SPDX-License-Identifier: GPL-2.0 2 2 - 3 3 - CAIF 4 4 - ==== 5 5 - 6 6 - Contents: 7 7 - 8 8 - .. toctree:: 9 9 - :maxdepth: 2 10 10 - 11 11 - linux_caif 12 12 - caif

-195

Documentation/networking/caif/linux_caif.rst

reviewed

··· 1 1 - .. SPDX-License-Identifier: GPL-2.0 2 2 - .. include:: <isonum.txt> 3 3 - 4 4 - ========== 5 5 - Linux CAIF 6 6 - ========== 7 7 - 8 8 - Copyright |copy| ST-Ericsson AB 2010 9 9 - 10 10 - :Author: Sjur Brendeland/ sjur.brandeland@stericsson.com 11 11 - :License terms: GNU General Public License (GPL) version 2 12 12 - 13 13 - 14 14 - Introduction 15 15 - ============ 16 16 - 17 17 - CAIF is a MUX protocol used by ST-Ericsson cellular modems for 18 18 - communication between Modem and host. The host processes can open virtual AT 19 19 - channels, initiate GPRS Data connections, Video channels and Utility Channels. 20 20 - The Utility Channels are general purpose pipes between modem and host. 21 21 - 22 22 - ST-Ericsson modems support a number of transports between modem 23 23 - and host. Currently, UART and Loopback are available for Linux. 24 24 - 25 25 - 26 26 - Architecture 27 27 - ============ 28 28 - 29 29 - The implementation of CAIF is divided into: 30 30 - 31 31 - * CAIF Socket Layer and GPRS IP Interface. 32 32 - * CAIF Core Protocol Implementation 33 33 - * CAIF Link Layer, implemented as NET devices. 34 34 - 35 35 - :: 36 36 - 37 37 - RTNL 38 38 - ! 39 39 - ! +------+ +------+ 40 40 - ! +------+! +------+! 41 41 - ! ! IP !! !Socket!! 42 42 - +-------> !interf!+ ! API !+ <- CAIF Client APIs 43 43 - ! +------+ +------! 44 44 - ! ! ! 45 45 - ! +-----------+ 46 46 - ! ! 47 47 - ! +------+ <- CAIF Core Protocol 48 48 - ! ! CAIF ! 49 49 - ! ! Core ! 50 50 - ! +------+ 51 51 - ! +----------!---------+ 52 52 - ! ! ! ! 53 53 - ! +------+ +-----+ +------+ 54 54 - +--> ! HSI ! ! TTY ! ! USB ! <- Link Layer (Net Devices) 55 55 - +------+ +-----+ +------+ 56 56 - 57 57 - 58 58 - 59 59 - Implementation 60 60 - ============== 61 61 - 62 62 - 63 63 - CAIF Core Protocol Layer 64 64 - ------------------------ 65 65 - 66 66 - CAIF Core layer implements the CAIF protocol as defined by ST-Ericsson. 67 67 - It implements the CAIF protocol stack in a layered approach, where 68 68 - each layer described in the specification is implemented as a separate layer. 69 69 - The architecture is inspired by the design patterns "Protocol Layer" and 70 70 - "Protocol Packet". 71 71 - 72 72 - CAIF structure 73 73 - ^^^^^^^^^^^^^^ 74 74 - 75 75 - The Core CAIF implementation contains: 76 76 - 77 77 - - Simple implementation of CAIF. 78 78 - - Layered architecture (a la Streams), each layer in the CAIF 79 79 - specification is implemented in a separate c-file. 80 80 - - Clients must call configuration function to add PHY layer. 81 81 - - Clients must implement CAIF layer to consume/produce 82 82 - CAIF payload with receive and transmit functions. 83 83 - - Clients must call configuration function to add and connect the 84 84 - Client layer. 85 85 - - When receiving / transmitting CAIF Packets (cfpkt), ownership is passed 86 86 - to the called function (except for framing layers' receive function) 87 87 - 88 88 - Layered Architecture 89 89 - ==================== 90 90 - 91 91 - The CAIF protocol can be divided into two parts: Support functions and Protocol 92 92 - Implementation. The support functions include: 93 93 - 94 94 - - CFPKT CAIF Packet. Implementation of CAIF Protocol Packet. The 95 95 - CAIF Packet has functions for creating, destroying and adding content 96 96 - and for adding/extracting header and trailers to protocol packets. 97 97 - 98 98 - The CAIF Protocol implementation contains: 99 99 - 100 100 - - CFCNFG CAIF Configuration layer. Configures the CAIF Protocol 101 101 - Stack and provides a Client interface for adding Link-Layer and 102 102 - Driver interfaces on top of the CAIF Stack. 103 103 - 104 104 - - CFCTRL CAIF Control layer. Encodes and Decodes control messages 105 105 - such as enumeration and channel setup. Also matches request and 106 106 - response messages. 107 107 - 108 108 - - CFSERVL General CAIF Service Layer functionality; handles flow 109 109 - control and remote shutdown requests. 110 110 - 111 111 - - CFVEI CAIF VEI layer. Handles CAIF AT Channels on VEI (Virtual 112 112 - External Interface). This layer encodes/decodes VEI frames. 113 113 - 114 114 - - CFDGML CAIF Datagram layer. Handles CAIF Datagram layer (IP 115 115 - traffic), encodes/decodes Datagram frames. 116 116 - 117 117 - - CFMUX CAIF Mux layer. Handles multiplexing between multiple 118 118 - physical bearers and multiple channels such as VEI, Datagram, etc. 119 119 - The MUX keeps track of the existing CAIF Channels and 120 120 - Physical Instances and selects the appropriate instance based 121 121 - on Channel-Id and Physical-ID. 122 122 - 123 123 - - CFFRML CAIF Framing layer. Handles Framing i.e. Frame length 124 124 - and frame checksum. 125 125 - 126 126 - - CFSERL CAIF Serial layer. Handles concatenation/split of frames 127 127 - into CAIF Frames with correct length. 128 128 - 129 129 - :: 130 130 - 131 131 - +---------+ 132 132 - | Config | 133 133 - | CFCNFG | 134 134 - +---------+ 135 135 - ! 136 136 - +---------+ +---------+ +---------+ 137 137 - | AT | | Control | | Datagram| 138 138 - | CFVEIL | | CFCTRL | | CFDGML | 139 139 - +---------+ +---------+ +---------+ 140 140 - \_____________!______________/ 141 141 - ! 142 142 - +---------+ 143 143 - | MUX | 144 144 - | | 145 145 - +---------+ 146 146 - _____!_____ 147 147 - / \ 148 148 - +---------+ +---------+ 149 149 - | CFFRML | | CFFRML | 150 150 - | Framing | | Framing | 151 151 - +---------+ +---------+ 152 152 - ! ! 153 153 - +---------+ +---------+ 154 154 - | | | Serial | 155 155 - | | | CFSERL | 156 156 - +---------+ +---------+ 157 157 - 158 158 - 159 159 - In this layered approach the following "rules" apply. 160 160 - 161 161 - - All layers embed the same structure "struct cflayer" 162 162 - - A layer does not depend on any other layer's private data. 163 163 - - Layers are stacked by setting the pointers:: 164 164 - 165 165 - layer->up , layer->dn 166 166 - 167 167 - - In order to send data upwards, each layer should do:: 168 168 - 169 169 - layer->up->receive(layer->up, packet); 170 170 - 171 171 - - In order to send data downwards, each layer should do:: 172 172 - 173 173 - layer->dn->transmit(layer->dn, packet); 174 174 - 175 175 - 176 176 - CAIF Socket and IP interface 177 177 - ============================ 178 178 - 179 179 - The IP interface and CAIF socket API are implemented on top of the 180 180 - CAIF Core protocol. The IP Interface and CAIF socket have an instance of 181 181 - 'struct cflayer', just like the CAIF Core protocol stack. 182 182 - Net device and Socket implement the 'receive()' function defined by 183 183 - 'struct cflayer', just like the rest of the CAIF stack. In this way, transmit and 184 184 - receive of packets is handled as by the rest of the layers: the 'dn->transmit()' 185 185 - function is called in order to transmit data. 186 186 - 187 187 - Configuration of Link Layer 188 188 - --------------------------- 189 189 - The Link Layer is implemented as Linux network devices (struct net_device). 190 190 - Payload handling and registration is done using standard Linux mechanisms. 191 191 - 192 192 - The CAIF Protocol relies on a loss-less link layer without implementing 193 193 - retransmission. This implies that packet drops must not happen. 194 194 - Therefore a flow-control mechanism is implemented where the physical 195 195 - interface can initiate flow stop for all CAIF Channels.

-1

Documentation/networking/index.rst

reviewed

··· 17 17 diagnostic/index 18 18 dsa/index 19 19 devlink/index 20 20 - caif/index 21 20 ethtool-netlink 22 21 ieee802154 23 22 iso15765-2

-1

Documentation/translations/zh_CN/networking/index.rst

reviewed

··· 42 42 * diagnostic/index 43 43 * dsa/index 44 44 * devlink/index 45 45 - * caif/index 46 45 * ethtool-netlink 47 46 * ieee802154 48 47 * iso15765-2

-9

MAINTAINERS

reviewed

··· 5674 5674 F: Documentation/admin-guide/media/cafe_ccic* 5675 5675 F: drivers/media/platform/marvell/ 5676 5676 5677 5677 - CAIF NETWORK LAYER 5678 5678 - L: netdev@vger.kernel.org 5679 5679 - S: Orphan 5680 5680 - F: Documentation/networking/caif/ 5681 5681 - F: drivers/net/caif/ 5682 5682 - F: include/net/caif/ 5683 5683 - F: include/uapi/linux/caif/ 5684 5684 - F: net/caif/ 5685 5685 - 5686 5677 CAKE QDISC 5687 5678 M: Toke Høiland-Jørgensen <toke@toke.dk> 5688 5679 L: cake@lists.bufferbloat.net (moderated for non-subscribers)

-1

arch/arm/configs/u8500_defconfig

reviewed

··· 37 37 CONFIG_CFG80211_DEBUGFS=y 38 38 CONFIG_MAC80211=y 39 39 CONFIG_MAC80211_LEDS=y 40 40 - CONFIG_CAIF=y 41 40 CONFIG_NFC=m 42 41 CONFIG_NFC_HCI=m 43 42 CONFIG_NFC_SHDLC=y

-2

drivers/net/Kconfig

reviewed

··· 503 503 504 504 source "drivers/atm/Kconfig" 505 505 506 506 - source "drivers/net/caif/Kconfig" 507 507 - 508 506 source "drivers/net/dsa/Kconfig" 509 507 510 508 source "drivers/net/ethernet/Kconfig"

-1

drivers/net/Makefile

reviewed

··· 48 48 # Networking Drivers 49 49 # 50 50 obj-$(CONFIG_ARCNET) += arcnet/ 51 51 - obj-$(CONFIG_CAIF) += caif/ 52 51 obj-$(CONFIG_CAN) += can/ 53 52 ifdef CONFIG_NET_DSA 54 53 obj-y += dsa/

-33

drivers/net/caif/Kconfig

reviewed

··· 1 1 - # SPDX-License-Identifier: GPL-2.0-only 2 2 - # 3 3 - # CAIF physical drivers 4 4 - # 5 5 - 6 6 - menuconfig CAIF_DRIVERS 7 7 - bool "CAIF transport drivers" 8 8 - depends on CAIF 9 9 - help 10 10 - Enable this to see CAIF physical drivers. 11 11 - 12 12 - if CAIF_DRIVERS 13 13 - 14 14 - config CAIF_TTY 15 15 - tristate "CAIF TTY transport driver" 16 16 - depends on CAIF && TTY 17 17 - default n 18 18 - help 19 19 - The CAIF TTY transport driver is a Line Discipline (ldisc) 20 20 - identified as N_CAIF. When this ldisc is opened from user space 21 21 - it will redirect the TTY's traffic into the CAIF stack. 22 22 - 23 23 - config CAIF_VIRTIO 24 24 - tristate "CAIF virtio transport driver" 25 25 - depends on CAIF && HAS_DMA 26 26 - select VHOST_RING 27 27 - select VIRTIO 28 28 - select GENERIC_ALLOCATOR 29 29 - default n 30 30 - help 31 31 - The CAIF driver for CAIF over Virtio. 32 32 - 33 33 - endif # CAIF_DRIVERS

-8

drivers/net/caif/Makefile

reviewed

··· 1 1 - # SPDX-License-Identifier: GPL-2.0 2 2 - ccflags-$(CONFIG_CAIF_DEBUG) := -DDEBUG 3 3 - 4 4 - # Serial interface 5 5 - obj-$(CONFIG_CAIF_TTY) += caif_serial.o 6 6 - 7 7 - # Virtio interface 8 8 - obj-$(CONFIG_CAIF_VIRTIO) += caif_virtio.o

-443

drivers/net/caif/caif_serial.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #include <linux/hardirq.h> 8 8 - #include <linux/init.h> 9 9 - #include <linux/module.h> 10 10 - #include <linux/device.h> 11 11 - #include <linux/types.h> 12 12 - #include <linux/skbuff.h> 13 13 - #include <linux/netdevice.h> 14 14 - #include <linux/rtnetlink.h> 15 15 - #include <linux/tty.h> 16 16 - #include <linux/file.h> 17 17 - #include <linux/if_arp.h> 18 18 - #include <net/caif/caif_device.h> 19 19 - #include <net/caif/cfcnfg.h> 20 20 - #include <linux/err.h> 21 21 - #include <linux/debugfs.h> 22 22 - 23 23 - MODULE_LICENSE("GPL"); 24 24 - MODULE_AUTHOR("Sjur Brendeland"); 25 25 - MODULE_DESCRIPTION("CAIF serial device TTY line discipline"); 26 26 - MODULE_LICENSE("GPL"); 27 27 - MODULE_ALIAS_LDISC(N_CAIF); 28 28 - 29 29 - #define SEND_QUEUE_LOW 10 30 30 - #define SEND_QUEUE_HIGH 100 31 31 - #define CAIF_SENDING 1 /* Bit 1 = 0x02*/ 32 32 - #define CAIF_FLOW_OFF_SENT 4 /* Bit 4 = 0x10 */ 33 33 - #define MAX_WRITE_CHUNK 4096 34 34 - #define ON 1 35 35 - #define OFF 0 36 36 - #define CAIF_MAX_MTU 4096 37 37 - 38 38 - static DEFINE_SPINLOCK(ser_lock); 39 39 - static LIST_HEAD(ser_list); 40 40 - static LIST_HEAD(ser_release_list); 41 41 - 42 42 - static bool ser_loop; 43 43 - module_param(ser_loop, bool, 0444); 44 44 - MODULE_PARM_DESC(ser_loop, "Run in simulated loopback mode."); 45 45 - 46 46 - static bool ser_use_stx = true; 47 47 - module_param(ser_use_stx, bool, 0444); 48 48 - MODULE_PARM_DESC(ser_use_stx, "STX enabled or not."); 49 49 - 50 50 - static bool ser_use_fcs = true; 51 51 - 52 52 - module_param(ser_use_fcs, bool, 0444); 53 53 - MODULE_PARM_DESC(ser_use_fcs, "FCS enabled or not."); 54 54 - 55 55 - static int ser_write_chunk = MAX_WRITE_CHUNK; 56 56 - module_param(ser_write_chunk, int, 0444); 57 57 - 58 58 - MODULE_PARM_DESC(ser_write_chunk, "Maximum size of data written to UART."); 59 59 - 60 60 - static struct dentry *debugfsdir; 61 61 - 62 62 - static int caif_net_open(struct net_device *dev); 63 63 - static int caif_net_close(struct net_device *dev); 64 64 - 65 65 - struct ser_device { 66 66 - struct caif_dev_common common; 67 67 - struct list_head node; 68 68 - struct net_device *dev; 69 69 - struct sk_buff_head head; 70 70 - struct tty_struct *tty; 71 71 - bool tx_started; 72 72 - unsigned long state; 73 73 - #ifdef CONFIG_DEBUG_FS 74 74 - struct dentry *debugfs_tty_dir; 75 75 - struct debugfs_blob_wrapper tx_blob; 76 76 - struct debugfs_blob_wrapper rx_blob; 77 77 - u8 rx_data[128]; 78 78 - u8 tx_data[128]; 79 79 - u8 tty_status; 80 80 - 81 81 - #endif 82 82 - }; 83 83 - 84 84 - static void caifdev_setup(struct net_device *dev); 85 85 - static void ldisc_tx_wakeup(struct tty_struct *tty); 86 86 - #ifdef CONFIG_DEBUG_FS 87 87 - static inline void update_tty_status(struct ser_device *ser) 88 88 - { 89 89 - ser->tty_status = 90 90 - ser->tty->flow.stopped << 5 | 91 91 - ser->tty->flow.tco_stopped << 3 | 92 92 - ser->tty->ctrl.packet << 2; 93 93 - } 94 94 - static inline void debugfs_init(struct ser_device *ser, struct tty_struct *tty) 95 95 - { 96 96 - ser->debugfs_tty_dir = debugfs_create_dir(tty->name, debugfsdir); 97 97 - 98 98 - debugfs_create_blob("last_tx_msg", 0400, ser->debugfs_tty_dir, 99 99 - &ser->tx_blob); 100 100 - 101 101 - debugfs_create_blob("last_rx_msg", 0400, ser->debugfs_tty_dir, 102 102 - &ser->rx_blob); 103 103 - 104 104 - debugfs_create_xul("ser_state", 0400, ser->debugfs_tty_dir, 105 105 - &ser->state); 106 106 - 107 107 - debugfs_create_x8("tty_status", 0400, ser->debugfs_tty_dir, 108 108 - &ser->tty_status); 109 109 - 110 110 - ser->tx_blob.data = ser->tx_data; 111 111 - ser->tx_blob.size = 0; 112 112 - ser->rx_blob.data = ser->rx_data; 113 113 - ser->rx_blob.size = 0; 114 114 - } 115 115 - 116 116 - static inline void debugfs_deinit(struct ser_device *ser) 117 117 - { 118 118 - debugfs_remove_recursive(ser->debugfs_tty_dir); 119 119 - } 120 120 - 121 121 - static inline void debugfs_rx(struct ser_device *ser, const u8 *data, int size) 122 122 - { 123 123 - if (size > sizeof(ser->rx_data)) 124 124 - size = sizeof(ser->rx_data); 125 125 - memcpy(ser->rx_data, data, size); 126 126 - ser->rx_blob.data = ser->rx_data; 127 127 - ser->rx_blob.size = size; 128 128 - } 129 129 - #else 130 130 - static inline void debugfs_init(struct ser_device *ser, struct tty_struct *tty) 131 131 - { 132 132 - } 133 133 - 134 134 - static inline void debugfs_deinit(struct ser_device *ser) 135 135 - { 136 136 - } 137 137 - 138 138 - static inline void update_tty_status(struct ser_device *ser) 139 139 - { 140 140 - } 141 141 - 142 142 - static inline void debugfs_rx(struct ser_device *ser, const u8 *data, int size) 143 143 - { 144 144 - } 145 145 - #endif 146 146 - 147 147 - static void ldisc_receive(struct tty_struct *tty, const u8 *data, 148 148 - const u8 *flags, size_t count) 149 149 - { 150 150 - struct sk_buff *skb = NULL; 151 151 - struct ser_device *ser; 152 152 - int ret; 153 153 - 154 154 - ser = tty->disc_data; 155 155 - 156 156 - /* 157 157 - * NOTE: flags may contain information about break or overrun. 158 158 - * This is not yet handled. 159 159 - */ 160 160 - 161 161 - 162 162 - /* 163 163 - * Workaround for garbage at start of transmission, 164 164 - * only enable if STX handling is not enabled. 165 165 - */ 166 166 - if (!ser->common.use_stx && !ser->tx_started) { 167 167 - dev_info(&ser->dev->dev, 168 168 - "Bytes received before initial transmission -" 169 169 - "bytes discarded.\n"); 170 170 - return; 171 171 - } 172 172 - 173 173 - BUG_ON(ser->dev == NULL); 174 174 - 175 175 - /* Get a suitable caif packet and copy in data. */ 176 176 - skb = netdev_alloc_skb(ser->dev, count+1); 177 177 - if (skb == NULL) 178 178 - return; 179 179 - skb_put_data(skb, data, count); 180 180 - 181 181 - skb->protocol = htons(ETH_P_CAIF); 182 182 - skb_reset_mac_header(skb); 183 183 - debugfs_rx(ser, data, count); 184 184 - /* Push received packet up the stack. */ 185 185 - ret = netif_rx(skb); 186 186 - if (!ret) { 187 187 - ser->dev->stats.rx_packets++; 188 188 - ser->dev->stats.rx_bytes += count; 189 189 - } else 190 190 - ++ser->dev->stats.rx_dropped; 191 191 - update_tty_status(ser); 192 192 - } 193 193 - 194 194 - static int handle_tx(struct ser_device *ser) 195 195 - { 196 196 - struct tty_struct *tty; 197 197 - struct sk_buff *skb; 198 198 - int tty_wr, len, room; 199 199 - 200 200 - tty = ser->tty; 201 201 - ser->tx_started = true; 202 202 - 203 203 - /* Enter critical section */ 204 204 - if (test_and_set_bit(CAIF_SENDING, &ser->state)) 205 205 - return 0; 206 206 - 207 207 - /* skb_peek is safe because handle_tx is called after skb_queue_tail */ 208 208 - while ((skb = skb_peek(&ser->head)) != NULL) { 209 209 - 210 210 - /* Make sure you don't write too much */ 211 211 - len = skb->len; 212 212 - room = tty_write_room(tty); 213 213 - if (!room) 214 214 - break; 215 215 - if (room > ser_write_chunk) 216 216 - room = ser_write_chunk; 217 217 - if (len > room) 218 218 - len = room; 219 219 - 220 220 - /* Write to tty or loopback */ 221 221 - if (!ser_loop) { 222 222 - tty_wr = tty->ops->write(tty, skb->data, len); 223 223 - update_tty_status(ser); 224 224 - } else { 225 225 - tty_wr = len; 226 226 - ldisc_receive(tty, skb->data, NULL, len); 227 227 - } 228 228 - ser->dev->stats.tx_packets++; 229 229 - ser->dev->stats.tx_bytes += tty_wr; 230 230 - 231 231 - /* Error on TTY ?! */ 232 232 - if (tty_wr < 0) 233 233 - goto error; 234 234 - /* Reduce buffer written, and discard if empty */ 235 235 - skb_pull(skb, tty_wr); 236 236 - if (skb->len == 0) { 237 237 - struct sk_buff *tmp = skb_dequeue(&ser->head); 238 238 - WARN_ON(tmp != skb); 239 239 - dev_consume_skb_any(skb); 240 240 - } 241 241 - } 242 242 - /* Send flow off if queue is empty */ 243 243 - if (ser->head.qlen <= SEND_QUEUE_LOW && 244 244 - test_and_clear_bit(CAIF_FLOW_OFF_SENT, &ser->state) && 245 245 - ser->common.flowctrl != NULL) 246 246 - ser->common.flowctrl(ser->dev, ON); 247 247 - clear_bit(CAIF_SENDING, &ser->state); 248 248 - return 0; 249 249 - error: 250 250 - clear_bit(CAIF_SENDING, &ser->state); 251 251 - return tty_wr; 252 252 - } 253 253 - 254 254 - static netdev_tx_t caif_xmit(struct sk_buff *skb, struct net_device *dev) 255 255 - { 256 256 - struct ser_device *ser; 257 257 - 258 258 - ser = netdev_priv(dev); 259 259 - 260 260 - /* Send flow off once, on high water mark */ 261 261 - if (ser->head.qlen > SEND_QUEUE_HIGH && 262 262 - !test_and_set_bit(CAIF_FLOW_OFF_SENT, &ser->state) && 263 263 - ser->common.flowctrl != NULL) 264 264 - 265 265 - ser->common.flowctrl(ser->dev, OFF); 266 266 - 267 267 - skb_queue_tail(&ser->head, skb); 268 268 - return handle_tx(ser); 269 269 - } 270 270 - 271 271 - 272 272 - static void ldisc_tx_wakeup(struct tty_struct *tty) 273 273 - { 274 274 - struct ser_device *ser; 275 275 - 276 276 - ser = tty->disc_data; 277 277 - BUG_ON(ser == NULL); 278 278 - WARN_ON(ser->tty != tty); 279 279 - handle_tx(ser); 280 280 - } 281 281 - 282 282 - 283 283 - static void ser_release(struct work_struct *work) 284 284 - { 285 285 - struct list_head list; 286 286 - struct ser_device *ser, *tmp; 287 287 - struct tty_struct *tty; 288 288 - 289 289 - spin_lock(&ser_lock); 290 290 - list_replace_init(&ser_release_list, &list); 291 291 - spin_unlock(&ser_lock); 292 292 - 293 293 - if (!list_empty(&list)) { 294 294 - rtnl_lock(); 295 295 - list_for_each_entry_safe(ser, tmp, &list, node) { 296 296 - tty = ser->tty; 297 297 - dev_close(ser->dev); 298 298 - unregister_netdevice(ser->dev); 299 299 - debugfs_deinit(ser); 300 300 - tty_kref_put(tty->link); 301 301 - tty_kref_put(tty); 302 302 - } 303 303 - rtnl_unlock(); 304 304 - } 305 305 - } 306 306 - 307 307 - static DECLARE_WORK(ser_release_work, ser_release); 308 308 - 309 309 - static int ldisc_open(struct tty_struct *tty) 310 310 - { 311 311 - struct ser_device *ser; 312 312 - struct net_device *dev; 313 313 - char name[64]; 314 314 - int result; 315 315 - 316 316 - /* No write no play */ 317 317 - if (tty->ops->write == NULL) 318 318 - return -EOPNOTSUPP; 319 319 - if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_TTY_CONFIG)) 320 320 - return -EPERM; 321 321 - 322 322 - /* release devices to avoid name collision */ 323 323 - ser_release(NULL); 324 324 - 325 325 - result = snprintf(name, sizeof(name), "cf%s", tty->name); 326 326 - if (result >= IFNAMSIZ) 327 327 - return -EINVAL; 328 328 - dev = alloc_netdev(sizeof(*ser), name, NET_NAME_UNKNOWN, 329 329 - caifdev_setup); 330 330 - if (!dev) 331 331 - return -ENOMEM; 332 332 - 333 333 - ser = netdev_priv(dev); 334 334 - ser->tty = tty_kref_get(tty); 335 335 - tty_kref_get(tty->link); 336 336 - ser->dev = dev; 337 337 - debugfs_init(ser, tty); 338 338 - tty->receive_room = 4096; 339 339 - tty->disc_data = ser; 340 340 - set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 341 341 - rtnl_lock(); 342 342 - result = register_netdevice(dev); 343 343 - if (result) { 344 344 - tty_kref_put(tty->link); 345 345 - tty_kref_put(tty); 346 346 - rtnl_unlock(); 347 347 - free_netdev(dev); 348 348 - return -ENODEV; 349 349 - } 350 350 - 351 351 - spin_lock(&ser_lock); 352 352 - list_add(&ser->node, &ser_list); 353 353 - spin_unlock(&ser_lock); 354 354 - rtnl_unlock(); 355 355 - netif_stop_queue(dev); 356 356 - update_tty_status(ser); 357 357 - return 0; 358 358 - } 359 359 - 360 360 - static void ldisc_close(struct tty_struct *tty) 361 361 - { 362 362 - struct ser_device *ser = tty->disc_data; 363 363 - 364 364 - spin_lock(&ser_lock); 365 365 - list_move(&ser->node, &ser_release_list); 366 366 - spin_unlock(&ser_lock); 367 367 - schedule_work(&ser_release_work); 368 368 - } 369 369 - 370 370 - /* The line discipline structure. */ 371 371 - static struct tty_ldisc_ops caif_ldisc = { 372 372 - .owner = THIS_MODULE, 373 373 - .num = N_CAIF, 374 374 - .name = "n_caif", 375 375 - .open = ldisc_open, 376 376 - .close = ldisc_close, 377 377 - .receive_buf = ldisc_receive, 378 378 - .write_wakeup = ldisc_tx_wakeup 379 379 - }; 380 380 - 381 381 - static const struct net_device_ops netdev_ops = { 382 382 - .ndo_open = caif_net_open, 383 383 - .ndo_stop = caif_net_close, 384 384 - .ndo_start_xmit = caif_xmit 385 385 - }; 386 386 - 387 387 - static void caifdev_setup(struct net_device *dev) 388 388 - { 389 389 - struct ser_device *serdev = netdev_priv(dev); 390 390 - 391 391 - dev->features = 0; 392 392 - dev->netdev_ops = &netdev_ops; 393 393 - dev->type = ARPHRD_CAIF; 394 394 - dev->flags = IFF_POINTOPOINT | IFF_NOARP; 395 395 - dev->mtu = CAIF_MAX_MTU; 396 396 - dev->priv_flags |= IFF_NO_QUEUE; 397 397 - dev->needs_free_netdev = true; 398 398 - skb_queue_head_init(&serdev->head); 399 399 - serdev->common.link_select = CAIF_LINK_LOW_LATENCY; 400 400 - serdev->common.use_frag = true; 401 401 - serdev->common.use_stx = ser_use_stx; 402 402 - serdev->common.use_fcs = ser_use_fcs; 403 403 - serdev->dev = dev; 404 404 - } 405 405 - 406 406 - 407 407 - static int caif_net_open(struct net_device *dev) 408 408 - { 409 409 - netif_wake_queue(dev); 410 410 - return 0; 411 411 - } 412 412 - 413 413 - static int caif_net_close(struct net_device *dev) 414 414 - { 415 415 - netif_stop_queue(dev); 416 416 - return 0; 417 417 - } 418 418 - 419 419 - static int __init caif_ser_init(void) 420 420 - { 421 421 - int ret; 422 422 - 423 423 - ret = tty_register_ldisc(&caif_ldisc); 424 424 - if (ret < 0) 425 425 - pr_err("cannot register CAIF ldisc=%d err=%d\n", N_CAIF, ret); 426 426 - 427 427 - debugfsdir = debugfs_create_dir("caif_serial", NULL); 428 428 - return ret; 429 429 - } 430 430 - 431 431 - static void __exit caif_ser_exit(void) 432 432 - { 433 433 - spin_lock(&ser_lock); 434 434 - list_splice(&ser_list, &ser_release_list); 435 435 - spin_unlock(&ser_lock); 436 436 - ser_release(NULL); 437 437 - cancel_work_sync(&ser_release_work); 438 438 - tty_unregister_ldisc(&caif_ldisc); 439 439 - debugfs_remove_recursive(debugfsdir); 440 440 - } 441 441 - 442 442 - module_init(caif_ser_init); 443 443 - module_exit(caif_ser_exit);

-791

drivers/net/caif/caif_virtio.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2013 4 4 - * Authors: Vicram Arv 5 5 - * Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no> 6 6 - * Sjur Brendeland 7 7 - */ 8 8 - #include <linux/module.h> 9 9 - #include <linux/if_arp.h> 10 10 - #include <linux/virtio.h> 11 11 - #include <linux/vringh.h> 12 12 - #include <linux/debugfs.h> 13 13 - #include <linux/spinlock.h> 14 14 - #include <linux/genalloc.h> 15 15 - #include <linux/interrupt.h> 16 16 - #include <linux/netdevice.h> 17 17 - #include <linux/rtnetlink.h> 18 18 - #include <linux/virtio_ids.h> 19 19 - #include <linux/virtio_caif.h> 20 20 - #include <linux/virtio_ring.h> 21 21 - #include <linux/dma-mapping.h> 22 22 - #include <net/caif/caif_dev.h> 23 23 - #include <linux/virtio_config.h> 24 24 - 25 25 - MODULE_LICENSE("GPL v2"); 26 26 - MODULE_AUTHOR("Vicram Arv"); 27 27 - MODULE_AUTHOR("Sjur Brendeland"); 28 28 - MODULE_DESCRIPTION("Virtio CAIF Driver"); 29 29 - 30 30 - /* NAPI schedule quota */ 31 31 - #define CFV_DEFAULT_QUOTA 32 32 32 - 33 33 - /* Defaults used if virtio config space is unavailable */ 34 34 - #define CFV_DEF_MTU_SIZE 4096 35 35 - #define CFV_DEF_HEADROOM 32 36 36 - #define CFV_DEF_TAILROOM 32 37 37 - 38 38 - /* Required IP header alignment */ 39 39 - #define IP_HDR_ALIGN 4 40 40 - 41 41 - /* struct cfv_napi_contxt - NAPI context info 42 42 - * @riov: IOV holding data read from the ring. Note that riov may 43 43 - * still hold data when cfv_rx_poll() returns. 44 44 - * @head: Last descriptor ID we received from vringh_getdesc_kern. 45 45 - * We use this to put descriptor back on the used ring. USHRT_MAX is 46 46 - * used to indicate invalid head-id. 47 47 - */ 48 48 - struct cfv_napi_context { 49 49 - struct vringh_kiov riov; 50 50 - unsigned short head; 51 51 - }; 52 52 - 53 53 - /* struct cfv_stats - statistics for debugfs 54 54 - * @rx_napi_complete: Number of NAPI completions (RX) 55 55 - * @rx_napi_resched: Number of calls where the full quota was used (RX) 56 56 - * @rx_nomem: Number of SKB alloc failures (RX) 57 57 - * @rx_kicks: Number of RX kicks 58 58 - * @tx_full_ring: Number times TX ring was full 59 59 - * @tx_no_mem: Number of times TX went out of memory 60 60 - * @tx_flow_on: Number of flow on (TX) 61 61 - * @tx_kicks: Number of TX kicks 62 62 - */ 63 63 - struct cfv_stats { 64 64 - u32 rx_napi_complete; 65 65 - u32 rx_napi_resched; 66 66 - u32 rx_nomem; 67 67 - u32 rx_kicks; 68 68 - u32 tx_full_ring; 69 69 - u32 tx_no_mem; 70 70 - u32 tx_flow_on; 71 71 - u32 tx_kicks; 72 72 - }; 73 73 - 74 74 - /* struct cfv_info - Caif Virtio control structure 75 75 - * @cfdev: caif common header 76 76 - * @vdev: Associated virtio device 77 77 - * @vr_rx: rx/downlink host vring 78 78 - * @vq_tx: tx/uplink virtqueue 79 79 - * @ndev: CAIF link layer device 80 80 - * @watermark_tx: indicates number of free descriptors we need 81 81 - * to reopen the tx-queues after overload. 82 82 - * @tx_lock: protects vq_tx from concurrent use 83 83 - * @tx_release_tasklet: Tasklet for freeing consumed TX buffers 84 84 - * @napi: Napi context used in cfv_rx_poll() 85 85 - * @ctx: Context data used in cfv_rx_poll() 86 86 - * @tx_hr: transmit headroom 87 87 - * @rx_hr: receive headroom 88 88 - * @tx_tr: transmit tail room 89 89 - * @rx_tr: receive tail room 90 90 - * @mtu: transmit max size 91 91 - * @mru: receive max size 92 92 - * @allocsz: size of dma memory reserved for TX buffers 93 93 - * @alloc_addr: virtual address to dma memory for TX buffers 94 94 - * @alloc_dma: dma address to dma memory for TX buffers 95 95 - * @genpool: Gen Pool used for allocating TX buffers 96 96 - * @reserved_mem: Pointer to memory reserve allocated from genpool 97 97 - * @reserved_size: Size of memory reserve allocated from genpool 98 98 - * @stats: Statistics exposed in sysfs 99 99 - * @debugfs: Debugfs dentry for statistic counters 100 100 - */ 101 101 - struct cfv_info { 102 102 - struct caif_dev_common cfdev; 103 103 - struct virtio_device *vdev; 104 104 - struct vringh *vr_rx; 105 105 - struct virtqueue *vq_tx; 106 106 - struct net_device *ndev; 107 107 - unsigned int watermark_tx; 108 108 - /* Protect access to vq_tx */ 109 109 - spinlock_t tx_lock; 110 110 - struct tasklet_struct tx_release_tasklet; 111 111 - struct napi_struct napi; 112 112 - struct cfv_napi_context ctx; 113 113 - u16 tx_hr; 114 114 - u16 rx_hr; 115 115 - u16 tx_tr; 116 116 - u16 rx_tr; 117 117 - u32 mtu; 118 118 - u32 mru; 119 119 - size_t allocsz; 120 120 - void *alloc_addr; 121 121 - dma_addr_t alloc_dma; 122 122 - struct gen_pool *genpool; 123 123 - unsigned long reserved_mem; 124 124 - size_t reserved_size; 125 125 - struct cfv_stats stats; 126 126 - struct dentry *debugfs; 127 127 - }; 128 128 - 129 129 - /* struct buf_info - maintains transmit buffer data handle 130 130 - * @size: size of transmit buffer 131 131 - * @dma_handle: handle to allocated dma device memory area 132 132 - * @vaddr: virtual address mapping to allocated memory area 133 133 - */ 134 134 - struct buf_info { 135 135 - size_t size; 136 136 - u8 *vaddr; 137 137 - }; 138 138 - 139 139 - /* Called from virtio device, in IRQ context */ 140 140 - static void cfv_release_cb(struct virtqueue *vq_tx) 141 141 - { 142 142 - struct cfv_info *cfv = vq_tx->vdev->priv; 143 143 - 144 144 - ++cfv->stats.tx_kicks; 145 145 - tasklet_schedule(&cfv->tx_release_tasklet); 146 146 - } 147 147 - 148 148 - static void free_buf_info(struct cfv_info *cfv, struct buf_info *buf_info) 149 149 - { 150 150 - if (!buf_info) 151 151 - return; 152 152 - gen_pool_free(cfv->genpool, (unsigned long) buf_info->vaddr, 153 153 - buf_info->size); 154 154 - kfree(buf_info); 155 155 - } 156 156 - 157 157 - /* This is invoked whenever the remote processor completed processing 158 158 - * a TX msg we just sent, and the buffer is put back to the used ring. 159 159 - */ 160 160 - static void cfv_release_used_buf(struct virtqueue *vq_tx) 161 161 - { 162 162 - struct cfv_info *cfv = vq_tx->vdev->priv; 163 163 - unsigned long flags; 164 164 - 165 165 - BUG_ON(vq_tx != cfv->vq_tx); 166 166 - 167 167 - for (;;) { 168 168 - unsigned int len; 169 169 - struct buf_info *buf_info; 170 170 - 171 171 - /* Get used buffer from used ring to recycle used descriptors */ 172 172 - spin_lock_irqsave(&cfv->tx_lock, flags); 173 173 - buf_info = virtqueue_get_buf(vq_tx, &len); 174 174 - spin_unlock_irqrestore(&cfv->tx_lock, flags); 175 175 - 176 176 - /* Stop looping if there are no more buffers to free */ 177 177 - if (!buf_info) 178 178 - break; 179 179 - 180 180 - free_buf_info(cfv, buf_info); 181 181 - 182 182 - /* watermark_tx indicates if we previously stopped the tx 183 183 - * queues. If we have enough free stots in the virtio ring, 184 184 - * re-establish memory reserved and open up tx queues. 185 185 - */ 186 186 - if (cfv->vq_tx->num_free <= cfv->watermark_tx) 187 187 - continue; 188 188 - 189 189 - /* Re-establish memory reserve */ 190 190 - if (cfv->reserved_mem == 0 && cfv->genpool) 191 191 - cfv->reserved_mem = 192 192 - gen_pool_alloc(cfv->genpool, 193 193 - cfv->reserved_size); 194 194 - 195 195 - /* Open up the tx queues */ 196 196 - if (cfv->reserved_mem) { 197 197 - cfv->watermark_tx = 198 198 - virtqueue_get_vring_size(cfv->vq_tx); 199 199 - netif_tx_wake_all_queues(cfv->ndev); 200 200 - /* Buffers are recycled in cfv_netdev_tx, so 201 201 - * disable notifications when queues are opened. 202 202 - */ 203 203 - virtqueue_disable_cb(cfv->vq_tx); 204 204 - ++cfv->stats.tx_flow_on; 205 205 - } else { 206 206 - /* if no memory reserve, wait for more free slots */ 207 207 - WARN_ON(cfv->watermark_tx > 208 208 - virtqueue_get_vring_size(cfv->vq_tx)); 209 209 - cfv->watermark_tx += 210 210 - virtqueue_get_vring_size(cfv->vq_tx) / 4; 211 211 - } 212 212 - } 213 213 - } 214 214 - 215 215 - /* Allocate a SKB and copy packet data to it */ 216 216 - static struct sk_buff *cfv_alloc_and_copy_skb(int *err, 217 217 - struct cfv_info *cfv, 218 218 - u8 *frm, u32 frm_len) 219 219 - { 220 220 - struct sk_buff *skb; 221 221 - u32 cfpkt_len, pad_len; 222 222 - 223 223 - *err = 0; 224 224 - /* Verify that packet size with down-link header and mtu size */ 225 225 - if (frm_len > cfv->mru || frm_len <= cfv->rx_hr + cfv->rx_tr) { 226 226 - netdev_err(cfv->ndev, 227 227 - "Invalid frmlen:%u mtu:%u hr:%d tr:%d\n", 228 228 - frm_len, cfv->mru, cfv->rx_hr, 229 229 - cfv->rx_tr); 230 230 - *err = -EPROTO; 231 231 - return NULL; 232 232 - } 233 233 - 234 234 - cfpkt_len = frm_len - (cfv->rx_hr + cfv->rx_tr); 235 235 - pad_len = (unsigned long)(frm + cfv->rx_hr) & (IP_HDR_ALIGN - 1); 236 236 - 237 237 - skb = netdev_alloc_skb(cfv->ndev, frm_len + pad_len); 238 238 - if (!skb) { 239 239 - *err = -ENOMEM; 240 240 - return NULL; 241 241 - } 242 242 - 243 243 - skb_reserve(skb, cfv->rx_hr + pad_len); 244 244 - 245 245 - skb_put_data(skb, frm + cfv->rx_hr, cfpkt_len); 246 246 - return skb; 247 247 - } 248 248 - 249 249 - /* Get packets from the host vring */ 250 250 - static int cfv_rx_poll(struct napi_struct *napi, int quota) 251 251 - { 252 252 - struct cfv_info *cfv = container_of(napi, struct cfv_info, napi); 253 253 - int rxcnt = 0; 254 254 - int err = 0; 255 255 - void *buf; 256 256 - struct sk_buff *skb; 257 257 - struct vringh_kiov *riov = &cfv->ctx.riov; 258 258 - unsigned int skb_len; 259 259 - 260 260 - do { 261 261 - skb = NULL; 262 262 - 263 263 - /* Put the previous iovec back on the used ring and 264 264 - * fetch a new iovec if we have processed all elements. 265 265 - */ 266 266 - if (riov->i == riov->used) { 267 267 - if (cfv->ctx.head != USHRT_MAX) { 268 268 - vringh_complete_kern(cfv->vr_rx, 269 269 - cfv->ctx.head, 270 270 - 0); 271 271 - cfv->ctx.head = USHRT_MAX; 272 272 - } 273 273 - 274 274 - err = vringh_getdesc_kern( 275 275 - cfv->vr_rx, 276 276 - riov, 277 277 - NULL, 278 278 - &cfv->ctx.head, 279 279 - GFP_ATOMIC); 280 280 - 281 281 - if (err <= 0) 282 282 - goto exit; 283 283 - } 284 284 - 285 285 - buf = phys_to_virt((unsigned long) riov->iov[riov->i].iov_base); 286 286 - /* TODO: Add check on valid buffer address */ 287 287 - 288 288 - skb = cfv_alloc_and_copy_skb(&err, cfv, buf, 289 289 - riov->iov[riov->i].iov_len); 290 290 - if (unlikely(err)) 291 291 - goto exit; 292 292 - 293 293 - /* Push received packet up the stack. */ 294 294 - skb_len = skb->len; 295 295 - skb->protocol = htons(ETH_P_CAIF); 296 296 - skb_reset_mac_header(skb); 297 297 - skb->dev = cfv->ndev; 298 298 - err = netif_receive_skb(skb); 299 299 - if (unlikely(err)) { 300 300 - ++cfv->ndev->stats.rx_dropped; 301 301 - } else { 302 302 - ++cfv->ndev->stats.rx_packets; 303 303 - cfv->ndev->stats.rx_bytes += skb_len; 304 304 - } 305 305 - 306 306 - ++riov->i; 307 307 - ++rxcnt; 308 308 - } while (rxcnt < quota); 309 309 - 310 310 - ++cfv->stats.rx_napi_resched; 311 311 - goto out; 312 312 - 313 313 - exit: 314 314 - switch (err) { 315 315 - case 0: 316 316 - ++cfv->stats.rx_napi_complete; 317 317 - 318 318 - /* Really out of packets? (stolen from virtio_net)*/ 319 319 - napi_complete(napi); 320 320 - if (unlikely(!vringh_notify_enable_kern(cfv->vr_rx)) && 321 321 - napi_schedule_prep(napi)) { 322 322 - vringh_notify_disable_kern(cfv->vr_rx); 323 323 - __napi_schedule(napi); 324 324 - } 325 325 - break; 326 326 - 327 327 - case -ENOMEM: 328 328 - ++cfv->stats.rx_nomem; 329 329 - dev_kfree_skb(skb); 330 330 - /* Stop NAPI poll on OOM, we hope to be polled later */ 331 331 - napi_complete(napi); 332 332 - vringh_notify_enable_kern(cfv->vr_rx); 333 333 - break; 334 334 - 335 335 - default: 336 336 - /* We're doomed, any modem fault is fatal */ 337 337 - netdev_warn(cfv->ndev, "Bad ring, disable device\n"); 338 338 - cfv->ndev->stats.rx_dropped = riov->used - riov->i; 339 339 - napi_complete(napi); 340 340 - vringh_notify_disable_kern(cfv->vr_rx); 341 341 - netif_carrier_off(cfv->ndev); 342 342 - break; 343 343 - } 344 344 - out: 345 345 - if (rxcnt && vringh_need_notify_kern(cfv->vr_rx) > 0) 346 346 - vringh_notify(cfv->vr_rx); 347 347 - return rxcnt; 348 348 - } 349 349 - 350 350 - static void cfv_recv(struct virtio_device *vdev, struct vringh *vr_rx) 351 351 - { 352 352 - struct cfv_info *cfv = vdev->priv; 353 353 - 354 354 - ++cfv->stats.rx_kicks; 355 355 - vringh_notify_disable_kern(cfv->vr_rx); 356 356 - napi_schedule(&cfv->napi); 357 357 - } 358 358 - 359 359 - static void cfv_destroy_genpool(struct cfv_info *cfv) 360 360 - { 361 361 - if (cfv->alloc_addr) 362 362 - dma_free_coherent(cfv->vdev->dev.parent->parent, 363 363 - cfv->allocsz, cfv->alloc_addr, 364 364 - cfv->alloc_dma); 365 365 - 366 366 - if (!cfv->genpool) 367 367 - return; 368 368 - gen_pool_free(cfv->genpool, cfv->reserved_mem, 369 369 - cfv->reserved_size); 370 370 - gen_pool_destroy(cfv->genpool); 371 371 - cfv->genpool = NULL; 372 372 - } 373 373 - 374 374 - static int cfv_create_genpool(struct cfv_info *cfv) 375 375 - { 376 376 - int err; 377 377 - 378 378 - /* dma_alloc can only allocate whole pages, and we need a more 379 379 - * fine graned allocation so we use genpool. We ask for space needed 380 380 - * by IP and a full ring. If the dma allcoation fails we retry with a 381 381 - * smaller allocation size. 382 382 - */ 383 383 - err = -ENOMEM; 384 384 - cfv->allocsz = (virtqueue_get_vring_size(cfv->vq_tx) * 385 385 - (ETH_DATA_LEN + cfv->tx_hr + cfv->tx_tr) * 11)/10; 386 386 - if (cfv->allocsz <= (num_possible_cpus() + 1) * cfv->ndev->mtu) 387 387 - return -EINVAL; 388 388 - 389 389 - for (;;) { 390 390 - if (cfv->allocsz <= num_possible_cpus() * cfv->ndev->mtu) { 391 391 - netdev_info(cfv->ndev, "Not enough device memory\n"); 392 392 - return -ENOMEM; 393 393 - } 394 394 - 395 395 - cfv->alloc_addr = dma_alloc_coherent( 396 396 - cfv->vdev->dev.parent->parent, 397 397 - cfv->allocsz, &cfv->alloc_dma, 398 398 - GFP_ATOMIC); 399 399 - if (cfv->alloc_addr) 400 400 - break; 401 401 - 402 402 - cfv->allocsz = (cfv->allocsz * 3) >> 2; 403 403 - } 404 404 - 405 405 - netdev_dbg(cfv->ndev, "Allocated %zd bytes from dma-memory\n", 406 406 - cfv->allocsz); 407 407 - 408 408 - /* Allocate on 128 bytes boundaries (1 << 7)*/ 409 409 - cfv->genpool = gen_pool_create(7, -1); 410 410 - if (!cfv->genpool) 411 411 - goto err; 412 412 - 413 413 - err = gen_pool_add_virt(cfv->genpool, (unsigned long)cfv->alloc_addr, 414 414 - (phys_addr_t)virt_to_phys(cfv->alloc_addr), 415 415 - cfv->allocsz, -1); 416 416 - if (err) 417 417 - goto err; 418 418 - 419 419 - /* Reserve some memory for low memory situations. If we hit the roof 420 420 - * in the memory pool, we stop TX flow and release the reserve. 421 421 - */ 422 422 - cfv->reserved_size = num_possible_cpus() * cfv->ndev->mtu; 423 423 - cfv->reserved_mem = gen_pool_alloc(cfv->genpool, 424 424 - cfv->reserved_size); 425 425 - if (!cfv->reserved_mem) { 426 426 - err = -ENOMEM; 427 427 - goto err; 428 428 - } 429 429 - 430 430 - cfv->watermark_tx = virtqueue_get_vring_size(cfv->vq_tx); 431 431 - return 0; 432 432 - err: 433 433 - cfv_destroy_genpool(cfv); 434 434 - return err; 435 435 - } 436 436 - 437 437 - /* Enable the CAIF interface and allocate the memory-pool */ 438 438 - static int cfv_netdev_open(struct net_device *netdev) 439 439 - { 440 440 - struct cfv_info *cfv = netdev_priv(netdev); 441 441 - 442 442 - if (cfv_create_genpool(cfv)) 443 443 - return -ENOMEM; 444 444 - 445 445 - netif_carrier_on(netdev); 446 446 - napi_enable(&cfv->napi); 447 447 - 448 448 - /* Schedule NAPI to read any pending packets */ 449 449 - napi_schedule(&cfv->napi); 450 450 - return 0; 451 451 - } 452 452 - 453 453 - /* Disable the CAIF interface and free the memory-pool */ 454 454 - static int cfv_netdev_close(struct net_device *netdev) 455 455 - { 456 456 - struct cfv_info *cfv = netdev_priv(netdev); 457 457 - unsigned long flags; 458 458 - struct buf_info *buf_info; 459 459 - 460 460 - /* Disable interrupts, queues and NAPI polling */ 461 461 - netif_carrier_off(netdev); 462 462 - virtqueue_disable_cb(cfv->vq_tx); 463 463 - vringh_notify_disable_kern(cfv->vr_rx); 464 464 - napi_disable(&cfv->napi); 465 465 - 466 466 - /* Release any TX buffers on both used and available rings */ 467 467 - cfv_release_used_buf(cfv->vq_tx); 468 468 - spin_lock_irqsave(&cfv->tx_lock, flags); 469 469 - while ((buf_info = virtqueue_detach_unused_buf(cfv->vq_tx))) 470 470 - free_buf_info(cfv, buf_info); 471 471 - spin_unlock_irqrestore(&cfv->tx_lock, flags); 472 472 - 473 473 - /* Release all dma allocated memory and destroy the pool */ 474 474 - cfv_destroy_genpool(cfv); 475 475 - return 0; 476 476 - } 477 477 - 478 478 - /* Allocate a buffer in dma-memory and copy skb to it */ 479 479 - static struct buf_info *cfv_alloc_and_copy_to_shm(struct cfv_info *cfv, 480 480 - struct sk_buff *skb, 481 481 - struct scatterlist *sg) 482 482 - { 483 483 - struct caif_payload_info *info = (void *)&skb->cb; 484 484 - struct buf_info *buf_info = NULL; 485 485 - u8 pad_len, hdr_ofs; 486 486 - 487 487 - if (!cfv->genpool) 488 488 - goto err; 489 489 - 490 490 - if (unlikely(cfv->tx_hr + skb->len + cfv->tx_tr > cfv->mtu)) { 491 491 - netdev_warn(cfv->ndev, "Invalid packet len (%d > %d)\n", 492 492 - cfv->tx_hr + skb->len + cfv->tx_tr, cfv->mtu); 493 493 - goto err; 494 494 - } 495 495 - 496 496 - buf_info = kmalloc_obj(struct buf_info, GFP_ATOMIC); 497 497 - if (unlikely(!buf_info)) 498 498 - goto err; 499 499 - 500 500 - /* Make the IP header aligned in the buffer */ 501 501 - hdr_ofs = cfv->tx_hr + info->hdr_len; 502 502 - pad_len = hdr_ofs & (IP_HDR_ALIGN - 1); 503 503 - buf_info->size = cfv->tx_hr + skb->len + cfv->tx_tr + pad_len; 504 504 - 505 505 - /* allocate dma memory buffer */ 506 506 - buf_info->vaddr = (void *)gen_pool_alloc(cfv->genpool, buf_info->size); 507 507 - if (unlikely(!buf_info->vaddr)) 508 508 - goto err; 509 509 - 510 510 - /* copy skbuf contents to send buffer */ 511 511 - skb_copy_bits(skb, 0, buf_info->vaddr + cfv->tx_hr + pad_len, skb->len); 512 512 - sg_init_one(sg, buf_info->vaddr + pad_len, 513 513 - skb->len + cfv->tx_hr + cfv->rx_hr); 514 514 - 515 515 - return buf_info; 516 516 - err: 517 517 - kfree(buf_info); 518 518 - return NULL; 519 519 - } 520 520 - 521 521 - /* Put the CAIF packet on the virtio ring and kick the receiver */ 522 522 - static netdev_tx_t cfv_netdev_tx(struct sk_buff *skb, struct net_device *netdev) 523 523 - { 524 524 - struct cfv_info *cfv = netdev_priv(netdev); 525 525 - struct buf_info *buf_info; 526 526 - struct scatterlist sg; 527 527 - unsigned long flags; 528 528 - bool flow_off = false; 529 529 - int ret; 530 530 - 531 531 - /* garbage collect released buffers */ 532 532 - cfv_release_used_buf(cfv->vq_tx); 533 533 - spin_lock_irqsave(&cfv->tx_lock, flags); 534 534 - 535 535 - /* Flow-off check takes into account number of cpus to make sure 536 536 - * virtqueue will not be overfilled in any possible smp conditions. 537 537 - * 538 538 - * Flow-on is triggered when sufficient buffers are freed 539 539 - */ 540 540 - if (unlikely(cfv->vq_tx->num_free <= num_present_cpus())) { 541 541 - flow_off = true; 542 542 - cfv->stats.tx_full_ring++; 543 543 - } 544 544 - 545 545 - /* If we run out of memory, we release the memory reserve and retry 546 546 - * allocation. 547 547 - */ 548 548 - buf_info = cfv_alloc_and_copy_to_shm(cfv, skb, &sg); 549 549 - if (unlikely(!buf_info)) { 550 550 - cfv->stats.tx_no_mem++; 551 551 - flow_off = true; 552 552 - 553 553 - if (cfv->reserved_mem && cfv->genpool) { 554 554 - gen_pool_free(cfv->genpool, cfv->reserved_mem, 555 555 - cfv->reserved_size); 556 556 - cfv->reserved_mem = 0; 557 557 - buf_info = cfv_alloc_and_copy_to_shm(cfv, skb, &sg); 558 558 - } 559 559 - } 560 560 - 561 561 - if (unlikely(flow_off)) { 562 562 - /* Turn flow on when a 1/4 of the descriptors are released */ 563 563 - cfv->watermark_tx = virtqueue_get_vring_size(cfv->vq_tx) / 4; 564 564 - /* Enable notifications of recycled TX buffers */ 565 565 - virtqueue_enable_cb(cfv->vq_tx); 566 566 - netif_tx_stop_all_queues(netdev); 567 567 - } 568 568 - 569 569 - if (unlikely(!buf_info)) { 570 570 - /* If the memory reserve does it's job, this shouldn't happen */ 571 571 - netdev_warn(cfv->ndev, "Out of gen_pool memory\n"); 572 572 - goto err; 573 573 - } 574 574 - 575 575 - ret = virtqueue_add_outbuf(cfv->vq_tx, &sg, 1, buf_info, GFP_ATOMIC); 576 576 - if (unlikely((ret < 0))) { 577 577 - /* If flow control works, this shouldn't happen */ 578 578 - netdev_warn(cfv->ndev, "Failed adding buffer to TX vring:%d\n", 579 579 - ret); 580 580 - goto err; 581 581 - } 582 582 - 583 583 - /* update netdev statistics */ 584 584 - cfv->ndev->stats.tx_packets++; 585 585 - cfv->ndev->stats.tx_bytes += skb->len; 586 586 - spin_unlock_irqrestore(&cfv->tx_lock, flags); 587 587 - 588 588 - /* tell the remote processor it has a pending message to read */ 589 589 - virtqueue_kick(cfv->vq_tx); 590 590 - 591 591 - dev_kfree_skb(skb); 592 592 - return NETDEV_TX_OK; 593 593 - err: 594 594 - spin_unlock_irqrestore(&cfv->tx_lock, flags); 595 595 - cfv->ndev->stats.tx_dropped++; 596 596 - free_buf_info(cfv, buf_info); 597 597 - dev_kfree_skb(skb); 598 598 - return NETDEV_TX_OK; 599 599 - } 600 600 - 601 601 - static void cfv_tx_release_tasklet(struct tasklet_struct *t) 602 602 - { 603 603 - struct cfv_info *cfv = from_tasklet(cfv, t, tx_release_tasklet); 604 604 - cfv_release_used_buf(cfv->vq_tx); 605 605 - } 606 606 - 607 607 - static const struct net_device_ops cfv_netdev_ops = { 608 608 - .ndo_open = cfv_netdev_open, 609 609 - .ndo_stop = cfv_netdev_close, 610 610 - .ndo_start_xmit = cfv_netdev_tx, 611 611 - }; 612 612 - 613 613 - static void cfv_netdev_setup(struct net_device *netdev) 614 614 - { 615 615 - netdev->netdev_ops = &cfv_netdev_ops; 616 616 - netdev->type = ARPHRD_CAIF; 617 617 - netdev->tx_queue_len = 100; 618 618 - netdev->flags = IFF_POINTOPOINT | IFF_NOARP; 619 619 - netdev->mtu = CFV_DEF_MTU_SIZE; 620 620 - netdev->needs_free_netdev = true; 621 621 - } 622 622 - 623 623 - /* Create debugfs counters for the device */ 624 624 - static inline void debugfs_init(struct cfv_info *cfv) 625 625 - { 626 626 - cfv->debugfs = debugfs_create_dir(netdev_name(cfv->ndev), NULL); 627 627 - 628 628 - debugfs_create_u32("rx-napi-complete", 0400, cfv->debugfs, 629 629 - &cfv->stats.rx_napi_complete); 630 630 - debugfs_create_u32("rx-napi-resched", 0400, cfv->debugfs, 631 631 - &cfv->stats.rx_napi_resched); 632 632 - debugfs_create_u32("rx-nomem", 0400, cfv->debugfs, 633 633 - &cfv->stats.rx_nomem); 634 634 - debugfs_create_u32("rx-kicks", 0400, cfv->debugfs, 635 635 - &cfv->stats.rx_kicks); 636 636 - debugfs_create_u32("tx-full-ring", 0400, cfv->debugfs, 637 637 - &cfv->stats.tx_full_ring); 638 638 - debugfs_create_u32("tx-no-mem", 0400, cfv->debugfs, 639 639 - &cfv->stats.tx_no_mem); 640 640 - debugfs_create_u32("tx-kicks", 0400, cfv->debugfs, 641 641 - &cfv->stats.tx_kicks); 642 642 - debugfs_create_u32("tx-flow-on", 0400, cfv->debugfs, 643 643 - &cfv->stats.tx_flow_on); 644 644 - } 645 645 - 646 646 - /* Setup CAIF for the a virtio device */ 647 647 - static int cfv_probe(struct virtio_device *vdev) 648 648 - { 649 649 - vrh_callback_t *vrh_cbs = cfv_recv; 650 650 - const char *cfv_netdev_name = "cfvrt"; 651 651 - struct net_device *netdev; 652 652 - struct cfv_info *cfv; 653 653 - int err; 654 654 - 655 655 - netdev = alloc_netdev(sizeof(struct cfv_info), cfv_netdev_name, 656 656 - NET_NAME_UNKNOWN, cfv_netdev_setup); 657 657 - if (!netdev) 658 658 - return -ENOMEM; 659 659 - 660 660 - cfv = netdev_priv(netdev); 661 661 - cfv->vdev = vdev; 662 662 - cfv->ndev = netdev; 663 663 - 664 664 - spin_lock_init(&cfv->tx_lock); 665 665 - 666 666 - /* Get the RX virtio ring. This is a "host side vring". */ 667 667 - err = -ENODEV; 668 668 - if (!vdev->vringh_config || !vdev->vringh_config->find_vrhs) 669 669 - goto err; 670 670 - 671 671 - err = vdev->vringh_config->find_vrhs(vdev, 1, &cfv->vr_rx, &vrh_cbs); 672 672 - if (err) 673 673 - goto err; 674 674 - 675 675 - /* Get the TX virtio ring. This is a "guest side vring". */ 676 676 - cfv->vq_tx = virtio_find_single_vq(vdev, cfv_release_cb, "output"); 677 677 - if (IS_ERR(cfv->vq_tx)) { 678 678 - err = PTR_ERR(cfv->vq_tx); 679 679 - goto err; 680 680 - } 681 681 - 682 682 - /* Get the CAIF configuration from virtio config space, if available */ 683 683 - if (vdev->config->get) { 684 684 - virtio_cread(vdev, struct virtio_caif_transf_config, headroom, 685 685 - &cfv->tx_hr); 686 686 - virtio_cread(vdev, struct virtio_caif_transf_config, headroom, 687 687 - &cfv->rx_hr); 688 688 - virtio_cread(vdev, struct virtio_caif_transf_config, tailroom, 689 689 - &cfv->tx_tr); 690 690 - virtio_cread(vdev, struct virtio_caif_transf_config, tailroom, 691 691 - &cfv->rx_tr); 692 692 - virtio_cread(vdev, struct virtio_caif_transf_config, mtu, 693 693 - &cfv->mtu); 694 694 - virtio_cread(vdev, struct virtio_caif_transf_config, mtu, 695 695 - &cfv->mru); 696 696 - } else { 697 697 - cfv->tx_hr = CFV_DEF_HEADROOM; 698 698 - cfv->rx_hr = CFV_DEF_HEADROOM; 699 699 - cfv->tx_tr = CFV_DEF_TAILROOM; 700 700 - cfv->rx_tr = CFV_DEF_TAILROOM; 701 701 - cfv->mtu = CFV_DEF_MTU_SIZE; 702 702 - cfv->mru = CFV_DEF_MTU_SIZE; 703 703 - } 704 704 - 705 705 - netdev->needed_headroom = cfv->tx_hr; 706 706 - netdev->needed_tailroom = cfv->tx_tr; 707 707 - 708 708 - /* Disable buffer release interrupts unless we have stopped TX queues */ 709 709 - virtqueue_disable_cb(cfv->vq_tx); 710 710 - 711 711 - netdev->mtu = cfv->mtu - cfv->tx_tr; 712 712 - vdev->priv = cfv; 713 713 - 714 714 - /* Initialize NAPI poll context data */ 715 715 - vringh_kiov_init(&cfv->ctx.riov, NULL, 0); 716 716 - cfv->ctx.head = USHRT_MAX; 717 717 - netif_napi_add_weight(netdev, &cfv->napi, cfv_rx_poll, 718 718 - CFV_DEFAULT_QUOTA); 719 719 - 720 720 - tasklet_setup(&cfv->tx_release_tasklet, cfv_tx_release_tasklet); 721 721 - 722 722 - /* Carrier is off until netdevice is opened */ 723 723 - netif_carrier_off(netdev); 724 724 - 725 725 - /* serialize netdev register + virtio_device_ready() with ndo_open() */ 726 726 - rtnl_lock(); 727 727 - 728 728 - /* register Netdev */ 729 729 - err = register_netdevice(netdev); 730 730 - if (err) { 731 731 - rtnl_unlock(); 732 732 - dev_err(&vdev->dev, "Unable to register netdev (%d)\n", err); 733 733 - goto err; 734 734 - } 735 735 - 736 736 - virtio_device_ready(vdev); 737 737 - 738 738 - rtnl_unlock(); 739 739 - 740 740 - debugfs_init(cfv); 741 741 - 742 742 - return 0; 743 743 - err: 744 744 - netdev_warn(cfv->ndev, "CAIF Virtio probe failed:%d\n", err); 745 745 - 746 746 - if (cfv->vr_rx) 747 747 - vdev->vringh_config->del_vrhs(cfv->vdev); 748 748 - if (cfv->vq_tx) 749 749 - vdev->config->del_vqs(cfv->vdev); 750 750 - free_netdev(netdev); 751 751 - return err; 752 752 - } 753 753 - 754 754 - static void cfv_remove(struct virtio_device *vdev) 755 755 - { 756 756 - struct cfv_info *cfv = vdev->priv; 757 757 - 758 758 - rtnl_lock(); 759 759 - dev_close(cfv->ndev); 760 760 - rtnl_unlock(); 761 761 - 762 762 - tasklet_kill(&cfv->tx_release_tasklet); 763 763 - debugfs_remove_recursive(cfv->debugfs); 764 764 - 765 765 - vringh_kiov_cleanup(&cfv->ctx.riov); 766 766 - virtio_reset_device(vdev); 767 767 - vdev->vringh_config->del_vrhs(cfv->vdev); 768 768 - cfv->vr_rx = NULL; 769 769 - vdev->config->del_vqs(cfv->vdev); 770 770 - unregister_netdev(cfv->ndev); 771 771 - } 772 772 - 773 773 - static struct virtio_device_id id_table[] = { 774 774 - { VIRTIO_ID_CAIF, VIRTIO_DEV_ANY_ID }, 775 775 - { 0 }, 776 776 - }; 777 777 - 778 778 - static unsigned int features[] = { 779 779 - }; 780 780 - 781 781 - static struct virtio_driver caif_virtio_driver = { 782 782 - .feature_table = features, 783 783 - .feature_table_size = ARRAY_SIZE(features), 784 784 - .driver.name = KBUILD_MODNAME, 785 785 - .id_table = id_table, 786 786 - .probe = cfv_probe, 787 787 - .remove = cfv_remove, 788 788 - }; 789 789 - 790 790 - module_virtio_driver(caif_virtio_driver); 791 791 - MODULE_DEVICE_TABLE(virtio, id_table);

-24

include/linux/virtio_caif.h

reviewed

··· 1 1 - /* 2 2 - * Copyright (C) ST-Ericsson AB 2012 3 3 - * Author: Sjur Brændeland <sjur.brandeland@stericsson.com> 4 4 - * 5 5 - * This header is BSD licensed so 6 6 - * anyone can use the definitions to implement compatible remote processors 7 7 - */ 8 8 - 9 9 - #ifndef VIRTIO_CAIF_H 10 10 - #define VIRTIO_CAIF_H 11 11 - 12 12 - #include <linux/types.h> 13 13 - struct virtio_caif_transf_config { 14 14 - __virtio16 headroom; 15 15 - __virtio16 tailroom; 16 16 - __virtio32 mtu; 17 17 - u8 reserved[4]; 18 18 - }; 19 19 - 20 20 - struct virtio_caif_config { 21 21 - struct virtio_caif_transf_config uplink, downlink; 22 22 - u8 reserved[8]; 23 23 - }; 24 24 - #endif

-128

include/net/caif/caif_dev.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CAIF_DEV_H_ 8 8 - #define CAIF_DEV_H_ 9 9 - 10 10 - #include <net/caif/caif_layer.h> 11 11 - #include <net/caif/cfcnfg.h> 12 12 - #include <net/caif/caif_device.h> 13 13 - #include <linux/caif/caif_socket.h> 14 14 - #include <linux/if.h> 15 15 - #include <linux/net.h> 16 16 - 17 17 - /** 18 18 - * struct caif_param - CAIF parameters. 19 19 - * @size: Length of data 20 20 - * @data: Binary Data Blob 21 21 - */ 22 22 - struct caif_param { 23 23 - u16 size; 24 24 - u8 data[256]; 25 25 - }; 26 26 - 27 27 - /** 28 28 - * struct caif_connect_request - Request data for CAIF channel setup. 29 29 - * @protocol: Type of CAIF protocol to use (at, datagram etc) 30 30 - * @sockaddr: Socket address to connect. 31 31 - * @priority: Priority of the connection. 32 32 - * @link_selector: Link selector (high bandwidth or low latency) 33 33 - * @ifindex: kernel index of the interface. 34 34 - * @param: Connect Request parameters (CAIF_SO_REQ_PARAM). 35 35 - * 36 36 - * This struct is used when connecting a CAIF channel. 37 37 - * It contains all CAIF channel configuration options. 38 38 - */ 39 39 - struct caif_connect_request { 40 40 - enum caif_protocol_type protocol; 41 41 - struct sockaddr_caif sockaddr; 42 42 - enum caif_channel_priority priority; 43 43 - enum caif_link_selector link_selector; 44 44 - int ifindex; 45 45 - struct caif_param param; 46 46 - }; 47 47 - 48 48 - /** 49 49 - * caif_connect_client - Connect a client to CAIF Core Stack. 50 50 - * @config: Channel setup parameters, specifying what address 51 51 - * to connect on the Modem. 52 52 - * @client_layer: User implementation of client layer. This layer 53 53 - * MUST have receive and control callback functions 54 54 - * implemented. 55 55 - * @ifindex: Link layer interface index used for this connection. 56 56 - * @headroom: Head room needed by CAIF protocol. 57 57 - * @tailroom: Tail room needed by CAIF protocol. 58 58 - * 59 59 - * This function connects a CAIF channel. The Client must implement 60 60 - * the struct cflayer. This layer represents the Client layer and holds 61 61 - * receive functions and control callback functions. Control callback 62 62 - * function will receive information about connect/disconnect responses, 63 63 - * flow control etc (see enum caif_control). 64 64 - * E.g. CAIF Socket will call this function for each socket it connects 65 65 - * and have one client_layer instance for each socket. 66 66 - */ 67 67 - int caif_connect_client(struct net *net, 68 68 - struct caif_connect_request *conn_req, 69 69 - struct cflayer *client_layer, int *ifindex, 70 70 - int *headroom, int *tailroom); 71 71 - 72 72 - /** 73 73 - * caif_disconnect_client - Disconnects a client from the CAIF stack. 74 74 - * 75 75 - * @client_layer: Client layer to be disconnected. 76 76 - */ 77 77 - int caif_disconnect_client(struct net *net, struct cflayer *client_layer); 78 78 - 79 79 - 80 80 - /** 81 81 - * caif_client_register_refcnt - register ref-count functions provided by client. 82 82 - * 83 83 - * @adapt_layer: Client layer using CAIF Stack. 84 84 - * @hold: Function provided by client layer increasing ref-count 85 85 - * @put: Function provided by client layer decreasing ref-count 86 86 - * 87 87 - * Client of the CAIF Stack must register functions for reference counting. 88 88 - * These functions are called by the CAIF Stack for every upstream packet, 89 89 - * and must therefore be implemented efficiently. 90 90 - * 91 91 - * Client should call caif_free_client when reference count degrease to zero. 92 92 - */ 93 93 - 94 94 - void caif_client_register_refcnt(struct cflayer *adapt_layer, 95 95 - void (*hold)(struct cflayer *lyr), 96 96 - void (*put)(struct cflayer *lyr)); 97 97 - /** 98 98 - * caif_free_client - Free memory used to manage the client in the CAIF Stack. 99 99 - * 100 100 - * @client_layer: Client layer to be removed. 101 101 - * 102 102 - * This function must be called from client layer in order to free memory. 103 103 - * Caller must guarantee that no packets are in flight upstream when calling 104 104 - * this function. 105 105 - */ 106 106 - void caif_free_client(struct cflayer *adap_layer); 107 107 - 108 108 - /** 109 109 - * struct caif_enroll_dev - Enroll a net-device as a CAIF Link layer 110 110 - * @dev: Network device to enroll. 111 111 - * @caifdev: Configuration information from CAIF Link Layer 112 112 - * @link_support: Link layer support layer 113 113 - * @head_room: Head room needed by link support layer 114 114 - * @layer: Lowest layer in CAIF stack 115 115 - * @rcv_fun: Receive function for CAIF stack. 116 116 - * 117 117 - * This function enroll a CAIF link layer into CAIF Stack and 118 118 - * expects the interface to be able to handle CAIF payload. 119 119 - * The link_support layer is used to add any Link Layer specific 120 120 - * framing. 121 121 - */ 122 122 - int caif_enroll_dev(struct net_device *dev, struct caif_dev_common *caifdev, 123 123 - struct cflayer *link_support, int head_room, 124 124 - struct cflayer **layer, int (**rcv_func)( 125 125 - struct sk_buff *, struct net_device *, 126 126 - struct packet_type *, struct net_device *)); 127 127 - 128 128 - #endif /* CAIF_DEV_H_ */

-55

include/net/caif/caif_device.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CAIF_DEVICE_H_ 8 8 - #define CAIF_DEVICE_H_ 9 9 - #include <linux/kernel.h> 10 10 - #include <linux/net.h> 11 11 - #include <linux/netdevice.h> 12 12 - #include <linux/caif/caif_socket.h> 13 13 - #include <net/caif/caif_device.h> 14 14 - 15 15 - /** 16 16 - * struct caif_dev_common - data shared between CAIF drivers and stack. 17 17 - * @flowctrl: Flow Control callback function. This function is 18 18 - * supplied by CAIF Core Stack and is used by CAIF 19 19 - * Link Layer to send flow-stop to CAIF Core. 20 20 - * The flow information will be distributed to all 21 21 - * clients of CAIF. 22 22 - * 23 23 - * @link_select: Profile of device, either high-bandwidth or 24 24 - * low-latency. This member is set by CAIF Link 25 25 - * Layer Device in order to indicate if this device 26 26 - * is a high bandwidth or low latency device. 27 27 - * 28 28 - * @use_frag: CAIF Frames may be fragmented. 29 29 - * Is set by CAIF Link Layer in order to indicate if the 30 30 - * interface receives fragmented frames that must be 31 31 - * assembled by CAIF Core Layer. 32 32 - * 33 33 - * @use_fcs: Indicate if Frame CheckSum (fcs) is used. 34 34 - * Is set if the physical interface is 35 35 - * using Frame Checksum on the CAIF Frames. 36 36 - * 37 37 - * @use_stx: Indicate STart of frame eXtension (stx) in use. 38 38 - * Is set if the CAIF Link Layer expects 39 39 - * CAIF Frames to start with the STX byte. 40 40 - * 41 41 - * This structure is shared between the CAIF drivers and the CAIF stack. 42 42 - * It is used by the device to register its behavior. 43 43 - * CAIF Core layer must set the member flowctrl in order to supply 44 44 - * CAIF Link Layer with the flow control function. 45 45 - * 46 46 - */ 47 47 - struct caif_dev_common { 48 48 - void (*flowctrl)(struct net_device *net, int on); 49 49 - enum caif_link_selector link_select; 50 50 - int use_frag; 51 51 - int use_fcs; 52 52 - int use_stx; 53 53 - }; 54 54 - 55 55 - #endif /* CAIF_DEVICE_H_ */

-277

include/net/caif/caif_layer.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CAIF_LAYER_H_ 8 8 - #define CAIF_LAYER_H_ 9 9 - 10 10 - #include <linux/list.h> 11 11 - 12 12 - struct cflayer; 13 13 - struct cfpkt; 14 14 - struct caif_payload_info; 15 15 - 16 16 - #define CAIF_LAYER_NAME_SZ 16 17 17 - 18 18 - /** 19 19 - * caif_assert() - Assert function for CAIF. 20 20 - * @assert: expression to evaluate. 21 21 - * 22 22 - * This function will print a error message and a do WARN_ON if the 23 23 - * assertion fails. Normally this will do a stack up at the current location. 24 24 - */ 25 25 - #define caif_assert(assert) \ 26 26 - do { \ 27 27 - if (!(assert)) { \ 28 28 - pr_err("caif:Assert detected:'%s'\n", #assert); \ 29 29 - WARN_ON(!(assert)); \ 30 30 - } \ 31 31 - } while (0) 32 32 - 33 33 - /** 34 34 - * enum caif_ctrlcmd - CAIF Stack Control Signaling sent in layer.ctrlcmd(). 35 35 - * 36 36 - * @CAIF_CTRLCMD_FLOW_OFF_IND: Flow Control is OFF, transmit function 37 37 - * should stop sending data 38 38 - * 39 39 - * @CAIF_CTRLCMD_FLOW_ON_IND: Flow Control is ON, transmit function 40 40 - * can start sending data 41 41 - * 42 42 - * @CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND: Remote end modem has decided to close 43 43 - * down channel 44 44 - * 45 45 - * @CAIF_CTRLCMD_INIT_RSP: Called initially when the layer below 46 46 - * has finished initialization 47 47 - * 48 48 - * @CAIF_CTRLCMD_DEINIT_RSP: Called when de-initialization is 49 49 - * complete 50 50 - * 51 51 - * @CAIF_CTRLCMD_INIT_FAIL_RSP: Called if initialization fails 52 52 - * 53 53 - * @_CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND: CAIF Link layer temporarily cannot 54 54 - * send more packets. 55 55 - * @_CAIF_CTRLCMD_PHYIF_FLOW_ON_IND: Called if CAIF Link layer is able 56 56 - * to send packets again. 57 57 - * @_CAIF_CTRLCMD_PHYIF_DOWN_IND: Called if CAIF Link layer is going 58 58 - * down. 59 59 - * 60 60 - * These commands are sent upwards in the CAIF stack to the CAIF Client. 61 61 - * They are used for signaling originating from the modem or CAIF Link Layer. 62 62 - * These are either responses (*_RSP) or events (*_IND). 63 63 - */ 64 64 - enum caif_ctrlcmd { 65 65 - CAIF_CTRLCMD_FLOW_OFF_IND, 66 66 - CAIF_CTRLCMD_FLOW_ON_IND, 67 67 - CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND, 68 68 - CAIF_CTRLCMD_INIT_RSP, 69 69 - CAIF_CTRLCMD_DEINIT_RSP, 70 70 - CAIF_CTRLCMD_INIT_FAIL_RSP, 71 71 - _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND, 72 72 - _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND, 73 73 - _CAIF_CTRLCMD_PHYIF_DOWN_IND, 74 74 - }; 75 75 - 76 76 - /** 77 77 - * enum caif_modemcmd - Modem Control Signaling, sent from CAIF Client 78 78 - * to the CAIF Link Layer or modem. 79 79 - * 80 80 - * @CAIF_MODEMCMD_FLOW_ON_REQ: Flow Control is ON, transmit function 81 81 - * can start sending data. 82 82 - * 83 83 - * @CAIF_MODEMCMD_FLOW_OFF_REQ: Flow Control is OFF, transmit function 84 84 - * should stop sending data. 85 85 - * 86 86 - * @_CAIF_MODEMCMD_PHYIF_USEFULL: Notify physical layer that it is in use 87 87 - * 88 88 - * @_CAIF_MODEMCMD_PHYIF_USELESS: Notify physical layer that it is 89 89 - * no longer in use. 90 90 - * 91 91 - * These are requests sent 'downwards' in the stack. 92 92 - * Flow ON, OFF can be indicated to the modem. 93 93 - */ 94 94 - enum caif_modemcmd { 95 95 - CAIF_MODEMCMD_FLOW_ON_REQ = 0, 96 96 - CAIF_MODEMCMD_FLOW_OFF_REQ = 1, 97 97 - _CAIF_MODEMCMD_PHYIF_USEFULL = 3, 98 98 - _CAIF_MODEMCMD_PHYIF_USELESS = 4 99 99 - }; 100 100 - 101 101 - /** 102 102 - * enum caif_direction - CAIF Packet Direction. 103 103 - * Indicate if a packet is to be sent out or to be received in. 104 104 - * @CAIF_DIR_IN: Incoming packet received. 105 105 - * @CAIF_DIR_OUT: Outgoing packet to be transmitted. 106 106 - */ 107 107 - enum caif_direction { 108 108 - CAIF_DIR_IN = 0, 109 109 - CAIF_DIR_OUT = 1 110 110 - }; 111 111 - 112 112 - /** 113 113 - * struct cflayer - CAIF Stack layer. 114 114 - * Defines the framework for the CAIF Core Stack. 115 115 - * @up: Pointer up to the layer above. 116 116 - * @dn: Pointer down to the layer below. 117 117 - * @node: List node used when layer participate in a list. 118 118 - * @receive: Packet receive function. 119 119 - * @transmit: Packet transmit function. 120 120 - * @ctrlcmd: Used for control signalling upwards in the stack. 121 121 - * @modemcmd: Used for control signaling downwards in the stack. 122 122 - * @id: The identity of this layer 123 123 - * @name: Name of the layer. 124 124 - * 125 125 - * This structure defines the layered structure in CAIF. 126 126 - * 127 127 - * It defines CAIF layering structure, used by all CAIF Layers and the 128 128 - * layers interfacing CAIF. 129 129 - * 130 130 - * In order to integrate with CAIF an adaptation layer on top of the CAIF stack 131 131 - * and PHY layer below the CAIF stack 132 132 - * must be implemented. These layer must follow the design principles below. 133 133 - * 134 134 - * Principles for layering of protocol layers: 135 135 - * - All layers must use this structure. If embedding it, then place this 136 136 - * structure first in the layer specific structure. 137 137 - * 138 138 - * - Each layer should not depend on any others layer's private data. 139 139 - * 140 140 - * - In order to send data upwards do 141 141 - * layer->up->receive(layer->up, packet); 142 142 - * 143 143 - * - In order to send data downwards do 144 144 - * layer->dn->transmit(layer->dn, info, packet); 145 145 - */ 146 146 - struct cflayer { 147 147 - struct cflayer *up; 148 148 - struct cflayer *dn; 149 149 - struct list_head node; 150 150 - 151 151 - /* 152 152 - * receive() - Receive Function (non-blocking). 153 153 - * Contract: Each layer must implement a receive function passing the 154 154 - * CAIF packets upwards in the stack. 155 155 - * Packet handling rules: 156 156 - * - The CAIF packet (cfpkt) ownership is passed to the 157 157 - * called receive function. This means that the 158 158 - * packet cannot be accessed after passing it to the 159 159 - * above layer using up->receive(). 160 160 - * 161 161 - * - If parsing of the packet fails, the packet must be 162 162 - * destroyed and negative error code returned 163 163 - * from the function. 164 164 - * EXCEPTION: If the framing layer (cffrml) returns 165 165 - * -EILSEQ, the packet is not freed. 166 166 - * 167 167 - * - If parsing succeeds (and above layers return OK) then 168 168 - * the function must return a value >= 0. 169 169 - * 170 170 - * Returns result < 0 indicates an error, 0 or positive value 171 171 - * indicates success. 172 172 - * 173 173 - * @layr: Pointer to the current layer the receive function is 174 174 - * implemented for (this pointer). 175 175 - * @cfpkt: Pointer to CaifPacket to be handled. 176 176 - */ 177 177 - int (*receive)(struct cflayer *layr, struct cfpkt *cfpkt); 178 178 - 179 179 - /* 180 180 - * transmit() - Transmit Function (non-blocking). 181 181 - * Contract: Each layer must implement a transmit function passing the 182 182 - * CAIF packet downwards in the stack. 183 183 - * Packet handling rules: 184 184 - * - The CAIF packet (cfpkt) ownership is passed to the 185 185 - * transmit function. This means that the packet 186 186 - * cannot be accessed after passing it to the below 187 187 - * layer using dn->transmit(). 188 188 - * 189 189 - * - Upon error the packet ownership is still passed on, 190 190 - * so the packet shall be freed where error is detected. 191 191 - * Callers of the transmit function shall not free packets, 192 192 - * but errors shall be returned. 193 193 - * 194 194 - * - Return value less than zero means error, zero or 195 195 - * greater than zero means OK. 196 196 - * 197 197 - * Returns result < 0 indicates an error, 0 or positive value 198 198 - * indicates success. 199 199 - * 200 200 - * @layr: Pointer to the current layer the receive function 201 201 - * isimplemented for (this pointer). 202 202 - * @cfpkt: Pointer to CaifPacket to be handled. 203 203 - */ 204 204 - int (*transmit) (struct cflayer *layr, struct cfpkt *cfpkt); 205 205 - 206 206 - /* 207 207 - * cttrlcmd() - Control Function upwards in CAIF Stack (non-blocking). 208 208 - * Used for signaling responses (CAIF_CTRLCMD_*_RSP) 209 209 - * and asynchronous events from the modem (CAIF_CTRLCMD_*_IND) 210 210 - * 211 211 - * @layr: Pointer to the current layer the receive function 212 212 - * is implemented for (this pointer). 213 213 - * @ctrl: Control Command. 214 214 - */ 215 215 - void (*ctrlcmd) (struct cflayer *layr, enum caif_ctrlcmd ctrl, 216 216 - int phyid); 217 217 - 218 218 - /* 219 219 - * modemctrl() - Control Function used for controlling the modem. 220 220 - * Used to signal down-wards in the CAIF stack. 221 221 - * Returns 0 on success, < 0 upon failure. 222 222 - * 223 223 - * @layr: Pointer to the current layer the receive function 224 224 - * is implemented for (this pointer). 225 225 - * @ctrl: Control Command. 226 226 - */ 227 227 - int (*modemcmd) (struct cflayer *layr, enum caif_modemcmd ctrl); 228 228 - 229 229 - unsigned int id; 230 230 - char name[CAIF_LAYER_NAME_SZ]; 231 231 - }; 232 232 - 233 233 - /** 234 234 - * layer_set_up() - Set the up pointer for a specified layer. 235 235 - * @layr: Layer where up pointer shall be set. 236 236 - * @above: Layer above. 237 237 - */ 238 238 - #define layer_set_up(layr, above) ((layr)->up = (struct cflayer *)(above)) 239 239 - 240 240 - /** 241 241 - * layer_set_dn() - Set the down pointer for a specified layer. 242 242 - * @layr: Layer where down pointer shall be set. 243 243 - * @below: Layer below. 244 244 - */ 245 245 - #define layer_set_dn(layr, below) ((layr)->dn = (struct cflayer *)(below)) 246 246 - 247 247 - /** 248 248 - * struct dev_info - Physical Device info information about physical layer. 249 249 - * @dev: Pointer to native physical device. 250 250 - * @id: Physical ID of the physical connection used by the 251 251 - * logical CAIF connection. Used by service layers to 252 252 - * identify their physical id to Caif MUX (CFMUXL)so 253 253 - * that the MUX can add the correct physical ID to the 254 254 - * packet. 255 255 - */ 256 256 - struct dev_info { 257 257 - void *dev; 258 258 - unsigned int id; 259 259 - }; 260 260 - 261 261 - /** 262 262 - * struct caif_payload_info - Payload information embedded in packet (sk_buff). 263 263 - * 264 264 - * @dev_info: Information about the receiving device. 265 265 - * 266 266 - * @hdr_len: Header length, used to align pay load on 32bit boundary. 267 267 - * 268 268 - * @channel_id: Channel ID of the logical CAIF connection. 269 269 - * Used by mux to insert channel id into the caif packet. 270 270 - */ 271 271 - struct caif_payload_info { 272 272 - struct dev_info *dev_info; 273 273 - unsigned short hdr_len; 274 274 - unsigned short channel_id; 275 275 - }; 276 276 - 277 277 - #endif /* CAIF_LAYER_H_ */

-90

include/net/caif/cfcnfg.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CFCNFG_H_ 8 8 - #define CFCNFG_H_ 9 9 - #include <linux/spinlock.h> 10 10 - #include <linux/netdevice.h> 11 11 - #include <net/caif/caif_layer.h> 12 12 - #include <net/caif/cfctrl.h> 13 13 - 14 14 - struct cfcnfg; 15 15 - 16 16 - /** 17 17 - * enum cfcnfg_phy_preference - Physical preference HW Abstraction 18 18 - * 19 19 - * @CFPHYPREF_UNSPECIFIED: Default physical interface 20 20 - * 21 21 - * @CFPHYPREF_LOW_LAT: Default physical interface for low-latency 22 22 - * traffic 23 23 - * @CFPHYPREF_HIGH_BW: Default physical interface for high-bandwidth 24 24 - * traffic 25 25 - * @CFPHYPREF_LOOP: TEST only Loopback interface simulating modem 26 26 - * responses. 27 27 - * 28 28 - */ 29 29 - enum cfcnfg_phy_preference { 30 30 - CFPHYPREF_UNSPECIFIED, 31 31 - CFPHYPREF_LOW_LAT, 32 32 - CFPHYPREF_HIGH_BW, 33 33 - CFPHYPREF_LOOP 34 34 - }; 35 35 - 36 36 - /** 37 37 - * cfcnfg_create() - Get the CAIF configuration object given network. 38 38 - * @net: Network for the CAIF configuration object. 39 39 - */ 40 40 - struct cfcnfg *get_cfcnfg(struct net *net); 41 41 - 42 42 - /** 43 43 - * cfcnfg_create() - Create the CAIF configuration object. 44 44 - */ 45 45 - struct cfcnfg *cfcnfg_create(void); 46 46 - 47 47 - /** 48 48 - * cfcnfg_remove() - Remove the CFCNFG object 49 49 - * @cfg: config object 50 50 - */ 51 51 - void cfcnfg_remove(struct cfcnfg *cfg); 52 52 - 53 53 - /** 54 54 - * cfcnfg_add_phy_layer() - Adds a physical layer to the CAIF stack. 55 55 - * @cnfg: Pointer to a CAIF configuration object, created by 56 56 - * cfcnfg_create(). 57 57 - * @dev: Pointer to link layer device 58 58 - * @phy_layer: Specify the physical layer. The transmit function 59 59 - * MUST be set in the structure. 60 60 - * @pref: The phy (link layer) preference. 61 61 - * @link_support: Protocol implementation for link layer specific protocol. 62 62 - * @fcs: Specify if checksum is used in CAIF Framing Layer. 63 63 - * @head_room: Head space needed by link specific protocol. 64 64 - */ 65 65 - int 66 66 - cfcnfg_add_phy_layer(struct cfcnfg *cnfg, 67 67 - struct net_device *dev, struct cflayer *phy_layer, 68 68 - enum cfcnfg_phy_preference pref, 69 69 - struct cflayer *link_support, 70 70 - bool fcs, int head_room); 71 71 - 72 72 - /** 73 73 - * cfcnfg_del_phy_layer - Deletes an phy layer from the CAIF stack. 74 74 - * 75 75 - * @cnfg: Pointer to a CAIF configuration object, created by 76 76 - * cfcnfg_create(). 77 77 - * @phy_layer: Adaptation layer to be removed. 78 78 - */ 79 79 - int cfcnfg_del_phy_layer(struct cfcnfg *cnfg, struct cflayer *phy_layer); 80 80 - 81 81 - /** 82 82 - * cfcnfg_set_phy_state() - Set the state of the physical interface device. 83 83 - * @cnfg: Configuration object 84 84 - * @phy_layer: Physical Layer representation 85 85 - * @up: State of device 86 86 - */ 87 87 - int cfcnfg_set_phy_state(struct cfcnfg *cnfg, struct cflayer *phy_layer, 88 88 - bool up); 89 89 - 90 90 - #endif /* CFCNFG_H_ */

-130

include/net/caif/cfctrl.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CFCTRL_H_ 8 8 - #define CFCTRL_H_ 9 9 - #include <net/caif/caif_layer.h> 10 10 - #include <net/caif/cfsrvl.h> 11 11 - 12 12 - /* CAIF Control packet commands */ 13 13 - enum cfctrl_cmd { 14 14 - CFCTRL_CMD_LINK_SETUP = 0, 15 15 - CFCTRL_CMD_LINK_DESTROY = 1, 16 16 - CFCTRL_CMD_LINK_ERR = 2, 17 17 - CFCTRL_CMD_ENUM = 3, 18 18 - CFCTRL_CMD_SLEEP = 4, 19 19 - CFCTRL_CMD_WAKE = 5, 20 20 - CFCTRL_CMD_LINK_RECONF = 6, 21 21 - CFCTRL_CMD_START_REASON = 7, 22 22 - CFCTRL_CMD_RADIO_SET = 8, 23 23 - CFCTRL_CMD_MODEM_SET = 9, 24 24 - CFCTRL_CMD_MASK = 0xf 25 25 - }; 26 26 - 27 27 - /* Channel types */ 28 28 - enum cfctrl_srv { 29 29 - CFCTRL_SRV_DECM = 0, 30 30 - CFCTRL_SRV_VEI = 1, 31 31 - CFCTRL_SRV_VIDEO = 2, 32 32 - CFCTRL_SRV_DBG = 3, 33 33 - CFCTRL_SRV_DATAGRAM = 4, 34 34 - CFCTRL_SRV_RFM = 5, 35 35 - CFCTRL_SRV_UTIL = 6, 36 36 - CFCTRL_SRV_MASK = 0xf 37 37 - }; 38 38 - 39 39 - #define CFCTRL_RSP_BIT 0x20 40 40 - #define CFCTRL_ERR_BIT 0x10 41 41 - 42 42 - struct cfctrl_rsp { 43 43 - void (*linksetup_rsp)(struct cflayer *layer, u8 linkid, 44 44 - enum cfctrl_srv serv, u8 phyid, 45 45 - struct cflayer *adapt_layer); 46 46 - void (*linkdestroy_rsp)(struct cflayer *layer, u8 linkid); 47 47 - void (*linkerror_ind)(void); 48 48 - void (*enum_rsp)(void); 49 49 - void (*sleep_rsp)(void); 50 50 - void (*wake_rsp)(void); 51 51 - void (*restart_rsp)(void); 52 52 - void (*radioset_rsp)(void); 53 53 - void (*reject_rsp)(struct cflayer *layer, u8 linkid, 54 54 - struct cflayer *client_layer); 55 55 - }; 56 56 - 57 57 - /* Link Setup Parameters for CAIF-Links. */ 58 58 - struct cfctrl_link_param { 59 59 - enum cfctrl_srv linktype;/* (T3,T0) Type of Channel */ 60 60 - u8 priority; /* (P4,P0) Priority of the channel */ 61 61 - u8 phyid; /* (U2-U0) Physical interface to connect */ 62 62 - u8 endpoint; /* (E1,E0) Endpoint for data channels */ 63 63 - u8 chtype; /* (H1,H0) Channel-Type, applies to 64 64 - * VEI, DEBUG */ 65 65 - union { 66 66 - struct { 67 67 - u8 connid; /* (D7,D0) Video LinkId */ 68 68 - } video; 69 69 - 70 70 - struct { 71 71 - u32 connid; /* (N31,Ngit0) Connection ID used 72 72 - * for Datagram */ 73 73 - } datagram; 74 74 - 75 75 - struct { 76 76 - u32 connid; /* Connection ID used for RFM */ 77 77 - char volume[20]; /* Volume to mount for RFM */ 78 78 - } rfm; /* Configuration for RFM */ 79 79 - 80 80 - struct { 81 81 - u16 fifosize_kb; /* Psock FIFO size in KB */ 82 82 - u16 fifosize_bufs; /* Psock # signal buffers */ 83 83 - char name[16]; /* Name of the PSOCK service */ 84 84 - u8 params[255]; /* Link setup Parameters> */ 85 85 - u16 paramlen; /* Length of Link Setup 86 86 - * Parameters */ 87 87 - } utility; /* Configuration for Utility Links (Psock) */ 88 88 - } u; 89 89 - }; 90 90 - 91 91 - /* This structure is used internally in CFCTRL */ 92 92 - struct cfctrl_request_info { 93 93 - int sequence_no; 94 94 - enum cfctrl_cmd cmd; 95 95 - u8 channel_id; 96 96 - struct cfctrl_link_param param; 97 97 - struct cflayer *client_layer; 98 98 - struct list_head list; 99 99 - }; 100 100 - 101 101 - struct cfctrl { 102 102 - struct cfsrvl serv; 103 103 - struct cfctrl_rsp res; 104 104 - atomic_t req_seq_no; 105 105 - atomic_t rsp_seq_no; 106 106 - struct list_head list; 107 107 - /* Protects from simultaneous access to first_req list */ 108 108 - spinlock_t info_list_lock; 109 109 - #ifndef CAIF_NO_LOOP 110 110 - u8 loop_linkid; 111 111 - int loop_linkused[256]; 112 112 - /* Protects simultaneous access to loop_linkid and loop_linkused */ 113 113 - spinlock_t loop_linkid_lock; 114 114 - #endif 115 115 - 116 116 - }; 117 117 - 118 118 - void cfctrl_enum_req(struct cflayer *cfctrl, u8 physlinkid); 119 119 - int cfctrl_linkup_request(struct cflayer *cfctrl, 120 120 - struct cfctrl_link_param *param, 121 121 - struct cflayer *user_layer); 122 122 - int cfctrl_linkdown_req(struct cflayer *cfctrl, u8 linkid, 123 123 - struct cflayer *client); 124 124 - 125 125 - struct cflayer *cfctrl_create(void); 126 126 - struct cfctrl_rsp *cfctrl_get_respfuncs(struct cflayer *layer); 127 127 - int cfctrl_cancel_req(struct cflayer *layr, struct cflayer *adap_layer); 128 128 - void cfctrl_remove(struct cflayer *layr); 129 129 - 130 130 - #endif /* CFCTRL_H_ */

-21

include/net/caif/cffrml.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CFFRML_H_ 8 8 - #define CFFRML_H_ 9 9 - #include <net/caif/caif_layer.h> 10 10 - #include <linux/netdevice.h> 11 11 - 12 12 - struct cffrml; 13 13 - struct cflayer *cffrml_create(u16 phyid, bool use_fcs); 14 14 - void cffrml_free(struct cflayer *layr); 15 15 - void cffrml_set_uplayer(struct cflayer *this, struct cflayer *up); 16 16 - void cffrml_set_dnlayer(struct cflayer *this, struct cflayer *dn); 17 17 - void cffrml_put(struct cflayer *layr); 18 18 - void cffrml_hold(struct cflayer *layr); 19 19 - int cffrml_refcnt_read(struct cflayer *layr); 20 20 - 21 21 - #endif /* CFFRML_H_ */

-20

include/net/caif/cfmuxl.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CFMUXL_H_ 8 8 - #define CFMUXL_H_ 9 9 - #include <net/caif/caif_layer.h> 10 10 - 11 11 - struct cfsrvl; 12 12 - struct cffrml; 13 13 - 14 14 - struct cflayer *cfmuxl_create(void); 15 15 - int cfmuxl_set_uplayer(struct cflayer *layr, struct cflayer *up, u8 linkid); 16 16 - struct cflayer *cfmuxl_remove_dnlayer(struct cflayer *layr, u8 phyid); 17 17 - int cfmuxl_set_dnlayer(struct cflayer *layr, struct cflayer *up, u8 phyid); 18 18 - struct cflayer *cfmuxl_remove_uplayer(struct cflayer *layr, u8 linkid); 19 19 - 20 20 - #endif /* CFMUXL_H_ */

-232

include/net/caif/cfpkt.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CFPKT_H_ 8 8 - #define CFPKT_H_ 9 9 - #include <net/caif/caif_layer.h> 10 10 - #include <linux/types.h> 11 11 - struct cfpkt; 12 12 - 13 13 - /* Create a CAIF packet. 14 14 - * len: Length of packet to be created 15 15 - * @return New packet. 16 16 - */ 17 17 - struct cfpkt *cfpkt_create(u16 len); 18 18 - 19 19 - /* 20 20 - * Destroy a CAIF Packet. 21 21 - * pkt Packet to be destroyed. 22 22 - */ 23 23 - void cfpkt_destroy(struct cfpkt *pkt); 24 24 - 25 25 - /* 26 26 - * Extract header from packet. 27 27 - * 28 28 - * pkt Packet to extract header data from. 29 29 - * data Pointer to copy the header data into. 30 30 - * len Length of head data to copy. 31 31 - * @return zero on success and error code upon failure 32 32 - */ 33 33 - int cfpkt_extr_head(struct cfpkt *pkt, void *data, u16 len); 34 34 - 35 35 - static inline u8 cfpkt_extr_head_u8(struct cfpkt *pkt) 36 36 - { 37 37 - u8 tmp; 38 38 - 39 39 - cfpkt_extr_head(pkt, &tmp, 1); 40 40 - 41 41 - return tmp; 42 42 - } 43 43 - 44 44 - static inline u16 cfpkt_extr_head_u16(struct cfpkt *pkt) 45 45 - { 46 46 - __le16 tmp; 47 47 - 48 48 - cfpkt_extr_head(pkt, &tmp, 2); 49 49 - 50 50 - return le16_to_cpu(tmp); 51 51 - } 52 52 - 53 53 - static inline u32 cfpkt_extr_head_u32(struct cfpkt *pkt) 54 54 - { 55 55 - __le32 tmp; 56 56 - 57 57 - cfpkt_extr_head(pkt, &tmp, 4); 58 58 - 59 59 - return le32_to_cpu(tmp); 60 60 - } 61 61 - 62 62 - /* 63 63 - * Peek header from packet. 64 64 - * Reads data from packet without changing packet. 65 65 - * 66 66 - * pkt Packet to extract header data from. 67 67 - * data Pointer to copy the header data into. 68 68 - * len Length of head data to copy. 69 69 - * @return zero on success and error code upon failure 70 70 - */ 71 71 - int cfpkt_peek_head(struct cfpkt *pkt, void *data, u16 len); 72 72 - 73 73 - /* 74 74 - * Extract header from trailer (end of packet). 75 75 - * 76 76 - * pkt Packet to extract header data from. 77 77 - * data Pointer to copy the trailer data into. 78 78 - * len Length of header data to copy. 79 79 - * @return zero on success and error code upon failure 80 80 - */ 81 81 - int cfpkt_extr_trail(struct cfpkt *pkt, void *data, u16 len); 82 82 - 83 83 - /* 84 84 - * Add header to packet. 85 85 - * 86 86 - * 87 87 - * pkt Packet to add header data to. 88 88 - * data Pointer to data to copy into the header. 89 89 - * len Length of header data to copy. 90 90 - * @return zero on success and error code upon failure 91 91 - */ 92 92 - int cfpkt_add_head(struct cfpkt *pkt, const void *data, u16 len); 93 93 - 94 94 - /* 95 95 - * Add trailer to packet. 96 96 - * 97 97 - * 98 98 - * pkt Packet to add trailer data to. 99 99 - * data Pointer to data to copy into the trailer. 100 100 - * len Length of trailer data to copy. 101 101 - * @return zero on success and error code upon failure 102 102 - */ 103 103 - int cfpkt_add_trail(struct cfpkt *pkt, const void *data, u16 len); 104 104 - 105 105 - /* 106 106 - * Pad trailer on packet. 107 107 - * Moves data pointer in packet, no content copied. 108 108 - * 109 109 - * pkt Packet in which to pad trailer. 110 110 - * len Length of padding to add. 111 111 - * @return zero on success and error code upon failure 112 112 - */ 113 113 - int cfpkt_pad_trail(struct cfpkt *pkt, u16 len); 114 114 - 115 115 - /* 116 116 - * Add a single byte to packet body (tail). 117 117 - * 118 118 - * pkt Packet in which to add byte. 119 119 - * data Byte to add. 120 120 - * @return zero on success and error code upon failure 121 121 - */ 122 122 - int cfpkt_addbdy(struct cfpkt *pkt, const u8 data); 123 123 - 124 124 - /* 125 125 - * Add a data to packet body (tail). 126 126 - * 127 127 - * pkt Packet in which to add data. 128 128 - * data Pointer to data to copy into the packet body. 129 129 - * len Length of data to add. 130 130 - * @return zero on success and error code upon failure 131 131 - */ 132 132 - int cfpkt_add_body(struct cfpkt *pkt, const void *data, u16 len); 133 133 - 134 134 - /* 135 135 - * Checks whether there are more data to process in packet. 136 136 - * pkt Packet to check. 137 137 - * @return true if more data are available in packet false otherwise 138 138 - */ 139 139 - bool cfpkt_more(struct cfpkt *pkt); 140 140 - 141 141 - /* 142 142 - * Checks whether the packet is erroneous, 143 143 - * i.e. if it has been attempted to extract more data than available in packet 144 144 - * or writing more data than has been allocated in cfpkt_create(). 145 145 - * pkt Packet to check. 146 146 - * @return true on error false otherwise 147 147 - */ 148 148 - bool cfpkt_erroneous(struct cfpkt *pkt); 149 149 - 150 150 - /* 151 151 - * Get the packet length. 152 152 - * pkt Packet to get length from. 153 153 - * @return Number of bytes in packet. 154 154 - */ 155 155 - u16 cfpkt_getlen(struct cfpkt *pkt); 156 156 - 157 157 - /* 158 158 - * Set the packet length, by adjusting the trailer pointer according to length. 159 159 - * pkt Packet to set length. 160 160 - * len Packet length. 161 161 - * @return Number of bytes in packet. 162 162 - */ 163 163 - int cfpkt_setlen(struct cfpkt *pkt, u16 len); 164 164 - 165 165 - /* 166 166 - * cfpkt_append - Appends a packet's data to another packet. 167 167 - * dstpkt: Packet to append data into, WILL BE FREED BY THIS FUNCTION 168 168 - * addpkt: Packet to be appended and automatically released, 169 169 - * WILL BE FREED BY THIS FUNCTION. 170 170 - * expectlen: Packet's expected total length. This should be considered 171 171 - * as a hint. 172 172 - * NB: Input packets will be destroyed after appending and cannot be used 173 173 - * after calling this function. 174 174 - * @return The new appended packet. 175 175 - */ 176 176 - struct cfpkt *cfpkt_append(struct cfpkt *dstpkt, struct cfpkt *addpkt, 177 177 - u16 expectlen); 178 178 - 179 179 - /* 180 180 - * cfpkt_split - Split a packet into two packets at the specified split point. 181 181 - * pkt: Packet to be split (will contain the first part of the data on exit) 182 182 - * pos: Position to split packet in two parts. 183 183 - * @return The new packet, containing the second part of the data. 184 184 - */ 185 185 - struct cfpkt *cfpkt_split(struct cfpkt *pkt, u16 pos); 186 186 - 187 187 - /* 188 188 - * Iteration function, iterates the packet buffers from start to end. 189 189 - * 190 190 - * Checksum iteration function used to iterate buffers 191 191 - * (we may have packets consisting of a chain of buffers) 192 192 - * pkt: Packet to calculate checksum for 193 193 - * iter_func: Function pointer to iteration function 194 194 - * chks: Checksum calculated so far. 195 195 - * buf: Pointer to the buffer to checksum 196 196 - * len: Length of buf. 197 197 - * data: Initial checksum value. 198 198 - * @return Checksum of buffer. 199 199 - */ 200 200 - 201 201 - int cfpkt_iterate(struct cfpkt *pkt, 202 202 - u16 (*iter_func)(u16 chks, void *buf, u16 len), 203 203 - u16 data); 204 204 - 205 205 - /* Map from a "native" packet (e.g. Linux Socket Buffer) to a CAIF packet. 206 206 - * dir - Direction indicating whether this packet is to be sent or received. 207 207 - * nativepkt - The native packet to be transformed to a CAIF packet 208 208 - * @return The mapped CAIF Packet CFPKT. 209 209 - */ 210 210 - struct cfpkt *cfpkt_fromnative(enum caif_direction dir, void *nativepkt); 211 211 - 212 212 - /* Map from a CAIF packet to a "native" packet (e.g. Linux Socket Buffer). 213 213 - * pkt - The CAIF packet to be transformed into a "native" packet. 214 214 - * @return The native packet transformed from a CAIF packet. 215 215 - */ 216 216 - void *cfpkt_tonative(struct cfpkt *pkt); 217 217 - 218 218 - /* 219 219 - * Returns packet information for a packet. 220 220 - * pkt Packet to get info from; 221 221 - * @return Packet information 222 222 - */ 223 223 - struct caif_payload_info *cfpkt_info(struct cfpkt *pkt); 224 224 - 225 225 - /** cfpkt_set_prio - set priority for a CAIF packet. 226 226 - * 227 227 - * @pkt: The CAIF packet to be adjusted. 228 228 - * @prio: one of TC_PRIO_ constants. 229 229 - */ 230 230 - void cfpkt_set_prio(struct cfpkt *pkt, int prio); 231 231 - 232 232 - #endif /* CFPKT_H_ */

-13

include/net/caif/cfserl.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CFSERL_H_ 8 8 - #define CFSERL_H_ 9 9 - #include <net/caif/caif_layer.h> 10 10 - 11 11 - struct cflayer *cfserl_create(int instance, bool use_stx); 12 12 - void cfserl_release(struct cflayer *layer); 13 13 - #endif

-61

include/net/caif/cfsrvl.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #ifndef CFSRVL_H_ 8 8 - #define CFSRVL_H_ 9 9 - #include <linux/list.h> 10 10 - #include <linux/stddef.h> 11 11 - #include <linux/types.h> 12 12 - #include <linux/kref.h> 13 13 - #include <linux/rculist.h> 14 14 - 15 15 - struct cfsrvl { 16 16 - struct cflayer layer; 17 17 - bool open; 18 18 - bool phy_flow_on; 19 19 - bool modem_flow_on; 20 20 - bool supports_flowctrl; 21 21 - void (*release)(struct cflayer *layer); 22 22 - struct dev_info dev_info; 23 23 - void (*hold)(struct cflayer *lyr); 24 24 - void (*put)(struct cflayer *lyr); 25 25 - struct rcu_head rcu; 26 26 - }; 27 27 - 28 28 - struct cflayer *cfvei_create(u8 linkid, struct dev_info *dev_info); 29 29 - struct cflayer *cfdgml_create(u8 linkid, struct dev_info *dev_info); 30 30 - struct cflayer *cfutill_create(u8 linkid, struct dev_info *dev_info); 31 31 - struct cflayer *cfvidl_create(u8 linkid, struct dev_info *dev_info); 32 32 - struct cflayer *cfrfml_create(u8 linkid, struct dev_info *dev_info, 33 33 - int mtu_size); 34 34 - struct cflayer *cfdbgl_create(u8 linkid, struct dev_info *dev_info); 35 35 - 36 36 - bool cfsrvl_phyid_match(struct cflayer *layer, int phyid); 37 37 - 38 38 - void cfsrvl_init(struct cfsrvl *service, 39 39 - u8 channel_id, 40 40 - struct dev_info *dev_info, 41 41 - bool supports_flowctrl); 42 42 - bool cfsrvl_ready(struct cfsrvl *service, int *err); 43 43 - 44 44 - static inline void cfsrvl_get(struct cflayer *layr) 45 45 - { 46 46 - struct cfsrvl *s = container_of(layr, struct cfsrvl, layer); 47 47 - if (layr == NULL || layr->up == NULL || s->hold == NULL) 48 48 - return; 49 49 - 50 50 - s->hold(layr->up); 51 51 - } 52 52 - 53 53 - static inline void cfsrvl_put(struct cflayer *layr) 54 54 - { 55 55 - struct cfsrvl *s = container_of(layr, struct cfsrvl, layer); 56 56 - if (layr == NULL || layr->up == NULL || s->hold == NULL) 57 57 - return; 58 58 - 59 59 - s->put(layr->up); 60 60 - } 61 61 - #endif /* CFSRVL_H_ */

-195

include/uapi/linux/caif/caif_socket.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ 2 2 - /* linux/caif_socket.h 3 3 - * CAIF Definitions for CAIF socket and network layer 4 4 - * Copyright (C) ST-Ericsson AB 2010 5 5 - * Author: Sjur Brendeland 6 6 - * License terms: GNU General Public License (GPL) version 2 7 7 - */ 8 8 - 9 9 - #ifndef _LINUX_CAIF_SOCKET_H 10 10 - #define _LINUX_CAIF_SOCKET_H 11 11 - 12 12 - #include <linux/types.h> 13 13 - #include <linux/socket.h> 14 14 - 15 15 - /** 16 16 - * enum caif_link_selector - Physical Link Selection. 17 17 - * @CAIF_LINK_HIGH_BANDW: Physical interface for high-bandwidth 18 18 - * traffic. 19 19 - * @CAIF_LINK_LOW_LATENCY: Physical interface for low-latency 20 20 - * traffic. 21 21 - * 22 22 - * CAIF Link Layers can register their link properties. 23 23 - * This enum is used for choosing between CAIF Link Layers when 24 24 - * setting up CAIF Channels when multiple CAIF Link Layers exists. 25 25 - */ 26 26 - enum caif_link_selector { 27 27 - CAIF_LINK_HIGH_BANDW, 28 28 - CAIF_LINK_LOW_LATENCY 29 29 - }; 30 30 - 31 31 - /** 32 32 - * enum caif_channel_priority - CAIF channel priorities. 33 33 - * 34 34 - * @CAIF_PRIO_MIN: Min priority for a channel. 35 35 - * @CAIF_PRIO_LOW: Low-priority channel. 36 36 - * @CAIF_PRIO_NORMAL: Normal/default priority level. 37 37 - * @CAIF_PRIO_HIGH: High priority level 38 38 - * @CAIF_PRIO_MAX: Max priority for channel 39 39 - * 40 40 - * Priority can be set on CAIF Channels in order to 41 41 - * prioritize between traffic on different CAIF Channels. 42 42 - * These priority levels are recommended, but the priority value 43 43 - * is not restricted to the values defined in this enum, any value 44 44 - * between CAIF_PRIO_MIN and CAIF_PRIO_MAX could be used. 45 45 - */ 46 46 - enum caif_channel_priority { 47 47 - CAIF_PRIO_MIN = 0x01, 48 48 - CAIF_PRIO_LOW = 0x04, 49 49 - CAIF_PRIO_NORMAL = 0x0f, 50 50 - CAIF_PRIO_HIGH = 0x14, 51 51 - CAIF_PRIO_MAX = 0x1F 52 52 - }; 53 53 - 54 54 - /** 55 55 - * enum caif_protocol_type - CAIF Channel type. 56 56 - * @CAIFPROTO_AT: Classic AT channel. 57 57 - * @CAIFPROTO_DATAGRAM: Datagram channel. 58 58 - * @CAIFPROTO_DATAGRAM_LOOP: Datagram loopback channel, used for testing. 59 59 - * @CAIFPROTO_UTIL: Utility (Psock) channel. 60 60 - * @CAIFPROTO_RFM: Remote File Manager 61 61 - * @CAIFPROTO_DEBUG: Debug link 62 62 - * 63 63 - * This enum defines the CAIF Channel type to be used. This defines 64 64 - * the service to connect to on the modem. 65 65 - */ 66 66 - enum caif_protocol_type { 67 67 - CAIFPROTO_AT, 68 68 - CAIFPROTO_DATAGRAM, 69 69 - CAIFPROTO_DATAGRAM_LOOP, 70 70 - CAIFPROTO_UTIL, 71 71 - CAIFPROTO_RFM, 72 72 - CAIFPROTO_DEBUG, 73 73 - _CAIFPROTO_MAX 74 74 - }; 75 75 - #define CAIFPROTO_MAX _CAIFPROTO_MAX 76 76 - 77 77 - /** 78 78 - * enum caif_at_type - AT Service Endpoint 79 79 - * @CAIF_ATTYPE_PLAIN: Connects to a plain vanilla AT channel. 80 80 - */ 81 81 - enum caif_at_type { 82 82 - CAIF_ATTYPE_PLAIN = 2 83 83 - }; 84 84 - /** 85 85 - * enum caif_debug_type - Content selection for debug connection 86 86 - * @CAIF_DEBUG_TRACE_INTERACTIVE: Connection will contain 87 87 - * both trace and interactive debug. 88 88 - * @CAIF_DEBUG_TRACE: Connection contains trace only. 89 89 - * @CAIF_DEBUG_INTERACTIVE: Connection to interactive debug. 90 90 - */ 91 91 - enum caif_debug_type { 92 92 - CAIF_DEBUG_TRACE_INTERACTIVE = 0, 93 93 - CAIF_DEBUG_TRACE, 94 94 - CAIF_DEBUG_INTERACTIVE, 95 95 - }; 96 96 - 97 97 - /** 98 98 - * enum caif_debug_service - Debug Service Endpoint 99 99 - * @CAIF_RADIO_DEBUG_SERVICE: Debug service on the Radio sub-system 100 100 - * @CAIF_APP_DEBUG_SERVICE: Debug for the applications sub-system 101 101 - */ 102 102 - enum caif_debug_service { 103 103 - CAIF_RADIO_DEBUG_SERVICE = 1, 104 104 - CAIF_APP_DEBUG_SERVICE 105 105 - }; 106 106 - 107 107 - /** 108 108 - * struct sockaddr_caif - the sockaddr structure for CAIF sockets. 109 109 - * @family: Address family number, must be AF_CAIF. 110 110 - * @u: Union of address data 'switched' by family. 111 111 - * : 112 112 - * @u.at: Applies when family = CAIFPROTO_AT. 113 113 - * 114 114 - * @u.at.type: Type of AT link to set up (enum caif_at_type). 115 115 - * 116 116 - * @u.util: Applies when family = CAIFPROTO_UTIL 117 117 - * 118 118 - * @u.util.service: Utility service name. 119 119 - * 120 120 - * @u.dgm: Applies when family = CAIFPROTO_DATAGRAM 121 121 - * 122 122 - * @u.dgm.connection_id: Datagram connection id. 123 123 - * 124 124 - * @u.dgm.nsapi: NSAPI of the PDP-Context. 125 125 - * 126 126 - * @u.rfm: Applies when family = CAIFPROTO_RFM 127 127 - * 128 128 - * @u.rfm.connection_id: Connection ID for RFM. 129 129 - * 130 130 - * @u.rfm.volume: Volume to mount. 131 131 - * 132 132 - * @u.dbg: Applies when family = CAIFPROTO_DEBUG. 133 133 - * 134 134 - * @u.dbg.type: Type of debug connection to set up 135 135 - * (caif_debug_type). 136 136 - * 137 137 - * @u.dbg.service: Service sub-system to connect (caif_debug_service 138 138 - * Description: 139 139 - * This structure holds the connect parameters used for setting up a 140 140 - * CAIF Channel. It defines the service to connect to on the modem. 141 141 - */ 142 142 - struct sockaddr_caif { 143 143 - __kernel_sa_family_t family; 144 144 - union { 145 145 - struct { 146 146 - __u8 type; /* type: enum caif_at_type */ 147 147 - } at; /* CAIFPROTO_AT */ 148 148 - struct { 149 149 - char service[16]; 150 150 - } util; /* CAIFPROTO_UTIL */ 151 151 - union { 152 152 - __u32 connection_id; 153 153 - __u8 nsapi; 154 154 - } dgm; /* CAIFPROTO_DATAGRAM(_LOOP)*/ 155 155 - struct { 156 156 - __u32 connection_id; 157 157 - char volume[16]; 158 158 - } rfm; /* CAIFPROTO_RFM */ 159 159 - struct { 160 160 - __u8 type; /* type:enum caif_debug_type */ 161 161 - __u8 service; /* service:caif_debug_service */ 162 162 - } dbg; /* CAIFPROTO_DEBUG */ 163 163 - } u; 164 164 - }; 165 165 - 166 166 - /** 167 167 - * enum caif_socket_opts - CAIF option values for getsockopt and setsockopt. 168 168 - * 169 169 - * @CAIFSO_LINK_SELECT: Selector used if multiple CAIF Link layers are 170 170 - * available. Either a high bandwidth 171 171 - * link can be selected (CAIF_LINK_HIGH_BANDW) or 172 172 - * a low latency link (CAIF_LINK_LOW_LATENCY). 173 173 - * This option is of type __u32. 174 174 - * Alternatively SO_BINDTODEVICE can be used. 175 175 - * 176 176 - * @CAIFSO_REQ_PARAM: Used to set the request parameters for a 177 177 - * utility channel. (maximum 256 bytes). This 178 178 - * option must be set before connecting. 179 179 - * 180 180 - * @CAIFSO_RSP_PARAM: Gets the response parameters for a utility 181 181 - * channel. (maximum 256 bytes). This option 182 182 - * is valid after a successful connect. 183 183 - * 184 184 - * 185 185 - * This enum defines the CAIF Socket options to be used on a socket 186 186 - * of type PF_CAIF. 187 187 - * 188 188 - */ 189 189 - enum caif_socket_opts { 190 190 - CAIFSO_LINK_SELECT = 127, 191 191 - CAIFSO_REQ_PARAM = 128, 192 192 - CAIFSO_RSP_PARAM = 129, 193 193 - }; 194 194 - 195 195 - #endif /* _LINUX_CAIF_SOCKET_H */

-35

include/uapi/linux/caif/if_caif.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - * License terms: GNU General Public License (GPL) version 2 6 6 - */ 7 7 - 8 8 - #ifndef IF_CAIF_H_ 9 9 - #define IF_CAIF_H_ 10 10 - #include <linux/sockios.h> 11 11 - #include <linux/types.h> 12 12 - #include <linux/socket.h> 13 13 - 14 14 - /** 15 15 - * enum ifla_caif - CAIF NetlinkRT parameters. 16 16 - * @IFLA_CAIF_IPV4_CONNID: Connection ID for IPv4 PDP Context. 17 17 - * The type of attribute is NLA_U32. 18 18 - * @IFLA_CAIF_IPV6_CONNID: Connection ID for IPv6 PDP Context. 19 19 - * The type of attribute is NLA_U32. 20 20 - * @IFLA_CAIF_LOOPBACK: If different from zero, device is doing loopback 21 21 - * The type of attribute is NLA_U8. 22 22 - * 23 23 - * When using RT Netlink to create, destroy or configure a CAIF IP interface, 24 24 - * enum ifla_caif is used to specify the configuration attributes. 25 25 - */ 26 26 - enum ifla_caif { 27 27 - __IFLA_CAIF_UNSPEC, 28 28 - IFLA_CAIF_IPV4_CONNID, 29 29 - IFLA_CAIF_IPV6_CONNID, 30 30 - IFLA_CAIF_LOOPBACK, 31 31 - __IFLA_CAIF_MAX 32 32 - }; 33 33 - #define IFLA_CAIF_MAX (__IFLA_CAIF_MAX-1) 34 34 - 35 35 - #endif /*IF_CAIF_H_*/

-1

net/Kconfig

reviewed

··· 439 439 440 440 source "net/rfkill/Kconfig" 441 441 source "net/9p/Kconfig" 442 442 - source "net/caif/Kconfig" 443 442 source "net/ceph/Kconfig" 444 443 source "net/nfc/Kconfig" 445 444 source "net/psample/Kconfig"

-1

net/Makefile

reviewed

··· 53 53 obj-$(CONFIG_SMC) += smc/ 54 54 obj-$(CONFIG_RFKILL) += rfkill/ 55 55 obj-$(CONFIG_NET_9P) += 9p/ 56 56 - obj-$(CONFIG_CAIF) += caif/ 57 56 obj-$(CONFIG_DCB) += dcb/ 58 57 obj-$(CONFIG_6LOWPAN) += 6lowpan/ 59 58 obj-$(CONFIG_IEEE802154) += ieee802154/

-54

net/caif/Kconfig

reviewed

··· 1 1 - # SPDX-License-Identifier: GPL-2.0-only 2 2 - # 3 3 - # CAIF net configurations 4 4 - # 5 5 - 6 6 - menuconfig CAIF 7 7 - tristate "CAIF support" 8 8 - select CRC_CCITT 9 9 - default n 10 10 - help 11 11 - The "Communication CPU to Application CPU Interface" (CAIF) is a packet 12 12 - based connection-oriented MUX protocol developed by ST-Ericsson for use 13 13 - with its modems. It is accessed from user space as sockets (PF_CAIF). 14 14 - 15 15 - Say Y (or M) here if you build for a phone product (e.g. Android or 16 16 - MeeGo) that uses CAIF as transport. If unsure say N. 17 17 - 18 18 - If you select to build it as module then CAIF_NETDEV also needs to be 19 19 - built as a module. You will also need to say Y (or M) to any CAIF 20 20 - physical devices that your platform requires. 21 21 - 22 22 - See Documentation/networking/caif for a further explanation on how to 23 23 - use and configure CAIF. 24 24 - 25 25 - config CAIF_DEBUG 26 26 - bool "Enable Debug" 27 27 - depends on CAIF 28 28 - default n 29 29 - help 30 30 - Enable the inclusion of debug code in the CAIF stack. 31 31 - Be aware that doing this will impact performance. 32 32 - If unsure say N. 33 33 - 34 34 - config CAIF_NETDEV 35 35 - tristate "CAIF GPRS Network device" 36 36 - depends on CAIF 37 37 - default CAIF 38 38 - help 39 39 - Say Y if you will be using a CAIF based GPRS network device. 40 40 - This can be either built-in or a loadable module. 41 41 - If you select to build it as a built-in then the main CAIF device must 42 42 - also be a built-in. 43 43 - If unsure say Y. 44 44 - 45 45 - config CAIF_USB 46 46 - tristate "CAIF USB support" 47 47 - depends on CAIF 48 48 - default n 49 49 - help 50 50 - Say Y if you are using CAIF over USB CDC NCM. 51 51 - This can be either built-in or a loadable module. 52 52 - If you select to build it as a built-in then the main CAIF device must 53 53 - also be a built-in. 54 54 - If unsure say N.

-16

net/caif/Makefile

reviewed

··· 1 1 - # SPDX-License-Identifier: GPL-2.0 2 2 - ccflags-$(CONFIG_CAIF_DEBUG) := -DDEBUG 3 3 - 4 4 - caif-y := caif_dev.o \ 5 5 - cfcnfg.o cfmuxl.o cfctrl.o \ 6 6 - cffrml.o cfveil.o cfdbgl.o\ 7 7 - cfserl.o cfdgml.o \ 8 8 - cfrfml.o cfvidl.o cfutill.o \ 9 9 - cfsrvl.o cfpkt_skbuff.o 10 10 - 11 11 - obj-$(CONFIG_CAIF) += caif.o 12 12 - obj-$(CONFIG_CAIF_NETDEV) += chnl_net.o 13 13 - obj-$(CONFIG_CAIF) += caif_socket.o 14 14 - obj-$(CONFIG_CAIF_USB) += caif_usb.o 15 15 - 16 16 - export-y := caif.o

-586

net/caif/caif_dev.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * CAIF Interface registration. 4 4 - * Copyright (C) ST-Ericsson AB 2010 5 5 - * Author: Sjur Brendeland 6 6 - * 7 7 - * Borrowed heavily from file: pn_dev.c. Thanks to Remi Denis-Courmont 8 8 - * and Sakari Ailus <sakari.ailus@nokia.com> 9 9 - */ 10 10 - 11 11 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 12 12 - 13 13 - #include <linux/kernel.h> 14 14 - #include <linux/if_arp.h> 15 15 - #include <linux/net.h> 16 16 - #include <linux/netdevice.h> 17 17 - #include <linux/mutex.h> 18 18 - #include <linux/module.h> 19 19 - #include <linux/spinlock.h> 20 20 - #include <net/netns/generic.h> 21 21 - #include <net/net_namespace.h> 22 22 - #include <net/pkt_sched.h> 23 23 - #include <net/caif/caif_device.h> 24 24 - #include <net/caif/caif_layer.h> 25 25 - #include <net/caif/caif_dev.h> 26 26 - #include <net/caif/cfpkt.h> 27 27 - #include <net/caif/cfcnfg.h> 28 28 - #include <net/caif/cfserl.h> 29 29 - 30 30 - MODULE_DESCRIPTION("ST-Ericsson CAIF modem protocol support"); 31 31 - MODULE_LICENSE("GPL"); 32 32 - 33 33 - /* Used for local tracking of the CAIF net devices */ 34 34 - struct caif_device_entry { 35 35 - struct cflayer layer; 36 36 - struct list_head list; 37 37 - struct net_device *netdev; 38 38 - int __percpu *pcpu_refcnt; 39 39 - spinlock_t flow_lock; 40 40 - struct sk_buff *xoff_skb; 41 41 - void (*xoff_skb_dtor)(struct sk_buff *skb); 42 42 - bool xoff; 43 43 - }; 44 44 - 45 45 - struct caif_device_entry_list { 46 46 - struct list_head list; 47 47 - /* Protects simulanous deletes in list */ 48 48 - struct mutex lock; 49 49 - }; 50 50 - 51 51 - struct caif_net { 52 52 - struct cfcnfg *cfg; 53 53 - struct caif_device_entry_list caifdevs; 54 54 - }; 55 55 - 56 56 - static unsigned int caif_net_id; 57 57 - static int q_high = 50; /* Percent */ 58 58 - 59 59 - struct cfcnfg *get_cfcnfg(struct net *net) 60 60 - { 61 61 - struct caif_net *caifn; 62 62 - caifn = net_generic(net, caif_net_id); 63 63 - return caifn->cfg; 64 64 - } 65 65 - EXPORT_SYMBOL(get_cfcnfg); 66 66 - 67 67 - static struct caif_device_entry_list *caif_device_list(struct net *net) 68 68 - { 69 69 - struct caif_net *caifn; 70 70 - caifn = net_generic(net, caif_net_id); 71 71 - return &caifn->caifdevs; 72 72 - } 73 73 - 74 74 - static void caifd_put(struct caif_device_entry *e) 75 75 - { 76 76 - this_cpu_dec(*e->pcpu_refcnt); 77 77 - } 78 78 - 79 79 - static void caifd_hold(struct caif_device_entry *e) 80 80 - { 81 81 - this_cpu_inc(*e->pcpu_refcnt); 82 82 - } 83 83 - 84 84 - static int caifd_refcnt_read(struct caif_device_entry *e) 85 85 - { 86 86 - int i, refcnt = 0; 87 87 - for_each_possible_cpu(i) 88 88 - refcnt += *per_cpu_ptr(e->pcpu_refcnt, i); 89 89 - return refcnt; 90 90 - } 91 91 - 92 92 - /* Allocate new CAIF device. */ 93 93 - static struct caif_device_entry *caif_device_alloc(struct net_device *dev) 94 94 - { 95 95 - struct caif_device_entry *caifd; 96 96 - 97 97 - caifd = kzalloc_obj(*caifd); 98 98 - if (!caifd) 99 99 - return NULL; 100 100 - caifd->pcpu_refcnt = alloc_percpu(int); 101 101 - if (!caifd->pcpu_refcnt) { 102 102 - kfree(caifd); 103 103 - return NULL; 104 104 - } 105 105 - caifd->netdev = dev; 106 106 - dev_hold(dev); 107 107 - return caifd; 108 108 - } 109 109 - 110 110 - static struct caif_device_entry *caif_get(struct net_device *dev) 111 111 - { 112 112 - struct caif_device_entry_list *caifdevs = 113 113 - caif_device_list(dev_net(dev)); 114 114 - struct caif_device_entry *caifd; 115 115 - 116 116 - list_for_each_entry_rcu(caifd, &caifdevs->list, list, 117 117 - lockdep_rtnl_is_held()) { 118 118 - if (caifd->netdev == dev) 119 119 - return caifd; 120 120 - } 121 121 - return NULL; 122 122 - } 123 123 - 124 124 - static void caif_flow_cb(struct sk_buff *skb) 125 125 - { 126 126 - struct caif_device_entry *caifd; 127 127 - void (*dtor)(struct sk_buff *skb) = NULL; 128 128 - bool send_xoff; 129 129 - 130 130 - WARN_ON(skb->dev == NULL); 131 131 - 132 132 - rcu_read_lock(); 133 133 - caifd = caif_get(skb->dev); 134 134 - 135 135 - WARN_ON(caifd == NULL); 136 136 - if (!caifd) { 137 137 - rcu_read_unlock(); 138 138 - return; 139 139 - } 140 140 - 141 141 - caifd_hold(caifd); 142 142 - rcu_read_unlock(); 143 143 - 144 144 - spin_lock_bh(&caifd->flow_lock); 145 145 - send_xoff = caifd->xoff; 146 146 - caifd->xoff = false; 147 147 - dtor = caifd->xoff_skb_dtor; 148 148 - 149 149 - if (WARN_ON(caifd->xoff_skb != skb)) 150 150 - skb = NULL; 151 151 - 152 152 - caifd->xoff_skb = NULL; 153 153 - caifd->xoff_skb_dtor = NULL; 154 154 - 155 155 - spin_unlock_bh(&caifd->flow_lock); 156 156 - 157 157 - if (dtor && skb) 158 158 - dtor(skb); 159 159 - 160 160 - if (send_xoff) 161 161 - caifd->layer.up-> 162 162 - ctrlcmd(caifd->layer.up, 163 163 - _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND, 164 164 - caifd->layer.id); 165 165 - caifd_put(caifd); 166 166 - } 167 167 - 168 168 - static int transmit(struct cflayer *layer, struct cfpkt *pkt) 169 169 - { 170 170 - int err, high = 0, qlen = 0; 171 171 - struct caif_device_entry *caifd = 172 172 - container_of(layer, struct caif_device_entry, layer); 173 173 - struct sk_buff *skb; 174 174 - struct netdev_queue *txq; 175 175 - 176 176 - rcu_read_lock_bh(); 177 177 - 178 178 - skb = cfpkt_tonative(pkt); 179 179 - skb->dev = caifd->netdev; 180 180 - skb_reset_network_header(skb); 181 181 - skb->protocol = htons(ETH_P_CAIF); 182 182 - 183 183 - /* Check if we need to handle xoff */ 184 184 - if (likely(caifd->netdev->priv_flags & IFF_NO_QUEUE)) 185 185 - goto noxoff; 186 186 - 187 187 - if (unlikely(caifd->xoff)) 188 188 - goto noxoff; 189 189 - 190 190 - if (likely(!netif_queue_stopped(caifd->netdev))) { 191 191 - struct Qdisc *sch; 192 192 - 193 193 - /* If we run with a TX queue, check if the queue is too long*/ 194 194 - txq = netdev_get_tx_queue(skb->dev, 0); 195 195 - sch = rcu_dereference_bh(txq->qdisc); 196 196 - if (likely(qdisc_is_empty(sch))) 197 197 - goto noxoff; 198 198 - 199 199 - /* can check for explicit qdisc len value only !NOLOCK, 200 200 - * always set flow off otherwise 201 201 - */ 202 202 - high = (caifd->netdev->tx_queue_len * q_high) / 100; 203 203 - if (!(sch->flags & TCQ_F_NOLOCK) && likely(sch->q.qlen < high)) 204 204 - goto noxoff; 205 205 - } 206 206 - 207 207 - /* Hold lock while accessing xoff */ 208 208 - spin_lock_bh(&caifd->flow_lock); 209 209 - if (caifd->xoff) { 210 210 - spin_unlock_bh(&caifd->flow_lock); 211 211 - goto noxoff; 212 212 - } 213 213 - 214 214 - /* 215 215 - * Handle flow off, we do this by temporary hi-jacking this 216 216 - * skb's destructor function, and replace it with our own 217 217 - * flow-on callback. The callback will set flow-on and call 218 218 - * the original destructor. 219 219 - */ 220 220 - 221 221 - pr_debug("queue has stopped(%d) or is full (%d > %d)\n", 222 222 - netif_queue_stopped(caifd->netdev), 223 223 - qlen, high); 224 224 - caifd->xoff = true; 225 225 - caifd->xoff_skb = skb; 226 226 - caifd->xoff_skb_dtor = skb->destructor; 227 227 - skb->destructor = caif_flow_cb; 228 228 - spin_unlock_bh(&caifd->flow_lock); 229 229 - 230 230 - caifd->layer.up->ctrlcmd(caifd->layer.up, 231 231 - _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND, 232 232 - caifd->layer.id); 233 233 - noxoff: 234 234 - rcu_read_unlock_bh(); 235 235 - 236 236 - err = dev_queue_xmit(skb); 237 237 - if (err > 0) 238 238 - err = -EIO; 239 239 - 240 240 - return err; 241 241 - } 242 242 - 243 243 - /* 244 244 - * Stuff received packets into the CAIF stack. 245 245 - * On error, returns non-zero and releases the skb. 246 246 - */ 247 247 - static int receive(struct sk_buff *skb, struct net_device *dev, 248 248 - struct packet_type *pkttype, struct net_device *orig_dev) 249 249 - { 250 250 - struct cfpkt *pkt; 251 251 - struct caif_device_entry *caifd; 252 252 - int err; 253 253 - 254 254 - pkt = cfpkt_fromnative(CAIF_DIR_IN, skb); 255 255 - 256 256 - rcu_read_lock(); 257 257 - caifd = caif_get(dev); 258 258 - 259 259 - if (!caifd || !caifd->layer.up || !caifd->layer.up->receive || 260 260 - !netif_oper_up(caifd->netdev)) { 261 261 - rcu_read_unlock(); 262 262 - kfree_skb(skb); 263 263 - return NET_RX_DROP; 264 264 - } 265 265 - 266 266 - /* Hold reference to netdevice while using CAIF stack */ 267 267 - caifd_hold(caifd); 268 268 - rcu_read_unlock(); 269 269 - 270 270 - err = caifd->layer.up->receive(caifd->layer.up, pkt); 271 271 - 272 272 - /* For -EILSEQ the packet is not freed so free it now */ 273 273 - if (err == -EILSEQ) 274 274 - cfpkt_destroy(pkt); 275 275 - 276 276 - /* Release reference to stack upwards */ 277 277 - caifd_put(caifd); 278 278 - 279 279 - if (err != 0) 280 280 - err = NET_RX_DROP; 281 281 - return err; 282 282 - } 283 283 - 284 284 - static struct packet_type caif_packet_type __read_mostly = { 285 285 - .type = cpu_to_be16(ETH_P_CAIF), 286 286 - .func = receive, 287 287 - }; 288 288 - 289 289 - static void dev_flowctrl(struct net_device *dev, int on) 290 290 - { 291 291 - struct caif_device_entry *caifd; 292 292 - 293 293 - rcu_read_lock(); 294 294 - 295 295 - caifd = caif_get(dev); 296 296 - if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd) { 297 297 - rcu_read_unlock(); 298 298 - return; 299 299 - } 300 300 - 301 301 - caifd_hold(caifd); 302 302 - rcu_read_unlock(); 303 303 - 304 304 - caifd->layer.up->ctrlcmd(caifd->layer.up, 305 305 - on ? 306 306 - _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND : 307 307 - _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND, 308 308 - caifd->layer.id); 309 309 - caifd_put(caifd); 310 310 - } 311 311 - 312 312 - int caif_enroll_dev(struct net_device *dev, struct caif_dev_common *caifdev, 313 313 - struct cflayer *link_support, int head_room, 314 314 - struct cflayer **layer, 315 315 - int (**rcv_func)(struct sk_buff *, struct net_device *, 316 316 - struct packet_type *, 317 317 - struct net_device *)) 318 318 - { 319 319 - struct caif_device_entry *caifd; 320 320 - enum cfcnfg_phy_preference pref; 321 321 - struct cfcnfg *cfg = get_cfcnfg(dev_net(dev)); 322 322 - struct caif_device_entry_list *caifdevs; 323 323 - int res; 324 324 - 325 325 - caifdevs = caif_device_list(dev_net(dev)); 326 326 - caifd = caif_device_alloc(dev); 327 327 - if (!caifd) 328 328 - return -ENOMEM; 329 329 - *layer = &caifd->layer; 330 330 - spin_lock_init(&caifd->flow_lock); 331 331 - 332 332 - switch (caifdev->link_select) { 333 333 - case CAIF_LINK_HIGH_BANDW: 334 334 - pref = CFPHYPREF_HIGH_BW; 335 335 - break; 336 336 - case CAIF_LINK_LOW_LATENCY: 337 337 - pref = CFPHYPREF_LOW_LAT; 338 338 - break; 339 339 - default: 340 340 - pref = CFPHYPREF_HIGH_BW; 341 341 - break; 342 342 - } 343 343 - mutex_lock(&caifdevs->lock); 344 344 - list_add_rcu(&caifd->list, &caifdevs->list); 345 345 - 346 346 - strscpy(caifd->layer.name, dev->name, 347 347 - sizeof(caifd->layer.name)); 348 348 - caifd->layer.transmit = transmit; 349 349 - res = cfcnfg_add_phy_layer(cfg, 350 350 - dev, 351 351 - &caifd->layer, 352 352 - pref, 353 353 - link_support, 354 354 - caifdev->use_fcs, 355 355 - head_room); 356 356 - mutex_unlock(&caifdevs->lock); 357 357 - if (rcv_func) 358 358 - *rcv_func = receive; 359 359 - return res; 360 360 - } 361 361 - EXPORT_SYMBOL(caif_enroll_dev); 362 362 - 363 363 - /* notify Caif of device events */ 364 364 - static int caif_device_notify(struct notifier_block *me, unsigned long what, 365 365 - void *ptr) 366 366 - { 367 367 - struct net_device *dev = netdev_notifier_info_to_dev(ptr); 368 368 - struct caif_device_entry *caifd = NULL; 369 369 - struct caif_dev_common *caifdev; 370 370 - struct cfcnfg *cfg; 371 371 - struct cflayer *layer, *link_support; 372 372 - int head_room = 0; 373 373 - struct caif_device_entry_list *caifdevs; 374 374 - int res; 375 375 - 376 376 - cfg = get_cfcnfg(dev_net(dev)); 377 377 - caifdevs = caif_device_list(dev_net(dev)); 378 378 - 379 379 - caifd = caif_get(dev); 380 380 - if (caifd == NULL && dev->type != ARPHRD_CAIF) 381 381 - return 0; 382 382 - 383 383 - switch (what) { 384 384 - case NETDEV_REGISTER: 385 385 - if (caifd != NULL) 386 386 - break; 387 387 - 388 388 - caifdev = netdev_priv(dev); 389 389 - 390 390 - link_support = NULL; 391 391 - if (caifdev->use_frag) { 392 392 - head_room = 1; 393 393 - link_support = cfserl_create(dev->ifindex, 394 394 - caifdev->use_stx); 395 395 - if (!link_support) { 396 396 - pr_warn("Out of memory\n"); 397 397 - break; 398 398 - } 399 399 - } 400 400 - res = caif_enroll_dev(dev, caifdev, link_support, head_room, 401 401 - &layer, NULL); 402 402 - if (res) 403 403 - cfserl_release(link_support); 404 404 - caifdev->flowctrl = dev_flowctrl; 405 405 - break; 406 406 - 407 407 - case NETDEV_UP: 408 408 - rcu_read_lock(); 409 409 - 410 410 - caifd = caif_get(dev); 411 411 - if (caifd == NULL) { 412 412 - rcu_read_unlock(); 413 413 - break; 414 414 - } 415 415 - 416 416 - caifd->xoff = false; 417 417 - cfcnfg_set_phy_state(cfg, &caifd->layer, true); 418 418 - rcu_read_unlock(); 419 419 - 420 420 - break; 421 421 - 422 422 - case NETDEV_DOWN: 423 423 - rcu_read_lock(); 424 424 - 425 425 - caifd = caif_get(dev); 426 426 - if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd) { 427 427 - rcu_read_unlock(); 428 428 - return -EINVAL; 429 429 - } 430 430 - 431 431 - cfcnfg_set_phy_state(cfg, &caifd->layer, false); 432 432 - caifd_hold(caifd); 433 433 - rcu_read_unlock(); 434 434 - 435 435 - caifd->layer.up->ctrlcmd(caifd->layer.up, 436 436 - _CAIF_CTRLCMD_PHYIF_DOWN_IND, 437 437 - caifd->layer.id); 438 438 - 439 439 - spin_lock_bh(&caifd->flow_lock); 440 440 - 441 441 - /* 442 442 - * Replace our xoff-destructor with original destructor. 443 443 - * We trust that skb->destructor *always* is called before 444 444 - * the skb reference is invalid. The hijacked SKB destructor 445 445 - * takes the flow_lock so manipulating the skb->destructor here 446 446 - * should be safe. 447 447 - */ 448 448 - if (caifd->xoff_skb_dtor != NULL && caifd->xoff_skb != NULL) 449 449 - caifd->xoff_skb->destructor = caifd->xoff_skb_dtor; 450 450 - 451 451 - caifd->xoff = false; 452 452 - caifd->xoff_skb_dtor = NULL; 453 453 - caifd->xoff_skb = NULL; 454 454 - 455 455 - spin_unlock_bh(&caifd->flow_lock); 456 456 - caifd_put(caifd); 457 457 - break; 458 458 - 459 459 - case NETDEV_UNREGISTER: 460 460 - mutex_lock(&caifdevs->lock); 461 461 - 462 462 - caifd = caif_get(dev); 463 463 - if (caifd == NULL) { 464 464 - mutex_unlock(&caifdevs->lock); 465 465 - break; 466 466 - } 467 467 - list_del_rcu(&caifd->list); 468 468 - 469 469 - /* 470 470 - * NETDEV_UNREGISTER is called repeatedly until all reference 471 471 - * counts for the net-device are released. If references to 472 472 - * caifd is taken, simply ignore NETDEV_UNREGISTER and wait for 473 473 - * the next call to NETDEV_UNREGISTER. 474 474 - * 475 475 - * If any packets are in flight down the CAIF Stack, 476 476 - * cfcnfg_del_phy_layer will return nonzero. 477 477 - * If no packets are in flight, the CAIF Stack associated 478 478 - * with the net-device un-registering is freed. 479 479 - */ 480 480 - 481 481 - if (caifd_refcnt_read(caifd) != 0 || 482 482 - cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0) { 483 483 - 484 484 - pr_info("Wait for device inuse\n"); 485 485 - /* Enrole device if CAIF Stack is still in use */ 486 486 - list_add_rcu(&caifd->list, &caifdevs->list); 487 487 - mutex_unlock(&caifdevs->lock); 488 488 - break; 489 489 - } 490 490 - 491 491 - synchronize_rcu(); 492 492 - dev_put(caifd->netdev); 493 493 - free_percpu(caifd->pcpu_refcnt); 494 494 - kfree(caifd); 495 495 - 496 496 - mutex_unlock(&caifdevs->lock); 497 497 - break; 498 498 - } 499 499 - return 0; 500 500 - } 501 501 - 502 502 - static struct notifier_block caif_device_notifier = { 503 503 - .notifier_call = caif_device_notify, 504 504 - .priority = 0, 505 505 - }; 506 506 - 507 507 - /* Per-namespace Caif devices handling */ 508 508 - static int caif_init_net(struct net *net) 509 509 - { 510 510 - struct caif_net *caifn = net_generic(net, caif_net_id); 511 511 - INIT_LIST_HEAD(&caifn->caifdevs.list); 512 512 - mutex_init(&caifn->caifdevs.lock); 513 513 - 514 514 - caifn->cfg = cfcnfg_create(); 515 515 - if (!caifn->cfg) 516 516 - return -ENOMEM; 517 517 - 518 518 - return 0; 519 519 - } 520 520 - 521 521 - static void caif_exit_net(struct net *net) 522 522 - { 523 523 - struct caif_device_entry *caifd, *tmp; 524 524 - struct caif_device_entry_list *caifdevs = 525 525 - caif_device_list(net); 526 526 - struct cfcnfg *cfg = get_cfcnfg(net); 527 527 - 528 528 - rtnl_lock(); 529 529 - mutex_lock(&caifdevs->lock); 530 530 - 531 531 - list_for_each_entry_safe(caifd, tmp, &caifdevs->list, list) { 532 532 - int i = 0; 533 533 - list_del_rcu(&caifd->list); 534 534 - cfcnfg_set_phy_state(cfg, &caifd->layer, false); 535 535 - 536 536 - while (i < 10 && 537 537 - (caifd_refcnt_read(caifd) != 0 || 538 538 - cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0)) { 539 539 - 540 540 - pr_info("Wait for device inuse\n"); 541 541 - msleep(250); 542 542 - i++; 543 543 - } 544 544 - synchronize_rcu(); 545 545 - dev_put(caifd->netdev); 546 546 - free_percpu(caifd->pcpu_refcnt); 547 547 - kfree(caifd); 548 548 - } 549 549 - cfcnfg_remove(cfg); 550 550 - 551 551 - mutex_unlock(&caifdevs->lock); 552 552 - rtnl_unlock(); 553 553 - } 554 554 - 555 555 - static struct pernet_operations caif_net_ops = { 556 556 - .init = caif_init_net, 557 557 - .exit = caif_exit_net, 558 558 - .id = &caif_net_id, 559 559 - .size = sizeof(struct caif_net), 560 560 - }; 561 561 - 562 562 - /* Initialize Caif devices list */ 563 563 - static int __init caif_device_init(void) 564 564 - { 565 565 - int result; 566 566 - 567 567 - result = register_pernet_subsys(&caif_net_ops); 568 568 - 569 569 - if (result) 570 570 - return result; 571 571 - 572 572 - register_netdevice_notifier(&caif_device_notifier); 573 573 - dev_add_pack(&caif_packet_type); 574 574 - 575 575 - return result; 576 576 - } 577 577 - 578 578 - static void __exit caif_device_exit(void) 579 579 - { 580 580 - unregister_netdevice_notifier(&caif_device_notifier); 581 581 - dev_remove_pack(&caif_packet_type); 582 582 - unregister_pernet_subsys(&caif_net_ops); 583 583 - } 584 584 - 585 585 - module_init(caif_device_init); 586 586 - module_exit(caif_device_exit);

-1114

net/caif/caif_socket.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/filter.h> 10 10 - #include <linux/fs.h> 11 11 - #include <linux/init.h> 12 12 - #include <linux/module.h> 13 13 - #include <linux/sched/signal.h> 14 14 - #include <linux/spinlock.h> 15 15 - #include <linux/mutex.h> 16 16 - #include <linux/list.h> 17 17 - #include <linux/wait.h> 18 18 - #include <linux/poll.h> 19 19 - #include <linux/tcp.h> 20 20 - #include <linux/uaccess.h> 21 21 - #include <linux/debugfs.h> 22 22 - #include <linux/caif/caif_socket.h> 23 23 - #include <linux/pkt_sched.h> 24 24 - #include <net/sock.h> 25 25 - #include <net/tcp_states.h> 26 26 - #include <net/caif/caif_layer.h> 27 27 - #include <net/caif/caif_dev.h> 28 28 - #include <net/caif/cfpkt.h> 29 29 - 30 30 - MODULE_DESCRIPTION("ST-Ericsson CAIF modem protocol socket support (AF_CAIF)"); 31 31 - MODULE_LICENSE("GPL"); 32 32 - MODULE_ALIAS_NETPROTO(AF_CAIF); 33 33 - 34 34 - /* 35 35 - * CAIF state is re-using the TCP socket states. 36 36 - * caif_states stored in sk_state reflect the state as reported by 37 37 - * the CAIF stack, while sk_socket->state is the state of the socket. 38 38 - */ 39 39 - enum caif_states { 40 40 - CAIF_CONNECTED = TCP_ESTABLISHED, 41 41 - CAIF_CONNECTING = TCP_SYN_SENT, 42 42 - CAIF_DISCONNECTED = TCP_CLOSE 43 43 - }; 44 44 - 45 45 - #define TX_FLOW_ON_BIT 1 46 46 - #define RX_FLOW_ON_BIT 2 47 47 - 48 48 - struct caifsock { 49 49 - struct sock sk; /* must be first member */ 50 50 - struct cflayer layer; 51 51 - unsigned long flow_state; 52 52 - struct caif_connect_request conn_req; 53 53 - struct mutex readlock; 54 54 - struct dentry *debugfs_socket_dir; 55 55 - int headroom, tailroom, maxframe; 56 56 - }; 57 57 - 58 58 - static int rx_flow_is_on(struct caifsock *cf_sk) 59 59 - { 60 60 - return test_bit(RX_FLOW_ON_BIT, &cf_sk->flow_state); 61 61 - } 62 62 - 63 63 - static int tx_flow_is_on(struct caifsock *cf_sk) 64 64 - { 65 65 - return test_bit(TX_FLOW_ON_BIT, &cf_sk->flow_state); 66 66 - } 67 67 - 68 68 - static void set_rx_flow_off(struct caifsock *cf_sk) 69 69 - { 70 70 - clear_bit(RX_FLOW_ON_BIT, &cf_sk->flow_state); 71 71 - } 72 72 - 73 73 - static void set_rx_flow_on(struct caifsock *cf_sk) 74 74 - { 75 75 - set_bit(RX_FLOW_ON_BIT, &cf_sk->flow_state); 76 76 - } 77 77 - 78 78 - static void set_tx_flow_off(struct caifsock *cf_sk) 79 79 - { 80 80 - clear_bit(TX_FLOW_ON_BIT, &cf_sk->flow_state); 81 81 - } 82 82 - 83 83 - static void set_tx_flow_on(struct caifsock *cf_sk) 84 84 - { 85 85 - set_bit(TX_FLOW_ON_BIT, &cf_sk->flow_state); 86 86 - } 87 87 - 88 88 - static void caif_read_lock(struct sock *sk) 89 89 - { 90 90 - struct caifsock *cf_sk; 91 91 - cf_sk = container_of(sk, struct caifsock, sk); 92 92 - mutex_lock(&cf_sk->readlock); 93 93 - } 94 94 - 95 95 - static void caif_read_unlock(struct sock *sk) 96 96 - { 97 97 - struct caifsock *cf_sk; 98 98 - cf_sk = container_of(sk, struct caifsock, sk); 99 99 - mutex_unlock(&cf_sk->readlock); 100 100 - } 101 101 - 102 102 - static int sk_rcvbuf_lowwater(struct caifsock *cf_sk) 103 103 - { 104 104 - /* A quarter of full buffer is used a low water mark */ 105 105 - return cf_sk->sk.sk_rcvbuf / 4; 106 106 - } 107 107 - 108 108 - static void caif_flow_ctrl(struct sock *sk, int mode) 109 109 - { 110 110 - struct caifsock *cf_sk; 111 111 - cf_sk = container_of(sk, struct caifsock, sk); 112 112 - if (cf_sk->layer.dn && cf_sk->layer.dn->modemcmd) 113 113 - cf_sk->layer.dn->modemcmd(cf_sk->layer.dn, mode); 114 114 - } 115 115 - 116 116 - /* 117 117 - * Copied from sock.c:sock_queue_rcv_skb(), but changed so packets are 118 118 - * not dropped, but CAIF is sending flow off instead. 119 119 - */ 120 120 - static void caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) 121 121 - { 122 122 - int err; 123 123 - unsigned long flags; 124 124 - struct sk_buff_head *list = &sk->sk_receive_queue; 125 125 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 126 126 - bool queued = false; 127 127 - 128 128 - if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >= 129 129 - (unsigned int)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) { 130 130 - net_dbg_ratelimited("sending flow OFF (queue len = %d %d)\n", 131 131 - atomic_read(&cf_sk->sk.sk_rmem_alloc), 132 132 - sk_rcvbuf_lowwater(cf_sk)); 133 133 - set_rx_flow_off(cf_sk); 134 134 - caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ); 135 135 - } 136 136 - 137 137 - err = sk_filter(sk, skb); 138 138 - if (err) 139 139 - goto out; 140 140 - 141 141 - if (!sk_rmem_schedule(sk, skb, skb->truesize) && rx_flow_is_on(cf_sk)) { 142 142 - set_rx_flow_off(cf_sk); 143 143 - net_dbg_ratelimited("sending flow OFF due to rmem_schedule\n"); 144 144 - caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ); 145 145 - } 146 146 - skb->dev = NULL; 147 147 - skb_set_owner_r(skb, sk); 148 148 - spin_lock_irqsave(&list->lock, flags); 149 149 - queued = !sock_flag(sk, SOCK_DEAD); 150 150 - if (queued) 151 151 - __skb_queue_tail(list, skb); 152 152 - spin_unlock_irqrestore(&list->lock, flags); 153 153 - out: 154 154 - if (queued) 155 155 - sk->sk_data_ready(sk); 156 156 - else 157 157 - kfree_skb(skb); 158 158 - } 159 159 - 160 160 - /* Packet Receive Callback function called from CAIF Stack */ 161 161 - static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt) 162 162 - { 163 163 - struct caifsock *cf_sk; 164 164 - struct sk_buff *skb; 165 165 - 166 166 - cf_sk = container_of(layr, struct caifsock, layer); 167 167 - skb = cfpkt_tonative(pkt); 168 168 - 169 169 - if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) { 170 170 - kfree_skb(skb); 171 171 - return 0; 172 172 - } 173 173 - caif_queue_rcv_skb(&cf_sk->sk, skb); 174 174 - return 0; 175 175 - } 176 176 - 177 177 - static void cfsk_hold(struct cflayer *layr) 178 178 - { 179 179 - struct caifsock *cf_sk = container_of(layr, struct caifsock, layer); 180 180 - sock_hold(&cf_sk->sk); 181 181 - } 182 182 - 183 183 - static void cfsk_put(struct cflayer *layr) 184 184 - { 185 185 - struct caifsock *cf_sk = container_of(layr, struct caifsock, layer); 186 186 - sock_put(&cf_sk->sk); 187 187 - } 188 188 - 189 189 - /* Packet Control Callback function called from CAIF */ 190 190 - static void caif_ctrl_cb(struct cflayer *layr, 191 191 - enum caif_ctrlcmd flow, 192 192 - int phyid) 193 193 - { 194 194 - struct caifsock *cf_sk = container_of(layr, struct caifsock, layer); 195 195 - switch (flow) { 196 196 - case CAIF_CTRLCMD_FLOW_ON_IND: 197 197 - /* OK from modem to start sending again */ 198 198 - set_tx_flow_on(cf_sk); 199 199 - cf_sk->sk.sk_state_change(&cf_sk->sk); 200 200 - break; 201 201 - 202 202 - case CAIF_CTRLCMD_FLOW_OFF_IND: 203 203 - /* Modem asks us to shut up */ 204 204 - set_tx_flow_off(cf_sk); 205 205 - cf_sk->sk.sk_state_change(&cf_sk->sk); 206 206 - break; 207 207 - 208 208 - case CAIF_CTRLCMD_INIT_RSP: 209 209 - /* We're now connected */ 210 210 - caif_client_register_refcnt(&cf_sk->layer, 211 211 - cfsk_hold, cfsk_put); 212 212 - cf_sk->sk.sk_state = CAIF_CONNECTED; 213 213 - set_tx_flow_on(cf_sk); 214 214 - cf_sk->sk.sk_shutdown = 0; 215 215 - cf_sk->sk.sk_state_change(&cf_sk->sk); 216 216 - break; 217 217 - 218 218 - case CAIF_CTRLCMD_DEINIT_RSP: 219 219 - /* We're now disconnected */ 220 220 - cf_sk->sk.sk_state = CAIF_DISCONNECTED; 221 221 - cf_sk->sk.sk_state_change(&cf_sk->sk); 222 222 - break; 223 223 - 224 224 - case CAIF_CTRLCMD_INIT_FAIL_RSP: 225 225 - /* Connect request failed */ 226 226 - cf_sk->sk.sk_err = ECONNREFUSED; 227 227 - cf_sk->sk.sk_state = CAIF_DISCONNECTED; 228 228 - cf_sk->sk.sk_shutdown = SHUTDOWN_MASK; 229 229 - /* 230 230 - * Socket "standards" seems to require POLLOUT to 231 231 - * be set at connect failure. 232 232 - */ 233 233 - set_tx_flow_on(cf_sk); 234 234 - cf_sk->sk.sk_state_change(&cf_sk->sk); 235 235 - break; 236 236 - 237 237 - case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND: 238 238 - /* Modem has closed this connection, or device is down. */ 239 239 - cf_sk->sk.sk_shutdown = SHUTDOWN_MASK; 240 240 - cf_sk->sk.sk_err = ECONNRESET; 241 241 - set_rx_flow_on(cf_sk); 242 242 - sk_error_report(&cf_sk->sk); 243 243 - break; 244 244 - 245 245 - default: 246 246 - pr_debug("Unexpected flow command %d\n", flow); 247 247 - } 248 248 - } 249 249 - 250 250 - static void caif_check_flow_release(struct sock *sk) 251 251 - { 252 252 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 253 253 - 254 254 - if (rx_flow_is_on(cf_sk)) 255 255 - return; 256 256 - 257 257 - if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) { 258 258 - set_rx_flow_on(cf_sk); 259 259 - caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_ON_REQ); 260 260 - } 261 261 - } 262 262 - 263 263 - /* 264 264 - * Copied from unix_dgram_recvmsg, but removed credit checks, 265 265 - * changed locking, address handling and added MSG_TRUNC. 266 266 - */ 267 267 - static int caif_seqpkt_recvmsg(struct socket *sock, struct msghdr *m, 268 268 - size_t len, int flags) 269 269 - 270 270 - { 271 271 - struct sock *sk = sock->sk; 272 272 - struct sk_buff *skb; 273 273 - int ret; 274 274 - int copylen; 275 275 - 276 276 - ret = -EOPNOTSUPP; 277 277 - if (flags & MSG_OOB) 278 278 - goto read_error; 279 279 - 280 280 - skb = skb_recv_datagram(sk, flags, &ret); 281 281 - if (!skb) 282 282 - goto read_error; 283 283 - copylen = skb->len; 284 284 - if (len < copylen) { 285 285 - m->msg_flags |= MSG_TRUNC; 286 286 - copylen = len; 287 287 - } 288 288 - 289 289 - ret = skb_copy_datagram_msg(skb, 0, m, copylen); 290 290 - if (ret) 291 291 - goto out_free; 292 292 - 293 293 - ret = (flags & MSG_TRUNC) ? skb->len : copylen; 294 294 - out_free: 295 295 - skb_free_datagram(sk, skb); 296 296 - caif_check_flow_release(sk); 297 297 - return ret; 298 298 - 299 299 - read_error: 300 300 - return ret; 301 301 - } 302 302 - 303 303 - 304 304 - /* Copied from unix_stream_wait_data, identical except for lock call. */ 305 305 - static long caif_stream_data_wait(struct sock *sk, long timeo) 306 306 - { 307 307 - DEFINE_WAIT(wait); 308 308 - lock_sock(sk); 309 309 - 310 310 - for (;;) { 311 311 - prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 312 312 - 313 313 - if (!skb_queue_empty(&sk->sk_receive_queue) || 314 314 - sk->sk_err || 315 315 - sk->sk_state != CAIF_CONNECTED || 316 316 - sock_flag(sk, SOCK_DEAD) || 317 317 - (sk->sk_shutdown & RCV_SHUTDOWN) || 318 318 - signal_pending(current) || 319 319 - !timeo) 320 320 - break; 321 321 - 322 322 - sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk); 323 323 - release_sock(sk); 324 324 - timeo = schedule_timeout(timeo); 325 325 - lock_sock(sk); 326 326 - 327 327 - if (sock_flag(sk, SOCK_DEAD)) 328 328 - break; 329 329 - 330 330 - sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk); 331 331 - } 332 332 - 333 333 - finish_wait(sk_sleep(sk), &wait); 334 334 - release_sock(sk); 335 335 - return timeo; 336 336 - } 337 337 - 338 338 - 339 339 - /* 340 340 - * Copied from unix_stream_recvmsg, but removed credit checks, 341 341 - * changed locking calls, changed address handling. 342 342 - */ 343 343 - static int caif_stream_recvmsg(struct socket *sock, struct msghdr *msg, 344 344 - size_t size, int flags) 345 345 - { 346 346 - struct sock *sk = sock->sk; 347 347 - int copied = 0; 348 348 - int target; 349 349 - int err = 0; 350 350 - long timeo; 351 351 - 352 352 - err = -EOPNOTSUPP; 353 353 - if (flags&MSG_OOB) 354 354 - goto out; 355 355 - 356 356 - /* 357 357 - * Lock the socket to prevent queue disordering 358 358 - * while sleeps in memcpy_tomsg 359 359 - */ 360 360 - err = -EAGAIN; 361 361 - if (sk->sk_state == CAIF_CONNECTING) 362 362 - goto out; 363 363 - 364 364 - caif_read_lock(sk); 365 365 - target = sock_rcvlowat(sk, flags&MSG_WAITALL, size); 366 366 - timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT); 367 367 - 368 368 - do { 369 369 - int chunk; 370 370 - struct sk_buff *skb; 371 371 - 372 372 - lock_sock(sk); 373 373 - if (sock_flag(sk, SOCK_DEAD)) { 374 374 - err = -ECONNRESET; 375 375 - goto unlock; 376 376 - } 377 377 - skb = skb_dequeue(&sk->sk_receive_queue); 378 378 - caif_check_flow_release(sk); 379 379 - 380 380 - if (skb == NULL) { 381 381 - if (copied >= target) 382 382 - goto unlock; 383 383 - /* 384 384 - * POSIX 1003.1g mandates this order. 385 385 - */ 386 386 - err = sock_error(sk); 387 387 - if (err) 388 388 - goto unlock; 389 389 - err = -ECONNRESET; 390 390 - if (sk->sk_shutdown & RCV_SHUTDOWN) 391 391 - goto unlock; 392 392 - 393 393 - err = -EPIPE; 394 394 - if (sk->sk_state != CAIF_CONNECTED) 395 395 - goto unlock; 396 396 - if (sock_flag(sk, SOCK_DEAD)) 397 397 - goto unlock; 398 398 - 399 399 - release_sock(sk); 400 400 - 401 401 - err = -EAGAIN; 402 402 - if (!timeo) 403 403 - break; 404 404 - 405 405 - caif_read_unlock(sk); 406 406 - 407 407 - timeo = caif_stream_data_wait(sk, timeo); 408 408 - 409 409 - if (signal_pending(current)) { 410 410 - err = sock_intr_errno(timeo); 411 411 - goto out; 412 412 - } 413 413 - caif_read_lock(sk); 414 414 - continue; 415 415 - unlock: 416 416 - release_sock(sk); 417 417 - break; 418 418 - } 419 419 - release_sock(sk); 420 420 - chunk = min_t(unsigned int, skb->len, size); 421 421 - if (memcpy_to_msg(msg, skb->data, chunk)) { 422 422 - skb_queue_head(&sk->sk_receive_queue, skb); 423 423 - if (copied == 0) 424 424 - copied = -EFAULT; 425 425 - break; 426 426 - } 427 427 - copied += chunk; 428 428 - size -= chunk; 429 429 - 430 430 - /* Mark read part of skb as used */ 431 431 - if (!(flags & MSG_PEEK)) { 432 432 - skb_pull(skb, chunk); 433 433 - 434 434 - /* put the skb back if we didn't use it up. */ 435 435 - if (skb->len) { 436 436 - skb_queue_head(&sk->sk_receive_queue, skb); 437 437 - break; 438 438 - } 439 439 - kfree_skb(skb); 440 440 - 441 441 - } else { 442 442 - /* 443 443 - * It is questionable, see note in unix_dgram_recvmsg. 444 444 - */ 445 445 - /* put message back and return */ 446 446 - skb_queue_head(&sk->sk_receive_queue, skb); 447 447 - break; 448 448 - } 449 449 - } while (size); 450 450 - caif_read_unlock(sk); 451 451 - 452 452 - out: 453 453 - return copied ? : err; 454 454 - } 455 455 - 456 456 - /* 457 457 - * Copied from sock.c:sock_wait_for_wmem, but change to wait for 458 458 - * CAIF flow-on and sock_writable. 459 459 - */ 460 460 - static long caif_wait_for_flow_on(struct caifsock *cf_sk, 461 461 - int wait_writeable, long timeo, int *err) 462 462 - { 463 463 - struct sock *sk = &cf_sk->sk; 464 464 - DEFINE_WAIT(wait); 465 465 - for (;;) { 466 466 - *err = 0; 467 467 - if (tx_flow_is_on(cf_sk) && 468 468 - (!wait_writeable || sock_writeable(&cf_sk->sk))) 469 469 - break; 470 470 - *err = -ETIMEDOUT; 471 471 - if (!timeo) 472 472 - break; 473 473 - *err = -ERESTARTSYS; 474 474 - if (signal_pending(current)) 475 475 - break; 476 476 - prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 477 477 - *err = -ECONNRESET; 478 478 - if (sk->sk_shutdown & SHUTDOWN_MASK) 479 479 - break; 480 480 - *err = -sk->sk_err; 481 481 - if (sk->sk_err) 482 482 - break; 483 483 - *err = -EPIPE; 484 484 - if (cf_sk->sk.sk_state != CAIF_CONNECTED) 485 485 - break; 486 486 - timeo = schedule_timeout(timeo); 487 487 - } 488 488 - finish_wait(sk_sleep(sk), &wait); 489 489 - return timeo; 490 490 - } 491 491 - 492 492 - /* 493 493 - * Transmit a SKB. The device may temporarily request re-transmission 494 494 - * by returning EAGAIN. 495 495 - */ 496 496 - static int transmit_skb(struct sk_buff *skb, struct caifsock *cf_sk, 497 497 - int noblock, long timeo) 498 498 - { 499 499 - struct cfpkt *pkt; 500 500 - 501 501 - pkt = cfpkt_fromnative(CAIF_DIR_OUT, skb); 502 502 - memset(skb->cb, 0, sizeof(struct caif_payload_info)); 503 503 - cfpkt_set_prio(pkt, cf_sk->sk.sk_priority); 504 504 - 505 505 - if (cf_sk->layer.dn == NULL) { 506 506 - kfree_skb(skb); 507 507 - return -EINVAL; 508 508 - } 509 509 - 510 510 - return cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt); 511 511 - } 512 512 - 513 513 - /* Copied from af_unix:unix_dgram_sendmsg, and adapted to CAIF */ 514 514 - static int caif_seqpkt_sendmsg(struct socket *sock, struct msghdr *msg, 515 515 - size_t len) 516 516 - { 517 517 - struct sock *sk = sock->sk; 518 518 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 519 519 - int buffer_size; 520 520 - int ret = 0; 521 521 - struct sk_buff *skb = NULL; 522 522 - int noblock; 523 523 - long timeo; 524 524 - caif_assert(cf_sk); 525 525 - ret = sock_error(sk); 526 526 - if (ret) 527 527 - goto err; 528 528 - 529 529 - ret = -EOPNOTSUPP; 530 530 - if (msg->msg_flags&MSG_OOB) 531 531 - goto err; 532 532 - 533 533 - ret = -EOPNOTSUPP; 534 534 - if (msg->msg_namelen) 535 535 - goto err; 536 536 - 537 537 - noblock = msg->msg_flags & MSG_DONTWAIT; 538 538 - 539 539 - timeo = sock_sndtimeo(sk, noblock); 540 540 - timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk), 541 541 - 1, timeo, &ret); 542 542 - 543 543 - if (ret) 544 544 - goto err; 545 545 - ret = -EPIPE; 546 546 - if (cf_sk->sk.sk_state != CAIF_CONNECTED || 547 547 - sock_flag(sk, SOCK_DEAD) || 548 548 - (sk->sk_shutdown & RCV_SHUTDOWN)) 549 549 - goto err; 550 550 - 551 551 - /* Error if trying to write more than maximum frame size. */ 552 552 - ret = -EMSGSIZE; 553 553 - if (len > cf_sk->maxframe && cf_sk->sk.sk_protocol != CAIFPROTO_RFM) 554 554 - goto err; 555 555 - 556 556 - buffer_size = len + cf_sk->headroom + cf_sk->tailroom; 557 557 - 558 558 - ret = -ENOMEM; 559 559 - skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret); 560 560 - 561 561 - if (!skb || skb_tailroom(skb) < buffer_size) 562 562 - goto err; 563 563 - 564 564 - skb_reserve(skb, cf_sk->headroom); 565 565 - 566 566 - ret = memcpy_from_msg(skb_put(skb, len), msg, len); 567 567 - 568 568 - if (ret) 569 569 - goto err; 570 570 - ret = transmit_skb(skb, cf_sk, noblock, timeo); 571 571 - if (ret < 0) 572 572 - /* skb is already freed */ 573 573 - return ret; 574 574 - 575 575 - return len; 576 576 - err: 577 577 - kfree_skb(skb); 578 578 - return ret; 579 579 - } 580 580 - 581 581 - /* 582 582 - * Copied from unix_stream_sendmsg and adapted to CAIF: 583 583 - * Changed removed permission handling and added waiting for flow on 584 584 - * and other minor adaptations. 585 585 - */ 586 586 - static int caif_stream_sendmsg(struct socket *sock, struct msghdr *msg, 587 587 - size_t len) 588 588 - { 589 589 - struct sock *sk = sock->sk; 590 590 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 591 591 - int err, size; 592 592 - struct sk_buff *skb; 593 593 - int sent = 0; 594 594 - long timeo; 595 595 - 596 596 - err = -EOPNOTSUPP; 597 597 - if (unlikely(msg->msg_flags&MSG_OOB)) 598 598 - goto out_err; 599 599 - 600 600 - if (unlikely(msg->msg_namelen)) 601 601 - goto out_err; 602 602 - 603 603 - timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT); 604 604 - timeo = caif_wait_for_flow_on(cf_sk, 1, timeo, &err); 605 605 - 606 606 - if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN)) 607 607 - goto pipe_err; 608 608 - 609 609 - while (sent < len) { 610 610 - 611 611 - size = len-sent; 612 612 - 613 613 - if (size > cf_sk->maxframe) 614 614 - size = cf_sk->maxframe; 615 615 - 616 616 - /* If size is more than half of sndbuf, chop up message */ 617 617 - if (size > ((sk->sk_sndbuf >> 1) - 64)) 618 618 - size = (sk->sk_sndbuf >> 1) - 64; 619 619 - 620 620 - if (size > SKB_MAX_ALLOC) 621 621 - size = SKB_MAX_ALLOC; 622 622 - 623 623 - skb = sock_alloc_send_skb(sk, 624 624 - size + cf_sk->headroom + 625 625 - cf_sk->tailroom, 626 626 - msg->msg_flags&MSG_DONTWAIT, 627 627 - &err); 628 628 - if (skb == NULL) 629 629 - goto out_err; 630 630 - 631 631 - skb_reserve(skb, cf_sk->headroom); 632 632 - /* 633 633 - * If you pass two values to the sock_alloc_send_skb 634 634 - * it tries to grab the large buffer with GFP_NOFS 635 635 - * (which can fail easily), and if it fails grab the 636 636 - * fallback size buffer which is under a page and will 637 637 - * succeed. [Alan] 638 638 - */ 639 639 - size = min_t(int, size, skb_tailroom(skb)); 640 640 - 641 641 - err = memcpy_from_msg(skb_put(skb, size), msg, size); 642 642 - if (err) { 643 643 - kfree_skb(skb); 644 644 - goto out_err; 645 645 - } 646 646 - err = transmit_skb(skb, cf_sk, 647 647 - msg->msg_flags&MSG_DONTWAIT, timeo); 648 648 - if (err < 0) 649 649 - /* skb is already freed */ 650 650 - goto pipe_err; 651 651 - 652 652 - sent += size; 653 653 - } 654 654 - 655 655 - return sent; 656 656 - 657 657 - pipe_err: 658 658 - if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL)) 659 659 - send_sig(SIGPIPE, current, 0); 660 660 - err = -EPIPE; 661 661 - out_err: 662 662 - return sent ? : err; 663 663 - } 664 664 - 665 665 - static int setsockopt(struct socket *sock, int lvl, int opt, sockptr_t ov, 666 666 - unsigned int ol) 667 667 - { 668 668 - struct sock *sk = sock->sk; 669 669 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 670 670 - int linksel; 671 671 - 672 672 - if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED) 673 673 - return -ENOPROTOOPT; 674 674 - 675 675 - switch (opt) { 676 676 - case CAIFSO_LINK_SELECT: 677 677 - if (ol < sizeof(int)) 678 678 - return -EINVAL; 679 679 - if (lvl != SOL_CAIF) 680 680 - goto bad_sol; 681 681 - if (copy_from_sockptr(&linksel, ov, sizeof(int))) 682 682 - return -EINVAL; 683 683 - lock_sock(&(cf_sk->sk)); 684 684 - cf_sk->conn_req.link_selector = linksel; 685 685 - release_sock(&cf_sk->sk); 686 686 - return 0; 687 687 - 688 688 - case CAIFSO_REQ_PARAM: 689 689 - if (lvl != SOL_CAIF) 690 690 - goto bad_sol; 691 691 - if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL) 692 692 - return -ENOPROTOOPT; 693 693 - lock_sock(&(cf_sk->sk)); 694 694 - if (ol > sizeof(cf_sk->conn_req.param.data) || 695 695 - copy_from_sockptr(&cf_sk->conn_req.param.data, ov, ol)) { 696 696 - release_sock(&cf_sk->sk); 697 697 - return -EINVAL; 698 698 - } 699 699 - cf_sk->conn_req.param.size = ol; 700 700 - release_sock(&cf_sk->sk); 701 701 - return 0; 702 702 - 703 703 - default: 704 704 - return -ENOPROTOOPT; 705 705 - } 706 706 - 707 707 - return 0; 708 708 - bad_sol: 709 709 - return -ENOPROTOOPT; 710 710 - 711 711 - } 712 712 - 713 713 - /* 714 714 - * caif_connect() - Connect a CAIF Socket 715 715 - * Copied and modified af_irda.c:irda_connect(). 716 716 - * 717 717 - * Note : by consulting "errno", the user space caller may learn the cause 718 718 - * of the failure. Most of them are visible in the function, others may come 719 719 - * from subroutines called and are listed here : 720 720 - * o -EAFNOSUPPORT: bad socket family or type. 721 721 - * o -ESOCKTNOSUPPORT: bad socket type or protocol 722 722 - * o -EINVAL: bad socket address, or CAIF link type 723 723 - * o -ECONNREFUSED: remote end refused the connection. 724 724 - * o -EINPROGRESS: connect request sent but timed out (or non-blocking) 725 725 - * o -EISCONN: already connected. 726 726 - * o -ETIMEDOUT: Connection timed out (send timeout) 727 727 - * o -ENODEV: No link layer to send request 728 728 - * o -ECONNRESET: Received Shutdown indication or lost link layer 729 729 - * o -ENOMEM: Out of memory 730 730 - * 731 731 - * State Strategy: 732 732 - * o sk_state: holds the CAIF_* protocol state, it's updated by 733 733 - * caif_ctrl_cb. 734 734 - * o sock->state: holds the SS_* socket state and is updated by connect and 735 735 - * disconnect. 736 736 - */ 737 737 - static int caif_connect(struct socket *sock, struct sockaddr_unsized *uaddr, 738 738 - int addr_len, int flags) 739 739 - { 740 740 - struct sock *sk = sock->sk; 741 741 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 742 742 - long timeo; 743 743 - int err; 744 744 - int ifindex, headroom, tailroom; 745 745 - unsigned int mtu; 746 746 - struct net_device *dev; 747 747 - 748 748 - lock_sock(sk); 749 749 - 750 750 - err = -EINVAL; 751 751 - if (addr_len < offsetofend(struct sockaddr, sa_family)) 752 752 - goto out; 753 753 - 754 754 - err = -EAFNOSUPPORT; 755 755 - if (uaddr->sa_family != AF_CAIF) 756 756 - goto out; 757 757 - 758 758 - switch (sock->state) { 759 759 - case SS_UNCONNECTED: 760 760 - /* Normal case, a fresh connect */ 761 761 - caif_assert(sk->sk_state == CAIF_DISCONNECTED); 762 762 - break; 763 763 - case SS_CONNECTING: 764 764 - switch (sk->sk_state) { 765 765 - case CAIF_CONNECTED: 766 766 - sock->state = SS_CONNECTED; 767 767 - err = -EISCONN; 768 768 - goto out; 769 769 - case CAIF_DISCONNECTED: 770 770 - /* Reconnect allowed */ 771 771 - break; 772 772 - case CAIF_CONNECTING: 773 773 - err = -EALREADY; 774 774 - if (flags & O_NONBLOCK) 775 775 - goto out; 776 776 - goto wait_connect; 777 777 - } 778 778 - break; 779 779 - case SS_CONNECTED: 780 780 - caif_assert(sk->sk_state == CAIF_CONNECTED || 781 781 - sk->sk_state == CAIF_DISCONNECTED); 782 782 - if (sk->sk_shutdown & SHUTDOWN_MASK) { 783 783 - /* Allow re-connect after SHUTDOWN_IND */ 784 784 - caif_disconnect_client(sock_net(sk), &cf_sk->layer); 785 785 - caif_free_client(&cf_sk->layer); 786 786 - break; 787 787 - } 788 788 - /* No reconnect on a seqpacket socket */ 789 789 - err = -EISCONN; 790 790 - goto out; 791 791 - case SS_DISCONNECTING: 792 792 - case SS_FREE: 793 793 - caif_assert(1); /*Should never happen */ 794 794 - break; 795 795 - } 796 796 - sk->sk_state = CAIF_DISCONNECTED; 797 797 - sock->state = SS_UNCONNECTED; 798 798 - sk_stream_kill_queues(&cf_sk->sk); 799 799 - 800 800 - err = -EINVAL; 801 801 - if (addr_len != sizeof(struct sockaddr_caif)) 802 802 - goto out; 803 803 - 804 804 - memcpy(&cf_sk->conn_req.sockaddr, uaddr, 805 805 - sizeof(struct sockaddr_caif)); 806 806 - 807 807 - /* Move to connecting socket, start sending Connect Requests */ 808 808 - sock->state = SS_CONNECTING; 809 809 - sk->sk_state = CAIF_CONNECTING; 810 810 - 811 811 - /* Check priority value comming from socket */ 812 812 - /* if priority value is out of range it will be ajusted */ 813 813 - if (cf_sk->sk.sk_priority > CAIF_PRIO_MAX) 814 814 - cf_sk->conn_req.priority = CAIF_PRIO_MAX; 815 815 - else if (cf_sk->sk.sk_priority < CAIF_PRIO_MIN) 816 816 - cf_sk->conn_req.priority = CAIF_PRIO_MIN; 817 817 - else 818 818 - cf_sk->conn_req.priority = cf_sk->sk.sk_priority; 819 819 - 820 820 - /*ifindex = id of the interface.*/ 821 821 - cf_sk->conn_req.ifindex = cf_sk->sk.sk_bound_dev_if; 822 822 - 823 823 - cf_sk->layer.receive = caif_sktrecv_cb; 824 824 - 825 825 - err = caif_connect_client(sock_net(sk), &cf_sk->conn_req, 826 826 - &cf_sk->layer, &ifindex, &headroom, &tailroom); 827 827 - 828 828 - if (err < 0) { 829 829 - cf_sk->sk.sk_socket->state = SS_UNCONNECTED; 830 830 - cf_sk->sk.sk_state = CAIF_DISCONNECTED; 831 831 - goto out; 832 832 - } 833 833 - 834 834 - err = -ENODEV; 835 835 - rcu_read_lock(); 836 836 - dev = dev_get_by_index_rcu(sock_net(sk), ifindex); 837 837 - if (!dev) { 838 838 - rcu_read_unlock(); 839 839 - goto out; 840 840 - } 841 841 - cf_sk->headroom = LL_RESERVED_SPACE_EXTRA(dev, headroom); 842 842 - mtu = dev->mtu; 843 843 - rcu_read_unlock(); 844 844 - 845 845 - cf_sk->tailroom = tailroom; 846 846 - cf_sk->maxframe = mtu - (headroom + tailroom); 847 847 - if (cf_sk->maxframe < 1) { 848 848 - pr_warn("CAIF Interface MTU too small (%d)\n", dev->mtu); 849 849 - err = -ENODEV; 850 850 - goto out; 851 851 - } 852 852 - 853 853 - err = -EINPROGRESS; 854 854 - wait_connect: 855 855 - 856 856 - if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK)) 857 857 - goto out; 858 858 - 859 859 - timeo = sock_sndtimeo(sk, flags & O_NONBLOCK); 860 860 - 861 861 - release_sock(sk); 862 862 - err = -ERESTARTSYS; 863 863 - timeo = wait_event_interruptible_timeout(*sk_sleep(sk), 864 864 - sk->sk_state != CAIF_CONNECTING, 865 865 - timeo); 866 866 - lock_sock(sk); 867 867 - if (timeo < 0) 868 868 - goto out; /* -ERESTARTSYS */ 869 869 - 870 870 - err = -ETIMEDOUT; 871 871 - if (timeo == 0 && sk->sk_state != CAIF_CONNECTED) 872 872 - goto out; 873 873 - if (sk->sk_state != CAIF_CONNECTED) { 874 874 - sock->state = SS_UNCONNECTED; 875 875 - err = sock_error(sk); 876 876 - if (!err) 877 877 - err = -ECONNREFUSED; 878 878 - goto out; 879 879 - } 880 880 - sock->state = SS_CONNECTED; 881 881 - err = 0; 882 882 - out: 883 883 - release_sock(sk); 884 884 - return err; 885 885 - } 886 886 - 887 887 - /* 888 888 - * caif_release() - Disconnect a CAIF Socket 889 889 - * Copied and modified af_irda.c:irda_release(). 890 890 - */ 891 891 - static int caif_release(struct socket *sock) 892 892 - { 893 893 - struct sock *sk = sock->sk; 894 894 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 895 895 - 896 896 - if (!sk) 897 897 - return 0; 898 898 - 899 899 - set_tx_flow_off(cf_sk); 900 900 - 901 901 - /* 902 902 - * Ensure that packets are not queued after this point in time. 903 903 - * caif_queue_rcv_skb checks SOCK_DEAD holding the queue lock, 904 904 - * this ensures no packets when sock is dead. 905 905 - */ 906 906 - spin_lock_bh(&sk->sk_receive_queue.lock); 907 907 - sock_set_flag(sk, SOCK_DEAD); 908 908 - spin_unlock_bh(&sk->sk_receive_queue.lock); 909 909 - sock->sk = NULL; 910 910 - 911 911 - WARN_ON(IS_ERR(cf_sk->debugfs_socket_dir)); 912 912 - debugfs_remove_recursive(cf_sk->debugfs_socket_dir); 913 913 - 914 914 - lock_sock(&(cf_sk->sk)); 915 915 - sk->sk_state = CAIF_DISCONNECTED; 916 916 - sk->sk_shutdown = SHUTDOWN_MASK; 917 917 - 918 918 - caif_disconnect_client(sock_net(sk), &cf_sk->layer); 919 919 - cf_sk->sk.sk_socket->state = SS_DISCONNECTING; 920 920 - wake_up_interruptible_poll(sk_sleep(sk), EPOLLERR|EPOLLHUP); 921 921 - 922 922 - sock_orphan(sk); 923 923 - sk_stream_kill_queues(&cf_sk->sk); 924 924 - release_sock(sk); 925 925 - sock_put(sk); 926 926 - return 0; 927 927 - } 928 928 - 929 929 - /* Copied from af_unix.c:unix_poll(), added CAIF tx_flow handling */ 930 930 - static __poll_t caif_poll(struct file *file, 931 931 - struct socket *sock, poll_table *wait) 932 932 - { 933 933 - struct sock *sk = sock->sk; 934 934 - __poll_t mask; 935 935 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 936 936 - 937 937 - sock_poll_wait(file, sock, wait); 938 938 - mask = 0; 939 939 - 940 940 - /* exceptional events? */ 941 941 - if (sk->sk_err) 942 942 - mask |= EPOLLERR; 943 943 - if (sk->sk_shutdown == SHUTDOWN_MASK) 944 944 - mask |= EPOLLHUP; 945 945 - if (sk->sk_shutdown & RCV_SHUTDOWN) 946 946 - mask |= EPOLLRDHUP; 947 947 - 948 948 - /* readable? */ 949 949 - if (!skb_queue_empty_lockless(&sk->sk_receive_queue) || 950 950 - (sk->sk_shutdown & RCV_SHUTDOWN)) 951 951 - mask |= EPOLLIN | EPOLLRDNORM; 952 952 - 953 953 - /* 954 954 - * we set writable also when the other side has shut down the 955 955 - * connection. This prevents stuck sockets. 956 956 - */ 957 957 - if (sock_writeable(sk) && tx_flow_is_on(cf_sk)) 958 958 - mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND; 959 959 - 960 960 - return mask; 961 961 - } 962 962 - 963 963 - static const struct proto_ops caif_seqpacket_ops = { 964 964 - .family = PF_CAIF, 965 965 - .owner = THIS_MODULE, 966 966 - .release = caif_release, 967 967 - .bind = sock_no_bind, 968 968 - .connect = caif_connect, 969 969 - .socketpair = sock_no_socketpair, 970 970 - .accept = sock_no_accept, 971 971 - .getname = sock_no_getname, 972 972 - .poll = caif_poll, 973 973 - .ioctl = sock_no_ioctl, 974 974 - .listen = sock_no_listen, 975 975 - .shutdown = sock_no_shutdown, 976 976 - .setsockopt = setsockopt, 977 977 - .sendmsg = caif_seqpkt_sendmsg, 978 978 - .recvmsg = caif_seqpkt_recvmsg, 979 979 - .mmap = sock_no_mmap, 980 980 - }; 981 981 - 982 982 - static const struct proto_ops caif_stream_ops = { 983 983 - .family = PF_CAIF, 984 984 - .owner = THIS_MODULE, 985 985 - .release = caif_release, 986 986 - .bind = sock_no_bind, 987 987 - .connect = caif_connect, 988 988 - .socketpair = sock_no_socketpair, 989 989 - .accept = sock_no_accept, 990 990 - .getname = sock_no_getname, 991 991 - .poll = caif_poll, 992 992 - .ioctl = sock_no_ioctl, 993 993 - .listen = sock_no_listen, 994 994 - .shutdown = sock_no_shutdown, 995 995 - .setsockopt = setsockopt, 996 996 - .sendmsg = caif_stream_sendmsg, 997 997 - .recvmsg = caif_stream_recvmsg, 998 998 - .mmap = sock_no_mmap, 999 999 - }; 1000 1000 - 1001 1001 - /* This function is called when a socket is finally destroyed. */ 1002 1002 - static void caif_sock_destructor(struct sock *sk) 1003 1003 - { 1004 1004 - struct caifsock *cf_sk = container_of(sk, struct caifsock, sk); 1005 1005 - caif_assert(!refcount_read(&sk->sk_wmem_alloc)); 1006 1006 - caif_assert(sk_unhashed(sk)); 1007 1007 - caif_assert(!sk->sk_socket); 1008 1008 - if (!sock_flag(sk, SOCK_DEAD)) { 1009 1009 - pr_debug("Attempt to release alive CAIF socket: %p\n", sk); 1010 1010 - return; 1011 1011 - } 1012 1012 - sk_stream_kill_queues(&cf_sk->sk); 1013 1013 - WARN_ON_ONCE(sk->sk_forward_alloc); 1014 1014 - caif_free_client(&cf_sk->layer); 1015 1015 - } 1016 1016 - 1017 1017 - static int caif_create(struct net *net, struct socket *sock, int protocol, 1018 1018 - int kern) 1019 1019 - { 1020 1020 - struct sock *sk = NULL; 1021 1021 - struct caifsock *cf_sk = NULL; 1022 1022 - static struct proto prot = {.name = "PF_CAIF", 1023 1023 - .owner = THIS_MODULE, 1024 1024 - .obj_size = sizeof(struct caifsock), 1025 1025 - .useroffset = offsetof(struct caifsock, conn_req.param), 1026 1026 - .usersize = sizeof_field(struct caifsock, conn_req.param) 1027 1027 - }; 1028 1028 - 1029 1029 - if (!capable(CAP_SYS_ADMIN) && !capable(CAP_NET_ADMIN)) 1030 1030 - return -EPERM; 1031 1031 - /* 1032 1032 - * The sock->type specifies the socket type to use. 1033 1033 - * The CAIF socket is a packet stream in the sense 1034 1034 - * that it is packet based. CAIF trusts the reliability 1035 1035 - * of the link, no resending is implemented. 1036 1036 - */ 1037 1037 - if (sock->type == SOCK_SEQPACKET) 1038 1038 - sock->ops = &caif_seqpacket_ops; 1039 1039 - else if (sock->type == SOCK_STREAM) 1040 1040 - sock->ops = &caif_stream_ops; 1041 1041 - else 1042 1042 - return -ESOCKTNOSUPPORT; 1043 1043 - 1044 1044 - if (protocol < 0 || protocol >= CAIFPROTO_MAX) 1045 1045 - return -EPROTONOSUPPORT; 1046 1046 - /* 1047 1047 - * Set the socket state to unconnected. The socket state 1048 1048 - * is really not used at all in the net/core or socket.c but the 1049 1049 - * initialization makes sure that sock->state is not uninitialized. 1050 1050 - */ 1051 1051 - sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot, kern); 1052 1052 - if (!sk) 1053 1053 - return -ENOMEM; 1054 1054 - 1055 1055 - cf_sk = container_of(sk, struct caifsock, sk); 1056 1056 - 1057 1057 - /* Store the protocol */ 1058 1058 - sk->sk_protocol = (unsigned char) protocol; 1059 1059 - 1060 1060 - /* Initialize default priority for well-known cases */ 1061 1061 - switch (protocol) { 1062 1062 - case CAIFPROTO_AT: 1063 1063 - sk->sk_priority = TC_PRIO_CONTROL; 1064 1064 - break; 1065 1065 - case CAIFPROTO_RFM: 1066 1066 - sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 1067 1067 - break; 1068 1068 - default: 1069 1069 - sk->sk_priority = TC_PRIO_BESTEFFORT; 1070 1070 - } 1071 1071 - 1072 1072 - /* 1073 1073 - * Lock in order to try to stop someone from opening the socket 1074 1074 - * too early. 1075 1075 - */ 1076 1076 - lock_sock(&(cf_sk->sk)); 1077 1077 - 1078 1078 - /* Initialize the nozero default sock structure data. */ 1079 1079 - sock_init_data(sock, sk); 1080 1080 - sk->sk_destruct = caif_sock_destructor; 1081 1081 - 1082 1082 - mutex_init(&cf_sk->readlock); /* single task reading lock */ 1083 1083 - cf_sk->layer.ctrlcmd = caif_ctrl_cb; 1084 1084 - cf_sk->sk.sk_socket->state = SS_UNCONNECTED; 1085 1085 - cf_sk->sk.sk_state = CAIF_DISCONNECTED; 1086 1086 - 1087 1087 - set_tx_flow_off(cf_sk); 1088 1088 - set_rx_flow_on(cf_sk); 1089 1089 - 1090 1090 - /* Set default options on configuration */ 1091 1091 - cf_sk->conn_req.link_selector = CAIF_LINK_LOW_LATENCY; 1092 1092 - cf_sk->conn_req.protocol = protocol; 1093 1093 - release_sock(&cf_sk->sk); 1094 1094 - return 0; 1095 1095 - } 1096 1096 - 1097 1097 - 1098 1098 - static const struct net_proto_family caif_family_ops = { 1099 1099 - .family = PF_CAIF, 1100 1100 - .create = caif_create, 1101 1101 - .owner = THIS_MODULE, 1102 1102 - }; 1103 1103 - 1104 1104 - static int __init caif_sktinit_module(void) 1105 1105 - { 1106 1106 - return sock_register(&caif_family_ops); 1107 1107 - } 1108 1108 - 1109 1109 - static void __exit caif_sktexit_module(void) 1110 1110 - { 1111 1111 - sock_unregister(PF_CAIF); 1112 1112 - } 1113 1113 - module_init(caif_sktinit_module); 1114 1114 - module_exit(caif_sktexit_module);

-216

net/caif/caif_usb.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * CAIF USB handler 4 4 - * Copyright (C) ST-Ericsson AB 2011 5 5 - * Author: Sjur Brendeland 6 6 - */ 7 7 - 8 8 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 9 9 - 10 10 - #include <linux/module.h> 11 11 - #include <linux/netdevice.h> 12 12 - #include <linux/slab.h> 13 13 - #include <linux/mii.h> 14 14 - #include <linux/usb.h> 15 15 - #include <linux/usb/usbnet.h> 16 16 - #include <linux/etherdevice.h> 17 17 - #include <net/netns/generic.h> 18 18 - #include <net/caif/caif_dev.h> 19 19 - #include <net/caif/caif_layer.h> 20 20 - #include <net/caif/cfpkt.h> 21 21 - #include <net/caif/cfcnfg.h> 22 22 - 23 23 - MODULE_DESCRIPTION("ST-Ericsson CAIF modem protocol USB support"); 24 24 - MODULE_LICENSE("GPL"); 25 25 - 26 26 - #define CFUSB_PAD_DESCR_SZ 1 /* Alignment descriptor length */ 27 27 - #define CFUSB_ALIGNMENT 4 /* Number of bytes to align. */ 28 28 - #define CFUSB_MAX_HEADLEN (CFUSB_PAD_DESCR_SZ + CFUSB_ALIGNMENT-1) 29 29 - #define STE_USB_VID 0x04cc /* USB Product ID for ST-Ericsson */ 30 30 - #define STE_USB_PID_CAIF 0x230f /* Product id for CAIF Modems */ 31 31 - 32 32 - struct cfusbl { 33 33 - struct cflayer layer; 34 34 - u8 tx_eth_hdr[ETH_HLEN]; 35 35 - }; 36 36 - 37 37 - static bool pack_added; 38 38 - 39 39 - static int cfusbl_receive(struct cflayer *layr, struct cfpkt *pkt) 40 40 - { 41 41 - u8 hpad; 42 42 - 43 43 - /* Remove padding. */ 44 44 - cfpkt_extr_head(pkt, &hpad, 1); 45 45 - cfpkt_extr_head(pkt, NULL, hpad); 46 46 - return layr->up->receive(layr->up, pkt); 47 47 - } 48 48 - 49 49 - static int cfusbl_transmit(struct cflayer *layr, struct cfpkt *pkt) 50 50 - { 51 51 - struct caif_payload_info *info; 52 52 - u8 hpad; 53 53 - u8 zeros[CFUSB_ALIGNMENT]; 54 54 - struct sk_buff *skb; 55 55 - struct cfusbl *usbl = container_of(layr, struct cfusbl, layer); 56 56 - 57 57 - skb = cfpkt_tonative(pkt); 58 58 - 59 59 - skb_reset_network_header(skb); 60 60 - skb->protocol = htons(ETH_P_IP); 61 61 - 62 62 - info = cfpkt_info(pkt); 63 63 - hpad = (info->hdr_len + CFUSB_PAD_DESCR_SZ) & (CFUSB_ALIGNMENT - 1); 64 64 - 65 65 - if (skb_headroom(skb) < ETH_HLEN + CFUSB_PAD_DESCR_SZ + hpad) { 66 66 - pr_warn("Headroom too small\n"); 67 67 - kfree_skb(skb); 68 68 - return -EIO; 69 69 - } 70 70 - memset(zeros, 0, hpad); 71 71 - 72 72 - cfpkt_add_head(pkt, zeros, hpad); 73 73 - cfpkt_add_head(pkt, &hpad, 1); 74 74 - cfpkt_add_head(pkt, usbl->tx_eth_hdr, sizeof(usbl->tx_eth_hdr)); 75 75 - return layr->dn->transmit(layr->dn, pkt); 76 76 - } 77 77 - 78 78 - static void cfusbl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 79 79 - int phyid) 80 80 - { 81 81 - if (layr->up && layr->up->ctrlcmd) 82 82 - layr->up->ctrlcmd(layr->up, ctrl, layr->id); 83 83 - } 84 84 - 85 85 - static struct cflayer *cfusbl_create(int phyid, const u8 ethaddr[ETH_ALEN], 86 86 - u8 braddr[ETH_ALEN]) 87 87 - { 88 88 - struct cfusbl *this = kmalloc_obj(struct cfusbl, GFP_ATOMIC); 89 89 - 90 90 - if (!this) 91 91 - return NULL; 92 92 - 93 93 - caif_assert(offsetof(struct cfusbl, layer) == 0); 94 94 - 95 95 - memset(&this->layer, 0, sizeof(this->layer)); 96 96 - this->layer.receive = cfusbl_receive; 97 97 - this->layer.transmit = cfusbl_transmit; 98 98 - this->layer.ctrlcmd = cfusbl_ctrlcmd; 99 99 - snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "usb%d", phyid); 100 100 - this->layer.id = phyid; 101 101 - 102 102 - /* 103 103 - * Construct TX ethernet header: 104 104 - * 0-5 destination address 105 105 - * 5-11 source address 106 106 - * 12-13 protocol type 107 107 - */ 108 108 - ether_addr_copy(&this->tx_eth_hdr[ETH_ALEN], braddr); 109 109 - ether_addr_copy(&this->tx_eth_hdr[ETH_ALEN], ethaddr); 110 110 - this->tx_eth_hdr[12] = cpu_to_be16(ETH_P_802_EX1) & 0xff; 111 111 - this->tx_eth_hdr[13] = (cpu_to_be16(ETH_P_802_EX1) >> 8) & 0xff; 112 112 - pr_debug("caif ethernet TX-header dst:%pM src:%pM type:%02x%02x\n", 113 113 - this->tx_eth_hdr, this->tx_eth_hdr + ETH_ALEN, 114 114 - this->tx_eth_hdr[12], this->tx_eth_hdr[13]); 115 115 - 116 116 - return (struct cflayer *) this; 117 117 - } 118 118 - 119 119 - static void cfusbl_release(struct cflayer *layer) 120 120 - { 121 121 - kfree(layer); 122 122 - } 123 123 - 124 124 - static struct packet_type caif_usb_type __read_mostly = { 125 125 - .type = cpu_to_be16(ETH_P_802_EX1), 126 126 - }; 127 127 - 128 128 - static int cfusbl_device_notify(struct notifier_block *me, unsigned long what, 129 129 - void *ptr) 130 130 - { 131 131 - struct net_device *dev = netdev_notifier_info_to_dev(ptr); 132 132 - struct caif_dev_common common; 133 133 - struct cflayer *layer, *link_support; 134 134 - struct usbnet *usbnet; 135 135 - struct usb_device *usbdev; 136 136 - int res; 137 137 - 138 138 - if (what == NETDEV_UNREGISTER && dev->reg_state >= NETREG_UNREGISTERED) 139 139 - return 0; 140 140 - 141 141 - /* Check whether we have a NCM device, and find its VID/PID. */ 142 142 - if (!(dev->dev.parent && dev->dev.parent->driver && 143 143 - strcmp(dev->dev.parent->driver->name, "cdc_ncm") == 0)) 144 144 - return 0; 145 145 - 146 146 - usbnet = netdev_priv(dev); 147 147 - usbdev = usbnet->udev; 148 148 - 149 149 - pr_debug("USB CDC NCM device VID:0x%4x PID:0x%4x\n", 150 150 - le16_to_cpu(usbdev->descriptor.idVendor), 151 151 - le16_to_cpu(usbdev->descriptor.idProduct)); 152 152 - 153 153 - /* Check for VID/PID that supports CAIF */ 154 154 - if (!(le16_to_cpu(usbdev->descriptor.idVendor) == STE_USB_VID && 155 155 - le16_to_cpu(usbdev->descriptor.idProduct) == STE_USB_PID_CAIF)) 156 156 - return 0; 157 157 - 158 158 - if (what == NETDEV_UNREGISTER) 159 159 - module_put(THIS_MODULE); 160 160 - 161 161 - if (what != NETDEV_REGISTER) 162 162 - return 0; 163 163 - 164 164 - __module_get(THIS_MODULE); 165 165 - 166 166 - memset(&common, 0, sizeof(common)); 167 167 - common.use_frag = false; 168 168 - common.use_fcs = false; 169 169 - common.use_stx = false; 170 170 - common.link_select = CAIF_LINK_HIGH_BANDW; 171 171 - common.flowctrl = NULL; 172 172 - 173 173 - link_support = cfusbl_create(dev->ifindex, dev->dev_addr, 174 174 - dev->broadcast); 175 175 - 176 176 - if (!link_support) 177 177 - return -ENOMEM; 178 178 - 179 179 - if (dev->num_tx_queues > 1) 180 180 - pr_warn("USB device uses more than one tx queue\n"); 181 181 - 182 182 - res = caif_enroll_dev(dev, &common, link_support, CFUSB_MAX_HEADLEN, 183 183 - &layer, &caif_usb_type.func); 184 184 - if (res) 185 185 - goto err; 186 186 - 187 187 - if (!pack_added) 188 188 - dev_add_pack(&caif_usb_type); 189 189 - pack_added = true; 190 190 - 191 191 - strscpy(layer->name, dev->name, sizeof(layer->name)); 192 192 - 193 193 - return 0; 194 194 - err: 195 195 - cfusbl_release(link_support); 196 196 - return res; 197 197 - } 198 198 - 199 199 - static struct notifier_block caif_device_notifier = { 200 200 - .notifier_call = cfusbl_device_notify, 201 201 - .priority = 0, 202 202 - }; 203 203 - 204 204 - static int __init cfusbl_init(void) 205 205 - { 206 206 - return register_netdevice_notifier(&caif_device_notifier); 207 207 - } 208 208 - 209 209 - static void __exit cfusbl_exit(void) 210 210 - { 211 211 - unregister_netdevice_notifier(&caif_device_notifier); 212 212 - dev_remove_pack(&caif_usb_type); 213 213 - } 214 214 - 215 215 - module_init(cfusbl_init); 216 216 - module_exit(cfusbl_exit);

-612

net/caif/cfcnfg.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/kernel.h> 10 10 - #include <linux/stddef.h> 11 11 - #include <linux/slab.h> 12 12 - #include <linux/netdevice.h> 13 13 - #include <linux/module.h> 14 14 - #include <net/caif/caif_layer.h> 15 15 - #include <net/caif/cfpkt.h> 16 16 - #include <net/caif/cfcnfg.h> 17 17 - #include <net/caif/cfctrl.h> 18 18 - #include <net/caif/cfmuxl.h> 19 19 - #include <net/caif/cffrml.h> 20 20 - #include <net/caif/cfserl.h> 21 21 - #include <net/caif/cfsrvl.h> 22 22 - #include <net/caif/caif_dev.h> 23 23 - 24 24 - #define container_obj(layr) container_of(layr, struct cfcnfg, layer) 25 25 - 26 26 - /* Information about CAIF physical interfaces held by Config Module in order 27 27 - * to manage physical interfaces 28 28 - */ 29 29 - struct cfcnfg_phyinfo { 30 30 - struct list_head node; 31 31 - bool up; 32 32 - 33 33 - /* Pointer to the layer below the MUX (framing layer) */ 34 34 - struct cflayer *frm_layer; 35 35 - /* Pointer to the lowest actual physical layer */ 36 36 - struct cflayer *phy_layer; 37 37 - /* Unique identifier of the physical interface */ 38 38 - unsigned int id; 39 39 - /* Preference of the physical in interface */ 40 40 - enum cfcnfg_phy_preference pref; 41 41 - 42 42 - /* Information about the physical device */ 43 43 - struct dev_info dev_info; 44 44 - 45 45 - /* Interface index */ 46 46 - int ifindex; 47 47 - 48 48 - /* Protocol head room added for CAIF link layer */ 49 49 - int head_room; 50 50 - 51 51 - /* Use Start of frame checksum */ 52 52 - bool use_fcs; 53 53 - }; 54 54 - 55 55 - struct cfcnfg { 56 56 - struct cflayer layer; 57 57 - struct cflayer *ctrl; 58 58 - struct cflayer *mux; 59 59 - struct list_head phys; 60 60 - struct mutex lock; 61 61 - }; 62 62 - 63 63 - static void cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id, 64 64 - enum cfctrl_srv serv, u8 phyid, 65 65 - struct cflayer *adapt_layer); 66 66 - static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id); 67 67 - static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id, 68 68 - struct cflayer *adapt_layer); 69 69 - static void cfctrl_resp_func(void); 70 70 - static void cfctrl_enum_resp(void); 71 71 - 72 72 - struct cfcnfg *cfcnfg_create(void) 73 73 - { 74 74 - struct cfcnfg *this; 75 75 - struct cfctrl_rsp *resp; 76 76 - 77 77 - might_sleep(); 78 78 - 79 79 - /* Initiate this layer */ 80 80 - this = kzalloc_obj(struct cfcnfg, GFP_ATOMIC); 81 81 - if (!this) 82 82 - return NULL; 83 83 - this->mux = cfmuxl_create(); 84 84 - if (!this->mux) 85 85 - goto out_of_mem; 86 86 - this->ctrl = cfctrl_create(); 87 87 - if (!this->ctrl) 88 88 - goto out_of_mem; 89 89 - /* Initiate response functions */ 90 90 - resp = cfctrl_get_respfuncs(this->ctrl); 91 91 - resp->enum_rsp = cfctrl_enum_resp; 92 92 - resp->linkerror_ind = cfctrl_resp_func; 93 93 - resp->linkdestroy_rsp = cfcnfg_linkdestroy_rsp; 94 94 - resp->sleep_rsp = cfctrl_resp_func; 95 95 - resp->wake_rsp = cfctrl_resp_func; 96 96 - resp->restart_rsp = cfctrl_resp_func; 97 97 - resp->radioset_rsp = cfctrl_resp_func; 98 98 - resp->linksetup_rsp = cfcnfg_linkup_rsp; 99 99 - resp->reject_rsp = cfcnfg_reject_rsp; 100 100 - INIT_LIST_HEAD(&this->phys); 101 101 - 102 102 - cfmuxl_set_uplayer(this->mux, this->ctrl, 0); 103 103 - layer_set_dn(this->ctrl, this->mux); 104 104 - layer_set_up(this->ctrl, this); 105 105 - mutex_init(&this->lock); 106 106 - 107 107 - return this; 108 108 - out_of_mem: 109 109 - synchronize_rcu(); 110 110 - 111 111 - kfree(this->mux); 112 112 - kfree(this->ctrl); 113 113 - kfree(this); 114 114 - return NULL; 115 115 - } 116 116 - 117 117 - void cfcnfg_remove(struct cfcnfg *cfg) 118 118 - { 119 119 - might_sleep(); 120 120 - if (cfg) { 121 121 - synchronize_rcu(); 122 122 - 123 123 - kfree(cfg->mux); 124 124 - cfctrl_remove(cfg->ctrl); 125 125 - kfree(cfg); 126 126 - } 127 127 - } 128 128 - 129 129 - static void cfctrl_resp_func(void) 130 130 - { 131 131 - } 132 132 - 133 133 - static struct cfcnfg_phyinfo *cfcnfg_get_phyinfo_rcu(struct cfcnfg *cnfg, 134 134 - u8 phyid) 135 135 - { 136 136 - struct cfcnfg_phyinfo *phy; 137 137 - 138 138 - list_for_each_entry_rcu(phy, &cnfg->phys, node) 139 139 - if (phy->id == phyid) 140 140 - return phy; 141 141 - return NULL; 142 142 - } 143 143 - 144 144 - static void cfctrl_enum_resp(void) 145 145 - { 146 146 - } 147 147 - 148 148 - static struct dev_info *cfcnfg_get_phyid(struct cfcnfg *cnfg, 149 149 - enum cfcnfg_phy_preference phy_pref) 150 150 - { 151 151 - /* Try to match with specified preference */ 152 152 - struct cfcnfg_phyinfo *phy; 153 153 - 154 154 - list_for_each_entry_rcu(phy, &cnfg->phys, node) { 155 155 - if (phy->up && phy->pref == phy_pref && 156 156 - phy->frm_layer != NULL) 157 157 - 158 158 - return &phy->dev_info; 159 159 - } 160 160 - 161 161 - /* Otherwise just return something */ 162 162 - list_for_each_entry_rcu(phy, &cnfg->phys, node) 163 163 - if (phy->up) 164 164 - return &phy->dev_info; 165 165 - 166 166 - return NULL; 167 167 - } 168 168 - 169 169 - static int cfcnfg_get_id_from_ifi(struct cfcnfg *cnfg, int ifi) 170 170 - { 171 171 - struct cfcnfg_phyinfo *phy; 172 172 - 173 173 - list_for_each_entry_rcu(phy, &cnfg->phys, node) 174 174 - if (phy->ifindex == ifi && phy->up) 175 175 - return phy->id; 176 176 - return -ENODEV; 177 177 - } 178 178 - 179 179 - int caif_disconnect_client(struct net *net, struct cflayer *adap_layer) 180 180 - { 181 181 - u8 channel_id; 182 182 - struct cfcnfg *cfg = get_cfcnfg(net); 183 183 - 184 184 - caif_assert(adap_layer != NULL); 185 185 - cfctrl_cancel_req(cfg->ctrl, adap_layer); 186 186 - channel_id = adap_layer->id; 187 187 - if (channel_id != 0) { 188 188 - struct cflayer *servl; 189 189 - servl = cfmuxl_remove_uplayer(cfg->mux, channel_id); 190 190 - cfctrl_linkdown_req(cfg->ctrl, channel_id, adap_layer); 191 191 - if (servl != NULL) 192 192 - layer_set_up(servl, NULL); 193 193 - } else 194 194 - pr_debug("nothing to disconnect\n"); 195 195 - 196 196 - /* Do RCU sync before initiating cleanup */ 197 197 - synchronize_rcu(); 198 198 - if (adap_layer->ctrlcmd != NULL) 199 199 - adap_layer->ctrlcmd(adap_layer, CAIF_CTRLCMD_DEINIT_RSP, 0); 200 200 - return 0; 201 201 - 202 202 - } 203 203 - EXPORT_SYMBOL(caif_disconnect_client); 204 204 - 205 205 - static void cfcnfg_linkdestroy_rsp(struct cflayer *layer, u8 channel_id) 206 206 - { 207 207 - } 208 208 - 209 209 - static const int protohead[CFCTRL_SRV_MASK] = { 210 210 - [CFCTRL_SRV_VEI] = 4, 211 211 - [CFCTRL_SRV_DATAGRAM] = 7, 212 212 - [CFCTRL_SRV_UTIL] = 4, 213 213 - [CFCTRL_SRV_RFM] = 3, 214 214 - [CFCTRL_SRV_DBG] = 3, 215 215 - }; 216 216 - 217 217 - 218 218 - static int caif_connect_req_to_link_param(struct cfcnfg *cnfg, 219 219 - struct caif_connect_request *s, 220 220 - struct cfctrl_link_param *l) 221 221 - { 222 222 - struct dev_info *dev_info; 223 223 - enum cfcnfg_phy_preference pref; 224 224 - int res; 225 225 - 226 226 - memset(l, 0, sizeof(*l)); 227 227 - /* In caif protocol low value is high priority */ 228 228 - l->priority = CAIF_PRIO_MAX - s->priority + 1; 229 229 - 230 230 - if (s->ifindex != 0) { 231 231 - res = cfcnfg_get_id_from_ifi(cnfg, s->ifindex); 232 232 - if (res < 0) 233 233 - return res; 234 234 - l->phyid = res; 235 235 - } else { 236 236 - switch (s->link_selector) { 237 237 - case CAIF_LINK_HIGH_BANDW: 238 238 - pref = CFPHYPREF_HIGH_BW; 239 239 - break; 240 240 - case CAIF_LINK_LOW_LATENCY: 241 241 - pref = CFPHYPREF_LOW_LAT; 242 242 - break; 243 243 - default: 244 244 - return -EINVAL; 245 245 - } 246 246 - dev_info = cfcnfg_get_phyid(cnfg, pref); 247 247 - if (dev_info == NULL) 248 248 - return -ENODEV; 249 249 - l->phyid = dev_info->id; 250 250 - } 251 251 - switch (s->protocol) { 252 252 - case CAIFPROTO_AT: 253 253 - l->linktype = CFCTRL_SRV_VEI; 254 254 - l->endpoint = (s->sockaddr.u.at.type >> 2) & 0x3; 255 255 - l->chtype = s->sockaddr.u.at.type & 0x3; 256 256 - break; 257 257 - case CAIFPROTO_DATAGRAM: 258 258 - l->linktype = CFCTRL_SRV_DATAGRAM; 259 259 - l->chtype = 0x00; 260 260 - l->u.datagram.connid = s->sockaddr.u.dgm.connection_id; 261 261 - break; 262 262 - case CAIFPROTO_DATAGRAM_LOOP: 263 263 - l->linktype = CFCTRL_SRV_DATAGRAM; 264 264 - l->chtype = 0x03; 265 265 - l->endpoint = 0x00; 266 266 - l->u.datagram.connid = s->sockaddr.u.dgm.connection_id; 267 267 - break; 268 268 - case CAIFPROTO_RFM: 269 269 - l->linktype = CFCTRL_SRV_RFM; 270 270 - l->u.datagram.connid = s->sockaddr.u.rfm.connection_id; 271 271 - strscpy(l->u.rfm.volume, s->sockaddr.u.rfm.volume, 272 272 - sizeof(l->u.rfm.volume)); 273 273 - break; 274 274 - case CAIFPROTO_UTIL: 275 275 - l->linktype = CFCTRL_SRV_UTIL; 276 276 - l->endpoint = 0x00; 277 277 - l->chtype = 0x00; 278 278 - strscpy(l->u.utility.name, s->sockaddr.u.util.service, 279 279 - sizeof(l->u.utility.name)); 280 280 - caif_assert(sizeof(l->u.utility.name) > 10); 281 281 - l->u.utility.paramlen = s->param.size; 282 282 - if (l->u.utility.paramlen > sizeof(l->u.utility.params)) 283 283 - l->u.utility.paramlen = sizeof(l->u.utility.params); 284 284 - 285 285 - memcpy(l->u.utility.params, s->param.data, 286 286 - l->u.utility.paramlen); 287 287 - 288 288 - break; 289 289 - case CAIFPROTO_DEBUG: 290 290 - l->linktype = CFCTRL_SRV_DBG; 291 291 - l->endpoint = s->sockaddr.u.dbg.service; 292 292 - l->chtype = s->sockaddr.u.dbg.type; 293 293 - break; 294 294 - default: 295 295 - return -EINVAL; 296 296 - } 297 297 - return 0; 298 298 - } 299 299 - 300 300 - int caif_connect_client(struct net *net, struct caif_connect_request *conn_req, 301 301 - struct cflayer *adap_layer, int *ifindex, 302 302 - int *proto_head, int *proto_tail) 303 303 - { 304 304 - struct cflayer *frml; 305 305 - struct cfcnfg_phyinfo *phy; 306 306 - int err; 307 307 - struct cfctrl_link_param param; 308 308 - struct cfcnfg *cfg = get_cfcnfg(net); 309 309 - 310 310 - rcu_read_lock(); 311 311 - err = caif_connect_req_to_link_param(cfg, conn_req, &param); 312 312 - if (err) 313 313 - goto unlock; 314 314 - 315 315 - phy = cfcnfg_get_phyinfo_rcu(cfg, param.phyid); 316 316 - if (!phy) { 317 317 - err = -ENODEV; 318 318 - goto unlock; 319 319 - } 320 320 - err = -EINVAL; 321 321 - 322 322 - if (adap_layer == NULL) { 323 323 - pr_err("adap_layer is zero\n"); 324 324 - goto unlock; 325 325 - } 326 326 - if (adap_layer->receive == NULL) { 327 327 - pr_err("adap_layer->receive is NULL\n"); 328 328 - goto unlock; 329 329 - } 330 330 - if (adap_layer->ctrlcmd == NULL) { 331 331 - pr_err("adap_layer->ctrlcmd == NULL\n"); 332 332 - goto unlock; 333 333 - } 334 334 - 335 335 - err = -ENODEV; 336 336 - frml = phy->frm_layer; 337 337 - if (frml == NULL) { 338 338 - pr_err("Specified PHY type does not exist!\n"); 339 339 - goto unlock; 340 340 - } 341 341 - caif_assert(param.phyid == phy->id); 342 342 - caif_assert(phy->frm_layer->id == 343 343 - param.phyid); 344 344 - caif_assert(phy->phy_layer->id == 345 345 - param.phyid); 346 346 - 347 347 - *ifindex = phy->ifindex; 348 348 - *proto_tail = 2; 349 349 - *proto_head = protohead[param.linktype] + phy->head_room; 350 350 - 351 351 - rcu_read_unlock(); 352 352 - 353 353 - /* FIXME: ENUMERATE INITIALLY WHEN ACTIVATING PHYSICAL INTERFACE */ 354 354 - cfctrl_enum_req(cfg->ctrl, param.phyid); 355 355 - return cfctrl_linkup_request(cfg->ctrl, &param, adap_layer); 356 356 - 357 357 - unlock: 358 358 - rcu_read_unlock(); 359 359 - return err; 360 360 - } 361 361 - EXPORT_SYMBOL(caif_connect_client); 362 362 - 363 363 - static void cfcnfg_reject_rsp(struct cflayer *layer, u8 channel_id, 364 364 - struct cflayer *adapt_layer) 365 365 - { 366 366 - if (adapt_layer != NULL && adapt_layer->ctrlcmd != NULL) 367 367 - adapt_layer->ctrlcmd(adapt_layer, 368 368 - CAIF_CTRLCMD_INIT_FAIL_RSP, 0); 369 369 - } 370 370 - 371 371 - static void 372 372 - cfcnfg_linkup_rsp(struct cflayer *layer, u8 channel_id, enum cfctrl_srv serv, 373 373 - u8 phyid, struct cflayer *adapt_layer) 374 374 - { 375 375 - struct cfcnfg *cnfg = container_obj(layer); 376 376 - struct cflayer *servicel = NULL; 377 377 - struct cfcnfg_phyinfo *phyinfo; 378 378 - struct net_device *netdev; 379 379 - 380 380 - if (channel_id == 0) { 381 381 - pr_warn("received channel_id zero\n"); 382 382 - if (adapt_layer != NULL && adapt_layer->ctrlcmd != NULL) 383 383 - adapt_layer->ctrlcmd(adapt_layer, 384 384 - CAIF_CTRLCMD_INIT_FAIL_RSP, 0); 385 385 - return; 386 386 - } 387 387 - 388 388 - rcu_read_lock(); 389 389 - 390 390 - if (adapt_layer == NULL) { 391 391 - pr_debug("link setup response but no client exist, send linkdown back\n"); 392 392 - cfctrl_linkdown_req(cnfg->ctrl, channel_id, NULL); 393 393 - goto unlock; 394 394 - } 395 395 - 396 396 - caif_assert(cnfg != NULL); 397 397 - caif_assert(phyid != 0); 398 398 - 399 399 - phyinfo = cfcnfg_get_phyinfo_rcu(cnfg, phyid); 400 400 - if (phyinfo == NULL) { 401 401 - pr_err("ERROR: Link Layer Device disappeared while connecting\n"); 402 402 - goto unlock; 403 403 - } 404 404 - 405 405 - caif_assert(phyinfo != NULL); 406 406 - caif_assert(phyinfo->id == phyid); 407 407 - caif_assert(phyinfo->phy_layer != NULL); 408 408 - caif_assert(phyinfo->phy_layer->id == phyid); 409 409 - 410 410 - adapt_layer->id = channel_id; 411 411 - 412 412 - switch (serv) { 413 413 - case CFCTRL_SRV_VEI: 414 414 - servicel = cfvei_create(channel_id, &phyinfo->dev_info); 415 415 - break; 416 416 - case CFCTRL_SRV_DATAGRAM: 417 417 - servicel = cfdgml_create(channel_id, 418 418 - &phyinfo->dev_info); 419 419 - break; 420 420 - case CFCTRL_SRV_RFM: 421 421 - netdev = phyinfo->dev_info.dev; 422 422 - servicel = cfrfml_create(channel_id, &phyinfo->dev_info, 423 423 - netdev->mtu); 424 424 - break; 425 425 - case CFCTRL_SRV_UTIL: 426 426 - servicel = cfutill_create(channel_id, &phyinfo->dev_info); 427 427 - break; 428 428 - case CFCTRL_SRV_VIDEO: 429 429 - servicel = cfvidl_create(channel_id, &phyinfo->dev_info); 430 430 - break; 431 431 - case CFCTRL_SRV_DBG: 432 432 - servicel = cfdbgl_create(channel_id, &phyinfo->dev_info); 433 433 - break; 434 434 - default: 435 435 - pr_err("Protocol error. Link setup response - unknown channel type\n"); 436 436 - goto unlock; 437 437 - } 438 438 - if (!servicel) 439 439 - goto unlock; 440 440 - layer_set_dn(servicel, cnfg->mux); 441 441 - cfmuxl_set_uplayer(cnfg->mux, servicel, channel_id); 442 442 - layer_set_up(servicel, adapt_layer); 443 443 - layer_set_dn(adapt_layer, servicel); 444 444 - 445 445 - rcu_read_unlock(); 446 446 - 447 447 - servicel->ctrlcmd(servicel, CAIF_CTRLCMD_INIT_RSP, 0); 448 448 - return; 449 449 - unlock: 450 450 - rcu_read_unlock(); 451 451 - } 452 452 - 453 453 - int 454 454 - cfcnfg_add_phy_layer(struct cfcnfg *cnfg, 455 455 - struct net_device *dev, struct cflayer *phy_layer, 456 456 - enum cfcnfg_phy_preference pref, 457 457 - struct cflayer *link_support, 458 458 - bool fcs, int head_room) 459 459 - { 460 460 - struct cflayer *frml; 461 461 - struct cfcnfg_phyinfo *phyinfo = NULL; 462 462 - int i, res = 0; 463 463 - u8 phyid; 464 464 - 465 465 - mutex_lock(&cnfg->lock); 466 466 - 467 467 - /* CAIF protocol allow maximum 6 link-layers */ 468 468 - for (i = 0; i < 7; i++) { 469 469 - phyid = (dev->ifindex + i) & 0x7; 470 470 - if (phyid == 0) 471 471 - continue; 472 472 - if (cfcnfg_get_phyinfo_rcu(cnfg, phyid) == NULL) 473 473 - goto got_phyid; 474 474 - } 475 475 - pr_warn("Too many CAIF Link Layers (max 6)\n"); 476 476 - res = -EEXIST; 477 477 - goto out; 478 478 - 479 479 - got_phyid: 480 480 - phyinfo = kzalloc_obj(struct cfcnfg_phyinfo, GFP_ATOMIC); 481 481 - if (!phyinfo) { 482 482 - res = -ENOMEM; 483 483 - goto out; 484 484 - } 485 485 - 486 486 - phy_layer->id = phyid; 487 487 - phyinfo->pref = pref; 488 488 - phyinfo->id = phyid; 489 489 - phyinfo->dev_info.id = phyid; 490 490 - phyinfo->dev_info.dev = dev; 491 491 - phyinfo->phy_layer = phy_layer; 492 492 - phyinfo->ifindex = dev->ifindex; 493 493 - phyinfo->head_room = head_room; 494 494 - phyinfo->use_fcs = fcs; 495 495 - 496 496 - frml = cffrml_create(phyid, fcs); 497 497 - 498 498 - if (!frml) { 499 499 - res = -ENOMEM; 500 500 - goto out_err; 501 501 - } 502 502 - phyinfo->frm_layer = frml; 503 503 - layer_set_up(frml, cnfg->mux); 504 504 - 505 505 - if (link_support != NULL) { 506 506 - link_support->id = phyid; 507 507 - layer_set_dn(frml, link_support); 508 508 - layer_set_up(link_support, frml); 509 509 - layer_set_dn(link_support, phy_layer); 510 510 - layer_set_up(phy_layer, link_support); 511 511 - } else { 512 512 - layer_set_dn(frml, phy_layer); 513 513 - layer_set_up(phy_layer, frml); 514 514 - } 515 515 - 516 516 - list_add_rcu(&phyinfo->node, &cnfg->phys); 517 517 - out: 518 518 - mutex_unlock(&cnfg->lock); 519 519 - return res; 520 520 - 521 521 - out_err: 522 522 - kfree(phyinfo); 523 523 - mutex_unlock(&cnfg->lock); 524 524 - return res; 525 525 - } 526 526 - EXPORT_SYMBOL(cfcnfg_add_phy_layer); 527 527 - 528 528 - int cfcnfg_set_phy_state(struct cfcnfg *cnfg, struct cflayer *phy_layer, 529 529 - bool up) 530 530 - { 531 531 - struct cfcnfg_phyinfo *phyinfo; 532 532 - 533 533 - rcu_read_lock(); 534 534 - phyinfo = cfcnfg_get_phyinfo_rcu(cnfg, phy_layer->id); 535 535 - if (phyinfo == NULL) { 536 536 - rcu_read_unlock(); 537 537 - return -ENODEV; 538 538 - } 539 539 - 540 540 - if (phyinfo->up == up) { 541 541 - rcu_read_unlock(); 542 542 - return 0; 543 543 - } 544 544 - phyinfo->up = up; 545 545 - 546 546 - if (up) { 547 547 - cffrml_hold(phyinfo->frm_layer); 548 548 - cfmuxl_set_dnlayer(cnfg->mux, phyinfo->frm_layer, 549 549 - phy_layer->id); 550 550 - } else { 551 551 - cfmuxl_remove_dnlayer(cnfg->mux, phy_layer->id); 552 552 - cffrml_put(phyinfo->frm_layer); 553 553 - } 554 554 - 555 555 - rcu_read_unlock(); 556 556 - return 0; 557 557 - } 558 558 - EXPORT_SYMBOL(cfcnfg_set_phy_state); 559 559 - 560 560 - int cfcnfg_del_phy_layer(struct cfcnfg *cnfg, struct cflayer *phy_layer) 561 561 - { 562 562 - struct cflayer *frml, *frml_dn; 563 563 - u16 phyid; 564 564 - struct cfcnfg_phyinfo *phyinfo; 565 565 - 566 566 - might_sleep(); 567 567 - 568 568 - mutex_lock(&cnfg->lock); 569 569 - 570 570 - phyid = phy_layer->id; 571 571 - phyinfo = cfcnfg_get_phyinfo_rcu(cnfg, phyid); 572 572 - 573 573 - if (phyinfo == NULL) { 574 574 - mutex_unlock(&cnfg->lock); 575 575 - return 0; 576 576 - } 577 577 - caif_assert(phyid == phyinfo->id); 578 578 - caif_assert(phy_layer == phyinfo->phy_layer); 579 579 - caif_assert(phy_layer->id == phyid); 580 580 - caif_assert(phyinfo->frm_layer->id == phyid); 581 581 - 582 582 - list_del_rcu(&phyinfo->node); 583 583 - synchronize_rcu(); 584 584 - 585 585 - /* Fail if reference count is not zero */ 586 586 - if (cffrml_refcnt_read(phyinfo->frm_layer) != 0) { 587 587 - pr_info("Wait for device inuse\n"); 588 588 - list_add_rcu(&phyinfo->node, &cnfg->phys); 589 589 - mutex_unlock(&cnfg->lock); 590 590 - return -EAGAIN; 591 591 - } 592 592 - 593 593 - frml = phyinfo->frm_layer; 594 594 - frml_dn = frml->dn; 595 595 - cffrml_set_uplayer(frml, NULL); 596 596 - cffrml_set_dnlayer(frml, NULL); 597 597 - if (phy_layer != frml_dn) { 598 598 - layer_set_up(frml_dn, NULL); 599 599 - layer_set_dn(frml_dn, NULL); 600 600 - } 601 601 - layer_set_up(phy_layer, NULL); 602 602 - 603 603 - if (phyinfo->phy_layer != frml_dn) 604 604 - kfree(frml_dn); 605 605 - 606 606 - cffrml_free(frml); 607 607 - kfree(phyinfo); 608 608 - mutex_unlock(&cnfg->lock); 609 609 - 610 610 - return 0; 611 611 - } 612 612 - EXPORT_SYMBOL(cfcnfg_del_phy_layer);

-631

net/caif/cfctrl.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/stddef.h> 10 10 - #include <linux/spinlock.h> 11 11 - #include <linux/slab.h> 12 12 - #include <linux/pkt_sched.h> 13 13 - #include <net/caif/caif_layer.h> 14 14 - #include <net/caif/cfpkt.h> 15 15 - #include <net/caif/cfctrl.h> 16 16 - 17 17 - #define container_obj(layr) container_of(layr, struct cfctrl, serv.layer) 18 18 - #define UTILITY_NAME_LENGTH 16 19 19 - #define CFPKT_CTRL_PKT_LEN 20 20 20 - 21 21 - #ifdef CAIF_NO_LOOP 22 22 - static int handle_loop(struct cfctrl *ctrl, 23 23 - int cmd, struct cfpkt *pkt){ 24 24 - return -1; 25 25 - } 26 26 - #else 27 27 - static int handle_loop(struct cfctrl *ctrl, 28 28 - int cmd, struct cfpkt *pkt); 29 29 - #endif 30 30 - static int cfctrl_recv(struct cflayer *layr, struct cfpkt *pkt); 31 31 - static void cfctrl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 32 32 - int phyid); 33 33 - 34 34 - 35 35 - struct cflayer *cfctrl_create(void) 36 36 - { 37 37 - struct dev_info dev_info; 38 38 - struct cfctrl *this = 39 39 - kzalloc_obj(struct cfctrl, GFP_ATOMIC); 40 40 - if (!this) 41 41 - return NULL; 42 42 - caif_assert(offsetof(struct cfctrl, serv.layer) == 0); 43 43 - memset(&dev_info, 0, sizeof(dev_info)); 44 44 - dev_info.id = 0xff; 45 45 - cfsrvl_init(&this->serv, 0, &dev_info, false); 46 46 - atomic_set(&this->req_seq_no, 1); 47 47 - atomic_set(&this->rsp_seq_no, 1); 48 48 - this->serv.layer.receive = cfctrl_recv; 49 49 - sprintf(this->serv.layer.name, "ctrl"); 50 50 - this->serv.layer.ctrlcmd = cfctrl_ctrlcmd; 51 51 - #ifndef CAIF_NO_LOOP 52 52 - spin_lock_init(&this->loop_linkid_lock); 53 53 - this->loop_linkid = 1; 54 54 - #endif 55 55 - spin_lock_init(&this->info_list_lock); 56 56 - INIT_LIST_HEAD(&this->list); 57 57 - return &this->serv.layer; 58 58 - } 59 59 - 60 60 - void cfctrl_remove(struct cflayer *layer) 61 61 - { 62 62 - struct cfctrl_request_info *p, *tmp; 63 63 - struct cfctrl *ctrl = container_obj(layer); 64 64 - 65 65 - spin_lock_bh(&ctrl->info_list_lock); 66 66 - list_for_each_entry_safe(p, tmp, &ctrl->list, list) { 67 67 - list_del(&p->list); 68 68 - kfree(p); 69 69 - } 70 70 - spin_unlock_bh(&ctrl->info_list_lock); 71 71 - kfree(layer); 72 72 - } 73 73 - 74 74 - static bool param_eq(const struct cfctrl_link_param *p1, 75 75 - const struct cfctrl_link_param *p2) 76 76 - { 77 77 - bool eq = 78 78 - p1->linktype == p2->linktype && 79 79 - p1->priority == p2->priority && 80 80 - p1->phyid == p2->phyid && 81 81 - p1->endpoint == p2->endpoint && p1->chtype == p2->chtype; 82 82 - 83 83 - if (!eq) 84 84 - return false; 85 85 - 86 86 - switch (p1->linktype) { 87 87 - case CFCTRL_SRV_VEI: 88 88 - return true; 89 89 - case CFCTRL_SRV_DATAGRAM: 90 90 - return p1->u.datagram.connid == p2->u.datagram.connid; 91 91 - case CFCTRL_SRV_RFM: 92 92 - return 93 93 - p1->u.rfm.connid == p2->u.rfm.connid && 94 94 - strcmp(p1->u.rfm.volume, p2->u.rfm.volume) == 0; 95 95 - case CFCTRL_SRV_UTIL: 96 96 - return 97 97 - p1->u.utility.fifosize_kb == p2->u.utility.fifosize_kb 98 98 - && p1->u.utility.fifosize_bufs == 99 99 - p2->u.utility.fifosize_bufs 100 100 - && strcmp(p1->u.utility.name, p2->u.utility.name) == 0 101 101 - && p1->u.utility.paramlen == p2->u.utility.paramlen 102 102 - && memcmp(p1->u.utility.params, p2->u.utility.params, 103 103 - p1->u.utility.paramlen) == 0; 104 104 - 105 105 - case CFCTRL_SRV_VIDEO: 106 106 - return p1->u.video.connid == p2->u.video.connid; 107 107 - case CFCTRL_SRV_DBG: 108 108 - return true; 109 109 - case CFCTRL_SRV_DECM: 110 110 - return false; 111 111 - default: 112 112 - return false; 113 113 - } 114 114 - return false; 115 115 - } 116 116 - 117 117 - static bool cfctrl_req_eq(const struct cfctrl_request_info *r1, 118 118 - const struct cfctrl_request_info *r2) 119 119 - { 120 120 - if (r1->cmd != r2->cmd) 121 121 - return false; 122 122 - if (r1->cmd == CFCTRL_CMD_LINK_SETUP) 123 123 - return param_eq(&r1->param, &r2->param); 124 124 - else 125 125 - return r1->channel_id == r2->channel_id; 126 126 - } 127 127 - 128 128 - /* Insert request at the end */ 129 129 - static void cfctrl_insert_req(struct cfctrl *ctrl, 130 130 - struct cfctrl_request_info *req) 131 131 - { 132 132 - spin_lock_bh(&ctrl->info_list_lock); 133 133 - atomic_inc(&ctrl->req_seq_no); 134 134 - req->sequence_no = atomic_read(&ctrl->req_seq_no); 135 135 - list_add_tail(&req->list, &ctrl->list); 136 136 - spin_unlock_bh(&ctrl->info_list_lock); 137 137 - } 138 138 - 139 139 - /* Compare and remove request */ 140 140 - static struct cfctrl_request_info *cfctrl_remove_req(struct cfctrl *ctrl, 141 141 - struct cfctrl_request_info *req) 142 142 - { 143 143 - struct cfctrl_request_info *p, *tmp, *first; 144 144 - 145 145 - first = list_first_entry(&ctrl->list, struct cfctrl_request_info, list); 146 146 - 147 147 - list_for_each_entry_safe(p, tmp, &ctrl->list, list) { 148 148 - if (cfctrl_req_eq(req, p)) { 149 149 - if (p != first) 150 150 - pr_warn("Requests are not received in order\n"); 151 151 - 152 152 - atomic_set(&ctrl->rsp_seq_no, 153 153 - p->sequence_no); 154 154 - list_del(&p->list); 155 155 - goto out; 156 156 - } 157 157 - } 158 158 - p = NULL; 159 159 - out: 160 160 - return p; 161 161 - } 162 162 - 163 163 - struct cfctrl_rsp *cfctrl_get_respfuncs(struct cflayer *layer) 164 164 - { 165 165 - struct cfctrl *this = container_obj(layer); 166 166 - return &this->res; 167 167 - } 168 168 - 169 169 - static void init_info(struct caif_payload_info *info, struct cfctrl *cfctrl) 170 170 - { 171 171 - info->hdr_len = 0; 172 172 - info->channel_id = cfctrl->serv.layer.id; 173 173 - info->dev_info = &cfctrl->serv.dev_info; 174 174 - } 175 175 - 176 176 - void cfctrl_enum_req(struct cflayer *layer, u8 physlinkid) 177 177 - { 178 178 - struct cfpkt *pkt; 179 179 - struct cfctrl *cfctrl = container_obj(layer); 180 180 - struct cflayer *dn = cfctrl->serv.layer.dn; 181 181 - 182 182 - if (!dn) { 183 183 - pr_debug("not able to send enum request\n"); 184 184 - return; 185 185 - } 186 186 - pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN); 187 187 - if (!pkt) 188 188 - return; 189 189 - caif_assert(offsetof(struct cfctrl, serv.layer) == 0); 190 190 - init_info(cfpkt_info(pkt), cfctrl); 191 191 - cfpkt_info(pkt)->dev_info->id = physlinkid; 192 192 - cfctrl->serv.dev_info.id = physlinkid; 193 193 - cfpkt_addbdy(pkt, CFCTRL_CMD_ENUM); 194 194 - cfpkt_addbdy(pkt, physlinkid); 195 195 - cfpkt_set_prio(pkt, TC_PRIO_CONTROL); 196 196 - dn->transmit(dn, pkt); 197 197 - } 198 198 - 199 199 - int cfctrl_linkup_request(struct cflayer *layer, 200 200 - struct cfctrl_link_param *param, 201 201 - struct cflayer *user_layer) 202 202 - { 203 203 - struct cfctrl *cfctrl = container_obj(layer); 204 204 - struct cflayer *dn = cfctrl->serv.layer.dn; 205 205 - char utility_name[UTILITY_NAME_LENGTH]; 206 206 - struct cfctrl_request_info *req; 207 207 - struct cfpkt *pkt; 208 208 - u32 tmp32; 209 209 - u16 tmp16; 210 210 - u8 tmp8; 211 211 - int ret; 212 212 - 213 213 - if (!dn) { 214 214 - pr_debug("not able to send linkup request\n"); 215 215 - return -ENODEV; 216 216 - } 217 217 - 218 218 - if (cfctrl_cancel_req(layer, user_layer) > 0) { 219 219 - /* Slight Paranoia, check if already connecting */ 220 220 - pr_err("Duplicate connect request for same client\n"); 221 221 - WARN_ON(1); 222 222 - return -EALREADY; 223 223 - } 224 224 - 225 225 - pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN); 226 226 - if (!pkt) 227 227 - return -ENOMEM; 228 228 - cfpkt_addbdy(pkt, CFCTRL_CMD_LINK_SETUP); 229 229 - cfpkt_addbdy(pkt, (param->chtype << 4) | param->linktype); 230 230 - cfpkt_addbdy(pkt, (param->priority << 3) | param->phyid); 231 231 - cfpkt_addbdy(pkt, param->endpoint & 0x03); 232 232 - 233 233 - switch (param->linktype) { 234 234 - case CFCTRL_SRV_VEI: 235 235 - break; 236 236 - case CFCTRL_SRV_VIDEO: 237 237 - cfpkt_addbdy(pkt, (u8) param->u.video.connid); 238 238 - break; 239 239 - case CFCTRL_SRV_DBG: 240 240 - break; 241 241 - case CFCTRL_SRV_DATAGRAM: 242 242 - tmp32 = cpu_to_le32(param->u.datagram.connid); 243 243 - cfpkt_add_body(pkt, &tmp32, 4); 244 244 - break; 245 245 - case CFCTRL_SRV_RFM: 246 246 - /* Construct a frame, convert DatagramConnectionID to network 247 247 - * format long and copy it out... 248 248 - */ 249 249 - tmp32 = cpu_to_le32(param->u.rfm.connid); 250 250 - cfpkt_add_body(pkt, &tmp32, 4); 251 251 - /* Add volume name, including zero termination... */ 252 252 - cfpkt_add_body(pkt, param->u.rfm.volume, 253 253 - strlen(param->u.rfm.volume) + 1); 254 254 - break; 255 255 - case CFCTRL_SRV_UTIL: 256 256 - tmp16 = cpu_to_le16(param->u.utility.fifosize_kb); 257 257 - cfpkt_add_body(pkt, &tmp16, 2); 258 258 - tmp16 = cpu_to_le16(param->u.utility.fifosize_bufs); 259 259 - cfpkt_add_body(pkt, &tmp16, 2); 260 260 - strscpy_pad(utility_name, param->u.utility.name); 261 261 - cfpkt_add_body(pkt, utility_name, UTILITY_NAME_LENGTH); 262 262 - tmp8 = param->u.utility.paramlen; 263 263 - cfpkt_add_body(pkt, &tmp8, 1); 264 264 - cfpkt_add_body(pkt, param->u.utility.params, 265 265 - param->u.utility.paramlen); 266 266 - break; 267 267 - default: 268 268 - pr_warn("Request setup of bad link type = %d\n", 269 269 - param->linktype); 270 270 - cfpkt_destroy(pkt); 271 271 - return -EINVAL; 272 272 - } 273 273 - req = kzalloc_obj(*req); 274 274 - if (!req) { 275 275 - cfpkt_destroy(pkt); 276 276 - return -ENOMEM; 277 277 - } 278 278 - 279 279 - req->client_layer = user_layer; 280 280 - req->cmd = CFCTRL_CMD_LINK_SETUP; 281 281 - req->param = *param; 282 282 - cfctrl_insert_req(cfctrl, req); 283 283 - init_info(cfpkt_info(pkt), cfctrl); 284 284 - /* 285 285 - * NOTE:Always send linkup and linkdown request on the same 286 286 - * device as the payload. Otherwise old queued up payload 287 287 - * might arrive with the newly allocated channel ID. 288 288 - */ 289 289 - cfpkt_info(pkt)->dev_info->id = param->phyid; 290 290 - cfpkt_set_prio(pkt, TC_PRIO_CONTROL); 291 291 - ret = 292 292 - dn->transmit(dn, pkt); 293 293 - if (ret < 0) { 294 294 - int count; 295 295 - 296 296 - count = cfctrl_cancel_req(&cfctrl->serv.layer, 297 297 - user_layer); 298 298 - if (count != 1) { 299 299 - pr_err("Could not remove request (%d)", count); 300 300 - return -ENODEV; 301 301 - } 302 302 - } 303 303 - return 0; 304 304 - } 305 305 - 306 306 - int cfctrl_linkdown_req(struct cflayer *layer, u8 channelid, 307 307 - struct cflayer *client) 308 308 - { 309 309 - int ret; 310 310 - struct cfpkt *pkt; 311 311 - struct cfctrl *cfctrl = container_obj(layer); 312 312 - struct cflayer *dn = cfctrl->serv.layer.dn; 313 313 - 314 314 - if (!dn) { 315 315 - pr_debug("not able to send link-down request\n"); 316 316 - return -ENODEV; 317 317 - } 318 318 - pkt = cfpkt_create(CFPKT_CTRL_PKT_LEN); 319 319 - if (!pkt) 320 320 - return -ENOMEM; 321 321 - cfpkt_addbdy(pkt, CFCTRL_CMD_LINK_DESTROY); 322 322 - cfpkt_addbdy(pkt, channelid); 323 323 - init_info(cfpkt_info(pkt), cfctrl); 324 324 - cfpkt_set_prio(pkt, TC_PRIO_CONTROL); 325 325 - ret = 326 326 - dn->transmit(dn, pkt); 327 327 - #ifndef CAIF_NO_LOOP 328 328 - cfctrl->loop_linkused[channelid] = 0; 329 329 - #endif 330 330 - return ret; 331 331 - } 332 332 - 333 333 - int cfctrl_cancel_req(struct cflayer *layr, struct cflayer *adap_layer) 334 334 - { 335 335 - struct cfctrl_request_info *p, *tmp; 336 336 - struct cfctrl *ctrl = container_obj(layr); 337 337 - int found = 0; 338 338 - spin_lock_bh(&ctrl->info_list_lock); 339 339 - 340 340 - list_for_each_entry_safe(p, tmp, &ctrl->list, list) { 341 341 - if (p->client_layer == adap_layer) { 342 342 - list_del(&p->list); 343 343 - kfree(p); 344 344 - found++; 345 345 - } 346 346 - } 347 347 - 348 348 - spin_unlock_bh(&ctrl->info_list_lock); 349 349 - return found; 350 350 - } 351 351 - 352 352 - static int cfctrl_link_setup(struct cfctrl *cfctrl, struct cfpkt *pkt, u8 cmdrsp) 353 353 - { 354 354 - u8 len; 355 355 - u8 linkid = 0; 356 356 - enum cfctrl_srv serv; 357 357 - enum cfctrl_srv servtype; 358 358 - u8 endpoint; 359 359 - u8 physlinkid; 360 360 - u8 prio; 361 361 - u8 tmp; 362 362 - u8 *cp; 363 363 - int i; 364 364 - struct cfctrl_link_param linkparam; 365 365 - struct cfctrl_request_info rsp, *req; 366 366 - 367 367 - memset(&linkparam, 0, sizeof(linkparam)); 368 368 - 369 369 - tmp = cfpkt_extr_head_u8(pkt); 370 370 - 371 371 - serv = tmp & CFCTRL_SRV_MASK; 372 372 - linkparam.linktype = serv; 373 373 - 374 374 - servtype = tmp >> 4; 375 375 - linkparam.chtype = servtype; 376 376 - 377 377 - tmp = cfpkt_extr_head_u8(pkt); 378 378 - physlinkid = tmp & 0x07; 379 379 - prio = tmp >> 3; 380 380 - 381 381 - linkparam.priority = prio; 382 382 - linkparam.phyid = physlinkid; 383 383 - endpoint = cfpkt_extr_head_u8(pkt); 384 384 - linkparam.endpoint = endpoint & 0x03; 385 385 - 386 386 - switch (serv) { 387 387 - case CFCTRL_SRV_VEI: 388 388 - case CFCTRL_SRV_DBG: 389 389 - if (CFCTRL_ERR_BIT & cmdrsp) 390 390 - break; 391 391 - /* Link ID */ 392 392 - linkid = cfpkt_extr_head_u8(pkt); 393 393 - break; 394 394 - case CFCTRL_SRV_VIDEO: 395 395 - tmp = cfpkt_extr_head_u8(pkt); 396 396 - linkparam.u.video.connid = tmp; 397 397 - if (CFCTRL_ERR_BIT & cmdrsp) 398 398 - break; 399 399 - /* Link ID */ 400 400 - linkid = cfpkt_extr_head_u8(pkt); 401 401 - break; 402 402 - 403 403 - case CFCTRL_SRV_DATAGRAM: 404 404 - linkparam.u.datagram.connid = cfpkt_extr_head_u32(pkt); 405 405 - if (CFCTRL_ERR_BIT & cmdrsp) 406 406 - break; 407 407 - /* Link ID */ 408 408 - linkid = cfpkt_extr_head_u8(pkt); 409 409 - break; 410 410 - case CFCTRL_SRV_RFM: 411 411 - /* Construct a frame, convert 412 412 - * DatagramConnectionID 413 413 - * to network format long and copy it out... 414 414 - */ 415 415 - linkparam.u.rfm.connid = cfpkt_extr_head_u32(pkt); 416 416 - cp = (u8 *) linkparam.u.rfm.volume; 417 417 - for (tmp = cfpkt_extr_head_u8(pkt); 418 418 - cfpkt_more(pkt) && tmp != '\0'; 419 419 - tmp = cfpkt_extr_head_u8(pkt)) 420 420 - *cp++ = tmp; 421 421 - *cp = '\0'; 422 422 - 423 423 - if (CFCTRL_ERR_BIT & cmdrsp) 424 424 - break; 425 425 - /* Link ID */ 426 426 - linkid = cfpkt_extr_head_u8(pkt); 427 427 - 428 428 - break; 429 429 - case CFCTRL_SRV_UTIL: 430 430 - /* Construct a frame, convert 431 431 - * DatagramConnectionID 432 432 - * to network format long and copy it out... 433 433 - */ 434 434 - /* Fifosize KB */ 435 435 - linkparam.u.utility.fifosize_kb = cfpkt_extr_head_u16(pkt); 436 436 - /* Fifosize bufs */ 437 437 - linkparam.u.utility.fifosize_bufs = cfpkt_extr_head_u16(pkt); 438 438 - /* name */ 439 439 - cp = (u8 *) linkparam.u.utility.name; 440 440 - caif_assert(sizeof(linkparam.u.utility.name) 441 441 - >= UTILITY_NAME_LENGTH); 442 442 - for (i = 0; i < UTILITY_NAME_LENGTH && cfpkt_more(pkt); i++) { 443 443 - tmp = cfpkt_extr_head_u8(pkt); 444 444 - *cp++ = tmp; 445 445 - } 446 446 - /* Length */ 447 447 - len = cfpkt_extr_head_u8(pkt); 448 448 - linkparam.u.utility.paramlen = len; 449 449 - /* Param Data */ 450 450 - cp = linkparam.u.utility.params; 451 451 - while (cfpkt_more(pkt) && len--) { 452 452 - tmp = cfpkt_extr_head_u8(pkt); 453 453 - *cp++ = tmp; 454 454 - } 455 455 - if (CFCTRL_ERR_BIT & cmdrsp) 456 456 - break; 457 457 - /* Link ID */ 458 458 - linkid = cfpkt_extr_head_u8(pkt); 459 459 - /* Length */ 460 460 - len = cfpkt_extr_head_u8(pkt); 461 461 - /* Param Data */ 462 462 - cfpkt_extr_head(pkt, NULL, len); 463 463 - break; 464 464 - default: 465 465 - pr_warn("Request setup, invalid type (%d)\n", serv); 466 466 - return -1; 467 467 - } 468 468 - 469 469 - rsp.cmd = CFCTRL_CMD_LINK_SETUP; 470 470 - rsp.param = linkparam; 471 471 - spin_lock_bh(&cfctrl->info_list_lock); 472 472 - req = cfctrl_remove_req(cfctrl, &rsp); 473 473 - 474 474 - if (CFCTRL_ERR_BIT == (CFCTRL_ERR_BIT & cmdrsp) || 475 475 - cfpkt_erroneous(pkt)) { 476 476 - pr_err("Invalid O/E bit or parse error " 477 477 - "on CAIF control channel\n"); 478 478 - cfctrl->res.reject_rsp(cfctrl->serv.layer.up, 0, 479 479 - req ? req->client_layer : NULL); 480 480 - } else { 481 481 - cfctrl->res.linksetup_rsp(cfctrl->serv.layer.up, linkid, 482 482 - serv, physlinkid, 483 483 - req ? req->client_layer : NULL); 484 484 - } 485 485 - 486 486 - kfree(req); 487 487 - 488 488 - spin_unlock_bh(&cfctrl->info_list_lock); 489 489 - 490 490 - return 0; 491 491 - } 492 492 - 493 493 - static int cfctrl_recv(struct cflayer *layer, struct cfpkt *pkt) 494 494 - { 495 495 - u8 cmdrsp; 496 496 - u8 cmd; 497 497 - int ret = 0; 498 498 - u8 linkid = 0; 499 499 - struct cfctrl *cfctrl = container_obj(layer); 500 500 - 501 501 - cmdrsp = cfpkt_extr_head_u8(pkt); 502 502 - cmd = cmdrsp & CFCTRL_CMD_MASK; 503 503 - if (cmd != CFCTRL_CMD_LINK_ERR 504 504 - && CFCTRL_RSP_BIT != (CFCTRL_RSP_BIT & cmdrsp) 505 505 - && CFCTRL_ERR_BIT != (CFCTRL_ERR_BIT & cmdrsp)) { 506 506 - if (handle_loop(cfctrl, cmd, pkt) != 0) 507 507 - cmdrsp |= CFCTRL_ERR_BIT; 508 508 - } 509 509 - 510 510 - switch (cmd) { 511 511 - case CFCTRL_CMD_LINK_SETUP: 512 512 - ret = cfctrl_link_setup(cfctrl, pkt, cmdrsp); 513 513 - break; 514 514 - case CFCTRL_CMD_LINK_DESTROY: 515 515 - linkid = cfpkt_extr_head_u8(pkt); 516 516 - cfctrl->res.linkdestroy_rsp(cfctrl->serv.layer.up, linkid); 517 517 - break; 518 518 - case CFCTRL_CMD_LINK_ERR: 519 519 - pr_err("Frame Error Indication received\n"); 520 520 - cfctrl->res.linkerror_ind(); 521 521 - break; 522 522 - case CFCTRL_CMD_ENUM: 523 523 - cfctrl->res.enum_rsp(); 524 524 - break; 525 525 - case CFCTRL_CMD_SLEEP: 526 526 - cfctrl->res.sleep_rsp(); 527 527 - break; 528 528 - case CFCTRL_CMD_WAKE: 529 529 - cfctrl->res.wake_rsp(); 530 530 - break; 531 531 - case CFCTRL_CMD_LINK_RECONF: 532 532 - cfctrl->res.restart_rsp(); 533 533 - break; 534 534 - case CFCTRL_CMD_RADIO_SET: 535 535 - cfctrl->res.radioset_rsp(); 536 536 - break; 537 537 - default: 538 538 - pr_err("Unrecognized Control Frame\n"); 539 539 - ret = -1; 540 540 - goto error; 541 541 - } 542 542 - error: 543 543 - cfpkt_destroy(pkt); 544 544 - return ret; 545 545 - } 546 546 - 547 547 - static void cfctrl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 548 548 - int phyid) 549 549 - { 550 550 - struct cfctrl *this = container_obj(layr); 551 551 - switch (ctrl) { 552 552 - case _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND: 553 553 - case CAIF_CTRLCMD_FLOW_OFF_IND: 554 554 - spin_lock_bh(&this->info_list_lock); 555 555 - if (!list_empty(&this->list)) 556 556 - pr_debug("Received flow off in control layer\n"); 557 557 - spin_unlock_bh(&this->info_list_lock); 558 558 - break; 559 559 - case _CAIF_CTRLCMD_PHYIF_DOWN_IND: { 560 560 - struct cfctrl_request_info *p, *tmp; 561 561 - 562 562 - /* Find all connect request and report failure */ 563 563 - spin_lock_bh(&this->info_list_lock); 564 564 - list_for_each_entry_safe(p, tmp, &this->list, list) { 565 565 - if (p->param.phyid == phyid) { 566 566 - list_del(&p->list); 567 567 - p->client_layer->ctrlcmd(p->client_layer, 568 568 - CAIF_CTRLCMD_INIT_FAIL_RSP, 569 569 - phyid); 570 570 - kfree(p); 571 571 - } 572 572 - } 573 573 - spin_unlock_bh(&this->info_list_lock); 574 574 - break; 575 575 - } 576 576 - default: 577 577 - break; 578 578 - } 579 579 - } 580 580 - 581 581 - #ifndef CAIF_NO_LOOP 582 582 - static int handle_loop(struct cfctrl *ctrl, int cmd, struct cfpkt *pkt) 583 583 - { 584 584 - static int last_linkid; 585 585 - static int dec; 586 586 - u8 linkid, linktype, tmp; 587 587 - switch (cmd) { 588 588 - case CFCTRL_CMD_LINK_SETUP: 589 589 - spin_lock_bh(&ctrl->loop_linkid_lock); 590 590 - if (!dec) { 591 591 - for (linkid = last_linkid + 1; linkid < 254; linkid++) 592 592 - if (!ctrl->loop_linkused[linkid]) 593 593 - goto found; 594 594 - } 595 595 - dec = 1; 596 596 - for (linkid = last_linkid - 1; linkid > 1; linkid--) 597 597 - if (!ctrl->loop_linkused[linkid]) 598 598 - goto found; 599 599 - spin_unlock_bh(&ctrl->loop_linkid_lock); 600 600 - return -1; 601 601 - found: 602 602 - if (linkid < 10) 603 603 - dec = 0; 604 604 - 605 605 - if (!ctrl->loop_linkused[linkid]) 606 606 - ctrl->loop_linkused[linkid] = 1; 607 607 - 608 608 - last_linkid = linkid; 609 609 - 610 610 - cfpkt_add_trail(pkt, &linkid, 1); 611 611 - spin_unlock_bh(&ctrl->loop_linkid_lock); 612 612 - cfpkt_peek_head(pkt, &linktype, 1); 613 613 - if (linktype == CFCTRL_SRV_UTIL) { 614 614 - tmp = 0x01; 615 615 - cfpkt_add_trail(pkt, &tmp, 1); 616 616 - cfpkt_add_trail(pkt, &tmp, 1); 617 617 - } 618 618 - break; 619 619 - 620 620 - case CFCTRL_CMD_LINK_DESTROY: 621 621 - spin_lock_bh(&ctrl->loop_linkid_lock); 622 622 - cfpkt_peek_head(pkt, &linkid, 1); 623 623 - ctrl->loop_linkused[linkid] = 0; 624 624 - spin_unlock_bh(&ctrl->loop_linkid_lock); 625 625 - break; 626 626 - default: 627 627 - break; 628 628 - } 629 629 - return 0; 630 630 - } 631 631 - #endif

-55

net/caif/cfdbgl.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/stddef.h> 10 10 - #include <linux/slab.h> 11 11 - #include <net/caif/caif_layer.h> 12 12 - #include <net/caif/cfsrvl.h> 13 13 - #include <net/caif/cfpkt.h> 14 14 - 15 15 - #define container_obj(layr) ((struct cfsrvl *) layr) 16 16 - 17 17 - static int cfdbgl_receive(struct cflayer *layr, struct cfpkt *pkt); 18 18 - static int cfdbgl_transmit(struct cflayer *layr, struct cfpkt *pkt); 19 19 - 20 20 - struct cflayer *cfdbgl_create(u8 channel_id, struct dev_info *dev_info) 21 21 - { 22 22 - struct cfsrvl *dbg = kzalloc_obj(struct cfsrvl, GFP_ATOMIC); 23 23 - if (!dbg) 24 24 - return NULL; 25 25 - caif_assert(offsetof(struct cfsrvl, layer) == 0); 26 26 - cfsrvl_init(dbg, channel_id, dev_info, false); 27 27 - dbg->layer.receive = cfdbgl_receive; 28 28 - dbg->layer.transmit = cfdbgl_transmit; 29 29 - snprintf(dbg->layer.name, CAIF_LAYER_NAME_SZ, "dbg%d", channel_id); 30 30 - return &dbg->layer; 31 31 - } 32 32 - 33 33 - static int cfdbgl_receive(struct cflayer *layr, struct cfpkt *pkt) 34 34 - { 35 35 - return layr->up->receive(layr->up, pkt); 36 36 - } 37 37 - 38 38 - static int cfdbgl_transmit(struct cflayer *layr, struct cfpkt *pkt) 39 39 - { 40 40 - struct cfsrvl *service = container_obj(layr); 41 41 - struct caif_payload_info *info; 42 42 - int ret; 43 43 - 44 44 - if (!cfsrvl_ready(service, &ret)) { 45 45 - cfpkt_destroy(pkt); 46 46 - return ret; 47 47 - } 48 48 - 49 49 - /* Add info for MUX-layer to route the packet out */ 50 50 - info = cfpkt_info(pkt); 51 51 - info->channel_id = service->layer.id; 52 52 - info->dev_info = &service->dev_info; 53 53 - 54 54 - return layr->dn->transmit(layr->dn, pkt); 55 55 - }

-113

net/caif/cfdgml.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/stddef.h> 10 10 - #include <linux/spinlock.h> 11 11 - #include <linux/slab.h> 12 12 - #include <net/caif/caif_layer.h> 13 13 - #include <net/caif/cfsrvl.h> 14 14 - #include <net/caif/cfpkt.h> 15 15 - 16 16 - 17 17 - #define container_obj(layr) ((struct cfsrvl *) layr) 18 18 - 19 19 - #define DGM_CMD_BIT 0x80 20 20 - #define DGM_FLOW_OFF 0x81 21 21 - #define DGM_FLOW_ON 0x80 22 22 - #define DGM_MTU 1500 23 23 - 24 24 - static int cfdgml_receive(struct cflayer *layr, struct cfpkt *pkt); 25 25 - static int cfdgml_transmit(struct cflayer *layr, struct cfpkt *pkt); 26 26 - 27 27 - struct cflayer *cfdgml_create(u8 channel_id, struct dev_info *dev_info) 28 28 - { 29 29 - struct cfsrvl *dgm = kzalloc_obj(struct cfsrvl, GFP_ATOMIC); 30 30 - if (!dgm) 31 31 - return NULL; 32 32 - caif_assert(offsetof(struct cfsrvl, layer) == 0); 33 33 - cfsrvl_init(dgm, channel_id, dev_info, true); 34 34 - dgm->layer.receive = cfdgml_receive; 35 35 - dgm->layer.transmit = cfdgml_transmit; 36 36 - snprintf(dgm->layer.name, CAIF_LAYER_NAME_SZ, "dgm%d", channel_id); 37 37 - return &dgm->layer; 38 38 - } 39 39 - 40 40 - static int cfdgml_receive(struct cflayer *layr, struct cfpkt *pkt) 41 41 - { 42 42 - u8 cmd = -1; 43 43 - u8 dgmhdr[3]; 44 44 - int ret; 45 45 - caif_assert(layr->up != NULL); 46 46 - caif_assert(layr->receive != NULL); 47 47 - caif_assert(layr->ctrlcmd != NULL); 48 48 - 49 49 - if (cfpkt_extr_head(pkt, &cmd, 1) < 0) { 50 50 - pr_err("Packet is erroneous!\n"); 51 51 - cfpkt_destroy(pkt); 52 52 - return -EPROTO; 53 53 - } 54 54 - 55 55 - if ((cmd & DGM_CMD_BIT) == 0) { 56 56 - if (cfpkt_extr_head(pkt, &dgmhdr, 3) < 0) { 57 57 - pr_err("Packet is erroneous!\n"); 58 58 - cfpkt_destroy(pkt); 59 59 - return -EPROTO; 60 60 - } 61 61 - ret = layr->up->receive(layr->up, pkt); 62 62 - return ret; 63 63 - } 64 64 - 65 65 - switch (cmd) { 66 66 - case DGM_FLOW_OFF: /* FLOW OFF */ 67 67 - layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_OFF_IND, 0); 68 68 - cfpkt_destroy(pkt); 69 69 - return 0; 70 70 - case DGM_FLOW_ON: /* FLOW ON */ 71 71 - layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_ON_IND, 0); 72 72 - cfpkt_destroy(pkt); 73 73 - return 0; 74 74 - default: 75 75 - cfpkt_destroy(pkt); 76 76 - pr_info("Unknown datagram control %d (0x%x)\n", cmd, cmd); 77 77 - return -EPROTO; 78 78 - } 79 79 - } 80 80 - 81 81 - static int cfdgml_transmit(struct cflayer *layr, struct cfpkt *pkt) 82 82 - { 83 83 - u8 packet_type; 84 84 - u32 zero = 0; 85 85 - struct caif_payload_info *info; 86 86 - struct cfsrvl *service = container_obj(layr); 87 87 - int ret; 88 88 - 89 89 - if (!cfsrvl_ready(service, &ret)) { 90 90 - cfpkt_destroy(pkt); 91 91 - return ret; 92 92 - } 93 93 - 94 94 - /* STE Modem cannot handle more than 1500 bytes datagrams */ 95 95 - if (cfpkt_getlen(pkt) > DGM_MTU) { 96 96 - cfpkt_destroy(pkt); 97 97 - return -EMSGSIZE; 98 98 - } 99 99 - 100 100 - cfpkt_add_head(pkt, &zero, 3); 101 101 - packet_type = 0x08; /* B9 set - UNCLASSIFIED */ 102 102 - cfpkt_add_head(pkt, &packet_type, 1); 103 103 - 104 104 - /* Add info for MUX-layer to route the packet out. */ 105 105 - info = cfpkt_info(pkt); 106 106 - info->channel_id = service->layer.id; 107 107 - /* To optimize alignment, we add up the size of CAIF header 108 108 - * before payload. 109 109 - */ 110 110 - info->hdr_len = 4; 111 111 - info->dev_info = &service->dev_info; 112 112 - return layr->dn->transmit(layr->dn, pkt); 113 113 - }

-204

net/caif/cffrml.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * CAIF Framing Layer. 4 4 - * 5 5 - * Copyright (C) ST-Ericsson AB 2010 6 6 - * Author: Sjur Brendeland 7 7 - */ 8 8 - 9 9 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 10 10 - 11 11 - #include <linux/stddef.h> 12 12 - #include <linux/spinlock.h> 13 13 - #include <linux/slab.h> 14 14 - #include <linux/crc-ccitt.h> 15 15 - #include <linux/netdevice.h> 16 16 - #include <net/caif/caif_layer.h> 17 17 - #include <net/caif/cfpkt.h> 18 18 - #include <net/caif/cffrml.h> 19 19 - 20 20 - #define container_obj(layr) container_of(layr, struct cffrml, layer) 21 21 - 22 22 - struct cffrml { 23 23 - struct cflayer layer; 24 24 - bool dofcs; /* !< FCS active */ 25 25 - int __percpu *pcpu_refcnt; 26 26 - }; 27 27 - 28 28 - static int cffrml_receive(struct cflayer *layr, struct cfpkt *pkt); 29 29 - static int cffrml_transmit(struct cflayer *layr, struct cfpkt *pkt); 30 30 - static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 31 31 - int phyid); 32 32 - 33 33 - static u32 cffrml_rcv_error; 34 34 - static u32 cffrml_rcv_checsum_error; 35 35 - struct cflayer *cffrml_create(u16 phyid, bool use_fcs) 36 36 - { 37 37 - struct cffrml *this = kzalloc_obj(struct cffrml, GFP_ATOMIC); 38 38 - if (!this) 39 39 - return NULL; 40 40 - this->pcpu_refcnt = alloc_percpu(int); 41 41 - if (this->pcpu_refcnt == NULL) { 42 42 - kfree(this); 43 43 - return NULL; 44 44 - } 45 45 - 46 46 - caif_assert(offsetof(struct cffrml, layer) == 0); 47 47 - 48 48 - this->layer.receive = cffrml_receive; 49 49 - this->layer.transmit = cffrml_transmit; 50 50 - this->layer.ctrlcmd = cffrml_ctrlcmd; 51 51 - snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "frm%d", phyid); 52 52 - this->dofcs = use_fcs; 53 53 - this->layer.id = phyid; 54 54 - return (struct cflayer *) this; 55 55 - } 56 56 - 57 57 - void cffrml_free(struct cflayer *layer) 58 58 - { 59 59 - struct cffrml *this = container_obj(layer); 60 60 - free_percpu(this->pcpu_refcnt); 61 61 - kfree(layer); 62 62 - } 63 63 - 64 64 - void cffrml_set_uplayer(struct cflayer *this, struct cflayer *up) 65 65 - { 66 66 - this->up = up; 67 67 - } 68 68 - 69 69 - void cffrml_set_dnlayer(struct cflayer *this, struct cflayer *dn) 70 70 - { 71 71 - this->dn = dn; 72 72 - } 73 73 - 74 74 - static u16 cffrml_checksum(u16 chks, void *buf, u16 len) 75 75 - { 76 76 - /* FIXME: FCS should be moved to glue in order to use OS-Specific 77 77 - * solutions 78 78 - */ 79 79 - return crc_ccitt(chks, buf, len); 80 80 - } 81 81 - 82 82 - static int cffrml_receive(struct cflayer *layr, struct cfpkt *pkt) 83 83 - { 84 84 - u16 tmp; 85 85 - u16 len; 86 86 - u16 hdrchks; 87 87 - int pktchks; 88 88 - struct cffrml *this; 89 89 - this = container_obj(layr); 90 90 - 91 91 - cfpkt_extr_head(pkt, &tmp, 2); 92 92 - len = le16_to_cpu(tmp); 93 93 - 94 94 - /* Subtract for FCS on length if FCS is not used. */ 95 95 - if (!this->dofcs) { 96 96 - if (len < 2) { 97 97 - ++cffrml_rcv_error; 98 98 - pr_err("Invalid frame length (%d)\n", len); 99 99 - cfpkt_destroy(pkt); 100 100 - return -EPROTO; 101 101 - } 102 102 - len -= 2; 103 103 - } 104 104 - 105 105 - if (cfpkt_setlen(pkt, len) < 0) { 106 106 - ++cffrml_rcv_error; 107 107 - pr_err("Framing length error (%d)\n", len); 108 108 - cfpkt_destroy(pkt); 109 109 - return -EPROTO; 110 110 - } 111 111 - /* 112 112 - * Don't do extract if FCS is false, rather do setlen - then we don't 113 113 - * get a cache-miss. 114 114 - */ 115 115 - if (this->dofcs) { 116 116 - cfpkt_extr_trail(pkt, &tmp, 2); 117 117 - hdrchks = le16_to_cpu(tmp); 118 118 - pktchks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff); 119 119 - if (pktchks != hdrchks) { 120 120 - cfpkt_add_trail(pkt, &tmp, 2); 121 121 - ++cffrml_rcv_error; 122 122 - ++cffrml_rcv_checsum_error; 123 123 - pr_info("Frame checksum error (0x%x != 0x%x)\n", 124 124 - hdrchks, pktchks); 125 125 - return -EILSEQ; 126 126 - } 127 127 - } 128 128 - if (cfpkt_erroneous(pkt)) { 129 129 - ++cffrml_rcv_error; 130 130 - pr_err("Packet is erroneous!\n"); 131 131 - cfpkt_destroy(pkt); 132 132 - return -EPROTO; 133 133 - } 134 134 - 135 135 - if (layr->up == NULL) { 136 136 - pr_err("Layr up is missing!\n"); 137 137 - cfpkt_destroy(pkt); 138 138 - return -EINVAL; 139 139 - } 140 140 - 141 141 - return layr->up->receive(layr->up, pkt); 142 142 - } 143 143 - 144 144 - static int cffrml_transmit(struct cflayer *layr, struct cfpkt *pkt) 145 145 - { 146 146 - u16 chks; 147 147 - u16 len; 148 148 - __le16 data; 149 149 - 150 150 - struct cffrml *this = container_obj(layr); 151 151 - if (this->dofcs) { 152 152 - chks = cfpkt_iterate(pkt, cffrml_checksum, 0xffff); 153 153 - data = cpu_to_le16(chks); 154 154 - cfpkt_add_trail(pkt, &data, 2); 155 155 - } else { 156 156 - cfpkt_pad_trail(pkt, 2); 157 157 - } 158 158 - len = cfpkt_getlen(pkt); 159 159 - data = cpu_to_le16(len); 160 160 - cfpkt_add_head(pkt, &data, 2); 161 161 - cfpkt_info(pkt)->hdr_len += 2; 162 162 - if (cfpkt_erroneous(pkt)) { 163 163 - pr_err("Packet is erroneous!\n"); 164 164 - cfpkt_destroy(pkt); 165 165 - return -EPROTO; 166 166 - } 167 167 - 168 168 - if (layr->dn == NULL) { 169 169 - cfpkt_destroy(pkt); 170 170 - return -ENODEV; 171 171 - 172 172 - } 173 173 - return layr->dn->transmit(layr->dn, pkt); 174 174 - } 175 175 - 176 176 - static void cffrml_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 177 177 - int phyid) 178 178 - { 179 179 - if (layr->up && layr->up->ctrlcmd) 180 180 - layr->up->ctrlcmd(layr->up, ctrl, layr->id); 181 181 - } 182 182 - 183 183 - void cffrml_put(struct cflayer *layr) 184 184 - { 185 185 - struct cffrml *this = container_obj(layr); 186 186 - if (layr != NULL && this->pcpu_refcnt != NULL) 187 187 - this_cpu_dec(*this->pcpu_refcnt); 188 188 - } 189 189 - 190 190 - void cffrml_hold(struct cflayer *layr) 191 191 - { 192 192 - struct cffrml *this = container_obj(layr); 193 193 - if (layr != NULL && this->pcpu_refcnt != NULL) 194 194 - this_cpu_inc(*this->pcpu_refcnt); 195 195 - } 196 196 - 197 197 - int cffrml_refcnt_read(struct cflayer *layr) 198 198 - { 199 199 - int i, refcnt = 0; 200 200 - struct cffrml *this = container_obj(layr); 201 201 - for_each_possible_cpu(i) 202 202 - refcnt += *per_cpu_ptr(this->pcpu_refcnt, i); 203 203 - return refcnt; 204 204 - }

-267

net/caif/cfmuxl.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/stddef.h> 10 10 - #include <linux/spinlock.h> 11 11 - #include <linux/slab.h> 12 12 - #include <linux/rculist.h> 13 13 - #include <net/caif/cfpkt.h> 14 14 - #include <net/caif/cfmuxl.h> 15 15 - #include <net/caif/cfsrvl.h> 16 16 - #include <net/caif/cffrml.h> 17 17 - 18 18 - #define container_obj(layr) container_of(layr, struct cfmuxl, layer) 19 19 - 20 20 - #define CAIF_CTRL_CHANNEL 0 21 21 - #define UP_CACHE_SIZE 8 22 22 - #define DN_CACHE_SIZE 8 23 23 - 24 24 - struct cfmuxl { 25 25 - struct cflayer layer; 26 26 - struct list_head srvl_list; 27 27 - struct list_head frml_list; 28 28 - struct cflayer *up_cache[UP_CACHE_SIZE]; 29 29 - struct cflayer *dn_cache[DN_CACHE_SIZE]; 30 30 - /* 31 31 - * Set when inserting or removing downwards layers. 32 32 - */ 33 33 - spinlock_t transmit_lock; 34 34 - 35 35 - /* 36 36 - * Set when inserting or removing upwards layers. 37 37 - */ 38 38 - spinlock_t receive_lock; 39 39 - 40 40 - }; 41 41 - 42 42 - static int cfmuxl_receive(struct cflayer *layr, struct cfpkt *pkt); 43 43 - static int cfmuxl_transmit(struct cflayer *layr, struct cfpkt *pkt); 44 44 - static void cfmuxl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 45 45 - int phyid); 46 46 - static struct cflayer *get_up(struct cfmuxl *muxl, u16 id); 47 47 - 48 48 - struct cflayer *cfmuxl_create(void) 49 49 - { 50 50 - struct cfmuxl *this = kzalloc_obj(struct cfmuxl, GFP_ATOMIC); 51 51 - 52 52 - if (!this) 53 53 - return NULL; 54 54 - this->layer.receive = cfmuxl_receive; 55 55 - this->layer.transmit = cfmuxl_transmit; 56 56 - this->layer.ctrlcmd = cfmuxl_ctrlcmd; 57 57 - INIT_LIST_HEAD(&this->srvl_list); 58 58 - INIT_LIST_HEAD(&this->frml_list); 59 59 - spin_lock_init(&this->transmit_lock); 60 60 - spin_lock_init(&this->receive_lock); 61 61 - snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "mux"); 62 62 - return &this->layer; 63 63 - } 64 64 - 65 65 - int cfmuxl_set_dnlayer(struct cflayer *layr, struct cflayer *dn, u8 phyid) 66 66 - { 67 67 - struct cfmuxl *muxl = (struct cfmuxl *) layr; 68 68 - 69 69 - spin_lock_bh(&muxl->transmit_lock); 70 70 - list_add_rcu(&dn->node, &muxl->frml_list); 71 71 - spin_unlock_bh(&muxl->transmit_lock); 72 72 - return 0; 73 73 - } 74 74 - 75 75 - static struct cflayer *get_from_id(struct list_head *list, u16 id) 76 76 - { 77 77 - struct cflayer *lyr; 78 78 - list_for_each_entry_rcu(lyr, list, node) { 79 79 - if (lyr->id == id) 80 80 - return lyr; 81 81 - } 82 82 - 83 83 - return NULL; 84 84 - } 85 85 - 86 86 - int cfmuxl_set_uplayer(struct cflayer *layr, struct cflayer *up, u8 linkid) 87 87 - { 88 88 - struct cfmuxl *muxl = container_obj(layr); 89 89 - struct cflayer *old; 90 90 - 91 91 - spin_lock_bh(&muxl->receive_lock); 92 92 - 93 93 - /* Two entries with same id is wrong, so remove old layer from mux */ 94 94 - old = get_from_id(&muxl->srvl_list, linkid); 95 95 - if (old != NULL) 96 96 - list_del_rcu(&old->node); 97 97 - 98 98 - list_add_rcu(&up->node, &muxl->srvl_list); 99 99 - spin_unlock_bh(&muxl->receive_lock); 100 100 - 101 101 - return 0; 102 102 - } 103 103 - 104 104 - struct cflayer *cfmuxl_remove_dnlayer(struct cflayer *layr, u8 phyid) 105 105 - { 106 106 - struct cfmuxl *muxl = container_obj(layr); 107 107 - struct cflayer *dn; 108 108 - int idx = phyid % DN_CACHE_SIZE; 109 109 - 110 110 - spin_lock_bh(&muxl->transmit_lock); 111 111 - RCU_INIT_POINTER(muxl->dn_cache[idx], NULL); 112 112 - dn = get_from_id(&muxl->frml_list, phyid); 113 113 - if (dn == NULL) 114 114 - goto out; 115 115 - 116 116 - list_del_rcu(&dn->node); 117 117 - caif_assert(dn != NULL); 118 118 - out: 119 119 - spin_unlock_bh(&muxl->transmit_lock); 120 120 - return dn; 121 121 - } 122 122 - 123 123 - static struct cflayer *get_up(struct cfmuxl *muxl, u16 id) 124 124 - { 125 125 - struct cflayer *up; 126 126 - int idx = id % UP_CACHE_SIZE; 127 127 - up = rcu_dereference(muxl->up_cache[idx]); 128 128 - if (up == NULL || up->id != id) { 129 129 - spin_lock_bh(&muxl->receive_lock); 130 130 - up = get_from_id(&muxl->srvl_list, id); 131 131 - rcu_assign_pointer(muxl->up_cache[idx], up); 132 132 - spin_unlock_bh(&muxl->receive_lock); 133 133 - } 134 134 - return up; 135 135 - } 136 136 - 137 137 - static struct cflayer *get_dn(struct cfmuxl *muxl, struct dev_info *dev_info) 138 138 - { 139 139 - struct cflayer *dn; 140 140 - int idx = dev_info->id % DN_CACHE_SIZE; 141 141 - dn = rcu_dereference(muxl->dn_cache[idx]); 142 142 - if (dn == NULL || dn->id != dev_info->id) { 143 143 - spin_lock_bh(&muxl->transmit_lock); 144 144 - dn = get_from_id(&muxl->frml_list, dev_info->id); 145 145 - rcu_assign_pointer(muxl->dn_cache[idx], dn); 146 146 - spin_unlock_bh(&muxl->transmit_lock); 147 147 - } 148 148 - return dn; 149 149 - } 150 150 - 151 151 - struct cflayer *cfmuxl_remove_uplayer(struct cflayer *layr, u8 id) 152 152 - { 153 153 - struct cflayer *up; 154 154 - struct cfmuxl *muxl = container_obj(layr); 155 155 - int idx = id % UP_CACHE_SIZE; 156 156 - 157 157 - if (id == 0) { 158 158 - pr_warn("Trying to remove control layer\n"); 159 159 - return NULL; 160 160 - } 161 161 - 162 162 - spin_lock_bh(&muxl->receive_lock); 163 163 - up = get_from_id(&muxl->srvl_list, id); 164 164 - if (up == NULL) 165 165 - goto out; 166 166 - 167 167 - RCU_INIT_POINTER(muxl->up_cache[idx], NULL); 168 168 - list_del_rcu(&up->node); 169 169 - out: 170 170 - spin_unlock_bh(&muxl->receive_lock); 171 171 - return up; 172 172 - } 173 173 - 174 174 - static int cfmuxl_receive(struct cflayer *layr, struct cfpkt *pkt) 175 175 - { 176 176 - int ret; 177 177 - struct cfmuxl *muxl = container_obj(layr); 178 178 - u8 id; 179 179 - struct cflayer *up; 180 180 - if (cfpkt_extr_head(pkt, &id, 1) < 0) { 181 181 - pr_err("erroneous Caif Packet\n"); 182 182 - cfpkt_destroy(pkt); 183 183 - return -EPROTO; 184 184 - } 185 185 - rcu_read_lock(); 186 186 - up = get_up(muxl, id); 187 187 - 188 188 - if (up == NULL) { 189 189 - pr_debug("Received data on unknown link ID = %d (0x%x)" 190 190 - " up == NULL", id, id); 191 191 - cfpkt_destroy(pkt); 192 192 - /* 193 193 - * Don't return ERROR, since modem misbehaves and sends out 194 194 - * flow on before linksetup response. 195 195 - */ 196 196 - 197 197 - rcu_read_unlock(); 198 198 - return /* CFGLU_EPROT; */ 0; 199 199 - } 200 200 - 201 201 - /* We can't hold rcu_lock during receive, so take a ref count instead */ 202 202 - cfsrvl_get(up); 203 203 - rcu_read_unlock(); 204 204 - 205 205 - ret = up->receive(up, pkt); 206 206 - 207 207 - cfsrvl_put(up); 208 208 - return ret; 209 209 - } 210 210 - 211 211 - static int cfmuxl_transmit(struct cflayer *layr, struct cfpkt *pkt) 212 212 - { 213 213 - struct cfmuxl *muxl = container_obj(layr); 214 214 - int err; 215 215 - u8 linkid; 216 216 - struct cflayer *dn; 217 217 - struct caif_payload_info *info = cfpkt_info(pkt); 218 218 - BUG_ON(!info); 219 219 - 220 220 - rcu_read_lock(); 221 221 - 222 222 - dn = get_dn(muxl, info->dev_info); 223 223 - if (dn == NULL) { 224 224 - pr_debug("Send data on unknown phy ID = %d (0x%x)\n", 225 225 - info->dev_info->id, info->dev_info->id); 226 226 - rcu_read_unlock(); 227 227 - cfpkt_destroy(pkt); 228 228 - return -ENOTCONN; 229 229 - } 230 230 - 231 231 - info->hdr_len += 1; 232 232 - linkid = info->channel_id; 233 233 - cfpkt_add_head(pkt, &linkid, 1); 234 234 - 235 235 - /* We can't hold rcu_lock during receive, so take a ref count instead */ 236 236 - cffrml_hold(dn); 237 237 - 238 238 - rcu_read_unlock(); 239 239 - 240 240 - err = dn->transmit(dn, pkt); 241 241 - 242 242 - cffrml_put(dn); 243 243 - return err; 244 244 - } 245 245 - 246 246 - static void cfmuxl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 247 247 - int phyid) 248 248 - { 249 249 - struct cfmuxl *muxl = container_obj(layr); 250 250 - struct cflayer *layer; 251 251 - 252 252 - rcu_read_lock(); 253 253 - list_for_each_entry_rcu(layer, &muxl->srvl_list, node) { 254 254 - 255 255 - if (cfsrvl_phyid_match(layer, phyid) && layer->ctrlcmd) { 256 256 - 257 257 - if ((ctrl == _CAIF_CTRLCMD_PHYIF_DOWN_IND || 258 258 - ctrl == CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND) && 259 259 - layer->id != 0) 260 260 - cfmuxl_remove_uplayer(layr, layer->id); 261 261 - 262 262 - /* NOTE: ctrlcmd is not allowed to block */ 263 263 - layer->ctrlcmd(layer, ctrl, phyid); 264 264 - } 265 265 - } 266 266 - rcu_read_unlock(); 267 267 - }

-373

net/caif/cfpkt_skbuff.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/string.h> 10 10 - #include <linux/skbuff.h> 11 11 - #include <linux/export.h> 12 12 - #include <net/caif/cfpkt.h> 13 13 - 14 14 - #define PKT_PREFIX 48 15 15 - #define PKT_POSTFIX 2 16 16 - #define PKT_LEN_WHEN_EXTENDING 128 17 17 - #define PKT_ERROR(pkt, errmsg) \ 18 18 - do { \ 19 19 - cfpkt_priv(pkt)->erronous = true; \ 20 20 - skb_reset_tail_pointer(&pkt->skb); \ 21 21 - pr_warn(errmsg); \ 22 22 - } while (0) 23 23 - 24 24 - /* 25 25 - * net/caif/ is generic and does not 26 26 - * understand SKB, so we do this typecast 27 27 - */ 28 28 - struct cfpkt { 29 29 - struct sk_buff skb; 30 30 - }; 31 31 - 32 32 - /* Private data inside SKB */ 33 33 - struct cfpkt_priv_data { 34 34 - struct dev_info dev_info; 35 35 - bool erronous; 36 36 - }; 37 37 - 38 38 - static inline struct cfpkt_priv_data *cfpkt_priv(struct cfpkt *pkt) 39 39 - { 40 40 - return (struct cfpkt_priv_data *) pkt->skb.cb; 41 41 - } 42 42 - 43 43 - static inline bool is_erronous(struct cfpkt *pkt) 44 44 - { 45 45 - return cfpkt_priv(pkt)->erronous; 46 46 - } 47 47 - 48 48 - static inline struct sk_buff *pkt_to_skb(struct cfpkt *pkt) 49 49 - { 50 50 - return &pkt->skb; 51 51 - } 52 52 - 53 53 - static inline struct cfpkt *skb_to_pkt(struct sk_buff *skb) 54 54 - { 55 55 - return (struct cfpkt *) skb; 56 56 - } 57 57 - 58 58 - struct cfpkt *cfpkt_fromnative(enum caif_direction dir, void *nativepkt) 59 59 - { 60 60 - struct cfpkt *pkt = skb_to_pkt(nativepkt); 61 61 - cfpkt_priv(pkt)->erronous = false; 62 62 - return pkt; 63 63 - } 64 64 - EXPORT_SYMBOL(cfpkt_fromnative); 65 65 - 66 66 - void *cfpkt_tonative(struct cfpkt *pkt) 67 67 - { 68 68 - return (void *) pkt; 69 69 - } 70 70 - EXPORT_SYMBOL(cfpkt_tonative); 71 71 - 72 72 - static struct cfpkt *cfpkt_create_pfx(u16 len, u16 pfx) 73 73 - { 74 74 - struct sk_buff *skb; 75 75 - 76 76 - skb = alloc_skb(len + pfx, GFP_ATOMIC); 77 77 - if (unlikely(skb == NULL)) 78 78 - return NULL; 79 79 - 80 80 - skb_reserve(skb, pfx); 81 81 - return skb_to_pkt(skb); 82 82 - } 83 83 - 84 84 - inline struct cfpkt *cfpkt_create(u16 len) 85 85 - { 86 86 - return cfpkt_create_pfx(len + PKT_POSTFIX, PKT_PREFIX); 87 87 - } 88 88 - 89 89 - void cfpkt_destroy(struct cfpkt *pkt) 90 90 - { 91 91 - struct sk_buff *skb = pkt_to_skb(pkt); 92 92 - kfree_skb(skb); 93 93 - } 94 94 - 95 95 - inline bool cfpkt_more(struct cfpkt *pkt) 96 96 - { 97 97 - struct sk_buff *skb = pkt_to_skb(pkt); 98 98 - return skb->len > 0; 99 99 - } 100 100 - 101 101 - int cfpkt_peek_head(struct cfpkt *pkt, void *data, u16 len) 102 102 - { 103 103 - struct sk_buff *skb = pkt_to_skb(pkt); 104 104 - if (skb_headlen(skb) >= len) { 105 105 - memcpy(data, skb->data, len); 106 106 - return 0; 107 107 - } 108 108 - return !cfpkt_extr_head(pkt, data, len) && 109 109 - !cfpkt_add_head(pkt, data, len); 110 110 - } 111 111 - 112 112 - int cfpkt_extr_head(struct cfpkt *pkt, void *data, u16 len) 113 113 - { 114 114 - struct sk_buff *skb = pkt_to_skb(pkt); 115 115 - u8 *from; 116 116 - if (unlikely(is_erronous(pkt))) 117 117 - return -EPROTO; 118 118 - 119 119 - if (unlikely(len > skb->len)) { 120 120 - PKT_ERROR(pkt, "read beyond end of packet\n"); 121 121 - return -EPROTO; 122 122 - } 123 123 - 124 124 - if (unlikely(len > skb_headlen(skb))) { 125 125 - if (unlikely(skb_linearize(skb) != 0)) { 126 126 - PKT_ERROR(pkt, "linearize failed\n"); 127 127 - return -EPROTO; 128 128 - } 129 129 - } 130 130 - from = skb_pull(skb, len); 131 131 - from -= len; 132 132 - if (data) 133 133 - memcpy(data, from, len); 134 134 - return 0; 135 135 - } 136 136 - EXPORT_SYMBOL(cfpkt_extr_head); 137 137 - 138 138 - int cfpkt_extr_trail(struct cfpkt *pkt, void *dta, u16 len) 139 139 - { 140 140 - struct sk_buff *skb = pkt_to_skb(pkt); 141 141 - u8 *data = dta; 142 142 - u8 *from; 143 143 - if (unlikely(is_erronous(pkt))) 144 144 - return -EPROTO; 145 145 - 146 146 - if (unlikely(skb_linearize(skb) != 0)) { 147 147 - PKT_ERROR(pkt, "linearize failed\n"); 148 148 - return -EPROTO; 149 149 - } 150 150 - if (unlikely(skb->data + len > skb_tail_pointer(skb))) { 151 151 - PKT_ERROR(pkt, "read beyond end of packet\n"); 152 152 - return -EPROTO; 153 153 - } 154 154 - from = skb_tail_pointer(skb) - len; 155 155 - skb_trim(skb, skb->len - len); 156 156 - memcpy(data, from, len); 157 157 - return 0; 158 158 - } 159 159 - 160 160 - int cfpkt_pad_trail(struct cfpkt *pkt, u16 len) 161 161 - { 162 162 - return cfpkt_add_body(pkt, NULL, len); 163 163 - } 164 164 - 165 165 - int cfpkt_add_body(struct cfpkt *pkt, const void *data, u16 len) 166 166 - { 167 167 - struct sk_buff *skb = pkt_to_skb(pkt); 168 168 - struct sk_buff *lastskb; 169 169 - u8 *to; 170 170 - u16 addlen = 0; 171 171 - 172 172 - 173 173 - if (unlikely(is_erronous(pkt))) 174 174 - return -EPROTO; 175 175 - 176 176 - lastskb = skb; 177 177 - 178 178 - /* Check whether we need to add space at the tail */ 179 179 - if (unlikely(skb_tailroom(skb) < len)) { 180 180 - if (likely(len < PKT_LEN_WHEN_EXTENDING)) 181 181 - addlen = PKT_LEN_WHEN_EXTENDING; 182 182 - else 183 183 - addlen = len; 184 184 - } 185 185 - 186 186 - /* Check whether we need to change the SKB before writing to the tail */ 187 187 - if (unlikely((addlen > 0) || skb_cloned(skb) || skb_shared(skb))) { 188 188 - 189 189 - /* Make sure data is writable */ 190 190 - if (unlikely(skb_cow_data(skb, addlen, &lastskb) < 0)) { 191 191 - PKT_ERROR(pkt, "cow failed\n"); 192 192 - return -EPROTO; 193 193 - } 194 194 - } 195 195 - 196 196 - /* All set to put the last SKB and optionally write data there. */ 197 197 - to = pskb_put(skb, lastskb, len); 198 198 - if (likely(data)) 199 199 - memcpy(to, data, len); 200 200 - return 0; 201 201 - } 202 202 - 203 203 - inline int cfpkt_addbdy(struct cfpkt *pkt, u8 data) 204 204 - { 205 205 - return cfpkt_add_body(pkt, &data, 1); 206 206 - } 207 207 - 208 208 - int cfpkt_add_head(struct cfpkt *pkt, const void *data2, u16 len) 209 209 - { 210 210 - struct sk_buff *skb = pkt_to_skb(pkt); 211 211 - struct sk_buff *lastskb; 212 212 - u8 *to; 213 213 - const u8 *data = data2; 214 214 - int ret; 215 215 - if (unlikely(is_erronous(pkt))) 216 216 - return -EPROTO; 217 217 - if (unlikely(skb_headroom(skb) < len)) { 218 218 - PKT_ERROR(pkt, "no headroom\n"); 219 219 - return -EPROTO; 220 220 - } 221 221 - 222 222 - /* Make sure data is writable */ 223 223 - ret = skb_cow_data(skb, 0, &lastskb); 224 224 - if (unlikely(ret < 0)) { 225 225 - PKT_ERROR(pkt, "cow failed\n"); 226 226 - return ret; 227 227 - } 228 228 - 229 229 - to = skb_push(skb, len); 230 230 - memcpy(to, data, len); 231 231 - return 0; 232 232 - } 233 233 - EXPORT_SYMBOL(cfpkt_add_head); 234 234 - 235 235 - inline int cfpkt_add_trail(struct cfpkt *pkt, const void *data, u16 len) 236 236 - { 237 237 - return cfpkt_add_body(pkt, data, len); 238 238 - } 239 239 - 240 240 - inline u16 cfpkt_getlen(struct cfpkt *pkt) 241 241 - { 242 242 - struct sk_buff *skb = pkt_to_skb(pkt); 243 243 - return skb->len; 244 244 - } 245 245 - 246 246 - int cfpkt_iterate(struct cfpkt *pkt, 247 247 - u16 (*iter_func)(u16, void *, u16), 248 248 - u16 data) 249 249 - { 250 250 - /* 251 251 - * Don't care about the performance hit of linearizing, 252 252 - * Checksum should not be used on high-speed interfaces anyway. 253 253 - */ 254 254 - if (unlikely(is_erronous(pkt))) 255 255 - return -EPROTO; 256 256 - if (unlikely(skb_linearize(&pkt->skb) != 0)) { 257 257 - PKT_ERROR(pkt, "linearize failed\n"); 258 258 - return -EPROTO; 259 259 - } 260 260 - return iter_func(data, pkt->skb.data, cfpkt_getlen(pkt)); 261 261 - } 262 262 - 263 263 - int cfpkt_setlen(struct cfpkt *pkt, u16 len) 264 264 - { 265 265 - struct sk_buff *skb = pkt_to_skb(pkt); 266 266 - 267 267 - 268 268 - if (unlikely(is_erronous(pkt))) 269 269 - return -EPROTO; 270 270 - 271 271 - if (likely(len <= skb->len)) { 272 272 - if (unlikely(skb->data_len)) 273 273 - ___pskb_trim(skb, len); 274 274 - else 275 275 - skb_trim(skb, len); 276 276 - 277 277 - return cfpkt_getlen(pkt); 278 278 - } 279 279 - 280 280 - /* Need to expand SKB */ 281 281 - if (unlikely(!cfpkt_pad_trail(pkt, len - skb->len))) 282 282 - PKT_ERROR(pkt, "skb_pad_trail failed\n"); 283 283 - 284 284 - return cfpkt_getlen(pkt); 285 285 - } 286 286 - 287 287 - struct cfpkt *cfpkt_append(struct cfpkt *dstpkt, 288 288 - struct cfpkt *addpkt, 289 289 - u16 expectlen) 290 290 - { 291 291 - struct sk_buff *dst = pkt_to_skb(dstpkt); 292 292 - struct sk_buff *add = pkt_to_skb(addpkt); 293 293 - u16 addlen = skb_headlen(add); 294 294 - u16 neededtailspace; 295 295 - struct sk_buff *tmp; 296 296 - u16 dstlen; 297 297 - u16 createlen; 298 298 - if (unlikely(is_erronous(dstpkt) || is_erronous(addpkt))) { 299 299 - return dstpkt; 300 300 - } 301 301 - 302 302 - neededtailspace = max(expectlen, addlen); 303 303 - 304 304 - if (dst->tail + neededtailspace > dst->end) { 305 305 - /* Create a dumplicate of 'dst' with more tail space */ 306 306 - struct cfpkt *tmppkt; 307 307 - dstlen = skb_headlen(dst); 308 308 - createlen = dstlen + neededtailspace; 309 309 - tmppkt = cfpkt_create(createlen + PKT_PREFIX + PKT_POSTFIX); 310 310 - if (tmppkt == NULL) 311 311 - return NULL; 312 312 - tmp = pkt_to_skb(tmppkt); 313 313 - skb_put_data(tmp, dst->data, dstlen); 314 314 - cfpkt_destroy(dstpkt); 315 315 - dst = tmp; 316 316 - } 317 317 - skb_put_data(dst, add->data, skb_headlen(add)); 318 318 - cfpkt_destroy(addpkt); 319 319 - return skb_to_pkt(dst); 320 320 - } 321 321 - 322 322 - struct cfpkt *cfpkt_split(struct cfpkt *pkt, u16 pos) 323 323 - { 324 324 - struct sk_buff *skb2; 325 325 - struct sk_buff *skb = pkt_to_skb(pkt); 326 326 - struct cfpkt *tmppkt; 327 327 - u8 *split = skb->data + pos; 328 328 - u16 len2nd = skb_tail_pointer(skb) - split; 329 329 - 330 330 - if (unlikely(is_erronous(pkt))) 331 331 - return NULL; 332 332 - 333 333 - if (skb->data + pos > skb_tail_pointer(skb)) { 334 334 - PKT_ERROR(pkt, "trying to split beyond end of packet\n"); 335 335 - return NULL; 336 336 - } 337 337 - 338 338 - /* Create a new packet for the second part of the data */ 339 339 - tmppkt = cfpkt_create_pfx(len2nd + PKT_PREFIX + PKT_POSTFIX, 340 340 - PKT_PREFIX); 341 341 - if (tmppkt == NULL) 342 342 - return NULL; 343 343 - skb2 = pkt_to_skb(tmppkt); 344 344 - 345 345 - 346 346 - if (skb2 == NULL) 347 347 - return NULL; 348 348 - 349 349 - skb_put_data(skb2, split, len2nd); 350 350 - 351 351 - /* Reduce the length of the original packet */ 352 352 - skb_trim(skb, pos); 353 353 - 354 354 - skb2->priority = skb->priority; 355 355 - return skb_to_pkt(skb2); 356 356 - } 357 357 - 358 358 - bool cfpkt_erroneous(struct cfpkt *pkt) 359 359 - { 360 360 - return cfpkt_priv(pkt)->erronous; 361 361 - } 362 362 - 363 363 - struct caif_payload_info *cfpkt_info(struct cfpkt *pkt) 364 364 - { 365 365 - return (struct caif_payload_info *)&pkt_to_skb(pkt)->cb; 366 366 - } 367 367 - EXPORT_SYMBOL(cfpkt_info); 368 368 - 369 369 - void cfpkt_set_prio(struct cfpkt *pkt, int prio) 370 370 - { 371 371 - pkt_to_skb(pkt)->priority = prio; 372 372 - } 373 373 - EXPORT_SYMBOL(cfpkt_set_prio);

-299

net/caif/cfrfml.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/stddef.h> 10 10 - #include <linux/spinlock.h> 11 11 - #include <linux/slab.h> 12 12 - #include <linux/unaligned.h> 13 13 - #include <net/caif/caif_layer.h> 14 14 - #include <net/caif/cfsrvl.h> 15 15 - #include <net/caif/cfpkt.h> 16 16 - 17 17 - #define container_obj(layr) container_of(layr, struct cfrfml, serv.layer) 18 18 - #define RFM_SEGMENTATION_BIT 0x01 19 19 - #define RFM_HEAD_SIZE 7 20 20 - 21 21 - static int cfrfml_receive(struct cflayer *layr, struct cfpkt *pkt); 22 22 - static int cfrfml_transmit(struct cflayer *layr, struct cfpkt *pkt); 23 23 - 24 24 - struct cfrfml { 25 25 - struct cfsrvl serv; 26 26 - struct cfpkt *incomplete_frm; 27 27 - int fragment_size; 28 28 - u8 seghead[6]; 29 29 - u16 pdu_size; 30 30 - /* Protects serialized processing of packets */ 31 31 - spinlock_t sync; 32 32 - }; 33 33 - 34 34 - static void cfrfml_release(struct cflayer *layer) 35 35 - { 36 36 - struct cfsrvl *srvl = container_of(layer, struct cfsrvl, layer); 37 37 - struct cfrfml *rfml = container_obj(&srvl->layer); 38 38 - 39 39 - if (rfml->incomplete_frm) 40 40 - cfpkt_destroy(rfml->incomplete_frm); 41 41 - 42 42 - kfree(srvl); 43 43 - } 44 44 - 45 45 - struct cflayer *cfrfml_create(u8 channel_id, struct dev_info *dev_info, 46 46 - int mtu_size) 47 47 - { 48 48 - int tmp; 49 49 - struct cfrfml *this = kzalloc_obj(struct cfrfml, GFP_ATOMIC); 50 50 - 51 51 - if (!this) 52 52 - return NULL; 53 53 - 54 54 - cfsrvl_init(&this->serv, channel_id, dev_info, false); 55 55 - this->serv.release = cfrfml_release; 56 56 - this->serv.layer.receive = cfrfml_receive; 57 57 - this->serv.layer.transmit = cfrfml_transmit; 58 58 - 59 59 - /* Round down to closest multiple of 16 */ 60 60 - tmp = (mtu_size - RFM_HEAD_SIZE - 6) / 16; 61 61 - tmp *= 16; 62 62 - 63 63 - this->fragment_size = tmp; 64 64 - spin_lock_init(&this->sync); 65 65 - snprintf(this->serv.layer.name, CAIF_LAYER_NAME_SZ, 66 66 - "rfm%d", channel_id); 67 67 - 68 68 - return &this->serv.layer; 69 69 - } 70 70 - 71 71 - static struct cfpkt *rfm_append(struct cfrfml *rfml, char *seghead, 72 72 - struct cfpkt *pkt, int *err) 73 73 - { 74 74 - struct cfpkt *tmppkt; 75 75 - *err = -EPROTO; 76 76 - /* n-th but not last segment */ 77 77 - 78 78 - if (cfpkt_extr_head(pkt, seghead, 6) < 0) 79 79 - return NULL; 80 80 - 81 81 - /* Verify correct header */ 82 82 - if (memcmp(seghead, rfml->seghead, 6) != 0) 83 83 - return NULL; 84 84 - 85 85 - tmppkt = cfpkt_append(rfml->incomplete_frm, pkt, 86 86 - rfml->pdu_size + RFM_HEAD_SIZE); 87 87 - 88 88 - /* If cfpkt_append failes input pkts are not freed */ 89 89 - *err = -ENOMEM; 90 90 - if (tmppkt == NULL) 91 91 - return NULL; 92 92 - 93 93 - *err = 0; 94 94 - return tmppkt; 95 95 - } 96 96 - 97 97 - static int cfrfml_receive(struct cflayer *layr, struct cfpkt *pkt) 98 98 - { 99 99 - u8 tmp; 100 100 - bool segmented; 101 101 - int err; 102 102 - u8 seghead[6]; 103 103 - struct cfrfml *rfml; 104 104 - struct cfpkt *tmppkt = NULL; 105 105 - 106 106 - caif_assert(layr->up != NULL); 107 107 - caif_assert(layr->receive != NULL); 108 108 - rfml = container_obj(layr); 109 109 - spin_lock(&rfml->sync); 110 110 - 111 111 - err = -EPROTO; 112 112 - if (cfpkt_extr_head(pkt, &tmp, 1) < 0) 113 113 - goto out; 114 114 - segmented = tmp & RFM_SEGMENTATION_BIT; 115 115 - 116 116 - if (segmented) { 117 117 - if (rfml->incomplete_frm == NULL) { 118 118 - /* Initial Segment */ 119 119 - if (cfpkt_peek_head(pkt, rfml->seghead, 6) != 0) 120 120 - goto out; 121 121 - 122 122 - rfml->pdu_size = get_unaligned_le16(rfml->seghead+4); 123 123 - 124 124 - if (cfpkt_erroneous(pkt)) 125 125 - goto out; 126 126 - rfml->incomplete_frm = pkt; 127 127 - pkt = NULL; 128 128 - } else { 129 129 - 130 130 - tmppkt = rfm_append(rfml, seghead, pkt, &err); 131 131 - if (tmppkt == NULL) 132 132 - goto out; 133 133 - 134 134 - if (cfpkt_erroneous(tmppkt)) 135 135 - goto out; 136 136 - 137 137 - rfml->incomplete_frm = tmppkt; 138 138 - 139 139 - 140 140 - if (cfpkt_erroneous(tmppkt)) 141 141 - goto out; 142 142 - } 143 143 - err = 0; 144 144 - goto out; 145 145 - } 146 146 - 147 147 - if (rfml->incomplete_frm) { 148 148 - 149 149 - /* Last Segment */ 150 150 - tmppkt = rfm_append(rfml, seghead, pkt, &err); 151 151 - if (tmppkt == NULL) 152 152 - goto out; 153 153 - 154 154 - if (cfpkt_erroneous(tmppkt)) 155 155 - goto out; 156 156 - 157 157 - rfml->incomplete_frm = NULL; 158 158 - pkt = tmppkt; 159 159 - tmppkt = NULL; 160 160 - 161 161 - /* Verify that length is correct */ 162 162 - err = -EPROTO; 163 163 - if (rfml->pdu_size != cfpkt_getlen(pkt) - RFM_HEAD_SIZE + 1) 164 164 - goto out; 165 165 - } 166 166 - 167 167 - err = rfml->serv.layer.up->receive(rfml->serv.layer.up, pkt); 168 168 - 169 169 - out: 170 170 - 171 171 - if (err != 0) { 172 172 - if (tmppkt) 173 173 - cfpkt_destroy(tmppkt); 174 174 - if (pkt) 175 175 - cfpkt_destroy(pkt); 176 176 - if (rfml->incomplete_frm) 177 177 - cfpkt_destroy(rfml->incomplete_frm); 178 178 - rfml->incomplete_frm = NULL; 179 179 - 180 180 - pr_info("Connection error %d triggered on RFM link\n", err); 181 181 - 182 182 - /* Trigger connection error upon failure.*/ 183 183 - layr->up->ctrlcmd(layr->up, CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND, 184 184 - rfml->serv.dev_info.id); 185 185 - } 186 186 - spin_unlock(&rfml->sync); 187 187 - 188 188 - if (unlikely(err == -EAGAIN)) 189 189 - /* It is not possible to recover after drop of a fragment */ 190 190 - err = -EIO; 191 191 - 192 192 - return err; 193 193 - } 194 194 - 195 195 - 196 196 - static int cfrfml_transmit_segment(struct cfrfml *rfml, struct cfpkt *pkt) 197 197 - { 198 198 - caif_assert(cfpkt_getlen(pkt) < rfml->fragment_size + RFM_HEAD_SIZE); 199 199 - 200 200 - /* Add info for MUX-layer to route the packet out. */ 201 201 - cfpkt_info(pkt)->channel_id = rfml->serv.layer.id; 202 202 - 203 203 - /* 204 204 - * To optimize alignment, we add up the size of CAIF header before 205 205 - * payload. 206 206 - */ 207 207 - cfpkt_info(pkt)->hdr_len = RFM_HEAD_SIZE; 208 208 - cfpkt_info(pkt)->dev_info = &rfml->serv.dev_info; 209 209 - 210 210 - return rfml->serv.layer.dn->transmit(rfml->serv.layer.dn, pkt); 211 211 - } 212 212 - 213 213 - static int cfrfml_transmit(struct cflayer *layr, struct cfpkt *pkt) 214 214 - { 215 215 - int err; 216 216 - u8 seg; 217 217 - u8 head[6]; 218 218 - struct cfpkt *rearpkt = NULL; 219 219 - struct cfpkt *frontpkt = pkt; 220 220 - struct cfrfml *rfml = container_obj(layr); 221 221 - 222 222 - caif_assert(layr->dn != NULL); 223 223 - caif_assert(layr->dn->transmit != NULL); 224 224 - 225 225 - if (!cfsrvl_ready(&rfml->serv, &err)) 226 226 - goto out; 227 227 - 228 228 - err = -EPROTO; 229 229 - if (cfpkt_getlen(pkt) <= RFM_HEAD_SIZE-1) 230 230 - goto out; 231 231 - 232 232 - err = 0; 233 233 - if (cfpkt_getlen(pkt) > rfml->fragment_size + RFM_HEAD_SIZE) 234 234 - err = cfpkt_peek_head(pkt, head, 6); 235 235 - 236 236 - if (err != 0) 237 237 - goto out; 238 238 - 239 239 - while (cfpkt_getlen(frontpkt) > rfml->fragment_size + RFM_HEAD_SIZE) { 240 240 - 241 241 - seg = 1; 242 242 - err = -EPROTO; 243 243 - 244 244 - if (cfpkt_add_head(frontpkt, &seg, 1) < 0) 245 245 - goto out; 246 246 - /* 247 247 - * On OOM error cfpkt_split returns NULL. 248 248 - * 249 249 - * NOTE: Segmented pdu is not correctly aligned. 250 250 - * This has negative performance impact. 251 251 - */ 252 252 - 253 253 - rearpkt = cfpkt_split(frontpkt, rfml->fragment_size); 254 254 - if (rearpkt == NULL) 255 255 - goto out; 256 256 - 257 257 - err = cfrfml_transmit_segment(rfml, frontpkt); 258 258 - 259 259 - if (err != 0) { 260 260 - frontpkt = NULL; 261 261 - goto out; 262 262 - } 263 263 - 264 264 - frontpkt = rearpkt; 265 265 - rearpkt = NULL; 266 266 - 267 267 - err = -EPROTO; 268 268 - if (cfpkt_add_head(frontpkt, head, 6) < 0) 269 269 - goto out; 270 270 - 271 271 - } 272 272 - 273 273 - seg = 0; 274 274 - err = -EPROTO; 275 275 - 276 276 - if (cfpkt_add_head(frontpkt, &seg, 1) < 0) 277 277 - goto out; 278 278 - 279 279 - err = cfrfml_transmit_segment(rfml, frontpkt); 280 280 - 281 281 - frontpkt = NULL; 282 282 - out: 283 283 - 284 284 - if (err != 0) { 285 285 - pr_info("Connection error %d triggered on RFM link\n", err); 286 286 - /* Trigger connection error upon failure.*/ 287 287 - 288 288 - layr->up->ctrlcmd(layr->up, CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND, 289 289 - rfml->serv.dev_info.id); 290 290 - 291 291 - if (rearpkt) 292 292 - cfpkt_destroy(rearpkt); 293 293 - 294 294 - if (frontpkt) 295 295 - cfpkt_destroy(frontpkt); 296 296 - } 297 297 - 298 298 - return err; 299 299 - }

-192

net/caif/cfserl.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/stddef.h> 10 10 - #include <linux/spinlock.h> 11 11 - #include <linux/slab.h> 12 12 - #include <net/caif/caif_layer.h> 13 13 - #include <net/caif/cfpkt.h> 14 14 - #include <net/caif/cfserl.h> 15 15 - 16 16 - #define container_obj(layr) ((struct cfserl *) layr) 17 17 - 18 18 - #define CFSERL_STX 0x02 19 19 - #define SERIAL_MINIUM_PACKET_SIZE 4 20 20 - #define SERIAL_MAX_FRAMESIZE 4096 21 21 - struct cfserl { 22 22 - struct cflayer layer; 23 23 - struct cfpkt *incomplete_frm; 24 24 - /* Protects parallel processing of incoming packets */ 25 25 - spinlock_t sync; 26 26 - bool usestx; 27 27 - }; 28 28 - 29 29 - static int cfserl_receive(struct cflayer *layr, struct cfpkt *pkt); 30 30 - static int cfserl_transmit(struct cflayer *layr, struct cfpkt *pkt); 31 31 - static void cfserl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 32 32 - int phyid); 33 33 - 34 34 - void cfserl_release(struct cflayer *layer) 35 35 - { 36 36 - kfree(layer); 37 37 - } 38 38 - 39 39 - struct cflayer *cfserl_create(int instance, bool use_stx) 40 40 - { 41 41 - struct cfserl *this = kzalloc_obj(struct cfserl, GFP_ATOMIC); 42 42 - if (!this) 43 43 - return NULL; 44 44 - caif_assert(offsetof(struct cfserl, layer) == 0); 45 45 - this->layer.receive = cfserl_receive; 46 46 - this->layer.transmit = cfserl_transmit; 47 47 - this->layer.ctrlcmd = cfserl_ctrlcmd; 48 48 - this->usestx = use_stx; 49 49 - spin_lock_init(&this->sync); 50 50 - snprintf(this->layer.name, CAIF_LAYER_NAME_SZ, "ser1"); 51 51 - return &this->layer; 52 52 - } 53 53 - 54 54 - static int cfserl_receive(struct cflayer *l, struct cfpkt *newpkt) 55 55 - { 56 56 - struct cfserl *layr = container_obj(l); 57 57 - u16 pkt_len; 58 58 - struct cfpkt *pkt = NULL; 59 59 - struct cfpkt *tail_pkt = NULL; 60 60 - u8 tmp8; 61 61 - u16 tmp; 62 62 - u8 stx = CFSERL_STX; 63 63 - int ret; 64 64 - u16 expectlen = 0; 65 65 - 66 66 - caif_assert(newpkt != NULL); 67 67 - spin_lock(&layr->sync); 68 68 - 69 69 - if (layr->incomplete_frm != NULL) { 70 70 - layr->incomplete_frm = 71 71 - cfpkt_append(layr->incomplete_frm, newpkt, expectlen); 72 72 - pkt = layr->incomplete_frm; 73 73 - if (pkt == NULL) { 74 74 - spin_unlock(&layr->sync); 75 75 - return -ENOMEM; 76 76 - } 77 77 - } else { 78 78 - pkt = newpkt; 79 79 - } 80 80 - layr->incomplete_frm = NULL; 81 81 - 82 82 - do { 83 83 - /* Search for STX at start of pkt if STX is used */ 84 84 - if (layr->usestx) { 85 85 - cfpkt_extr_head(pkt, &tmp8, 1); 86 86 - if (tmp8 != CFSERL_STX) { 87 87 - while (cfpkt_more(pkt) 88 88 - && tmp8 != CFSERL_STX) { 89 89 - cfpkt_extr_head(pkt, &tmp8, 1); 90 90 - } 91 91 - if (!cfpkt_more(pkt)) { 92 92 - cfpkt_destroy(pkt); 93 93 - layr->incomplete_frm = NULL; 94 94 - spin_unlock(&layr->sync); 95 95 - return -EPROTO; 96 96 - } 97 97 - } 98 98 - } 99 99 - 100 100 - pkt_len = cfpkt_getlen(pkt); 101 101 - 102 102 - /* 103 103 - * pkt_len is the accumulated length of the packet data 104 104 - * we have received so far. 105 105 - * Exit if frame doesn't hold length. 106 106 - */ 107 107 - 108 108 - if (pkt_len < 2) { 109 109 - if (layr->usestx) 110 110 - cfpkt_add_head(pkt, &stx, 1); 111 111 - layr->incomplete_frm = pkt; 112 112 - spin_unlock(&layr->sync); 113 113 - return 0; 114 114 - } 115 115 - 116 116 - /* 117 117 - * Find length of frame. 118 118 - * expectlen is the length we need for a full frame. 119 119 - */ 120 120 - cfpkt_peek_head(pkt, &tmp, 2); 121 121 - expectlen = le16_to_cpu(tmp) + 2; 122 122 - /* 123 123 - * Frame error handling 124 124 - */ 125 125 - if (expectlen < SERIAL_MINIUM_PACKET_SIZE 126 126 - || expectlen > SERIAL_MAX_FRAMESIZE) { 127 127 - if (!layr->usestx) { 128 128 - if (pkt != NULL) 129 129 - cfpkt_destroy(pkt); 130 130 - layr->incomplete_frm = NULL; 131 131 - spin_unlock(&layr->sync); 132 132 - return -EPROTO; 133 133 - } 134 134 - continue; 135 135 - } 136 136 - 137 137 - if (pkt_len < expectlen) { 138 138 - /* Too little received data */ 139 139 - if (layr->usestx) 140 140 - cfpkt_add_head(pkt, &stx, 1); 141 141 - layr->incomplete_frm = pkt; 142 142 - spin_unlock(&layr->sync); 143 143 - return 0; 144 144 - } 145 145 - 146 146 - /* 147 147 - * Enough data for at least one frame. 148 148 - * Split the frame, if too long 149 149 - */ 150 150 - if (pkt_len > expectlen) 151 151 - tail_pkt = cfpkt_split(pkt, expectlen); 152 152 - else 153 153 - tail_pkt = NULL; 154 154 - 155 155 - /* Send the first part of packet upwards.*/ 156 156 - spin_unlock(&layr->sync); 157 157 - ret = layr->layer.up->receive(layr->layer.up, pkt); 158 158 - spin_lock(&layr->sync); 159 159 - if (ret == -EILSEQ) { 160 160 - if (layr->usestx) { 161 161 - if (tail_pkt != NULL) 162 162 - pkt = cfpkt_append(pkt, tail_pkt, 0); 163 163 - /* Start search for next STX if frame failed */ 164 164 - continue; 165 165 - } else { 166 166 - cfpkt_destroy(pkt); 167 167 - pkt = NULL; 168 168 - } 169 169 - } 170 170 - 171 171 - pkt = tail_pkt; 172 172 - 173 173 - } while (pkt != NULL); 174 174 - 175 175 - spin_unlock(&layr->sync); 176 176 - return 0; 177 177 - } 178 178 - 179 179 - static int cfserl_transmit(struct cflayer *layer, struct cfpkt *newpkt) 180 180 - { 181 181 - struct cfserl *layr = container_obj(layer); 182 182 - u8 tmp8 = CFSERL_STX; 183 183 - if (layr->usestx) 184 184 - cfpkt_add_head(newpkt, &tmp8, 1); 185 185 - return layer->dn->transmit(layer->dn, newpkt); 186 186 - } 187 187 - 188 188 - static void cfserl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 189 189 - int phyid) 190 190 - { 191 191 - layr->up->ctrlcmd(layr->up, ctrl, phyid); 192 192 - }

-224

net/caif/cfsrvl.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/kernel.h> 10 10 - #include <linux/types.h> 11 11 - #include <linux/errno.h> 12 12 - #include <linux/slab.h> 13 13 - #include <linux/module.h> 14 14 - #include <linux/pkt_sched.h> 15 15 - #include <net/caif/caif_layer.h> 16 16 - #include <net/caif/cfsrvl.h> 17 17 - #include <net/caif/cfpkt.h> 18 18 - #include <net/caif/caif_dev.h> 19 19 - 20 20 - #define SRVL_CTRL_PKT_SIZE 1 21 21 - #define SRVL_FLOW_OFF 0x81 22 22 - #define SRVL_FLOW_ON 0x80 23 23 - #define SRVL_SET_PIN 0x82 24 24 - 25 25 - #define container_obj(layr) container_of(layr, struct cfsrvl, layer) 26 26 - 27 27 - static void cfservl_ctrlcmd(struct cflayer *layr, enum caif_ctrlcmd ctrl, 28 28 - int phyid) 29 29 - { 30 30 - struct cfsrvl *service = container_obj(layr); 31 31 - 32 32 - if (layr->up == NULL || layr->up->ctrlcmd == NULL) 33 33 - return; 34 34 - 35 35 - switch (ctrl) { 36 36 - case CAIF_CTRLCMD_INIT_RSP: 37 37 - service->open = true; 38 38 - layr->up->ctrlcmd(layr->up, ctrl, phyid); 39 39 - break; 40 40 - case CAIF_CTRLCMD_DEINIT_RSP: 41 41 - case CAIF_CTRLCMD_INIT_FAIL_RSP: 42 42 - service->open = false; 43 43 - layr->up->ctrlcmd(layr->up, ctrl, phyid); 44 44 - break; 45 45 - case _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND: 46 46 - if (phyid != service->dev_info.id) 47 47 - break; 48 48 - if (service->modem_flow_on) 49 49 - layr->up->ctrlcmd(layr->up, 50 50 - CAIF_CTRLCMD_FLOW_OFF_IND, phyid); 51 51 - service->phy_flow_on = false; 52 52 - break; 53 53 - case _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND: 54 54 - if (phyid != service->dev_info.id) 55 55 - return; 56 56 - if (service->modem_flow_on) { 57 57 - layr->up->ctrlcmd(layr->up, 58 58 - CAIF_CTRLCMD_FLOW_ON_IND, 59 59 - phyid); 60 60 - } 61 61 - service->phy_flow_on = true; 62 62 - break; 63 63 - case CAIF_CTRLCMD_FLOW_OFF_IND: 64 64 - if (service->phy_flow_on) { 65 65 - layr->up->ctrlcmd(layr->up, 66 66 - CAIF_CTRLCMD_FLOW_OFF_IND, phyid); 67 67 - } 68 68 - service->modem_flow_on = false; 69 69 - break; 70 70 - case CAIF_CTRLCMD_FLOW_ON_IND: 71 71 - if (service->phy_flow_on) { 72 72 - layr->up->ctrlcmd(layr->up, 73 73 - CAIF_CTRLCMD_FLOW_ON_IND, phyid); 74 74 - } 75 75 - service->modem_flow_on = true; 76 76 - break; 77 77 - case _CAIF_CTRLCMD_PHYIF_DOWN_IND: 78 78 - /* In case interface is down, let's fake a remove shutdown */ 79 79 - layr->up->ctrlcmd(layr->up, 80 80 - CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND, phyid); 81 81 - break; 82 82 - case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND: 83 83 - layr->up->ctrlcmd(layr->up, ctrl, phyid); 84 84 - break; 85 85 - default: 86 86 - pr_warn("Unexpected ctrl in cfsrvl (%d)\n", ctrl); 87 87 - /* We have both modem and phy flow on, send flow on */ 88 88 - layr->up->ctrlcmd(layr->up, ctrl, phyid); 89 89 - service->phy_flow_on = true; 90 90 - break; 91 91 - } 92 92 - } 93 93 - 94 94 - static int cfservl_modemcmd(struct cflayer *layr, enum caif_modemcmd ctrl) 95 95 - { 96 96 - struct cfsrvl *service = container_obj(layr); 97 97 - 98 98 - caif_assert(layr != NULL); 99 99 - caif_assert(layr->dn != NULL); 100 100 - caif_assert(layr->dn->transmit != NULL); 101 101 - 102 102 - if (!service->supports_flowctrl) 103 103 - return 0; 104 104 - 105 105 - switch (ctrl) { 106 106 - case CAIF_MODEMCMD_FLOW_ON_REQ: 107 107 - { 108 108 - struct cfpkt *pkt; 109 109 - struct caif_payload_info *info; 110 110 - u8 flow_on = SRVL_FLOW_ON; 111 111 - pkt = cfpkt_create(SRVL_CTRL_PKT_SIZE); 112 112 - if (!pkt) 113 113 - return -ENOMEM; 114 114 - 115 115 - if (cfpkt_add_head(pkt, &flow_on, 1) < 0) { 116 116 - pr_err("Packet is erroneous!\n"); 117 117 - cfpkt_destroy(pkt); 118 118 - return -EPROTO; 119 119 - } 120 120 - info = cfpkt_info(pkt); 121 121 - info->channel_id = service->layer.id; 122 122 - info->hdr_len = 1; 123 123 - info->dev_info = &service->dev_info; 124 124 - cfpkt_set_prio(pkt, TC_PRIO_CONTROL); 125 125 - return layr->dn->transmit(layr->dn, pkt); 126 126 - } 127 127 - case CAIF_MODEMCMD_FLOW_OFF_REQ: 128 128 - { 129 129 - struct cfpkt *pkt; 130 130 - struct caif_payload_info *info; 131 131 - u8 flow_off = SRVL_FLOW_OFF; 132 132 - pkt = cfpkt_create(SRVL_CTRL_PKT_SIZE); 133 133 - if (!pkt) 134 134 - return -ENOMEM; 135 135 - 136 136 - if (cfpkt_add_head(pkt, &flow_off, 1) < 0) { 137 137 - pr_err("Packet is erroneous!\n"); 138 138 - cfpkt_destroy(pkt); 139 139 - return -EPROTO; 140 140 - } 141 141 - info = cfpkt_info(pkt); 142 142 - info->channel_id = service->layer.id; 143 143 - info->hdr_len = 1; 144 144 - info->dev_info = &service->dev_info; 145 145 - cfpkt_set_prio(pkt, TC_PRIO_CONTROL); 146 146 - return layr->dn->transmit(layr->dn, pkt); 147 147 - } 148 148 - default: 149 149 - break; 150 150 - } 151 151 - return -EINVAL; 152 152 - } 153 153 - 154 154 - static void cfsrvl_release(struct cflayer *layer) 155 155 - { 156 156 - struct cfsrvl *service = container_of(layer, struct cfsrvl, layer); 157 157 - kfree(service); 158 158 - } 159 159 - 160 160 - void cfsrvl_init(struct cfsrvl *service, 161 161 - u8 channel_id, 162 162 - struct dev_info *dev_info, 163 163 - bool supports_flowctrl) 164 164 - { 165 165 - caif_assert(offsetof(struct cfsrvl, layer) == 0); 166 166 - service->open = false; 167 167 - service->modem_flow_on = true; 168 168 - service->phy_flow_on = true; 169 169 - service->layer.id = channel_id; 170 170 - service->layer.ctrlcmd = cfservl_ctrlcmd; 171 171 - service->layer.modemcmd = cfservl_modemcmd; 172 172 - service->dev_info = *dev_info; 173 173 - service->supports_flowctrl = supports_flowctrl; 174 174 - service->release = cfsrvl_release; 175 175 - } 176 176 - 177 177 - bool cfsrvl_ready(struct cfsrvl *service, int *err) 178 178 - { 179 179 - if (!service->open) { 180 180 - *err = -ENOTCONN; 181 181 - return false; 182 182 - } 183 183 - return true; 184 184 - } 185 185 - 186 186 - bool cfsrvl_phyid_match(struct cflayer *layer, int phyid) 187 187 - { 188 188 - struct cfsrvl *servl = container_obj(layer); 189 189 - return servl->dev_info.id == phyid; 190 190 - } 191 191 - 192 192 - void caif_free_client(struct cflayer *adap_layer) 193 193 - { 194 194 - struct cflayer *serv_layer; 195 195 - struct cfsrvl *servl; 196 196 - 197 197 - if (!adap_layer) 198 198 - return; 199 199 - 200 200 - serv_layer = adap_layer->dn; 201 201 - if (!serv_layer) 202 202 - return; 203 203 - 204 204 - layer_set_dn(adap_layer, NULL); 205 205 - layer_set_up(serv_layer, NULL); 206 206 - 207 207 - servl = container_obj(serv_layer); 208 208 - servl->release(&servl->layer); 209 209 - } 210 210 - EXPORT_SYMBOL(caif_free_client); 211 211 - 212 212 - void caif_client_register_refcnt(struct cflayer *adapt_layer, 213 213 - void (*hold)(struct cflayer *lyr), 214 214 - void (*put)(struct cflayer *lyr)) 215 215 - { 216 216 - struct cfsrvl *service; 217 217 - 218 218 - if (WARN_ON(adapt_layer == NULL || adapt_layer->dn == NULL)) 219 219 - return; 220 220 - service = container_of(adapt_layer->dn, struct cfsrvl, layer); 221 221 - service->hold = hold; 222 222 - service->put = put; 223 223 - } 224 224 - EXPORT_SYMBOL(caif_client_register_refcnt);

-104

net/caif/cfutill.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/kernel.h> 10 10 - #include <linux/types.h> 11 11 - #include <linux/slab.h> 12 12 - #include <linux/errno.h> 13 13 - #include <net/caif/caif_layer.h> 14 14 - #include <net/caif/cfsrvl.h> 15 15 - #include <net/caif/cfpkt.h> 16 16 - 17 17 - #define container_obj(layr) ((struct cfsrvl *) layr) 18 18 - #define UTIL_PAYLOAD 0x00 19 19 - #define UTIL_CMD_BIT 0x80 20 20 - #define UTIL_REMOTE_SHUTDOWN 0x82 21 21 - #define UTIL_FLOW_OFF 0x81 22 22 - #define UTIL_FLOW_ON 0x80 23 23 - 24 24 - static int cfutill_receive(struct cflayer *layr, struct cfpkt *pkt); 25 25 - static int cfutill_transmit(struct cflayer *layr, struct cfpkt *pkt); 26 26 - 27 27 - struct cflayer *cfutill_create(u8 channel_id, struct dev_info *dev_info) 28 28 - { 29 29 - struct cfsrvl *util = kzalloc_obj(struct cfsrvl, GFP_ATOMIC); 30 30 - if (!util) 31 31 - return NULL; 32 32 - caif_assert(offsetof(struct cfsrvl, layer) == 0); 33 33 - cfsrvl_init(util, channel_id, dev_info, true); 34 34 - util->layer.receive = cfutill_receive; 35 35 - util->layer.transmit = cfutill_transmit; 36 36 - snprintf(util->layer.name, CAIF_LAYER_NAME_SZ, "util1"); 37 37 - return &util->layer; 38 38 - } 39 39 - 40 40 - static int cfutill_receive(struct cflayer *layr, struct cfpkt *pkt) 41 41 - { 42 42 - u8 cmd = -1; 43 43 - struct cfsrvl *service = container_obj(layr); 44 44 - caif_assert(layr != NULL); 45 45 - caif_assert(layr->up != NULL); 46 46 - caif_assert(layr->up->receive != NULL); 47 47 - caif_assert(layr->up->ctrlcmd != NULL); 48 48 - if (cfpkt_extr_head(pkt, &cmd, 1) < 0) { 49 49 - pr_err("Packet is erroneous!\n"); 50 50 - cfpkt_destroy(pkt); 51 51 - return -EPROTO; 52 52 - } 53 53 - 54 54 - switch (cmd) { 55 55 - case UTIL_PAYLOAD: 56 56 - return layr->up->receive(layr->up, pkt); 57 57 - case UTIL_FLOW_OFF: 58 58 - layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_OFF_IND, 0); 59 59 - cfpkt_destroy(pkt); 60 60 - return 0; 61 61 - case UTIL_FLOW_ON: 62 62 - layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_ON_IND, 0); 63 63 - cfpkt_destroy(pkt); 64 64 - return 0; 65 65 - case UTIL_REMOTE_SHUTDOWN: /* Remote Shutdown Request */ 66 66 - pr_err("REMOTE SHUTDOWN REQUEST RECEIVED\n"); 67 67 - layr->ctrlcmd(layr, CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND, 0); 68 68 - service->open = false; 69 69 - cfpkt_destroy(pkt); 70 70 - return 0; 71 71 - default: 72 72 - cfpkt_destroy(pkt); 73 73 - pr_warn("Unknown service control %d (0x%x)\n", cmd, cmd); 74 74 - return -EPROTO; 75 75 - } 76 76 - } 77 77 - 78 78 - static int cfutill_transmit(struct cflayer *layr, struct cfpkt *pkt) 79 79 - { 80 80 - u8 zero = 0; 81 81 - struct caif_payload_info *info; 82 82 - int ret; 83 83 - struct cfsrvl *service = container_obj(layr); 84 84 - caif_assert(layr != NULL); 85 85 - caif_assert(layr->dn != NULL); 86 86 - caif_assert(layr->dn->transmit != NULL); 87 87 - 88 88 - if (!cfsrvl_ready(service, &ret)) { 89 89 - cfpkt_destroy(pkt); 90 90 - return ret; 91 91 - } 92 92 - 93 93 - cfpkt_add_head(pkt, &zero, 1); 94 94 - /* Add info for MUX-layer to route the packet out. */ 95 95 - info = cfpkt_info(pkt); 96 96 - info->channel_id = service->layer.id; 97 97 - /* 98 98 - * To optimize alignment, we add up the size of CAIF header before 99 99 - * payload. 100 100 - */ 101 101 - info->hdr_len = 1; 102 102 - info->dev_info = &service->dev_info; 103 103 - return layr->dn->transmit(layr->dn, pkt); 104 104 - }

-101

net/caif/cfveil.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/stddef.h> 10 10 - #include <linux/slab.h> 11 11 - #include <net/caif/caif_layer.h> 12 12 - #include <net/caif/cfsrvl.h> 13 13 - #include <net/caif/cfpkt.h> 14 14 - 15 15 - #define VEI_PAYLOAD 0x00 16 16 - #define VEI_CMD_BIT 0x80 17 17 - #define VEI_FLOW_OFF 0x81 18 18 - #define VEI_FLOW_ON 0x80 19 19 - #define VEI_SET_PIN 0x82 20 20 - 21 21 - #define container_obj(layr) container_of(layr, struct cfsrvl, layer) 22 22 - 23 23 - static int cfvei_receive(struct cflayer *layr, struct cfpkt *pkt); 24 24 - static int cfvei_transmit(struct cflayer *layr, struct cfpkt *pkt); 25 25 - 26 26 - struct cflayer *cfvei_create(u8 channel_id, struct dev_info *dev_info) 27 27 - { 28 28 - struct cfsrvl *vei = kzalloc_obj(struct cfsrvl, GFP_ATOMIC); 29 29 - if (!vei) 30 30 - return NULL; 31 31 - caif_assert(offsetof(struct cfsrvl, layer) == 0); 32 32 - cfsrvl_init(vei, channel_id, dev_info, true); 33 33 - vei->layer.receive = cfvei_receive; 34 34 - vei->layer.transmit = cfvei_transmit; 35 35 - snprintf(vei->layer.name, CAIF_LAYER_NAME_SZ, "vei%d", channel_id); 36 36 - return &vei->layer; 37 37 - } 38 38 - 39 39 - static int cfvei_receive(struct cflayer *layr, struct cfpkt *pkt) 40 40 - { 41 41 - u8 cmd; 42 42 - int ret; 43 43 - caif_assert(layr->up != NULL); 44 44 - caif_assert(layr->receive != NULL); 45 45 - caif_assert(layr->ctrlcmd != NULL); 46 46 - 47 47 - 48 48 - if (cfpkt_extr_head(pkt, &cmd, 1) < 0) { 49 49 - pr_err("Packet is erroneous!\n"); 50 50 - cfpkt_destroy(pkt); 51 51 - return -EPROTO; 52 52 - } 53 53 - switch (cmd) { 54 54 - case VEI_PAYLOAD: 55 55 - ret = layr->up->receive(layr->up, pkt); 56 56 - return ret; 57 57 - case VEI_FLOW_OFF: 58 58 - layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_OFF_IND, 0); 59 59 - cfpkt_destroy(pkt); 60 60 - return 0; 61 61 - case VEI_FLOW_ON: 62 62 - layr->ctrlcmd(layr, CAIF_CTRLCMD_FLOW_ON_IND, 0); 63 63 - cfpkt_destroy(pkt); 64 64 - return 0; 65 65 - case VEI_SET_PIN: /* SET RS232 PIN */ 66 66 - cfpkt_destroy(pkt); 67 67 - return 0; 68 68 - default: /* SET RS232 PIN */ 69 69 - pr_warn("Unknown VEI control packet %d (0x%x)!\n", cmd, cmd); 70 70 - cfpkt_destroy(pkt); 71 71 - return -EPROTO; 72 72 - } 73 73 - } 74 74 - 75 75 - static int cfvei_transmit(struct cflayer *layr, struct cfpkt *pkt) 76 76 - { 77 77 - u8 tmp = 0; 78 78 - struct caif_payload_info *info; 79 79 - int ret; 80 80 - struct cfsrvl *service = container_obj(layr); 81 81 - if (!cfsrvl_ready(service, &ret)) 82 82 - goto err; 83 83 - caif_assert(layr->dn != NULL); 84 84 - caif_assert(layr->dn->transmit != NULL); 85 85 - 86 86 - if (cfpkt_add_head(pkt, &tmp, 1) < 0) { 87 87 - pr_err("Packet is erroneous!\n"); 88 88 - ret = -EPROTO; 89 89 - goto err; 90 90 - } 91 91 - 92 92 - /* Add info-> for MUX-layer to route the packet out. */ 93 93 - info = cfpkt_info(pkt); 94 94 - info->channel_id = service->layer.id; 95 95 - info->hdr_len = 1; 96 96 - info->dev_info = &service->dev_info; 97 97 - return layr->dn->transmit(layr->dn, pkt); 98 98 - err: 99 99 - cfpkt_destroy(pkt); 100 100 - return ret; 101 101 - }

-65

net/caif/cfvidl.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Author: Sjur Brendeland 5 5 - */ 6 6 - 7 7 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 8 8 - 9 9 - #include <linux/kernel.h> 10 10 - #include <linux/types.h> 11 11 - #include <linux/slab.h> 12 12 - #include <linux/errno.h> 13 13 - #include <net/caif/caif_layer.h> 14 14 - #include <net/caif/cfsrvl.h> 15 15 - #include <net/caif/cfpkt.h> 16 16 - 17 17 - #define container_obj(layr) ((struct cfsrvl *) layr) 18 18 - 19 19 - static int cfvidl_receive(struct cflayer *layr, struct cfpkt *pkt); 20 20 - static int cfvidl_transmit(struct cflayer *layr, struct cfpkt *pkt); 21 21 - 22 22 - struct cflayer *cfvidl_create(u8 channel_id, struct dev_info *dev_info) 23 23 - { 24 24 - struct cfsrvl *vid = kzalloc_obj(struct cfsrvl, GFP_ATOMIC); 25 25 - if (!vid) 26 26 - return NULL; 27 27 - caif_assert(offsetof(struct cfsrvl, layer) == 0); 28 28 - 29 29 - cfsrvl_init(vid, channel_id, dev_info, false); 30 30 - vid->layer.receive = cfvidl_receive; 31 31 - vid->layer.transmit = cfvidl_transmit; 32 32 - snprintf(vid->layer.name, CAIF_LAYER_NAME_SZ, "vid1"); 33 33 - return &vid->layer; 34 34 - } 35 35 - 36 36 - static int cfvidl_receive(struct cflayer *layr, struct cfpkt *pkt) 37 37 - { 38 38 - u32 videoheader; 39 39 - if (cfpkt_extr_head(pkt, &videoheader, 4) < 0) { 40 40 - pr_err("Packet is erroneous!\n"); 41 41 - cfpkt_destroy(pkt); 42 42 - return -EPROTO; 43 43 - } 44 44 - return layr->up->receive(layr->up, pkt); 45 45 - } 46 46 - 47 47 - static int cfvidl_transmit(struct cflayer *layr, struct cfpkt *pkt) 48 48 - { 49 49 - struct cfsrvl *service = container_obj(layr); 50 50 - struct caif_payload_info *info; 51 51 - u32 videoheader = 0; 52 52 - int ret; 53 53 - 54 54 - if (!cfsrvl_ready(service, &ret)) { 55 55 - cfpkt_destroy(pkt); 56 56 - return ret; 57 57 - } 58 58 - 59 59 - cfpkt_add_head(pkt, &videoheader, 4); 60 60 - /* Add info for MUX-layer to route the packet out */ 61 61 - info = cfpkt_info(pkt); 62 62 - info->channel_id = service->layer.id; 63 63 - info->dev_info = &service->dev_info; 64 64 - return layr->dn->transmit(layr->dn, pkt); 65 65 - }

-531

net/caif/chnl_net.c

reviewed

··· 1 1 - // SPDX-License-Identifier: GPL-2.0-only 2 2 - /* 3 3 - * Copyright (C) ST-Ericsson AB 2010 4 4 - * Authors: Sjur Brendeland 5 5 - * Daniel Martensson 6 6 - */ 7 7 - 8 8 - #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ 9 9 - 10 10 - #include <linux/fs.h> 11 11 - #include <linux/init.h> 12 12 - #include <linux/module.h> 13 13 - #include <linux/netdevice.h> 14 14 - #include <linux/if_ether.h> 15 15 - #include <linux/ip.h> 16 16 - #include <linux/sched.h> 17 17 - #include <linux/sockios.h> 18 18 - #include <linux/caif/if_caif.h> 19 19 - #include <net/rtnetlink.h> 20 20 - #include <net/caif/caif_layer.h> 21 21 - #include <net/caif/cfpkt.h> 22 22 - #include <net/caif/caif_dev.h> 23 23 - 24 24 - /* GPRS PDP connection has MTU to 1500 */ 25 25 - #define GPRS_PDP_MTU 1500 26 26 - /* 5 sec. connect timeout */ 27 27 - #define CONNECT_TIMEOUT (5 * HZ) 28 28 - #define CAIF_NET_DEFAULT_QUEUE_LEN 500 29 29 - #define UNDEF_CONNID 0xffffffff 30 30 - 31 31 - /*This list is protected by the rtnl lock. */ 32 32 - static LIST_HEAD(chnl_net_list); 33 33 - 34 34 - MODULE_DESCRIPTION("ST-Ericsson CAIF modem protocol GPRS network device"); 35 35 - MODULE_LICENSE("GPL"); 36 36 - MODULE_ALIAS_RTNL_LINK("caif"); 37 37 - 38 38 - enum caif_states { 39 39 - CAIF_CONNECTED = 1, 40 40 - CAIF_CONNECTING, 41 41 - CAIF_DISCONNECTED, 42 42 - CAIF_SHUTDOWN 43 43 - }; 44 44 - 45 45 - struct chnl_net { 46 46 - struct cflayer chnl; 47 47 - struct caif_connect_request conn_req; 48 48 - struct list_head list_field; 49 49 - struct net_device *netdev; 50 50 - wait_queue_head_t netmgmt_wq; 51 51 - /* Flow status to remember and control the transmission. */ 52 52 - bool flowenabled; 53 53 - enum caif_states state; 54 54 - }; 55 55 - 56 56 - static int chnl_recv_cb(struct cflayer *layr, struct cfpkt *pkt) 57 57 - { 58 58 - struct sk_buff *skb; 59 59 - struct chnl_net *priv; 60 60 - int pktlen; 61 61 - const u8 *ip_version; 62 62 - u8 buf; 63 63 - 64 64 - priv = container_of(layr, struct chnl_net, chnl); 65 65 - 66 66 - skb = (struct sk_buff *) cfpkt_tonative(pkt); 67 67 - 68 68 - /* Get length of CAIF packet. */ 69 69 - pktlen = skb->len; 70 70 - 71 71 - /* Pass some minimum information and 72 72 - * send the packet to the net stack. 73 73 - */ 74 74 - skb->dev = priv->netdev; 75 75 - 76 76 - /* check the version of IP */ 77 77 - ip_version = skb_header_pointer(skb, 0, 1, &buf); 78 78 - if (!ip_version) { 79 79 - kfree_skb(skb); 80 80 - return -EINVAL; 81 81 - } 82 82 - 83 83 - switch (*ip_version >> 4) { 84 84 - case 4: 85 85 - skb->protocol = htons(ETH_P_IP); 86 86 - break; 87 87 - case 6: 88 88 - skb->protocol = htons(ETH_P_IPV6); 89 89 - break; 90 90 - default: 91 91 - kfree_skb(skb); 92 92 - priv->netdev->stats.rx_errors++; 93 93 - return -EINVAL; 94 94 - } 95 95 - 96 96 - /* If we change the header in loop mode, the checksum is corrupted. */ 97 97 - if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP) 98 98 - skb->ip_summed = CHECKSUM_UNNECESSARY; 99 99 - else 100 100 - skb->ip_summed = CHECKSUM_NONE; 101 101 - 102 102 - netif_rx(skb); 103 103 - 104 104 - /* Update statistics. */ 105 105 - priv->netdev->stats.rx_packets++; 106 106 - priv->netdev->stats.rx_bytes += pktlen; 107 107 - 108 108 - return 0; 109 109 - } 110 110 - 111 111 - static int delete_device(struct chnl_net *dev) 112 112 - { 113 113 - ASSERT_RTNL(); 114 114 - if (dev->netdev) 115 115 - unregister_netdevice(dev->netdev); 116 116 - return 0; 117 117 - } 118 118 - 119 119 - static void close_work(struct work_struct *work) 120 120 - { 121 121 - struct chnl_net *dev = NULL; 122 122 - struct list_head *list_node; 123 123 - struct list_head *_tmp; 124 124 - 125 125 - rtnl_lock(); 126 126 - list_for_each_safe(list_node, _tmp, &chnl_net_list) { 127 127 - dev = list_entry(list_node, struct chnl_net, list_field); 128 128 - if (dev->state == CAIF_SHUTDOWN) 129 129 - dev_close(dev->netdev); 130 130 - } 131 131 - rtnl_unlock(); 132 132 - } 133 133 - static DECLARE_WORK(close_worker, close_work); 134 134 - 135 135 - static void chnl_hold(struct cflayer *lyr) 136 136 - { 137 137 - struct chnl_net *priv = container_of(lyr, struct chnl_net, chnl); 138 138 - dev_hold(priv->netdev); 139 139 - } 140 140 - 141 141 - static void chnl_put(struct cflayer *lyr) 142 142 - { 143 143 - struct chnl_net *priv = container_of(lyr, struct chnl_net, chnl); 144 144 - dev_put(priv->netdev); 145 145 - } 146 146 - 147 147 - static void chnl_flowctrl_cb(struct cflayer *layr, enum caif_ctrlcmd flow, 148 148 - int phyid) 149 149 - { 150 150 - struct chnl_net *priv = container_of(layr, struct chnl_net, chnl); 151 151 - pr_debug("NET flowctrl func called flow: %s\n", 152 152 - flow == CAIF_CTRLCMD_FLOW_ON_IND ? "ON" : 153 153 - flow == CAIF_CTRLCMD_INIT_RSP ? "INIT" : 154 154 - flow == CAIF_CTRLCMD_FLOW_OFF_IND ? "OFF" : 155 155 - flow == CAIF_CTRLCMD_DEINIT_RSP ? "CLOSE/DEINIT" : 156 156 - flow == CAIF_CTRLCMD_INIT_FAIL_RSP ? "OPEN_FAIL" : 157 157 - flow == CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND ? 158 158 - "REMOTE_SHUTDOWN" : "UNKNOWN CTRL COMMAND"); 159 159 - 160 160 - 161 161 - 162 162 - switch (flow) { 163 163 - case CAIF_CTRLCMD_FLOW_OFF_IND: 164 164 - priv->flowenabled = false; 165 165 - netif_stop_queue(priv->netdev); 166 166 - break; 167 167 - case CAIF_CTRLCMD_DEINIT_RSP: 168 168 - priv->state = CAIF_DISCONNECTED; 169 169 - break; 170 170 - case CAIF_CTRLCMD_INIT_FAIL_RSP: 171 171 - priv->state = CAIF_DISCONNECTED; 172 172 - wake_up_interruptible(&priv->netmgmt_wq); 173 173 - break; 174 174 - case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND: 175 175 - priv->state = CAIF_SHUTDOWN; 176 176 - netif_tx_disable(priv->netdev); 177 177 - schedule_work(&close_worker); 178 178 - break; 179 179 - case CAIF_CTRLCMD_FLOW_ON_IND: 180 180 - priv->flowenabled = true; 181 181 - netif_wake_queue(priv->netdev); 182 182 - break; 183 183 - case CAIF_CTRLCMD_INIT_RSP: 184 184 - caif_client_register_refcnt(&priv->chnl, chnl_hold, chnl_put); 185 185 - priv->state = CAIF_CONNECTED; 186 186 - priv->flowenabled = true; 187 187 - netif_wake_queue(priv->netdev); 188 188 - wake_up_interruptible(&priv->netmgmt_wq); 189 189 - break; 190 190 - default: 191 191 - break; 192 192 - } 193 193 - } 194 194 - 195 195 - static netdev_tx_t chnl_net_start_xmit(struct sk_buff *skb, 196 196 - struct net_device *dev) 197 197 - { 198 198 - struct chnl_net *priv; 199 199 - struct cfpkt *pkt = NULL; 200 200 - int len; 201 201 - int result = -1; 202 202 - /* Get our private data. */ 203 203 - priv = netdev_priv(dev); 204 204 - 205 205 - if (skb->len > priv->netdev->mtu) { 206 206 - pr_warn("Size of skb exceeded MTU\n"); 207 207 - kfree_skb(skb); 208 208 - dev->stats.tx_errors++; 209 209 - return NETDEV_TX_OK; 210 210 - } 211 211 - 212 212 - if (!priv->flowenabled) { 213 213 - pr_debug("dropping packets flow off\n"); 214 214 - kfree_skb(skb); 215 215 - dev->stats.tx_dropped++; 216 216 - return NETDEV_TX_OK; 217 217 - } 218 218 - 219 219 - if (priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP) 220 220 - swap(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr); 221 221 - 222 222 - /* Store original SKB length. */ 223 223 - len = skb->len; 224 224 - 225 225 - pkt = cfpkt_fromnative(CAIF_DIR_OUT, (void *) skb); 226 226 - 227 227 - /* Send the packet down the stack. */ 228 228 - result = priv->chnl.dn->transmit(priv->chnl.dn, pkt); 229 229 - if (result) { 230 230 - dev->stats.tx_dropped++; 231 231 - return NETDEV_TX_OK; 232 232 - } 233 233 - 234 234 - /* Update statistics. */ 235 235 - dev->stats.tx_packets++; 236 236 - dev->stats.tx_bytes += len; 237 237 - 238 238 - return NETDEV_TX_OK; 239 239 - } 240 240 - 241 241 - static int chnl_net_open(struct net_device *dev) 242 242 - { 243 243 - struct chnl_net *priv = NULL; 244 244 - int result = -1; 245 245 - int llifindex, headroom, tailroom, mtu; 246 246 - struct net_device *lldev; 247 247 - ASSERT_RTNL(); 248 248 - priv = netdev_priv(dev); 249 249 - if (!priv) { 250 250 - pr_debug("chnl_net_open: no priv\n"); 251 251 - return -ENODEV; 252 252 - } 253 253 - 254 254 - if (priv->state != CAIF_CONNECTING) { 255 255 - priv->state = CAIF_CONNECTING; 256 256 - result = caif_connect_client(dev_net(dev), &priv->conn_req, 257 257 - &priv->chnl, &llifindex, 258 258 - &headroom, &tailroom); 259 259 - if (result != 0) { 260 260 - pr_debug("err: " 261 261 - "Unable to register and open device," 262 262 - " Err:%d\n", 263 263 - result); 264 264 - goto error; 265 265 - } 266 266 - 267 267 - lldev = __dev_get_by_index(dev_net(dev), llifindex); 268 268 - 269 269 - if (lldev == NULL) { 270 270 - pr_debug("no interface?\n"); 271 271 - result = -ENODEV; 272 272 - goto error; 273 273 - } 274 274 - 275 275 - dev->needed_tailroom = tailroom + lldev->needed_tailroom; 276 276 - dev->hard_header_len = headroom + lldev->hard_header_len + 277 277 - lldev->needed_tailroom; 278 278 - 279 279 - /* 280 280 - * MTU, head-room etc is not know before we have a 281 281 - * CAIF link layer device available. MTU calculation may 282 282 - * override initial RTNL configuration. 283 283 - * MTU is minimum of current mtu, link layer mtu pluss 284 284 - * CAIF head and tail, and PDP GPRS contexts max MTU. 285 285 - */ 286 286 - mtu = min_t(int, dev->mtu, lldev->mtu - (headroom + tailroom)); 287 287 - mtu = min_t(int, GPRS_PDP_MTU, mtu); 288 288 - dev_set_mtu(dev, mtu); 289 289 - 290 290 - if (mtu < 100) { 291 291 - pr_warn("CAIF Interface MTU too small (%d)\n", mtu); 292 292 - result = -ENODEV; 293 293 - goto error; 294 294 - } 295 295 - } 296 296 - 297 297 - rtnl_unlock(); /* Release RTNL lock during connect wait */ 298 298 - 299 299 - result = wait_event_interruptible_timeout(priv->netmgmt_wq, 300 300 - priv->state != CAIF_CONNECTING, 301 301 - CONNECT_TIMEOUT); 302 302 - 303 303 - rtnl_lock(); 304 304 - 305 305 - if (result == -ERESTARTSYS) { 306 306 - pr_debug("wait_event_interruptible woken by a signal\n"); 307 307 - result = -ERESTARTSYS; 308 308 - goto error; 309 309 - } 310 310 - 311 311 - if (result == 0) { 312 312 - pr_debug("connect timeout\n"); 313 313 - result = -ETIMEDOUT; 314 314 - goto error; 315 315 - } 316 316 - 317 317 - if (priv->state != CAIF_CONNECTED) { 318 318 - pr_debug("connect failed\n"); 319 319 - result = -ECONNREFUSED; 320 320 - goto error; 321 321 - } 322 322 - pr_debug("CAIF Netdevice connected\n"); 323 323 - return 0; 324 324 - 325 325 - error: 326 326 - caif_disconnect_client(dev_net(dev), &priv->chnl); 327 327 - priv->state = CAIF_DISCONNECTED; 328 328 - pr_debug("state disconnected\n"); 329 329 - return result; 330 330 - 331 331 - } 332 332 - 333 333 - static int chnl_net_stop(struct net_device *dev) 334 334 - { 335 335 - struct chnl_net *priv; 336 336 - 337 337 - ASSERT_RTNL(); 338 338 - priv = netdev_priv(dev); 339 339 - priv->state = CAIF_DISCONNECTED; 340 340 - caif_disconnect_client(dev_net(dev), &priv->chnl); 341 341 - return 0; 342 342 - } 343 343 - 344 344 - static int chnl_net_init(struct net_device *dev) 345 345 - { 346 346 - struct chnl_net *priv; 347 347 - ASSERT_RTNL(); 348 348 - priv = netdev_priv(dev); 349 349 - INIT_LIST_HEAD(&priv->list_field); 350 350 - return 0; 351 351 - } 352 352 - 353 353 - static void chnl_net_uninit(struct net_device *dev) 354 354 - { 355 355 - struct chnl_net *priv; 356 356 - ASSERT_RTNL(); 357 357 - priv = netdev_priv(dev); 358 358 - list_del_init(&priv->list_field); 359 359 - } 360 360 - 361 361 - static const struct net_device_ops netdev_ops = { 362 362 - .ndo_open = chnl_net_open, 363 363 - .ndo_stop = chnl_net_stop, 364 364 - .ndo_init = chnl_net_init, 365 365 - .ndo_uninit = chnl_net_uninit, 366 366 - .ndo_start_xmit = chnl_net_start_xmit, 367 367 - }; 368 368 - 369 369 - static void chnl_net_destructor(struct net_device *dev) 370 370 - { 371 371 - struct chnl_net *priv = netdev_priv(dev); 372 372 - caif_free_client(&priv->chnl); 373 373 - } 374 374 - 375 375 - static void ipcaif_net_setup(struct net_device *dev) 376 376 - { 377 377 - struct chnl_net *priv; 378 378 - dev->netdev_ops = &netdev_ops; 379 379 - dev->needs_free_netdev = true; 380 380 - dev->priv_destructor = chnl_net_destructor; 381 381 - dev->flags |= IFF_NOARP; 382 382 - dev->flags |= IFF_POINTOPOINT; 383 383 - dev->mtu = GPRS_PDP_MTU; 384 384 - dev->tx_queue_len = CAIF_NET_DEFAULT_QUEUE_LEN; 385 385 - 386 386 - priv = netdev_priv(dev); 387 387 - priv->chnl.receive = chnl_recv_cb; 388 388 - priv->chnl.ctrlcmd = chnl_flowctrl_cb; 389 389 - priv->netdev = dev; 390 390 - priv->conn_req.protocol = CAIFPROTO_DATAGRAM; 391 391 - priv->conn_req.link_selector = CAIF_LINK_HIGH_BANDW; 392 392 - priv->conn_req.priority = CAIF_PRIO_LOW; 393 393 - /* Insert illegal value */ 394 394 - priv->conn_req.sockaddr.u.dgm.connection_id = UNDEF_CONNID; 395 395 - priv->flowenabled = false; 396 396 - 397 397 - init_waitqueue_head(&priv->netmgmt_wq); 398 398 - } 399 399 - 400 400 - 401 401 - static int ipcaif_fill_info(struct sk_buff *skb, const struct net_device *dev) 402 402 - { 403 403 - struct chnl_net *priv; 404 404 - u8 loop; 405 405 - priv = netdev_priv(dev); 406 406 - if (nla_put_u32(skb, IFLA_CAIF_IPV4_CONNID, 407 407 - priv->conn_req.sockaddr.u.dgm.connection_id) || 408 408 - nla_put_u32(skb, IFLA_CAIF_IPV6_CONNID, 409 409 - priv->conn_req.sockaddr.u.dgm.connection_id)) 410 410 - goto nla_put_failure; 411 411 - loop = priv->conn_req.protocol == CAIFPROTO_DATAGRAM_LOOP; 412 412 - if (nla_put_u8(skb, IFLA_CAIF_LOOPBACK, loop)) 413 413 - goto nla_put_failure; 414 414 - return 0; 415 415 - nla_put_failure: 416 416 - return -EMSGSIZE; 417 417 - 418 418 - } 419 419 - 420 420 - static void caif_netlink_parms(struct nlattr *data[], 421 421 - struct caif_connect_request *conn_req) 422 422 - { 423 423 - if (!data) { 424 424 - pr_warn("no params data found\n"); 425 425 - return; 426 426 - } 427 427 - if (data[IFLA_CAIF_IPV4_CONNID]) 428 428 - conn_req->sockaddr.u.dgm.connection_id = 429 429 - nla_get_u32(data[IFLA_CAIF_IPV4_CONNID]); 430 430 - if (data[IFLA_CAIF_IPV6_CONNID]) 431 431 - conn_req->sockaddr.u.dgm.connection_id = 432 432 - nla_get_u32(data[IFLA_CAIF_IPV6_CONNID]); 433 433 - if (data[IFLA_CAIF_LOOPBACK]) { 434 434 - if (nla_get_u8(data[IFLA_CAIF_LOOPBACK])) 435 435 - conn_req->protocol = CAIFPROTO_DATAGRAM_LOOP; 436 436 - else 437 437 - conn_req->protocol = CAIFPROTO_DATAGRAM; 438 438 - } 439 439 - } 440 440 - 441 441 - static int ipcaif_newlink(struct net_device *dev, 442 442 - struct rtnl_newlink_params *params, 443 443 - struct netlink_ext_ack *extack) 444 444 - { 445 445 - struct nlattr **data = params->data; 446 446 - int ret; 447 447 - struct chnl_net *caifdev; 448 448 - ASSERT_RTNL(); 449 449 - caifdev = netdev_priv(dev); 450 450 - caif_netlink_parms(data, &caifdev->conn_req); 451 451 - 452 452 - ret = register_netdevice(dev); 453 453 - if (ret) 454 454 - pr_warn("device rtml registration failed\n"); 455 455 - else 456 456 - list_add(&caifdev->list_field, &chnl_net_list); 457 457 - 458 458 - /* Use ifindex as connection id, and use loopback channel default. */ 459 459 - if (caifdev->conn_req.sockaddr.u.dgm.connection_id == UNDEF_CONNID) { 460 460 - caifdev->conn_req.sockaddr.u.dgm.connection_id = dev->ifindex; 461 461 - caifdev->conn_req.protocol = CAIFPROTO_DATAGRAM_LOOP; 462 462 - } 463 463 - return ret; 464 464 - } 465 465 - 466 466 - static int ipcaif_changelink(struct net_device *dev, struct nlattr *tb[], 467 467 - struct nlattr *data[], 468 468 - struct netlink_ext_ack *extack) 469 469 - { 470 470 - struct chnl_net *caifdev; 471 471 - ASSERT_RTNL(); 472 472 - caifdev = netdev_priv(dev); 473 473 - caif_netlink_parms(data, &caifdev->conn_req); 474 474 - netdev_state_change(dev); 475 475 - return 0; 476 476 - } 477 477 - 478 478 - static size_t ipcaif_get_size(const struct net_device *dev) 479 479 - { 480 480 - return 481 481 - /* IFLA_CAIF_IPV4_CONNID */ 482 482 - nla_total_size(4) + 483 483 - /* IFLA_CAIF_IPV6_CONNID */ 484 484 - nla_total_size(4) + 485 485 - /* IFLA_CAIF_LOOPBACK */ 486 486 - nla_total_size(2) + 487 487 - 0; 488 488 - } 489 489 - 490 490 - static const struct nla_policy ipcaif_policy[IFLA_CAIF_MAX + 1] = { 491 491 - [IFLA_CAIF_IPV4_CONNID] = { .type = NLA_U32 }, 492 492 - [IFLA_CAIF_IPV6_CONNID] = { .type = NLA_U32 }, 493 493 - [IFLA_CAIF_LOOPBACK] = { .type = NLA_U8 } 494 494 - }; 495 495 - 496 496 - 497 497 - static struct rtnl_link_ops ipcaif_link_ops __read_mostly = { 498 498 - .kind = "caif", 499 499 - .priv_size = sizeof(struct chnl_net), 500 500 - .setup = ipcaif_net_setup, 501 501 - .maxtype = IFLA_CAIF_MAX, 502 502 - .policy = ipcaif_policy, 503 503 - .newlink = ipcaif_newlink, 504 504 - .changelink = ipcaif_changelink, 505 505 - .get_size = ipcaif_get_size, 506 506 - .fill_info = ipcaif_fill_info, 507 507 - 508 508 - }; 509 509 - 510 510 - static int __init chnl_init_module(void) 511 511 - { 512 512 - return rtnl_link_register(&ipcaif_link_ops); 513 513 - } 514 514 - 515 515 - static void __exit chnl_exit_module(void) 516 516 - { 517 517 - struct chnl_net *dev = NULL; 518 518 - struct list_head *list_node; 519 519 - struct list_head *_tmp; 520 520 - rtnl_link_unregister(&ipcaif_link_ops); 521 521 - rtnl_lock(); 522 522 - list_for_each_safe(list_node, _tmp, &chnl_net_list) { 523 523 - dev = list_entry(list_node, struct chnl_net, list_field); 524 524 - list_del_init(list_node); 525 525 - delete_device(dev); 526 526 - } 527 527 - rtnl_unlock(); 528 528 - } 529 529 - 530 530 - module_init(chnl_init_module); 531 531 - module_exit(chnl_exit_module);