2 * Copyright (C) ST-Ericsson AB 2010
3 * Author: Sjur Brendeland
4 * License terms: GNU General Public License (GPL) version 2
7 #include <linux/hardirq.h>
8 #include <linux/init.h>
9 #include <linux/module.h>
10 #include <linux/device.h>
11 #include <linux/types.h>
12 #include <linux/skbuff.h>
13 #include <linux/netdevice.h>
14 #include <linux/rtnetlink.h>
15 #include <linux/tty.h>
16 #include <linux/file.h>
17 #include <linux/if_arp.h>
18 #include <net/caif/caif_device.h>
19 #include <net/caif/cfcnfg.h>
20 #include <linux/err.h>
21 #include <linux/debugfs.h>
23 MODULE_LICENSE("GPL");
24 MODULE_AUTHOR("Sjur Brendeland");
25 MODULE_DESCRIPTION("CAIF serial device TTY line discipline");
26 MODULE_LICENSE("GPL");
27 MODULE_ALIAS_LDISC(N_CAIF
);
29 #define SEND_QUEUE_LOW 10
30 #define SEND_QUEUE_HIGH 100
31 #define CAIF_SENDING 1 /* Bit 1 = 0x02*/
32 #define CAIF_FLOW_OFF_SENT 4 /* Bit 4 = 0x10 */
33 #define MAX_WRITE_CHUNK 4096
36 #define CAIF_MAX_MTU 4096
38 /*This list is protected by the rtnl lock. */
39 static LIST_HEAD(ser_list
);
42 module_param(ser_loop
, bool, S_IRUGO
);
43 MODULE_PARM_DESC(ser_loop
, "Run in simulated loopback mode.");
45 static bool ser_use_stx
= true;
46 module_param(ser_use_stx
, bool, S_IRUGO
);
47 MODULE_PARM_DESC(ser_use_stx
, "STX enabled or not.");
49 static bool ser_use_fcs
= true;
51 module_param(ser_use_fcs
, bool, S_IRUGO
);
52 MODULE_PARM_DESC(ser_use_fcs
, "FCS enabled or not.");
54 static int ser_write_chunk
= MAX_WRITE_CHUNK
;
55 module_param(ser_write_chunk
, int, S_IRUGO
);
57 MODULE_PARM_DESC(ser_write_chunk
, "Maximum size of data written to UART.");
59 static struct dentry
*debugfsdir
;
61 static int caif_net_open(struct net_device
*dev
);
62 static int caif_net_close(struct net_device
*dev
);
65 struct caif_dev_common common
;
66 struct list_head node
;
67 struct net_device
*dev
;
68 struct sk_buff_head head
;
69 struct tty_struct
*tty
;
73 #ifdef CONFIG_DEBUG_FS
74 struct dentry
*debugfs_tty_dir
;
75 struct debugfs_blob_wrapper tx_blob
;
76 struct debugfs_blob_wrapper rx_blob
;
84 static void caifdev_setup(struct net_device
*dev
);
85 static void ldisc_tx_wakeup(struct tty_struct
*tty
);
86 #ifdef CONFIG_DEBUG_FS
87 static inline void update_tty_status(struct ser_device
*ser
)
90 ser
->tty
->stopped
<< 5 |
91 ser
->tty
->flow_stopped
<< 3 |
92 ser
->tty
->packet
<< 2 |
93 ser
->tty
->port
->low_latency
<< 1;
95 static inline void debugfs_init(struct ser_device
*ser
, struct tty_struct
*tty
)
97 ser
->debugfs_tty_dir
=
98 debugfs_create_dir(tty
->name
, debugfsdir
);
99 if (!IS_ERR(ser
->debugfs_tty_dir
)) {
100 debugfs_create_blob("last_tx_msg", S_IRUSR
,
101 ser
->debugfs_tty_dir
,
104 debugfs_create_blob("last_rx_msg", S_IRUSR
,
105 ser
->debugfs_tty_dir
,
108 debugfs_create_x32("ser_state", S_IRUSR
,
109 ser
->debugfs_tty_dir
,
112 debugfs_create_x8("tty_status", S_IRUSR
,
113 ser
->debugfs_tty_dir
,
117 ser
->tx_blob
.data
= ser
->tx_data
;
118 ser
->tx_blob
.size
= 0;
119 ser
->rx_blob
.data
= ser
->rx_data
;
120 ser
->rx_blob
.size
= 0;
123 static inline void debugfs_deinit(struct ser_device
*ser
)
125 debugfs_remove_recursive(ser
->debugfs_tty_dir
);
128 static inline void debugfs_rx(struct ser_device
*ser
, const u8
*data
, int size
)
130 if (size
> sizeof(ser
->rx_data
))
131 size
= sizeof(ser
->rx_data
);
132 memcpy(ser
->rx_data
, data
, size
);
133 ser
->rx_blob
.data
= ser
->rx_data
;
134 ser
->rx_blob
.size
= size
;
137 static inline void debugfs_tx(struct ser_device
*ser
, const u8
*data
, int size
)
139 if (size
> sizeof(ser
->tx_data
))
140 size
= sizeof(ser
->tx_data
);
141 memcpy(ser
->tx_data
, data
, size
);
142 ser
->tx_blob
.data
= ser
->tx_data
;
143 ser
->tx_blob
.size
= size
;
146 static inline void debugfs_init(struct ser_device
*ser
, struct tty_struct
*tty
)
150 static inline void debugfs_deinit(struct ser_device
*ser
)
154 static inline void update_tty_status(struct ser_device
*ser
)
158 static inline void debugfs_rx(struct ser_device
*ser
, const u8
*data
, int size
)
162 static inline void debugfs_tx(struct ser_device
*ser
, const u8
*data
, int size
)
168 static void ldisc_receive(struct tty_struct
*tty
, const u8
*data
,
169 char *flags
, int count
)
171 struct sk_buff
*skb
= NULL
;
172 struct ser_device
*ser
;
176 ser
= tty
->disc_data
;
179 * NOTE: flags may contain information about break or overrun.
180 * This is not yet handled.
185 * Workaround for garbage at start of transmission,
186 * only enable if STX handling is not enabled.
188 if (!ser
->common
.use_stx
&& !ser
->tx_started
) {
189 dev_info(&ser
->dev
->dev
,
190 "Bytes received before initial transmission -"
191 "bytes discarded.\n");
195 BUG_ON(ser
->dev
== NULL
);
197 /* Get a suitable caif packet and copy in data. */
198 skb
= netdev_alloc_skb(ser
->dev
, count
+1);
201 p
= skb_put(skb
, count
);
202 memcpy(p
, data
, count
);
204 skb
->protocol
= htons(ETH_P_CAIF
);
205 skb_reset_mac_header(skb
);
207 debugfs_rx(ser
, data
, count
);
208 /* Push received packet up the stack. */
209 ret
= netif_rx_ni(skb
);
211 ser
->dev
->stats
.rx_packets
++;
212 ser
->dev
->stats
.rx_bytes
+= count
;
214 ++ser
->dev
->stats
.rx_dropped
;
215 update_tty_status(ser
);
218 static int handle_tx(struct ser_device
*ser
)
220 struct tty_struct
*tty
;
222 int tty_wr
, len
, room
;
225 ser
->tx_started
= true;
227 /* Enter critical section */
228 if (test_and_set_bit(CAIF_SENDING
, &ser
->state
))
231 /* skb_peek is safe because handle_tx is called after skb_queue_tail */
232 while ((skb
= skb_peek(&ser
->head
)) != NULL
) {
234 /* Make sure you don't write too much */
236 room
= tty_write_room(tty
);
239 if (room
> ser_write_chunk
)
240 room
= ser_write_chunk
;
244 /* Write to tty or loopback */
246 tty_wr
= tty
->ops
->write(tty
, skb
->data
, len
);
247 update_tty_status(ser
);
250 ldisc_receive(tty
, skb
->data
, NULL
, len
);
252 ser
->dev
->stats
.tx_packets
++;
253 ser
->dev
->stats
.tx_bytes
+= tty_wr
;
255 /* Error on TTY ?! */
258 /* Reduce buffer written, and discard if empty */
259 skb_pull(skb
, tty_wr
);
261 struct sk_buff
*tmp
= skb_dequeue(&ser
->head
);
264 dev_kfree_skb_irq(skb
);
269 /* Send flow off if queue is empty */
270 if (ser
->head
.qlen
<= SEND_QUEUE_LOW
&&
271 test_and_clear_bit(CAIF_FLOW_OFF_SENT
, &ser
->state
) &&
272 ser
->common
.flowctrl
!= NULL
)
273 ser
->common
.flowctrl(ser
->dev
, ON
);
274 clear_bit(CAIF_SENDING
, &ser
->state
);
277 clear_bit(CAIF_SENDING
, &ser
->state
);
281 static int caif_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
283 struct ser_device
*ser
;
286 ser
= netdev_priv(dev
);
288 /* Send flow off once, on high water mark */
289 if (ser
->head
.qlen
> SEND_QUEUE_HIGH
&&
290 !test_and_set_bit(CAIF_FLOW_OFF_SENT
, &ser
->state
) &&
291 ser
->common
.flowctrl
!= NULL
)
293 ser
->common
.flowctrl(ser
->dev
, OFF
);
295 skb_queue_tail(&ser
->head
, skb
);
296 return handle_tx(ser
);
300 static void ldisc_tx_wakeup(struct tty_struct
*tty
)
302 struct ser_device
*ser
;
304 ser
= tty
->disc_data
;
306 WARN_ON(ser
->tty
!= tty
);
311 static int ldisc_open(struct tty_struct
*tty
)
313 struct ser_device
*ser
;
314 struct net_device
*dev
;
318 /* No write no play */
319 if (tty
->ops
->write
== NULL
)
321 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_TTY_CONFIG
))
324 sprintf(name
, "cf%s", tty
->name
);
325 dev
= alloc_netdev(sizeof(*ser
), name
, caifdev_setup
);
329 ser
= netdev_priv(dev
);
330 ser
->tty
= tty_kref_get(tty
);
332 debugfs_init(ser
, tty
);
333 tty
->receive_room
= N_TTY_BUF_SIZE
;
334 tty
->disc_data
= ser
;
335 set_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
337 result
= register_netdevice(dev
);
344 list_add(&ser
->node
, &ser_list
);
346 netif_stop_queue(dev
);
347 update_tty_status(ser
);
351 static void ldisc_close(struct tty_struct
*tty
)
353 struct ser_device
*ser
= tty
->disc_data
;
354 /* Remove may be called inside or outside of rtnl_lock */
355 int islocked
= rtnl_is_locked();
359 /* device is freed automagically by net-sysfs */
361 unregister_netdevice(ser
->dev
);
362 list_del(&ser
->node
);
364 tty_kref_put(ser
->tty
);
369 /* The line discipline structure. */
370 static struct tty_ldisc_ops caif_ldisc
= {
371 .owner
= THIS_MODULE
,
372 .magic
= TTY_LDISC_MAGIC
,
375 .close
= ldisc_close
,
376 .receive_buf
= ldisc_receive
,
377 .write_wakeup
= ldisc_tx_wakeup
380 static int register_ldisc(void)
384 result
= tty_register_ldisc(N_CAIF
, &caif_ldisc
);
386 pr_err("cannot register CAIF ldisc=%d err=%d\n", N_CAIF
,
392 static const struct net_device_ops netdev_ops
= {
393 .ndo_open
= caif_net_open
,
394 .ndo_stop
= caif_net_close
,
395 .ndo_start_xmit
= caif_xmit
398 static void caifdev_setup(struct net_device
*dev
)
400 struct ser_device
*serdev
= netdev_priv(dev
);
403 dev
->netdev_ops
= &netdev_ops
;
404 dev
->type
= ARPHRD_CAIF
;
405 dev
->flags
= IFF_POINTOPOINT
| IFF_NOARP
;
406 dev
->mtu
= CAIF_MAX_MTU
;
407 dev
->tx_queue_len
= 0;
408 dev
->destructor
= free_netdev
;
409 skb_queue_head_init(&serdev
->head
);
410 serdev
->common
.link_select
= CAIF_LINK_LOW_LATENCY
;
411 serdev
->common
.use_frag
= true;
412 serdev
->common
.use_stx
= ser_use_stx
;
413 serdev
->common
.use_fcs
= ser_use_fcs
;
418 static int caif_net_open(struct net_device
*dev
)
420 netif_wake_queue(dev
);
424 static int caif_net_close(struct net_device
*dev
)
426 netif_stop_queue(dev
);
430 static int __init
caif_ser_init(void)
434 ret
= register_ldisc();
435 debugfsdir
= debugfs_create_dir("caif_serial", NULL
);
439 static void __exit
caif_ser_exit(void)
441 struct ser_device
*ser
= NULL
;
442 struct list_head
*node
;
443 struct list_head
*_tmp
;
445 list_for_each_safe(node
, _tmp
, &ser_list
) {
446 ser
= list_entry(node
, struct ser_device
, node
);
448 unregister_netdevice(ser
->dev
);
451 tty_unregister_ldisc(N_CAIF
);
452 debugfs_remove_recursive(debugfsdir
);
455 module_init(caif_ser_init
);
456 module_exit(caif_ser_exit
);