1 /* 2 * Copyright (c) 2011, 2012, Qualcomm Atheros Communications Inc. 3 * Copyright (c) 2017, I2SE GmbH 4 * 5 * Permission to use, copy, modify, and/or distribute this software 6 * for any purpose with or without fee is hereby granted, provided 7 * that the above copyright notice and this permission notice appear 8 * in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL 13 * THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR 14 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 15 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 16 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 17 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /* This module implements the Qualcomm Atheros UART protocol for 21 * kernel-based UART device; it is essentially an Ethernet-to-UART 22 * serial converter; 23 */ 24 25 #include <linux/device.h> 26 #include <linux/errno.h> 27 #include <linux/etherdevice.h> 28 #include <linux/if_arp.h> 29 #include <linux/if_ether.h> 30 #include <linux/jiffies.h> 31 #include <linux/kernel.h> 32 #include <linux/module.h> 33 #include <linux/netdevice.h> 34 #include <linux/of.h> 35 #include <linux/of_net.h> 36 #include <linux/sched.h> 37 #include <linux/serdev.h> 38 #include <linux/skbuff.h> 39 #include <linux/types.h> 40 41 #include "qca_7k_common.h" 42 43 #define QCAUART_DRV_VERSION "0.1.0" 44 #define QCAUART_DRV_NAME "qcauart" 45 #define QCAUART_TX_TIMEOUT (1 * HZ) 46 47 struct qcauart { 48 struct net_device *net_dev; 49 spinlock_t lock; /* transmit lock */ 50 struct work_struct tx_work; /* Flushes transmit buffer */ 51 52 struct serdev_device *serdev; 53 struct qcafrm_handle frm_handle; 54 struct sk_buff *rx_skb; 55 56 unsigned char *tx_head; /* pointer to next XMIT byte */ 57 int tx_left; /* bytes left in XMIT queue */ 58 unsigned char *tx_buffer; 59 }; 60 61 static ssize_t 62 qca_tty_receive(struct serdev_device *serdev, const u8 *data, size_t count) 63 { 64 struct qcauart *qca = serdev_device_get_drvdata(serdev); 65 struct net_device *netdev = qca->net_dev; 66 struct net_device_stats *n_stats = &netdev->stats; 67 size_t i; 68 69 if (!qca->rx_skb) { 70 qca->rx_skb = netdev_alloc_skb_ip_align(netdev, 71 netdev->mtu + 72 VLAN_ETH_HLEN); 73 if (!qca->rx_skb) { 74 n_stats->rx_errors++; 75 n_stats->rx_dropped++; 76 return 0; 77 } 78 } 79 80 for (i = 0; i < count; i++) { 81 s32 retcode; 82 83 retcode = qcafrm_fsm_decode(&qca->frm_handle, 84 qca->rx_skb->data, 85 skb_tailroom(qca->rx_skb), 86 data[i]); 87 88 switch (retcode) { 89 case QCAFRM_GATHER: 90 case QCAFRM_NOHEAD: 91 break; 92 case QCAFRM_NOTAIL: 93 netdev_dbg(netdev, "recv: no RX tail\n"); 94 n_stats->rx_errors++; 95 n_stats->rx_dropped++; 96 break; 97 case QCAFRM_INVLEN: 98 netdev_dbg(netdev, "recv: invalid RX length\n"); 99 n_stats->rx_errors++; 100 n_stats->rx_dropped++; 101 break; 102 default: 103 n_stats->rx_packets++; 104 n_stats->rx_bytes += retcode; 105 skb_put(qca->rx_skb, retcode); 106 qca->rx_skb->protocol = eth_type_trans( 107 qca->rx_skb, qca->rx_skb->dev); 108 skb_checksum_none_assert(qca->rx_skb); 109 netif_rx(qca->rx_skb); 110 qca->rx_skb = netdev_alloc_skb_ip_align(netdev, 111 netdev->mtu + 112 VLAN_ETH_HLEN); 113 if (!qca->rx_skb) { 114 netdev_dbg(netdev, "recv: out of RX resources\n"); 115 n_stats->rx_errors++; 116 return i; 117 } 118 } 119 } 120 121 return i; 122 } 123 124 /* Write out any remaining transmit buffer. Scheduled when tty is writable */ 125 static void qcauart_transmit(struct work_struct *work) 126 { 127 struct qcauart *qca = container_of(work, struct qcauart, tx_work); 128 struct net_device_stats *n_stats = &qca->net_dev->stats; 129 int written; 130 131 spin_lock_bh(&qca->lock); 132 133 /* First make sure we're connected. */ 134 if (!netif_running(qca->net_dev)) { 135 spin_unlock_bh(&qca->lock); 136 return; 137 } 138 139 if (qca->tx_left <= 0) { 140 /* Now serial buffer is almost free & we can start 141 * transmission of another packet 142 */ 143 n_stats->tx_packets++; 144 spin_unlock_bh(&qca->lock); 145 netif_wake_queue(qca->net_dev); 146 return; 147 } 148 149 written = serdev_device_write_buf(qca->serdev, qca->tx_head, 150 qca->tx_left); 151 if (written > 0) { 152 qca->tx_left -= written; 153 qca->tx_head += written; 154 } 155 spin_unlock_bh(&qca->lock); 156 } 157 158 /* Called by the driver when there's room for more data. 159 * Schedule the transmit. 160 */ 161 static void qca_tty_wakeup(struct serdev_device *serdev) 162 { 163 struct qcauart *qca = serdev_device_get_drvdata(serdev); 164 165 schedule_work(&qca->tx_work); 166 } 167 168 static const struct serdev_device_ops qca_serdev_ops = { 169 .receive_buf = qca_tty_receive, 170 .write_wakeup = qca_tty_wakeup, 171 }; 172 173 static int qcauart_netdev_open(struct net_device *dev) 174 { 175 struct qcauart *qca = netdev_priv(dev); 176 177 netif_start_queue(qca->net_dev); 178 179 return 0; 180 } 181 182 static int qcauart_netdev_close(struct net_device *dev) 183 { 184 struct qcauart *qca = netdev_priv(dev); 185 186 netif_stop_queue(dev); 187 flush_work(&qca->tx_work); 188 189 spin_lock_bh(&qca->lock); 190 qca->tx_left = 0; 191 spin_unlock_bh(&qca->lock); 192 193 return 0; 194 } 195 196 static netdev_tx_t 197 qcauart_netdev_xmit(struct sk_buff *skb, struct net_device *dev) 198 { 199 struct net_device_stats *n_stats = &dev->stats; 200 struct qcauart *qca = netdev_priv(dev); 201 u8 pad_len = 0; 202 int written; 203 u8 *pos; 204 205 spin_lock(&qca->lock); 206 207 WARN_ON(qca->tx_left); 208 209 if (!netif_running(dev)) { 210 spin_unlock(&qca->lock); 211 netdev_warn(qca->net_dev, "xmit: iface is down\n"); 212 goto out; 213 } 214 215 pos = qca->tx_buffer; 216 217 if (skb->len < QCAFRM_MIN_LEN) 218 pad_len = QCAFRM_MIN_LEN - skb->len; 219 220 pos += qcafrm_create_header(pos, skb->len + pad_len); 221 222 memcpy(pos, skb->data, skb->len); 223 pos += skb->len; 224 225 if (pad_len) { 226 memset(pos, 0, pad_len); 227 pos += pad_len; 228 } 229 230 pos += qcafrm_create_footer(pos); 231 232 netif_stop_queue(qca->net_dev); 233 234 written = serdev_device_write_buf(qca->serdev, qca->tx_buffer, 235 pos - qca->tx_buffer); 236 if (written > 0) { 237 qca->tx_left = (pos - qca->tx_buffer) - written; 238 qca->tx_head = qca->tx_buffer + written; 239 n_stats->tx_bytes += written; 240 } 241 spin_unlock(&qca->lock); 242 243 netif_trans_update(dev); 244 out: 245 dev_kfree_skb_any(skb); 246 return NETDEV_TX_OK; 247 } 248 249 static void qcauart_netdev_tx_timeout(struct net_device *dev, unsigned int txqueue) 250 { 251 struct qcauart *qca = netdev_priv(dev); 252 253 netdev_info(qca->net_dev, "Transmit timeout at %ld, latency %ld\n", 254 jiffies, dev_trans_start(dev)); 255 dev->stats.tx_errors++; 256 dev->stats.tx_dropped++; 257 } 258 259 static int qcauart_netdev_init(struct net_device *dev) 260 { 261 struct qcauart *qca = netdev_priv(dev); 262 size_t len; 263 264 /* Finish setting up the device info. */ 265 dev->mtu = QCAFRM_MAX_MTU; 266 dev->type = ARPHRD_ETHER; 267 268 len = QCAFRM_HEADER_LEN + QCAFRM_MAX_LEN + QCAFRM_FOOTER_LEN; 269 qca->tx_buffer = devm_kmalloc(&qca->serdev->dev, len, GFP_KERNEL); 270 if (!qca->tx_buffer) 271 return -ENOMEM; 272 273 qca->rx_skb = netdev_alloc_skb_ip_align(qca->net_dev, 274 qca->net_dev->mtu + 275 VLAN_ETH_HLEN); 276 if (!qca->rx_skb) 277 return -ENOBUFS; 278 279 return 0; 280 } 281 282 static void qcauart_netdev_uninit(struct net_device *dev) 283 { 284 struct qcauart *qca = netdev_priv(dev); 285 286 dev_kfree_skb(qca->rx_skb); 287 } 288 289 static const struct net_device_ops qcauart_netdev_ops = { 290 .ndo_init = qcauart_netdev_init, 291 .ndo_uninit = qcauart_netdev_uninit, 292 .ndo_open = qcauart_netdev_open, 293 .ndo_stop = qcauart_netdev_close, 294 .ndo_start_xmit = qcauart_netdev_xmit, 295 .ndo_set_mac_address = eth_mac_addr, 296 .ndo_tx_timeout = qcauart_netdev_tx_timeout, 297 .ndo_validate_addr = eth_validate_addr, 298 }; 299 300 static void qcauart_netdev_setup(struct net_device *dev) 301 { 302 dev->netdev_ops = &qcauart_netdev_ops; 303 dev->watchdog_timeo = QCAUART_TX_TIMEOUT; 304 dev->priv_flags &= ~IFF_TX_SKB_SHARING; 305 dev->tx_queue_len = 100; 306 307 /* MTU range: 46 - 1500 */ 308 dev->min_mtu = QCAFRM_MIN_MTU; 309 dev->max_mtu = QCAFRM_MAX_MTU; 310 } 311 312 static const struct of_device_id qca_uart_of_match[] = { 313 { 314 .compatible = "qca,qca7000", 315 }, 316 {} 317 }; 318 MODULE_DEVICE_TABLE(of, qca_uart_of_match); 319 320 static int qca_uart_probe(struct serdev_device *serdev) 321 { 322 struct net_device *qcauart_dev = alloc_etherdev(sizeof(struct qcauart)); 323 struct qcauart *qca; 324 u32 speed = 115200; 325 int ret; 326 327 if (!qcauart_dev) 328 return -ENOMEM; 329 330 qcauart_netdev_setup(qcauart_dev); 331 SET_NETDEV_DEV(qcauart_dev, &serdev->dev); 332 333 qca = netdev_priv(qcauart_dev); 334 if (!qca) { 335 pr_err("qca_uart: Fail to retrieve private structure\n"); 336 ret = -ENOMEM; 337 goto free; 338 } 339 qca->net_dev = qcauart_dev; 340 qca->serdev = serdev; 341 qcafrm_fsm_init_uart(&qca->frm_handle); 342 343 spin_lock_init(&qca->lock); 344 INIT_WORK(&qca->tx_work, qcauart_transmit); 345 346 of_property_read_u32(serdev->dev.of_node, "current-speed", &speed); 347 348 ret = of_get_ethdev_address(serdev->dev.of_node, qca->net_dev); 349 if (ret) { 350 eth_hw_addr_random(qca->net_dev); 351 dev_info(&serdev->dev, "Using random MAC address: %pM\n", 352 qca->net_dev->dev_addr); 353 } 354 355 netif_carrier_on(qca->net_dev); 356 serdev_device_set_drvdata(serdev, qca); 357 serdev_device_set_client_ops(serdev, &qca_serdev_ops); 358 359 ret = serdev_device_open(serdev); 360 if (ret) { 361 dev_err(&serdev->dev, "Unable to open device %s\n", 362 qcauart_dev->name); 363 goto free; 364 } 365 366 speed = serdev_device_set_baudrate(serdev, speed); 367 dev_info(&serdev->dev, "Using baudrate: %u\n", speed); 368 369 serdev_device_set_flow_control(serdev, false); 370 371 ret = register_netdev(qcauart_dev); 372 if (ret) { 373 dev_err(&serdev->dev, "Unable to register net device %s\n", 374 qcauart_dev->name); 375 serdev_device_close(serdev); 376 cancel_work_sync(&qca->tx_work); 377 goto free; 378 } 379 380 return 0; 381 382 free: 383 free_netdev(qcauart_dev); 384 return ret; 385 } 386 387 static void qca_uart_remove(struct serdev_device *serdev) 388 { 389 struct qcauart *qca = serdev_device_get_drvdata(serdev); 390 391 unregister_netdev(qca->net_dev); 392 393 /* Flush any pending characters in the driver. */ 394 serdev_device_close(serdev); 395 cancel_work_sync(&qca->tx_work); 396 397 free_netdev(qca->net_dev); 398 } 399 400 static struct serdev_device_driver qca_uart_driver = { 401 .probe = qca_uart_probe, 402 .remove = qca_uart_remove, 403 .driver = { 404 .name = QCAUART_DRV_NAME, 405 .of_match_table = qca_uart_of_match, 406 }, 407 }; 408 409 module_serdev_device_driver(qca_uart_driver); 410 411 MODULE_DESCRIPTION("Qualcomm Atheros QCA7000 UART Driver"); 412 MODULE_AUTHOR("Qualcomm Atheros Communications"); 413 MODULE_AUTHOR("Stefan Wahren <stefan.wahren@i2se.com>"); 414 MODULE_LICENSE("Dual BSD/GPL"); 415 MODULE_VERSION(QCAUART_DRV_VERSION); 416