drivers/net/wwan/t7xx/t7xx_netdev.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2021, MediaTek Inc.
   4  * Copyright (c) 2021-2022, Intel Corporation.
   5  *
   6  * Authors:
   7  *  Chandrashekar Devegowda <chandrashekar.devegowda@intel.com>
   8  *  Haijun Liu <haijun.liu@mediatek.com>
   9  *  Ricardo Martinez <ricardo.martinez@linux.intel.com>
  10  *
  11  * Contributors:
  12  *  Amir Hanania <amir.hanania@intel.com>
  13  *  Andy Shevchenko <andriy.shevchenko@linux.intel.com>
  14  *  Chiranjeevi Rapolu <chiranjeevi.rapolu@intel.com>
  15  *  Eliot Lee <eliot.lee@intel.com>
  16  *  Moises Veleta <moises.veleta@intel.com>
  17  *  Sreehari Kancharla <sreehari.kancharla@intel.com>
  18  */
  19
  20 #include <linux/atomic.h>
  21 #include <linux/device.h>
  22 #include <linux/gfp.h>
  23 #include <linux/if_arp.h>
  24 #include <linux/if_ether.h>
  25 #include <linux/ip.h>
  26 #include <linux/kernel.h>
  27 #include <linux/list.h>
  28 #include <linux/netdev_features.h>
  29 #include <linux/netdevice.h>
  30 #include <linux/pm_runtime.h>
  31 #include <linux/skbuff.h>
  32 #include <linux/types.h>
  33 #include <linux/wwan.h>
  34 #include <net/ipv6.h>
  35 #include <net/pkt_sched.h>
  36
  37 #include "t7xx_hif_dpmaif_rx.h"
  38 #include "t7xx_hif_dpmaif_tx.h"
  39 #include "t7xx_netdev.h"
  40 #include "t7xx_pci.h"
  41 #include "t7xx_port_proxy.h"
  42 #include "t7xx_state_monitor.h"
  43
  44 #define IP_MUX_SESSION_DEFAULT  0
  45 #define SBD_PACKET_TYPE_MASK    GENMASK(7, 4)
  46
  47 static void t7xx_ccmni_enable_napi(struct t7xx_ccmni_ctrl *ctlb)
  48 {
  49         struct dpmaif_ctrl *ctrl;
  50         int i, ret;
  51
  52         ctrl =  ctlb->hif_ctrl;
  53
  54         if (ctlb->is_napi_en)
  55                 return;
  56
  57         for (i = 0; i < RXQ_NUM; i++) {
  58                 /* The usage count has to be bumped every time before calling
  59                  * napi_schedule. It will be decresed in the poll routine,
  60                  * right after napi_complete_done is called.
  61                  */
  62                 ret = pm_runtime_resume_and_get(ctrl->dev);
  63                 if (ret < 0) {
  64                         dev_err(ctrl->dev, "Failed to resume device: %d\n",
  65                                 ret);
  66                         return;
  67                 }
  68                 napi_enable(ctlb->napi[i]);
  69                 napi_schedule(ctlb->napi[i]);
  70         }
  71         ctlb->is_napi_en = true;
  72 }
  73
  74 static void t7xx_ccmni_disable_napi(struct t7xx_ccmni_ctrl *ctlb)
  75 {
  76         int i;
  77
  78         if (!ctlb->is_napi_en)
  79                 return;
  80
  81         for (i = 0; i < RXQ_NUM; i++) {
  82                 napi_synchronize(ctlb->napi[i]);
  83                 napi_disable(ctlb->napi[i]);
  84         }
  85
  86         ctlb->is_napi_en = false;
  87 }
  88
  89 static int t7xx_ccmni_open(struct net_device *dev)
  90 {
  91         struct t7xx_ccmni *ccmni = wwan_netdev_drvpriv(dev);
  92         struct t7xx_ccmni_ctrl *ccmni_ctl = ccmni->ctlb;
  93
  94         netif_carrier_on(dev);
  95         netif_tx_start_all_queues(dev);
  96         if (!atomic_fetch_inc(&ccmni_ctl->napi_usr_refcnt))
  97                 t7xx_ccmni_enable_napi(ccmni_ctl);
  98
  99         atomic_inc(&ccmni->usage);
 100         return 0;
 101 }
 102
 103 static int t7xx_ccmni_close(struct net_device *dev)
 104 {
 105         struct t7xx_ccmni *ccmni = wwan_netdev_drvpriv(dev);
 106         struct t7xx_ccmni_ctrl *ccmni_ctl = ccmni->ctlb;
 107
 108         atomic_dec(&ccmni->usage);
 109         if (atomic_dec_and_test(&ccmni_ctl->napi_usr_refcnt))
 110                 t7xx_ccmni_disable_napi(ccmni_ctl);
 111
 112         netif_carrier_off(dev);
 113         netif_tx_disable(dev);
 114         return 0;
 115 }
 116
 117 static int t7xx_ccmni_send_packet(struct t7xx_ccmni *ccmni, struct sk_buff *skb,
 118                                   unsigned int txq_number)
 119 {
 120         struct t7xx_ccmni_ctrl *ctlb = ccmni->ctlb;
 121         struct t7xx_skb_cb *skb_cb = T7XX_SKB_CB(skb);
 122
 123         skb_cb->netif_idx = ccmni->index;
 124
 125         if (t7xx_dpmaif_tx_send_skb(ctlb->hif_ctrl, txq_number, skb))
 126                 return NETDEV_TX_BUSY;
 127
 128         return 0;
 129 }
 130
 131 static netdev_tx_t t7xx_ccmni_start_xmit(struct sk_buff *skb, struct net_device *dev)
 132 {
 133         struct t7xx_ccmni *ccmni = wwan_netdev_drvpriv(dev);
 134         int skb_len = skb->len;
 135
 136         /* If MTU is changed or there is no headroom, drop the packet */
 137         if (skb->len > dev->mtu || skb_headroom(skb) < sizeof(struct ccci_header)) {
 138                 dev_kfree_skb(skb);
 139                 dev->stats.tx_dropped++;
 140                 return NETDEV_TX_OK;
 141         }
 142
 143         if (t7xx_ccmni_send_packet(ccmni, skb, DPMAIF_TX_DEFAULT_QUEUE))
 144                 return NETDEV_TX_BUSY;
 145
 146         dev->stats.tx_packets++;
 147         dev->stats.tx_bytes += skb_len;
 148
 149         return NETDEV_TX_OK;
 150 }
 151
 152 static void t7xx_ccmni_tx_timeout(struct net_device *dev, unsigned int __always_unused txqueue)
 153 {
 154         struct t7xx_ccmni *ccmni = netdev_priv(dev);
 155
 156         dev->stats.tx_errors++;
 157
 158         if (atomic_read(&ccmni->usage) > 0)
 159                 netif_tx_wake_all_queues(dev);
 160 }
 161
 162 static const struct net_device_ops ccmni_netdev_ops = {
 163         .ndo_open         = t7xx_ccmni_open,
 164         .ndo_stop         = t7xx_ccmni_close,
 165         .ndo_start_xmit   = t7xx_ccmni_start_xmit,
 166         .ndo_tx_timeout   = t7xx_ccmni_tx_timeout,
 167 };
 168
 169 static void t7xx_ccmni_start(struct t7xx_ccmni_ctrl *ctlb)
 170 {
 171         struct t7xx_ccmni *ccmni;
 172         int i;
 173
 174         for (i = 0; i < ctlb->nic_dev_num; i++) {
 175                 ccmni = ctlb->ccmni_inst[i];
 176                 if (!ccmni)
 177                         continue;
 178
 179                 if (atomic_read(&ccmni->usage) > 0) {
 180                         netif_tx_start_all_queues(ccmni->dev);
 181                         netif_carrier_on(ccmni->dev);
 182                 }
 183         }
 184
 185         if (atomic_read(&ctlb->napi_usr_refcnt))
 186                 t7xx_ccmni_enable_napi(ctlb);
 187 }
 188
 189 static void t7xx_ccmni_pre_stop(struct t7xx_ccmni_ctrl *ctlb)
 190 {
 191         struct t7xx_ccmni *ccmni;
 192         int i;
 193
 194         for (i = 0; i < ctlb->nic_dev_num; i++) {
 195                 ccmni = ctlb->ccmni_inst[i];
 196                 if (!ccmni)
 197                         continue;
 198
 199                 if (atomic_read(&ccmni->usage) > 0)
 200                         netif_tx_disable(ccmni->dev);
 201         }
 202 }
 203
 204 static void t7xx_ccmni_post_stop(struct t7xx_ccmni_ctrl *ctlb)
 205 {
 206         struct t7xx_ccmni *ccmni;
 207         int i;
 208
 209         if (atomic_read(&ctlb->napi_usr_refcnt))
 210                 t7xx_ccmni_disable_napi(ctlb);
 211
 212         for (i = 0; i < ctlb->nic_dev_num; i++) {
 213                 ccmni = ctlb->ccmni_inst[i];
 214                 if (!ccmni)
 215                         continue;
 216
 217                 if (atomic_read(&ccmni->usage) > 0)
 218                         netif_carrier_off(ccmni->dev);
 219         }
 220 }
 221
 222 static void t7xx_ccmni_wwan_setup(struct net_device *dev)
 223 {
 224         dev->needed_headroom += sizeof(struct ccci_header);
 225
 226         dev->mtu = ETH_DATA_LEN;
 227         dev->max_mtu = CCMNI_MTU_MAX;
 228         BUILD_BUG_ON(CCMNI_MTU_MAX > DPMAIF_HW_MTU_SIZE);
 229
 230         dev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
 231         dev->watchdog_timeo = CCMNI_NETDEV_WDT_TO;
 232
 233         dev->flags = IFF_POINTOPOINT | IFF_NOARP;
 234
 235         dev->features = NETIF_F_VLAN_CHALLENGED;
 236
 237         dev->features |= NETIF_F_SG;
 238         dev->hw_features |= NETIF_F_SG;
 239
 240         dev->features |= NETIF_F_HW_CSUM;
 241         dev->hw_features |= NETIF_F_HW_CSUM;
 242
 243         dev->features |= NETIF_F_RXCSUM;
 244         dev->hw_features |= NETIF_F_RXCSUM;
 245
 246         dev->features |= NETIF_F_GRO;
 247         dev->hw_features |= NETIF_F_GRO;
 248
 249         dev->needs_free_netdev = true;
 250
 251         dev->type = ARPHRD_NONE;
 252
 253         dev->netdev_ops = &ccmni_netdev_ops;
 254 }
 255
 256 static void t7xx_init_netdev_napi(struct t7xx_ccmni_ctrl *ctlb)
 257 {
 258         int i;
 259
 260         /* one HW, but shared with multiple net devices,
 261          * so add a dummy device for NAPI.
 262          */
 263         init_dummy_netdev(&ctlb->dummy_dev);
 264         atomic_set(&ctlb->napi_usr_refcnt, 0);
 265         ctlb->is_napi_en = false;
 266
 267         for (i = 0; i < RXQ_NUM; i++) {
 268                 ctlb->napi[i] = &ctlb->hif_ctrl->rxq[i].napi;
 269                 netif_napi_add_weight(&ctlb->dummy_dev, ctlb->napi[i], t7xx_dpmaif_napi_rx_poll,
 270                                       NIC_NAPI_POLL_BUDGET);
 271         }
 272 }
 273
 274 static void t7xx_uninit_netdev_napi(struct t7xx_ccmni_ctrl *ctlb)
 275 {
 276         int i;
 277
 278         for (i = 0; i < RXQ_NUM; i++) {
 279                 netif_napi_del(ctlb->napi[i]);
 280                 ctlb->napi[i] = NULL;
 281         }
 282 }
 283
 284 static int t7xx_ccmni_wwan_newlink(void *ctxt, struct net_device *dev, u32 if_id,
 285                                    struct netlink_ext_ack *extack)
 286 {
 287         struct t7xx_ccmni_ctrl *ctlb = ctxt;
 288         struct t7xx_ccmni *ccmni;
 289         int ret;
 290
 291         if (if_id >= ARRAY_SIZE(ctlb->ccmni_inst))
 292                 return -EINVAL;
 293
 294         ccmni = wwan_netdev_drvpriv(dev);
 295         ccmni->index = if_id;
 296         ccmni->ctlb = ctlb;
 297         ccmni->dev = dev;
 298         atomic_set(&ccmni->usage, 0);
 299         ctlb->ccmni_inst[if_id] = ccmni;
 300
 301         ret = register_netdevice(dev);
 302         if (ret)
 303                 return ret;
 304
 305         netif_device_attach(dev);
 306         return 0;
 307 }
 308
 309 static void t7xx_ccmni_wwan_dellink(void *ctxt, struct net_device *dev, struct list_head *head)
 310 {
 311         struct t7xx_ccmni *ccmni = wwan_netdev_drvpriv(dev);
 312         struct t7xx_ccmni_ctrl *ctlb = ctxt;
 313         u8 if_id = ccmni->index;
 314
 315         if (if_id >= ARRAY_SIZE(ctlb->ccmni_inst))
 316                 return;
 317
 318         if (WARN_ON(ctlb->ccmni_inst[if_id] != ccmni))
 319                 return;
 320
 321         unregister_netdevice(dev);
 322 }
 323
 324 static const struct wwan_ops ccmni_wwan_ops = {
 325         .priv_size = sizeof(struct t7xx_ccmni),
 326         .setup     = t7xx_ccmni_wwan_setup,
 327         .newlink   = t7xx_ccmni_wwan_newlink,
 328         .dellink   = t7xx_ccmni_wwan_dellink,
 329 };
 330
 331 static int t7xx_ccmni_register_wwan(struct t7xx_ccmni_ctrl *ctlb)
 332 {
 333         struct device *dev = ctlb->hif_ctrl->dev;
 334         int ret;
 335
 336         if (ctlb->wwan_is_registered)
 337                 return 0;
 338
 339         /* WWAN core will create a netdev for the default IP MUX channel */
 340         ret = wwan_register_ops(dev, &ccmni_wwan_ops, ctlb, IP_MUX_SESSION_DEFAULT);
 341         if (ret < 0) {
 342                 dev_err(dev, "Unable to register WWAN ops, %d\n", ret);
 343                 return ret;
 344         }
 345
 346         ctlb->wwan_is_registered = true;
 347         return 0;
 348 }
 349
 350 static int t7xx_ccmni_md_state_callback(enum md_state state, void *para)
 351 {
 352         struct t7xx_ccmni_ctrl *ctlb = para;
 353         struct device *dev;
 354         int ret = 0;
 355
 356         dev = ctlb->hif_ctrl->dev;
 357         ctlb->md_sta = state;
 358
 359         switch (state) {
 360         case MD_STATE_READY:
 361                 ret = t7xx_ccmni_register_wwan(ctlb);
 362                 if (!ret)
 363                         t7xx_ccmni_start(ctlb);
 364                 break;
 365
 366         case MD_STATE_EXCEPTION:
 367         case MD_STATE_STOPPED:
 368                 t7xx_ccmni_pre_stop(ctlb);
 369
 370                 ret = t7xx_dpmaif_md_state_callback(ctlb->hif_ctrl, state);
 371                 if (ret < 0)
 372                         dev_err(dev, "DPMAIF md state callback err, state=%d\n", state);
 373
 374                 t7xx_ccmni_post_stop(ctlb);
 375                 break;
 376
 377         case MD_STATE_WAITING_FOR_HS1:
 378         case MD_STATE_WAITING_TO_STOP:
 379                 ret = t7xx_dpmaif_md_state_callback(ctlb->hif_ctrl, state);
 380                 if (ret < 0)
 381                         dev_err(dev, "DPMAIF md state callback err, state=%d\n", state);
 382
 383                 break;
 384
 385         default:
 386                 break;
 387         }
 388
 389         return ret;
 390 }
 391
 392 static void init_md_status_notifier(struct t7xx_pci_dev *t7xx_dev)
 393 {
 394         struct t7xx_ccmni_ctrl  *ctlb = t7xx_dev->ccmni_ctlb;
 395         struct t7xx_fsm_notifier *md_status_notifier;
 396
 397         md_status_notifier = &ctlb->md_status_notify;
 398         INIT_LIST_HEAD(&md_status_notifier->entry);
 399         md_status_notifier->notifier_fn = t7xx_ccmni_md_state_callback;
 400         md_status_notifier->data = ctlb;
 401
 402         t7xx_fsm_notifier_register(t7xx_dev->md, md_status_notifier);
 403 }
 404
 405 static void t7xx_ccmni_recv_skb(struct t7xx_ccmni_ctrl *ccmni_ctlb, struct sk_buff *skb,
 406                                 struct napi_struct *napi)
 407 {
 408         struct t7xx_skb_cb *skb_cb;
 409         struct net_device *net_dev;
 410         struct t7xx_ccmni *ccmni;
 411         int pkt_type, skb_len;
 412         u8 netif_id;
 413
 414         skb_cb = T7XX_SKB_CB(skb);
 415         netif_id = skb_cb->netif_idx;
 416         ccmni = ccmni_ctlb->ccmni_inst[netif_id];
 417         if (!ccmni) {
 418                 dev_kfree_skb(skb);
 419                 return;
 420         }
 421
 422         net_dev = ccmni->dev;
 423         pkt_type = skb_cb->rx_pkt_type;
 424         skb->dev = net_dev;
 425         if (pkt_type == PKT_TYPE_IP6)
 426                 skb->protocol = htons(ETH_P_IPV6);
 427         else
 428                 skb->protocol = htons(ETH_P_IP);
 429
 430         skb_len = skb->len;
 431         napi_gro_receive(napi, skb);
 432         net_dev->stats.rx_packets++;
 433         net_dev->stats.rx_bytes += skb_len;
 434 }
 435
 436 static void t7xx_ccmni_queue_tx_irq_notify(struct t7xx_ccmni_ctrl *ctlb, int qno)
 437 {
 438         struct t7xx_ccmni *ccmni = ctlb->ccmni_inst[0];
 439         struct netdev_queue *net_queue;
 440
 441         if (netif_running(ccmni->dev) && atomic_read(&ccmni->usage) > 0) {
 442                 net_queue = netdev_get_tx_queue(ccmni->dev, qno);
 443                 if (netif_tx_queue_stopped(net_queue))
 444                         netif_tx_wake_queue(net_queue);
 445         }
 446 }
 447
 448 static void t7xx_ccmni_queue_tx_full_notify(struct t7xx_ccmni_ctrl *ctlb, int qno)
 449 {
 450         struct t7xx_ccmni *ccmni = ctlb->ccmni_inst[0];
 451         struct netdev_queue *net_queue;
 452
 453         if (atomic_read(&ccmni->usage) > 0) {
 454                 netdev_err(ccmni->dev, "TX queue %d is full\n", qno);
 455                 net_queue = netdev_get_tx_queue(ccmni->dev, qno);
 456                 netif_tx_stop_queue(net_queue);
 457         }
 458 }
 459
 460 static void t7xx_ccmni_queue_state_notify(struct t7xx_pci_dev *t7xx_dev,
 461                                           enum dpmaif_txq_state state, int qno)
 462 {
 463         struct t7xx_ccmni_ctrl *ctlb = t7xx_dev->ccmni_ctlb;
 464
 465         if (ctlb->md_sta != MD_STATE_READY)
 466                 return;
 467
 468         if (!ctlb->ccmni_inst[0]) {
 469                 dev_warn(&t7xx_dev->pdev->dev, "No netdev registered yet\n");
 470                 return;
 471         }
 472
 473         if (state == DMPAIF_TXQ_STATE_IRQ)
 474                 t7xx_ccmni_queue_tx_irq_notify(ctlb, qno);
 475         else if (state == DMPAIF_TXQ_STATE_FULL)
 476                 t7xx_ccmni_queue_tx_full_notify(ctlb, qno);
 477 }
 478
 479 int t7xx_ccmni_init(struct t7xx_pci_dev *t7xx_dev)
 480 {
 481         struct device *dev = &t7xx_dev->pdev->dev;
 482         struct t7xx_ccmni_ctrl *ctlb;
 483
 484         ctlb = devm_kzalloc(dev, sizeof(*ctlb), GFP_KERNEL);
 485         if (!ctlb)
 486                 return -ENOMEM;
 487
 488         t7xx_dev->ccmni_ctlb = ctlb;
 489         ctlb->t7xx_dev = t7xx_dev;
 490         ctlb->callbacks.state_notify = t7xx_ccmni_queue_state_notify;
 491         ctlb->callbacks.recv_skb = t7xx_ccmni_recv_skb;
 492         ctlb->nic_dev_num = NIC_DEV_DEFAULT;
 493
 494         ctlb->hif_ctrl = t7xx_dpmaif_hif_init(t7xx_dev, &ctlb->callbacks);
 495         if (!ctlb->hif_ctrl)
 496                 return -ENOMEM;
 497
 498         t7xx_init_netdev_napi(ctlb);
 499         init_md_status_notifier(t7xx_dev);
 500         return 0;
 501 }
 502
 503 void t7xx_ccmni_exit(struct t7xx_pci_dev *t7xx_dev)
 504 {
 505         struct t7xx_ccmni_ctrl *ctlb = t7xx_dev->ccmni_ctlb;
 506
 507         t7xx_fsm_notifier_unregister(t7xx_dev->md, &ctlb->md_status_notify);
 508
 509         if (ctlb->wwan_is_registered) {
 510                 wwan_unregister_ops(&t7xx_dev->pdev->dev);
 511                 ctlb->wwan_is_registered = false;
 512         }
 513
 514         t7xx_uninit_netdev_napi(ctlb);
 515         t7xx_dpmaif_hif_exit(ctlb->hif_ctrl);
 516 }