drivers/net/wwan/qcom_bam_dmux.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Qualcomm BAM-DMUX WWAN network driver
   4  * Copyright (c) 2020, Stephan Gerhold <[email protected]>
   5  */
   6
   7 #include <linux/atomic.h>
   8 #include <linux/bitops.h>
   9 #include <linux/completion.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/dmaengine.h>
  12 #include <linux/if_arp.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/mod_devicetable.h>
  15 #include <linux/module.h>
  16 #include <linux/netdevice.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/pm_runtime.h>
  19 #include <linux/soc/qcom/smem_state.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/wait.h>
  22 #include <linux/workqueue.h>
  23 #include <net/pkt_sched.h>
  24
  25 #define BAM_DMUX_BUFFER_SIZE            SZ_2K
  26 #define BAM_DMUX_HDR_SIZE               sizeof(struct bam_dmux_hdr)
  27 #define BAM_DMUX_MAX_DATA_SIZE          (BAM_DMUX_BUFFER_SIZE - BAM_DMUX_HDR_SIZE)
  28 #define BAM_DMUX_NUM_SKB                32
  29
  30 #define BAM_DMUX_HDR_MAGIC              0x33fc
  31
  32 #define BAM_DMUX_AUTOSUSPEND_DELAY      1000
  33 #define BAM_DMUX_REMOTE_TIMEOUT         msecs_to_jiffies(2000)
  34
  35 enum {
  36         BAM_DMUX_CMD_DATA,
  37         BAM_DMUX_CMD_OPEN,
  38         BAM_DMUX_CMD_CLOSE,
  39 };
  40
  41 enum {
  42         BAM_DMUX_CH_DATA_0,
  43         BAM_DMUX_CH_DATA_1,
  44         BAM_DMUX_CH_DATA_2,
  45         BAM_DMUX_CH_DATA_3,
  46         BAM_DMUX_CH_DATA_4,
  47         BAM_DMUX_CH_DATA_5,
  48         BAM_DMUX_CH_DATA_6,
  49         BAM_DMUX_CH_DATA_7,
  50         BAM_DMUX_NUM_CH
  51 };
  52
  53 struct bam_dmux_hdr {
  54         u16 magic;
  55         u8 signal;
  56         u8 cmd;
  57         u8 pad;
  58         u8 ch;
  59         u16 len;
  60 };
  61
  62 struct bam_dmux_skb_dma {
  63         struct bam_dmux *dmux;
  64         struct sk_buff *skb;
  65         dma_addr_t addr;
  66 };
  67
  68 struct bam_dmux {
  69         struct device *dev;
  70
  71         int pc_irq;
  72         bool pc_state, pc_ack_state;
  73         struct qcom_smem_state *pc, *pc_ack;
  74         u32 pc_mask, pc_ack_mask;
  75         wait_queue_head_t pc_wait;
  76         struct completion pc_ack_completion;
  77
  78         struct dma_chan *rx, *tx;
  79         struct bam_dmux_skb_dma rx_skbs[BAM_DMUX_NUM_SKB];
  80         struct bam_dmux_skb_dma tx_skbs[BAM_DMUX_NUM_SKB];
  81         spinlock_t tx_lock; /* Protect tx_skbs, tx_next_skb */
  82         unsigned int tx_next_skb;
  83         atomic_long_t tx_deferred_skb;
  84         struct work_struct tx_wakeup_work;
  85
  86         DECLARE_BITMAP(remote_channels, BAM_DMUX_NUM_CH);
  87         struct work_struct register_netdev_work;
  88         struct net_device *netdevs[BAM_DMUX_NUM_CH];
  89 };
  90
  91 struct bam_dmux_netdev {
  92         struct bam_dmux *dmux;
  93         u8 ch;
  94 };
  95
  96 static void bam_dmux_pc_vote(struct bam_dmux *dmux, bool enable)
  97 {
  98         reinit_completion(&dmux->pc_ack_completion);
  99         qcom_smem_state_update_bits(dmux->pc, dmux->pc_mask,
 100                                     enable ? dmux->pc_mask : 0);
 101 }
 102
 103 static void bam_dmux_pc_ack(struct bam_dmux *dmux)
 104 {
 105         qcom_smem_state_update_bits(dmux->pc_ack, dmux->pc_ack_mask,
 106                                     dmux->pc_ack_state ? 0 : dmux->pc_ack_mask);
 107         dmux->pc_ack_state = !dmux->pc_ack_state;
 108 }
 109
 110 static bool bam_dmux_skb_dma_map(struct bam_dmux_skb_dma *skb_dma,
 111                                  enum dma_data_direction dir)
 112 {
 113         struct device *dev = skb_dma->dmux->dev;
 114
 115         skb_dma->addr = dma_map_single(dev, skb_dma->skb->data, skb_dma->skb->len, dir);
 116         if (dma_mapping_error(dev, skb_dma->addr)) {
 117                 dev_err(dev, "Failed to DMA map buffer\n");
 118                 skb_dma->addr = 0;
 119                 return false;
 120         }
 121
 122         return true;
 123 }
 124
 125 static void bam_dmux_skb_dma_unmap(struct bam_dmux_skb_dma *skb_dma,
 126                                    enum dma_data_direction dir)
 127 {
 128         dma_unmap_single(skb_dma->dmux->dev, skb_dma->addr, skb_dma->skb->len, dir);
 129         skb_dma->addr = 0;
 130 }
 131
 132 static void bam_dmux_tx_wake_queues(struct bam_dmux *dmux)
 133 {
 134         int i;
 135
 136         dev_dbg(dmux->dev, "wake queues\n");
 137
 138         for (i = 0; i < BAM_DMUX_NUM_CH; ++i) {
 139                 struct net_device *netdev = dmux->netdevs[i];
 140
 141                 if (netdev && netif_running(netdev))
 142                         netif_wake_queue(netdev);
 143         }
 144 }
 145
 146 static void bam_dmux_tx_stop_queues(struct bam_dmux *dmux)
 147 {
 148         int i;
 149
 150         dev_dbg(dmux->dev, "stop queues\n");
 151
 152         for (i = 0; i < BAM_DMUX_NUM_CH; ++i) {
 153                 struct net_device *netdev = dmux->netdevs[i];
 154
 155                 if (netdev)
 156                         netif_stop_queue(netdev);
 157         }
 158 }
 159
 160 static void bam_dmux_tx_done(struct bam_dmux_skb_dma *skb_dma)
 161 {
 162         struct bam_dmux *dmux = skb_dma->dmux;
 163         unsigned long flags;
 164
 165         pm_runtime_mark_last_busy(dmux->dev);
 166         pm_runtime_put_autosuspend(dmux->dev);
 167
 168         if (skb_dma->addr)
 169                 bam_dmux_skb_dma_unmap(skb_dma, DMA_TO_DEVICE);
 170
 171         spin_lock_irqsave(&dmux->tx_lock, flags);
 172         skb_dma->skb = NULL;
 173         if (skb_dma == &dmux->tx_skbs[dmux->tx_next_skb % BAM_DMUX_NUM_SKB])
 174                 bam_dmux_tx_wake_queues(dmux);
 175         spin_unlock_irqrestore(&dmux->tx_lock, flags);
 176 }
 177
 178 static void bam_dmux_tx_callback(void *data)
 179 {
 180         struct bam_dmux_skb_dma *skb_dma = data;
 181         struct sk_buff *skb = skb_dma->skb;
 182
 183         bam_dmux_tx_done(skb_dma);
 184         dev_consume_skb_any(skb);
 185 }
 186
 187 static bool bam_dmux_skb_dma_submit_tx(struct bam_dmux_skb_dma *skb_dma)
 188 {
 189         struct bam_dmux *dmux = skb_dma->dmux;
 190         struct dma_async_tx_descriptor *desc;
 191
 192         desc = dmaengine_prep_slave_single(dmux->tx, skb_dma->addr,
 193                                            skb_dma->skb->len, DMA_MEM_TO_DEV,
 194                                            DMA_PREP_INTERRUPT);
 195         if (!desc) {
 196                 dev_err(dmux->dev, "Failed to prepare TX DMA buffer\n");
 197                 return false;
 198         }
 199
 200         desc->callback = bam_dmux_tx_callback;
 201         desc->callback_param = skb_dma;
 202         desc->cookie = dmaengine_submit(desc);
 203         return true;
 204 }
 205
 206 static struct bam_dmux_skb_dma *
 207 bam_dmux_tx_queue(struct bam_dmux *dmux, struct sk_buff *skb)
 208 {
 209         struct bam_dmux_skb_dma *skb_dma;
 210         unsigned long flags;
 211
 212         spin_lock_irqsave(&dmux->tx_lock, flags);
 213
 214         skb_dma = &dmux->tx_skbs[dmux->tx_next_skb % BAM_DMUX_NUM_SKB];
 215         if (skb_dma->skb) {
 216                 bam_dmux_tx_stop_queues(dmux);
 217                 spin_unlock_irqrestore(&dmux->tx_lock, flags);
 218                 return NULL;
 219         }
 220         skb_dma->skb = skb;
 221
 222         dmux->tx_next_skb++;
 223         if (dmux->tx_skbs[dmux->tx_next_skb % BAM_DMUX_NUM_SKB].skb)
 224                 bam_dmux_tx_stop_queues(dmux);
 225
 226         spin_unlock_irqrestore(&dmux->tx_lock, flags);
 227         return skb_dma;
 228 }
 229
 230 static int bam_dmux_send_cmd(struct bam_dmux_netdev *bndev, u8 cmd)
 231 {
 232         struct bam_dmux *dmux = bndev->dmux;
 233         struct bam_dmux_skb_dma *skb_dma;
 234         struct bam_dmux_hdr *hdr;
 235         struct sk_buff *skb;
 236         int ret;
 237
 238         skb = alloc_skb(sizeof(*hdr), GFP_KERNEL);
 239         if (!skb)
 240                 return -ENOMEM;
 241
 242         hdr = skb_put_zero(skb, sizeof(*hdr));
 243         hdr->magic = BAM_DMUX_HDR_MAGIC;
 244         hdr->cmd = cmd;
 245         hdr->ch = bndev->ch;
 246
 247         skb_dma = bam_dmux_tx_queue(dmux, skb);
 248         if (!skb_dma) {
 249                 ret = -EAGAIN;
 250                 goto free_skb;
 251         }
 252
 253         ret = pm_runtime_get_sync(dmux->dev);
 254         if (ret < 0)
 255                 goto tx_fail;
 256
 257         if (!bam_dmux_skb_dma_map(skb_dma, DMA_TO_DEVICE)) {
 258                 ret = -ENOMEM;
 259                 goto tx_fail;
 260         }
 261
 262         if (!bam_dmux_skb_dma_submit_tx(skb_dma)) {
 263                 ret = -EIO;
 264                 goto tx_fail;
 265         }
 266
 267         dma_async_issue_pending(dmux->tx);
 268         return 0;
 269
 270 tx_fail:
 271         bam_dmux_tx_done(skb_dma);
 272 free_skb:
 273         dev_kfree_skb(skb);
 274         return ret;
 275 }
 276
 277 static int bam_dmux_netdev_open(struct net_device *netdev)
 278 {
 279         struct bam_dmux_netdev *bndev = netdev_priv(netdev);
 280         int ret;
 281
 282         ret = bam_dmux_send_cmd(bndev, BAM_DMUX_CMD_OPEN);
 283         if (ret)
 284                 return ret;
 285
 286         netif_start_queue(netdev);
 287         return 0;
 288 }
 289
 290 static int bam_dmux_netdev_stop(struct net_device *netdev)
 291 {
 292         struct bam_dmux_netdev *bndev = netdev_priv(netdev);
 293
 294         netif_stop_queue(netdev);
 295         bam_dmux_send_cmd(bndev, BAM_DMUX_CMD_CLOSE);
 296         return 0;
 297 }
 298
 299 static unsigned int needed_room(unsigned int avail, unsigned int needed)
 300 {
 301         if (avail >= needed)
 302                 return 0;
 303         return needed - avail;
 304 }
 305
 306 static int bam_dmux_tx_prepare_skb(struct bam_dmux_netdev *bndev,
 307                                    struct sk_buff *skb)
 308 {
 309         unsigned int head = needed_room(skb_headroom(skb), BAM_DMUX_HDR_SIZE);
 310         unsigned int pad = sizeof(u32) - skb->len % sizeof(u32);
 311         unsigned int tail = needed_room(skb_tailroom(skb), pad);
 312         struct bam_dmux_hdr *hdr;
 313         int ret;
 314
 315         if (head || tail || skb_cloned(skb)) {
 316                 ret = pskb_expand_head(skb, head, tail, GFP_ATOMIC);
 317                 if (ret)
 318                         return ret;
 319         }
 320
 321         hdr = skb_push(skb, sizeof(*hdr));
 322         hdr->magic = BAM_DMUX_HDR_MAGIC;
 323         hdr->signal = 0;
 324         hdr->cmd = BAM_DMUX_CMD_DATA;
 325         hdr->pad = pad;
 326         hdr->ch = bndev->ch;
 327         hdr->len = skb->len - sizeof(*hdr);
 328         if (pad)
 329                 skb_put_zero(skb, pad);
 330
 331         return 0;
 332 }
 333
 334 static netdev_tx_t bam_dmux_netdev_start_xmit(struct sk_buff *skb,
 335                                               struct net_device *netdev)
 336 {
 337         struct bam_dmux_netdev *bndev = netdev_priv(netdev);
 338         struct bam_dmux *dmux = bndev->dmux;
 339         struct bam_dmux_skb_dma *skb_dma;
 340         int active, ret;
 341
 342         skb_dma = bam_dmux_tx_queue(dmux, skb);
 343         if (!skb_dma)
 344                 return NETDEV_TX_BUSY;
 345
 346         active = pm_runtime_get(dmux->dev);
 347         if (active < 0 && active != -EINPROGRESS)
 348                 goto drop;
 349
 350         ret = bam_dmux_tx_prepare_skb(bndev, skb);
 351         if (ret)
 352                 goto drop;
 353
 354         if (!bam_dmux_skb_dma_map(skb_dma, DMA_TO_DEVICE))
 355                 goto drop;
 356
 357         if (active <= 0) {
 358                 /* Cannot sleep here so mark skb for wakeup handler and return */
 359                 if (!atomic_long_fetch_or(BIT(skb_dma - dmux->tx_skbs),
 360                                           &dmux->tx_deferred_skb))
 361                         queue_pm_work(&dmux->tx_wakeup_work);
 362                 return NETDEV_TX_OK;
 363         }
 364
 365         if (!bam_dmux_skb_dma_submit_tx(skb_dma))
 366                 goto drop;
 367
 368         dma_async_issue_pending(dmux->tx);
 369         return NETDEV_TX_OK;
 370
 371 drop:
 372         bam_dmux_tx_done(skb_dma);
 373         dev_kfree_skb_any(skb);
 374         return NETDEV_TX_OK;
 375 }
 376
 377 static void bam_dmux_tx_wakeup_work(struct work_struct *work)
 378 {
 379         struct bam_dmux *dmux = container_of(work, struct bam_dmux, tx_wakeup_work);
 380         unsigned long pending;
 381         int ret, i;
 382
 383         ret = pm_runtime_resume_and_get(dmux->dev);
 384         if (ret < 0) {
 385                 dev_err(dmux->dev, "Failed to resume: %d\n", ret);
 386                 return;
 387         }
 388
 389         pending = atomic_long_xchg(&dmux->tx_deferred_skb, 0);
 390         if (!pending)
 391                 goto out;
 392
 393         dev_dbg(dmux->dev, "pending skbs after wakeup: %#lx\n", pending);
 394         for_each_set_bit(i, &pending, BAM_DMUX_NUM_SKB) {
 395                 bam_dmux_skb_dma_submit_tx(&dmux->tx_skbs[i]);
 396         }
 397         dma_async_issue_pending(dmux->tx);
 398
 399 out:
 400         pm_runtime_mark_last_busy(dmux->dev);
 401         pm_runtime_put_autosuspend(dmux->dev);
 402 }
 403
 404 static const struct net_device_ops bam_dmux_ops = {
 405         .ndo_open       = bam_dmux_netdev_open,
 406         .ndo_stop       = bam_dmux_netdev_stop,
 407         .ndo_start_xmit = bam_dmux_netdev_start_xmit,
 408 };
 409
 410 static const struct device_type wwan_type = {
 411         .name = "wwan",
 412 };
 413
 414 static void bam_dmux_netdev_setup(struct net_device *dev)
 415 {
 416         dev->netdev_ops = &bam_dmux_ops;
 417
 418         dev->type = ARPHRD_RAWIP;
 419         SET_NETDEV_DEVTYPE(dev, &wwan_type);
 420         dev->flags = IFF_POINTOPOINT | IFF_NOARP;
 421
 422         dev->mtu = ETH_DATA_LEN;
 423         dev->max_mtu = BAM_DMUX_MAX_DATA_SIZE;
 424         dev->needed_headroom = sizeof(struct bam_dmux_hdr);
 425         dev->needed_tailroom = sizeof(u32); /* word-aligned */
 426         dev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
 427
 428         /* This perm addr will be used as interface identifier by IPv6 */
 429         dev->addr_assign_type = NET_ADDR_RANDOM;
 430         eth_random_addr(dev->perm_addr);
 431 }
 432
 433 static void bam_dmux_register_netdev_work(struct work_struct *work)
 434 {
 435         struct bam_dmux *dmux = container_of(work, struct bam_dmux, register_netdev_work);
 436         struct bam_dmux_netdev *bndev;
 437         struct net_device *netdev;
 438         int ch, ret;
 439
 440         for_each_set_bit(ch, dmux->remote_channels, BAM_DMUX_NUM_CH) {
 441                 if (dmux->netdevs[ch])
 442                         continue;
 443
 444                 netdev = alloc_netdev(sizeof(*bndev), "wwan%d", NET_NAME_ENUM,
 445                                       bam_dmux_netdev_setup);
 446                 if (!netdev)
 447                         return;
 448
 449                 SET_NETDEV_DEV(netdev, dmux->dev);
 450                 netdev->dev_port = ch;
 451
 452                 bndev = netdev_priv(netdev);
 453                 bndev->dmux = dmux;
 454                 bndev->ch = ch;
 455
 456                 ret = register_netdev(netdev);
 457                 if (ret) {
 458                         dev_err(dmux->dev, "Failed to register netdev for channel %u: %d\n",
 459                                 ch, ret);
 460                         free_netdev(netdev);
 461                         return;
 462                 }
 463
 464                 dmux->netdevs[ch] = netdev;
 465         }
 466 }
 467
 468 static void bam_dmux_rx_callback(void *data);
 469
 470 static bool bam_dmux_skb_dma_submit_rx(struct bam_dmux_skb_dma *skb_dma)
 471 {
 472         struct bam_dmux *dmux = skb_dma->dmux;
 473         struct dma_async_tx_descriptor *desc;
 474
 475         desc = dmaengine_prep_slave_single(dmux->rx, skb_dma->addr,
 476                                            skb_dma->skb->len, DMA_DEV_TO_MEM,
 477                                            DMA_PREP_INTERRUPT);
 478         if (!desc) {
 479                 dev_err(dmux->dev, "Failed to prepare RX DMA buffer\n");
 480                 return false;
 481         }
 482
 483         desc->callback = bam_dmux_rx_callback;
 484         desc->callback_param = skb_dma;
 485         desc->cookie = dmaengine_submit(desc);
 486         return true;
 487 }
 488
 489 static bool bam_dmux_skb_dma_queue_rx(struct bam_dmux_skb_dma *skb_dma, gfp_t gfp)
 490 {
 491         if (!skb_dma->skb) {
 492                 skb_dma->skb = __netdev_alloc_skb(NULL, BAM_DMUX_BUFFER_SIZE, gfp);
 493                 if (!skb_dma->skb)
 494                         return false;
 495                 skb_put(skb_dma->skb, BAM_DMUX_BUFFER_SIZE);
 496         }
 497
 498         return bam_dmux_skb_dma_map(skb_dma, DMA_FROM_DEVICE) &&
 499                bam_dmux_skb_dma_submit_rx(skb_dma);
 500 }
 501
 502 static void bam_dmux_cmd_data(struct bam_dmux_skb_dma *skb_dma)
 503 {
 504         struct bam_dmux *dmux = skb_dma->dmux;
 505         struct sk_buff *skb = skb_dma->skb;
 506         struct bam_dmux_hdr *hdr = (struct bam_dmux_hdr *)skb->data;
 507         struct net_device *netdev = dmux->netdevs[hdr->ch];
 508
 509         if (!netdev || !netif_running(netdev)) {
 510                 dev_warn(dmux->dev, "Data for inactive channel %u\n", hdr->ch);
 511                 return;
 512         }
 513
 514         if (hdr->len > BAM_DMUX_MAX_DATA_SIZE) {
 515                 dev_err(dmux->dev, "Data larger than buffer? (%u > %u)\n",
 516                         hdr->len, (u16)BAM_DMUX_MAX_DATA_SIZE);
 517                 return;
 518         }
 519
 520         skb_dma->skb = NULL; /* Hand over to network stack */
 521
 522         skb_pull(skb, sizeof(*hdr));
 523         skb_trim(skb, hdr->len);
 524         skb->dev = netdev;
 525
 526         /* Only Raw-IP/QMAP is supported by this driver */
 527         switch (skb->data[0] & 0xf0) {
 528         case 0x40:
 529                 skb->protocol = htons(ETH_P_IP);
 530                 break;
 531         case 0x60:
 532                 skb->protocol = htons(ETH_P_IPV6);
 533                 break;
 534         default:
 535                 skb->protocol = htons(ETH_P_MAP);
 536                 break;
 537         }
 538
 539         netif_receive_skb(skb);
 540 }
 541
 542 static void bam_dmux_cmd_open(struct bam_dmux *dmux, struct bam_dmux_hdr *hdr)
 543 {
 544         struct net_device *netdev = dmux->netdevs[hdr->ch];
 545
 546         dev_dbg(dmux->dev, "open channel: %u\n", hdr->ch);
 547
 548         if (__test_and_set_bit(hdr->ch, dmux->remote_channels)) {
 549                 dev_warn(dmux->dev, "Channel already open: %u\n", hdr->ch);
 550                 return;
 551         }
 552
 553         if (netdev) {
 554                 netif_device_attach(netdev);
 555         } else {
 556                 /* Cannot sleep here, schedule work to register the netdev */
 557                 schedule_work(&dmux->register_netdev_work);
 558         }
 559 }
 560
 561 static void bam_dmux_cmd_close(struct bam_dmux *dmux, struct bam_dmux_hdr *hdr)
 562 {
 563         struct net_device *netdev = dmux->netdevs[hdr->ch];
 564
 565         dev_dbg(dmux->dev, "close channel: %u\n", hdr->ch);
 566
 567         if (!__test_and_clear_bit(hdr->ch, dmux->remote_channels)) {
 568                 dev_err(dmux->dev, "Channel not open: %u\n", hdr->ch);
 569                 return;
 570         }
 571
 572         if (netdev)
 573                 netif_device_detach(netdev);
 574 }
 575
 576 static void bam_dmux_rx_callback(void *data)
 577 {
 578         struct bam_dmux_skb_dma *skb_dma = data;
 579         struct bam_dmux *dmux = skb_dma->dmux;
 580         struct sk_buff *skb = skb_dma->skb;
 581         struct bam_dmux_hdr *hdr = (struct bam_dmux_hdr *)skb->data;
 582
 583         bam_dmux_skb_dma_unmap(skb_dma, DMA_FROM_DEVICE);
 584
 585         if (hdr->magic != BAM_DMUX_HDR_MAGIC) {
 586                 dev_err(dmux->dev, "Invalid magic in header: %#x\n", hdr->magic);
 587                 goto out;
 588         }
 589
 590         if (hdr->ch >= BAM_DMUX_NUM_CH) {
 591                 dev_dbg(dmux->dev, "Unsupported channel: %u\n", hdr->ch);
 592                 goto out;
 593         }
 594
 595         switch (hdr->cmd) {
 596         case BAM_DMUX_CMD_DATA:
 597                 bam_dmux_cmd_data(skb_dma);
 598                 break;
 599         case BAM_DMUX_CMD_OPEN:
 600                 bam_dmux_cmd_open(dmux, hdr);
 601                 break;
 602         case BAM_DMUX_CMD_CLOSE:
 603                 bam_dmux_cmd_close(dmux, hdr);
 604                 break;
 605         default:
 606                 dev_err(dmux->dev, "Unsupported command %u on channel %u\n",
 607                         hdr->cmd, hdr->ch);
 608                 break;
 609         }
 610
 611 out:
 612         if (bam_dmux_skb_dma_queue_rx(skb_dma, GFP_ATOMIC))
 613                 dma_async_issue_pending(dmux->rx);
 614 }
 615
 616 static bool bam_dmux_power_on(struct bam_dmux *dmux)
 617 {
 618         struct device *dev = dmux->dev;
 619         struct dma_slave_config dma_rx_conf = {
 620                 .direction = DMA_DEV_TO_MEM,
 621                 .src_maxburst = BAM_DMUX_BUFFER_SIZE,
 622         };
 623         int i;
 624
 625         dmux->rx = dma_request_chan(dev, "rx");
 626         if (IS_ERR(dmux->rx)) {
 627                 dev_err(dev, "Failed to request RX DMA channel: %pe\n", dmux->rx);
 628                 dmux->rx = NULL;
 629                 return false;
 630         }
 631         dmaengine_slave_config(dmux->rx, &dma_rx_conf);
 632
 633         for (i = 0; i < BAM_DMUX_NUM_SKB; i++) {
 634                 if (!bam_dmux_skb_dma_queue_rx(&dmux->rx_skbs[i], GFP_KERNEL))
 635                         return false;
 636         }
 637         dma_async_issue_pending(dmux->rx);
 638
 639         return true;
 640 }
 641
 642 static void bam_dmux_free_skbs(struct bam_dmux_skb_dma skbs[],
 643                                enum dma_data_direction dir)
 644 {
 645         int i;
 646
 647         for (i = 0; i < BAM_DMUX_NUM_SKB; i++) {
 648                 struct bam_dmux_skb_dma *skb_dma = &skbs[i];
 649
 650                 if (skb_dma->addr)
 651                         bam_dmux_skb_dma_unmap(skb_dma, dir);
 652                 if (skb_dma->skb) {
 653                         dev_kfree_skb(skb_dma->skb);
 654                         skb_dma->skb = NULL;
 655                 }
 656         }
 657 }
 658
 659 static void bam_dmux_power_off(struct bam_dmux *dmux)
 660 {
 661         if (dmux->tx) {
 662                 dmaengine_terminate_sync(dmux->tx);
 663                 dma_release_channel(dmux->tx);
 664                 dmux->tx = NULL;
 665         }
 666
 667         if (dmux->rx) {
 668                 dmaengine_terminate_sync(dmux->rx);
 669                 dma_release_channel(dmux->rx);
 670                 dmux->rx = NULL;
 671         }
 672
 673         bam_dmux_free_skbs(dmux->rx_skbs, DMA_FROM_DEVICE);
 674 }
 675
 676 static irqreturn_t bam_dmux_pc_irq(int irq, void *data)
 677 {
 678         struct bam_dmux *dmux = data;
 679         bool new_state = !dmux->pc_state;
 680
 681         dev_dbg(dmux->dev, "pc: %u\n", new_state);
 682
 683         if (new_state) {
 684                 if (bam_dmux_power_on(dmux))
 685                         bam_dmux_pc_ack(dmux);
 686                 else
 687                         bam_dmux_power_off(dmux);
 688         } else {
 689                 bam_dmux_power_off(dmux);
 690                 bam_dmux_pc_ack(dmux);
 691         }
 692
 693         dmux->pc_state = new_state;
 694         wake_up_all(&dmux->pc_wait);
 695
 696         return IRQ_HANDLED;
 697 }
 698
 699 static irqreturn_t bam_dmux_pc_ack_irq(int irq, void *data)
 700 {
 701         struct bam_dmux *dmux = data;
 702
 703         dev_dbg(dmux->dev, "pc ack\n");
 704         complete_all(&dmux->pc_ack_completion);
 705
 706         return IRQ_HANDLED;
 707 }
 708
 709 static int bam_dmux_runtime_suspend(struct device *dev)
 710 {
 711         struct bam_dmux *dmux = dev_get_drvdata(dev);
 712
 713         dev_dbg(dev, "runtime suspend\n");
 714         bam_dmux_pc_vote(dmux, false);
 715
 716         return 0;
 717 }
 718
 719 static int __maybe_unused bam_dmux_runtime_resume(struct device *dev)
 720 {
 721         struct bam_dmux *dmux = dev_get_drvdata(dev);
 722
 723         dev_dbg(dev, "runtime resume\n");
 724
 725         /* Wait until previous power down was acked */
 726         if (!wait_for_completion_timeout(&dmux->pc_ack_completion,
 727                                          BAM_DMUX_REMOTE_TIMEOUT))
 728                 return -ETIMEDOUT;
 729
 730         /* Vote for power state */
 731         bam_dmux_pc_vote(dmux, true);
 732
 733         /* Wait for ack */
 734         if (!wait_for_completion_timeout(&dmux->pc_ack_completion,
 735                                          BAM_DMUX_REMOTE_TIMEOUT)) {
 736                 bam_dmux_pc_vote(dmux, false);
 737                 return -ETIMEDOUT;
 738         }
 739
 740         /* Wait until we're up */
 741         if (!wait_event_timeout(dmux->pc_wait, dmux->pc_state,
 742                                 BAM_DMUX_REMOTE_TIMEOUT)) {
 743                 bam_dmux_pc_vote(dmux, false);
 744                 return -ETIMEDOUT;
 745         }
 746
 747         /* Ensure that we actually initialized successfully */
 748         if (!dmux->rx) {
 749                 bam_dmux_pc_vote(dmux, false);
 750                 return -ENXIO;
 751         }
 752
 753         /* Request TX channel if necessary */
 754         if (dmux->tx)
 755                 return 0;
 756
 757         dmux->tx = dma_request_chan(dev, "tx");
 758         if (IS_ERR(dmux->tx)) {
 759                 dev_err(dev, "Failed to request TX DMA channel: %pe\n", dmux->tx);
 760                 dmux->tx = NULL;
 761                 bam_dmux_runtime_suspend(dev);
 762                 return -ENXIO;
 763         }
 764
 765         return 0;
 766 }
 767
 768 static int bam_dmux_probe(struct platform_device *pdev)
 769 {
 770         struct device *dev = &pdev->dev;
 771         struct bam_dmux *dmux;
 772         int ret, pc_ack_irq, i;
 773         unsigned int bit;
 774
 775         dmux = devm_kzalloc(dev, sizeof(*dmux), GFP_KERNEL);
 776         if (!dmux)
 777                 return -ENOMEM;
 778
 779         dmux->dev = dev;
 780         platform_set_drvdata(pdev, dmux);
 781
 782         dmux->pc_irq = platform_get_irq_byname(pdev, "pc");
 783         if (dmux->pc_irq < 0)
 784                 return dmux->pc_irq;
 785
 786         pc_ack_irq = platform_get_irq_byname(pdev, "pc-ack");
 787         if (pc_ack_irq < 0)
 788                 return pc_ack_irq;
 789
 790         dmux->pc = devm_qcom_smem_state_get(dev, "pc", &bit);
 791         if (IS_ERR(dmux->pc))
 792                 return dev_err_probe(dev, PTR_ERR(dmux->pc),
 793                                      "Failed to get pc state\n");
 794         dmux->pc_mask = BIT(bit);
 795
 796         dmux->pc_ack = devm_qcom_smem_state_get(dev, "pc-ack", &bit);
 797         if (IS_ERR(dmux->pc_ack))
 798                 return dev_err_probe(dev, PTR_ERR(dmux->pc_ack),
 799                                      "Failed to get pc-ack state\n");
 800         dmux->pc_ack_mask = BIT(bit);
 801
 802         init_waitqueue_head(&dmux->pc_wait);
 803         init_completion(&dmux->pc_ack_completion);
 804         complete_all(&dmux->pc_ack_completion);
 805
 806         spin_lock_init(&dmux->tx_lock);
 807         INIT_WORK(&dmux->tx_wakeup_work, bam_dmux_tx_wakeup_work);
 808         INIT_WORK(&dmux->register_netdev_work, bam_dmux_register_netdev_work);
 809
 810         for (i = 0; i < BAM_DMUX_NUM_SKB; i++) {
 811                 dmux->rx_skbs[i].dmux = dmux;
 812                 dmux->tx_skbs[i].dmux = dmux;
 813         }
 814
 815         /* Runtime PM manages our own power vote.
 816          * Note that the RX path may be active even if we are runtime suspended,
 817          * since it is controlled by the remote side.
 818          */
 819         pm_runtime_set_autosuspend_delay(dev, BAM_DMUX_AUTOSUSPEND_DELAY);
 820         pm_runtime_use_autosuspend(dev);
 821         pm_runtime_enable(dev);
 822
 823         ret = devm_request_threaded_irq(dev, pc_ack_irq, NULL, bam_dmux_pc_ack_irq,
 824                                         IRQF_ONESHOT, NULL, dmux);
 825         if (ret)
 826                 return ret;
 827
 828         ret = devm_request_threaded_irq(dev, dmux->pc_irq, NULL, bam_dmux_pc_irq,
 829                                         IRQF_ONESHOT, NULL, dmux);
 830         if (ret)
 831                 return ret;
 832
 833         ret = irq_get_irqchip_state(dmux->pc_irq, IRQCHIP_STATE_LINE_LEVEL,
 834                                     &dmux->pc_state);
 835         if (ret)
 836                 return ret;
 837
 838         /* Check if remote finished initialization before us */
 839         if (dmux->pc_state) {
 840                 if (bam_dmux_power_on(dmux))
 841                         bam_dmux_pc_ack(dmux);
 842                 else
 843                         bam_dmux_power_off(dmux);
 844         }
 845
 846         return 0;
 847 }
 848
 849 static int bam_dmux_remove(struct platform_device *pdev)
 850 {
 851         struct bam_dmux *dmux = platform_get_drvdata(pdev);
 852         struct device *dev = dmux->dev;
 853         LIST_HEAD(list);
 854         int i;
 855
 856         /* Unregister network interfaces */
 857         cancel_work_sync(&dmux->register_netdev_work);
 858         rtnl_lock();
 859         for (i = 0; i < BAM_DMUX_NUM_CH; ++i)
 860                 if (dmux->netdevs[i])
 861                         unregister_netdevice_queue(dmux->netdevs[i], &list);
 862         unregister_netdevice_many(&list);
 863         rtnl_unlock();
 864         cancel_work_sync(&dmux->tx_wakeup_work);
 865
 866         /* Drop our own power vote */
 867         pm_runtime_disable(dev);
 868         pm_runtime_dont_use_autosuspend(dev);
 869         bam_dmux_runtime_suspend(dev);
 870         pm_runtime_set_suspended(dev);
 871
 872         /* Try to wait for remote side to drop power vote */
 873         if (!wait_event_timeout(dmux->pc_wait, !dmux->rx, BAM_DMUX_REMOTE_TIMEOUT))
 874                 dev_err(dev, "Timed out waiting for remote side to suspend\n");
 875
 876         /* Make sure everything is cleaned up before we return */
 877         disable_irq(dmux->pc_irq);
 878         bam_dmux_power_off(dmux);
 879         bam_dmux_free_skbs(dmux->tx_skbs, DMA_TO_DEVICE);
 880
 881         return 0;
 882 }
 883
 884 static const struct dev_pm_ops bam_dmux_pm_ops = {
 885         SET_RUNTIME_PM_OPS(bam_dmux_runtime_suspend, bam_dmux_runtime_resume, NULL)
 886 };
 887
 888 static const struct of_device_id bam_dmux_of_match[] = {
 889         { .compatible = "qcom,bam-dmux" },
 890         { /* sentinel */ }
 891 };
 892 MODULE_DEVICE_TABLE(of, bam_dmux_of_match);
 893
 894 static struct platform_driver bam_dmux_driver = {
 895         .probe = bam_dmux_probe,
 896         .remove = bam_dmux_remove,
 897         .driver = {
 898                 .name = "bam-dmux",
 899                 .pm = &bam_dmux_pm_ops,
 900                 .of_match_table = bam_dmux_of_match,
 901         },
 902 };
 903 module_platform_driver(bam_dmux_driver);
 904
 905 MODULE_LICENSE("GPL v2");
 906 MODULE_DESCRIPTION("Qualcomm BAM-DMUX WWAN Network Driver");
 907 MODULE_AUTHOR("Stephan Gerhold <[email protected]>");