1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* MHI MBIM Network driver - Network/MBIM over MHI bus 3 * 4 * Copyright (C) 2021 Linaro Ltd <loic.poulain@linaro.org> 5 * 6 * This driver copy some code from cdc_ncm, which is: 7 * Copyright (C) ST-Ericsson 2010-2012 8 * and cdc_mbim, which is: 9 * Copyright (c) 2012 Smith Micro Software, Inc. 10 * Copyright (c) 2012 Bjørn Mork <bjorn@mork.no> 11 * 12 */ 13 14 #include <linux/ethtool.h> 15 #include <linux/if_arp.h> 16 #include <linux/if_vlan.h> 17 #include <linux/ip.h> 18 #include <linux/mhi.h> 19 #include <linux/mii.h> 20 #include <linux/mod_devicetable.h> 21 #include <linux/module.h> 22 #include <linux/netdevice.h> 23 #include <linux/skbuff.h> 24 #include <linux/u64_stats_sync.h> 25 #include <linux/usb.h> 26 #include <linux/usb/cdc.h> 27 #include <linux/usb/usbnet.h> 28 #include <linux/usb/cdc_ncm.h> 29 #include <linux/wwan.h> 30 31 /* 3500 allows to optimize skb allocation, the skbs will basically fit in 32 * one 4K page. Large MBIM packets will simply be split over several MHI 33 * transfers and chained by the MHI net layer (zerocopy). 34 */ 35 #define MHI_DEFAULT_MRU 3500 36 37 #define MHI_MBIM_DEFAULT_MTU 1500 38 #define MHI_MAX_BUF_SZ 0xffff 39 40 #define MBIM_NDP16_SIGN_MASK 0x00ffffff 41 42 #define MHI_MBIM_LINK_HASH_SIZE 8 43 #define LINK_HASH(session) ((session) % MHI_MBIM_LINK_HASH_SIZE) 44 45 #define WDS_BIND_MUX_DATA_PORT_MUX_ID 112 46 47 struct mhi_mbim_link { 48 struct mhi_mbim_context *mbim; 49 struct net_device *ndev; 50 unsigned int session; 51 52 /* stats */ 53 u64_stats_t rx_packets; 54 u64_stats_t rx_bytes; 55 u64_stats_t rx_errors; 56 u64_stats_t tx_packets; 57 u64_stats_t tx_bytes; 58 u64_stats_t tx_errors; 59 u64_stats_t tx_dropped; 60 struct u64_stats_sync tx_syncp; 61 struct u64_stats_sync rx_syncp; 62 63 struct hlist_node hlnode; 64 }; 65 66 struct mhi_mbim_context { 67 struct mhi_device *mdev; 68 struct sk_buff *skbagg_head; 69 struct sk_buff *skbagg_tail; 70 unsigned int mru; 71 u32 rx_queue_sz; 72 u16 rx_seq; 73 u16 tx_seq; 74 struct delayed_work rx_refill; 75 spinlock_t tx_lock; 76 struct hlist_head link_list[MHI_MBIM_LINK_HASH_SIZE]; 77 }; 78 79 struct mbim_tx_hdr { 80 struct usb_cdc_ncm_nth16 nth16; 81 82 /* Must be last as it ends in a flexible-array member. */ 83 struct usb_cdc_ncm_ndp16 ndp16; 84 } __packed; 85 86 static struct mhi_mbim_link *mhi_mbim_get_link_rcu(struct mhi_mbim_context *mbim, 87 unsigned int session) 88 { 89 struct mhi_mbim_link *link; 90 91 hlist_for_each_entry_rcu(link, &mbim->link_list[LINK_HASH(session)], hlnode) { 92 if (link->session == session) 93 return link; 94 } 95 96 return NULL; 97 } 98 99 static int mhi_mbim_get_link_mux_id(struct mhi_controller *cntrl) 100 { 101 if (strcmp(cntrl->name, "foxconn-dw5934e") == 0 || 102 strcmp(cntrl->name, "foxconn-t99w640") == 0) 103 return WDS_BIND_MUX_DATA_PORT_MUX_ID; 104 105 return 0; 106 } 107 108 static struct sk_buff *mbim_tx_fixup(struct sk_buff *skb, unsigned int session, 109 u16 tx_seq) 110 { 111 DEFINE_RAW_FLEX(struct mbim_tx_hdr, mbim_hdr, ndp16.dpe16, 2); 112 unsigned int dgram_size = skb->len; 113 struct usb_cdc_ncm_nth16 *nth16; 114 struct usb_cdc_ncm_ndp16 *ndp16; 115 116 /* Only one NDP is sent, containing the IP packet (no aggregation) */ 117 118 /* Ensure we have enough headroom for crafting MBIM header */ 119 if (skb_cow_head(skb, __struct_size(mbim_hdr))) { 120 dev_kfree_skb_any(skb); 121 return NULL; 122 } 123 124 mbim_hdr = skb_push(skb, __struct_size(mbim_hdr)); 125 126 /* Fill NTB header */ 127 nth16 = &mbim_hdr->nth16; 128 nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN); 129 nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16)); 130 nth16->wSequence = cpu_to_le16(tx_seq); 131 nth16->wBlockLength = cpu_to_le16(skb->len); 132 nth16->wNdpIndex = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16)); 133 134 /* Fill the unique NDP */ 135 ndp16 = &mbim_hdr->ndp16; 136 ndp16->dwSignature = cpu_to_le32(USB_CDC_MBIM_NDP16_IPS_SIGN | (session << 24)); 137 ndp16->wLength = cpu_to_le16(struct_size(ndp16, dpe16, 2)); 138 ndp16->wNextNdpIndex = 0; 139 140 /* Datagram follows the mbim header */ 141 ndp16->dpe16[0].wDatagramIndex = cpu_to_le16(__struct_size(mbim_hdr)); 142 ndp16->dpe16[0].wDatagramLength = cpu_to_le16(dgram_size); 143 144 /* null termination */ 145 ndp16->dpe16[1].wDatagramIndex = 0; 146 ndp16->dpe16[1].wDatagramLength = 0; 147 148 return skb; 149 } 150 151 static netdev_tx_t mhi_mbim_ndo_xmit(struct sk_buff *skb, struct net_device *ndev) 152 { 153 struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev); 154 struct mhi_mbim_context *mbim = link->mbim; 155 unsigned long flags; 156 int err = -ENOMEM; 157 158 /* Serialize MHI channel queuing and MBIM seq */ 159 spin_lock_irqsave(&mbim->tx_lock, flags); 160 161 skb = mbim_tx_fixup(skb, link->session, mbim->tx_seq); 162 if (unlikely(!skb)) 163 goto exit_unlock; 164 165 err = mhi_queue_skb(mbim->mdev, DMA_TO_DEVICE, skb, skb->len, MHI_EOT); 166 167 if (mhi_queue_is_full(mbim->mdev, DMA_TO_DEVICE)) 168 netif_stop_queue(ndev); 169 170 if (!err) 171 mbim->tx_seq++; 172 173 exit_unlock: 174 spin_unlock_irqrestore(&mbim->tx_lock, flags); 175 176 if (unlikely(err)) { 177 net_err_ratelimited("%s: Failed to queue TX buf (%d)\n", 178 ndev->name, err); 179 dev_kfree_skb_any(skb); 180 goto exit_drop; 181 } 182 183 return NETDEV_TX_OK; 184 185 exit_drop: 186 u64_stats_update_begin(&link->tx_syncp); 187 u64_stats_inc(&link->tx_dropped); 188 u64_stats_update_end(&link->tx_syncp); 189 190 return NETDEV_TX_OK; 191 } 192 193 static int mbim_rx_verify_nth16(struct mhi_mbim_context *mbim, struct sk_buff *skb) 194 { 195 struct usb_cdc_ncm_nth16 *nth16; 196 int len; 197 198 if (skb->len < sizeof(struct usb_cdc_ncm_nth16) + 199 sizeof(struct usb_cdc_ncm_ndp16)) { 200 net_err_ratelimited("frame too short\n"); 201 return -EINVAL; 202 } 203 204 nth16 = (struct usb_cdc_ncm_nth16 *)skb->data; 205 206 if (nth16->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH16_SIGN)) { 207 net_err_ratelimited("invalid NTH16 signature <%#010x>\n", 208 le32_to_cpu(nth16->dwSignature)); 209 return -EINVAL; 210 } 211 212 /* No limit on the block length, except the size of the data pkt */ 213 len = le16_to_cpu(nth16->wBlockLength); 214 if (len > skb->len) { 215 net_err_ratelimited("NTB does not fit into the skb %u/%u\n", 216 len, skb->len); 217 return -EINVAL; 218 } 219 220 if (mbim->rx_seq + 1 != le16_to_cpu(nth16->wSequence) && 221 (mbim->rx_seq || le16_to_cpu(nth16->wSequence)) && 222 !(mbim->rx_seq == 0xffff && !le16_to_cpu(nth16->wSequence))) { 223 net_dbg_ratelimited("sequence number glitch prev=%d curr=%d\n", 224 mbim->rx_seq, le16_to_cpu(nth16->wSequence)); 225 } 226 mbim->rx_seq = le16_to_cpu(nth16->wSequence); 227 228 return le16_to_cpu(nth16->wNdpIndex); 229 } 230 231 static int mbim_rx_verify_ndp16(struct sk_buff *skb, struct usb_cdc_ncm_ndp16 *ndp16) 232 { 233 int ret; 234 235 if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) { 236 net_err_ratelimited("invalid DPT16 length <%u>\n", 237 le16_to_cpu(ndp16->wLength)); 238 return -EINVAL; 239 } 240 241 ret = ((le16_to_cpu(ndp16->wLength) - sizeof(struct usb_cdc_ncm_ndp16)) 242 / sizeof(struct usb_cdc_ncm_dpe16)); 243 ret--; /* Last entry is always a NULL terminator */ 244 245 if (sizeof(struct usb_cdc_ncm_ndp16) + 246 ret * sizeof(struct usb_cdc_ncm_dpe16) > skb->len) { 247 net_err_ratelimited("Invalid nframes = %d\n", ret); 248 return -EINVAL; 249 } 250 251 return ret; 252 } 253 254 static void mhi_mbim_rx(struct mhi_mbim_context *mbim, struct sk_buff *skb) 255 { 256 int ndpoffset; 257 258 /* Check NTB header and retrieve first NDP offset */ 259 ndpoffset = mbim_rx_verify_nth16(mbim, skb); 260 if (ndpoffset < 0) { 261 net_err_ratelimited("mbim: Incorrect NTB header\n"); 262 goto error; 263 } 264 265 /* Process each NDP */ 266 while (1) { 267 struct usb_cdc_ncm_ndp16 ndp16; 268 struct usb_cdc_ncm_dpe16 dpe16; 269 struct mhi_mbim_link *link; 270 int nframes, n, dpeoffset; 271 unsigned int session; 272 273 if (skb_copy_bits(skb, ndpoffset, &ndp16, sizeof(ndp16))) { 274 net_err_ratelimited("mbim: Incorrect NDP offset (%u)\n", 275 ndpoffset); 276 goto error; 277 } 278 279 /* Check NDP header and retrieve number of datagrams */ 280 nframes = mbim_rx_verify_ndp16(skb, &ndp16); 281 if (nframes < 0) { 282 net_err_ratelimited("mbim: Incorrect NDP16\n"); 283 goto error; 284 } 285 286 /* Only IP data type supported, no DSS in MHI context */ 287 if ((ndp16.dwSignature & cpu_to_le32(MBIM_NDP16_SIGN_MASK)) 288 != cpu_to_le32(USB_CDC_MBIM_NDP16_IPS_SIGN)) { 289 net_err_ratelimited("mbim: Unsupported NDP type\n"); 290 goto next_ndp; 291 } 292 293 session = (le32_to_cpu(ndp16.dwSignature) & ~MBIM_NDP16_SIGN_MASK) >> 24; 294 295 rcu_read_lock(); 296 297 link = mhi_mbim_get_link_rcu(mbim, session); 298 if (!link) { 299 net_err_ratelimited("mbim: bad packet session (%u)\n", session); 300 goto unlock; 301 } 302 303 /* de-aggregate and deliver IP packets */ 304 dpeoffset = ndpoffset + sizeof(struct usb_cdc_ncm_ndp16); 305 for (n = 0; n < nframes; n++, dpeoffset += sizeof(dpe16)) { 306 u16 dgram_offset, dgram_len; 307 struct sk_buff *skbn; 308 309 if (skb_copy_bits(skb, dpeoffset, &dpe16, sizeof(dpe16))) 310 break; 311 312 dgram_offset = le16_to_cpu(dpe16.wDatagramIndex); 313 dgram_len = le16_to_cpu(dpe16.wDatagramLength); 314 315 if (!dgram_offset || !dgram_len) 316 break; /* null terminator */ 317 318 skbn = netdev_alloc_skb(link->ndev, dgram_len); 319 if (!skbn) 320 continue; 321 322 skb_put(skbn, dgram_len); 323 skb_copy_bits(skb, dgram_offset, skbn->data, dgram_len); 324 325 switch (skbn->data[0] & 0xf0) { 326 case 0x40: 327 skbn->protocol = htons(ETH_P_IP); 328 break; 329 case 0x60: 330 skbn->protocol = htons(ETH_P_IPV6); 331 break; 332 default: 333 net_err_ratelimited("%s: unknown protocol\n", 334 link->ndev->name); 335 dev_kfree_skb_any(skbn); 336 u64_stats_update_begin(&link->rx_syncp); 337 u64_stats_inc(&link->rx_errors); 338 u64_stats_update_end(&link->rx_syncp); 339 continue; 340 } 341 342 u64_stats_update_begin(&link->rx_syncp); 343 u64_stats_inc(&link->rx_packets); 344 u64_stats_add(&link->rx_bytes, skbn->len); 345 u64_stats_update_end(&link->rx_syncp); 346 347 netif_rx(skbn); 348 } 349 unlock: 350 rcu_read_unlock(); 351 next_ndp: 352 /* Other NDP to process? */ 353 ndpoffset = (int)le16_to_cpu(ndp16.wNextNdpIndex); 354 if (!ndpoffset) 355 break; 356 } 357 358 /* free skb */ 359 dev_consume_skb_any(skb); 360 return; 361 error: 362 dev_kfree_skb_any(skb); 363 } 364 365 static struct sk_buff *mhi_net_skb_agg(struct mhi_mbim_context *mbim, 366 struct sk_buff *skb) 367 { 368 struct sk_buff *head = mbim->skbagg_head; 369 struct sk_buff *tail = mbim->skbagg_tail; 370 371 /* This is non-paged skb chaining using frag_list */ 372 if (!head) { 373 mbim->skbagg_head = skb; 374 return skb; 375 } 376 377 if (!skb_shinfo(head)->frag_list) 378 skb_shinfo(head)->frag_list = skb; 379 else 380 tail->next = skb; 381 382 head->len += skb->len; 383 head->data_len += skb->len; 384 head->truesize += skb->truesize; 385 386 mbim->skbagg_tail = skb; 387 388 return mbim->skbagg_head; 389 } 390 391 static void mhi_net_rx_refill_work(struct work_struct *work) 392 { 393 struct mhi_mbim_context *mbim = container_of(work, struct mhi_mbim_context, 394 rx_refill.work); 395 struct mhi_device *mdev = mbim->mdev; 396 int err; 397 398 while (!mhi_queue_is_full(mdev, DMA_FROM_DEVICE)) { 399 struct sk_buff *skb = alloc_skb(mbim->mru, GFP_KERNEL); 400 401 if (unlikely(!skb)) 402 break; 403 404 err = mhi_queue_skb(mdev, DMA_FROM_DEVICE, skb, 405 mbim->mru, MHI_EOT); 406 if (unlikely(err)) { 407 kfree_skb(skb); 408 break; 409 } 410 411 /* Do not hog the CPU if rx buffers are consumed faster than 412 * queued (unlikely). 413 */ 414 cond_resched(); 415 } 416 417 /* If we're still starved of rx buffers, reschedule later */ 418 if (mhi_get_free_desc_count(mdev, DMA_FROM_DEVICE) == mbim->rx_queue_sz) 419 schedule_delayed_work(&mbim->rx_refill, HZ / 2); 420 } 421 422 static void mhi_mbim_dl_callback(struct mhi_device *mhi_dev, 423 struct mhi_result *mhi_res) 424 { 425 struct mhi_mbim_context *mbim = dev_get_drvdata(&mhi_dev->dev); 426 struct sk_buff *skb = mhi_res->buf_addr; 427 int free_desc_count; 428 429 free_desc_count = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE); 430 431 if (unlikely(mhi_res->transaction_status)) { 432 switch (mhi_res->transaction_status) { 433 case -EOVERFLOW: 434 /* Packet has been split over multiple transfers */ 435 skb_put(skb, mhi_res->bytes_xferd); 436 mhi_net_skb_agg(mbim, skb); 437 break; 438 case -ENOTCONN: 439 /* MHI layer stopping/resetting the DL channel */ 440 dev_kfree_skb_any(skb); 441 return; 442 default: 443 /* Unknown error, simply drop */ 444 dev_kfree_skb_any(skb); 445 } 446 } else { 447 skb_put(skb, mhi_res->bytes_xferd); 448 449 if (mbim->skbagg_head) { 450 /* Aggregate the final fragment */ 451 skb = mhi_net_skb_agg(mbim, skb); 452 mbim->skbagg_head = NULL; 453 } 454 455 mhi_mbim_rx(mbim, skb); 456 } 457 458 /* Refill if RX buffers queue becomes low */ 459 if (free_desc_count >= mbim->rx_queue_sz / 2) 460 schedule_delayed_work(&mbim->rx_refill, 0); 461 } 462 463 static void mhi_mbim_ndo_get_stats64(struct net_device *ndev, 464 struct rtnl_link_stats64 *stats) 465 { 466 struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev); 467 unsigned int start; 468 469 do { 470 start = u64_stats_fetch_begin(&link->rx_syncp); 471 stats->rx_packets = u64_stats_read(&link->rx_packets); 472 stats->rx_bytes = u64_stats_read(&link->rx_bytes); 473 stats->rx_errors = u64_stats_read(&link->rx_errors); 474 } while (u64_stats_fetch_retry(&link->rx_syncp, start)); 475 476 do { 477 start = u64_stats_fetch_begin(&link->tx_syncp); 478 stats->tx_packets = u64_stats_read(&link->tx_packets); 479 stats->tx_bytes = u64_stats_read(&link->tx_bytes); 480 stats->tx_errors = u64_stats_read(&link->tx_errors); 481 stats->tx_dropped = u64_stats_read(&link->tx_dropped); 482 } while (u64_stats_fetch_retry(&link->tx_syncp, start)); 483 } 484 485 static void mhi_mbim_ul_callback(struct mhi_device *mhi_dev, 486 struct mhi_result *mhi_res) 487 { 488 struct mhi_mbim_context *mbim = dev_get_drvdata(&mhi_dev->dev); 489 struct sk_buff *skb = mhi_res->buf_addr; 490 struct net_device *ndev = skb->dev; 491 struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev); 492 493 /* Hardware has consumed the buffer, so free the skb (which is not 494 * freed by the MHI stack) and perform accounting. 495 */ 496 dev_consume_skb_any(skb); 497 498 u64_stats_update_begin(&link->tx_syncp); 499 if (unlikely(mhi_res->transaction_status)) { 500 /* MHI layer stopping/resetting the UL channel */ 501 if (mhi_res->transaction_status == -ENOTCONN) { 502 u64_stats_update_end(&link->tx_syncp); 503 return; 504 } 505 506 u64_stats_inc(&link->tx_errors); 507 } else { 508 u64_stats_inc(&link->tx_packets); 509 u64_stats_add(&link->tx_bytes, mhi_res->bytes_xferd); 510 } 511 u64_stats_update_end(&link->tx_syncp); 512 513 if (netif_queue_stopped(ndev) && !mhi_queue_is_full(mbim->mdev, DMA_TO_DEVICE)) 514 netif_wake_queue(ndev); 515 } 516 517 static int mhi_mbim_ndo_open(struct net_device *ndev) 518 { 519 struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev); 520 521 /* Feed the MHI rx buffer pool */ 522 schedule_delayed_work(&link->mbim->rx_refill, 0); 523 524 /* Carrier is established via out-of-band channel (e.g. qmi) */ 525 netif_carrier_on(ndev); 526 527 netif_start_queue(ndev); 528 529 return 0; 530 } 531 532 static int mhi_mbim_ndo_stop(struct net_device *ndev) 533 { 534 netif_stop_queue(ndev); 535 netif_carrier_off(ndev); 536 537 return 0; 538 } 539 540 static const struct net_device_ops mhi_mbim_ndo = { 541 .ndo_open = mhi_mbim_ndo_open, 542 .ndo_stop = mhi_mbim_ndo_stop, 543 .ndo_start_xmit = mhi_mbim_ndo_xmit, 544 .ndo_get_stats64 = mhi_mbim_ndo_get_stats64, 545 }; 546 547 static int mhi_mbim_newlink(void *ctxt, struct net_device *ndev, u32 if_id, 548 struct netlink_ext_ack *extack) 549 { 550 struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev); 551 struct mhi_mbim_context *mbim = ctxt; 552 553 link->mbim = mbim; 554 link->session = mhi_mbim_get_link_mux_id(link->mbim->mdev->mhi_cntrl) + if_id; 555 link->ndev = ndev; 556 u64_stats_init(&link->rx_syncp); 557 u64_stats_init(&link->tx_syncp); 558 559 rcu_read_lock(); 560 if (mhi_mbim_get_link_rcu(mbim, if_id)) { 561 rcu_read_unlock(); 562 return -EEXIST; 563 } 564 rcu_read_unlock(); 565 566 /* Already protected by RTNL lock */ 567 hlist_add_head_rcu(&link->hlnode, &mbim->link_list[LINK_HASH(if_id)]); 568 569 return register_netdevice(ndev); 570 } 571 572 static void mhi_mbim_dellink(void *ctxt, struct net_device *ndev, 573 struct list_head *head) 574 { 575 struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev); 576 577 hlist_del_init_rcu(&link->hlnode); 578 synchronize_rcu(); 579 580 unregister_netdevice_queue(ndev, head); 581 } 582 583 static void mhi_mbim_setup(struct net_device *ndev) 584 { 585 ndev->header_ops = NULL; /* No header */ 586 ndev->type = ARPHRD_RAWIP; 587 ndev->needed_headroom = 588 struct_size_t(struct mbim_tx_hdr, ndp16.dpe16, 2); 589 ndev->hard_header_len = 0; 590 ndev->addr_len = 0; 591 ndev->flags = IFF_POINTOPOINT | IFF_NOARP; 592 ndev->netdev_ops = &mhi_mbim_ndo; 593 ndev->mtu = MHI_MBIM_DEFAULT_MTU; 594 ndev->min_mtu = ETH_MIN_MTU; 595 ndev->max_mtu = MHI_MAX_BUF_SZ - ndev->needed_headroom; 596 ndev->tx_queue_len = 1000; 597 ndev->needs_free_netdev = true; 598 } 599 600 static const struct wwan_ops mhi_mbim_wwan_ops = { 601 .priv_size = sizeof(struct mhi_mbim_link), 602 .setup = mhi_mbim_setup, 603 .newlink = mhi_mbim_newlink, 604 .dellink = mhi_mbim_dellink, 605 }; 606 607 static int mhi_mbim_probe(struct mhi_device *mhi_dev, const struct mhi_device_id *id) 608 { 609 struct mhi_controller *cntrl = mhi_dev->mhi_cntrl; 610 struct mhi_mbim_context *mbim; 611 int err; 612 613 mbim = devm_kzalloc(&mhi_dev->dev, sizeof(*mbim), GFP_KERNEL); 614 if (!mbim) 615 return -ENOMEM; 616 617 spin_lock_init(&mbim->tx_lock); 618 dev_set_drvdata(&mhi_dev->dev, mbim); 619 mbim->mdev = mhi_dev; 620 mbim->mru = mhi_dev->mhi_cntrl->mru ? mhi_dev->mhi_cntrl->mru : MHI_DEFAULT_MRU; 621 622 INIT_DELAYED_WORK(&mbim->rx_refill, mhi_net_rx_refill_work); 623 624 /* Start MHI channels */ 625 err = mhi_prepare_for_transfer(mhi_dev); 626 if (err) 627 return err; 628 629 /* Number of transfer descriptors determines size of the queue */ 630 mbim->rx_queue_sz = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE); 631 632 /* Register wwan link ops with MHI controller representing WWAN instance */ 633 return wwan_register_ops(&cntrl->mhi_dev->dev, &mhi_mbim_wwan_ops, mbim, 0); 634 } 635 636 static void mhi_mbim_remove(struct mhi_device *mhi_dev) 637 { 638 struct mhi_mbim_context *mbim = dev_get_drvdata(&mhi_dev->dev); 639 struct mhi_controller *cntrl = mhi_dev->mhi_cntrl; 640 641 mhi_unprepare_from_transfer(mhi_dev); 642 cancel_delayed_work_sync(&mbim->rx_refill); 643 wwan_unregister_ops(&cntrl->mhi_dev->dev); 644 kfree_skb(mbim->skbagg_head); 645 dev_set_drvdata(&mhi_dev->dev, NULL); 646 } 647 648 static const struct mhi_device_id mhi_mbim_id_table[] = { 649 /* Hardware accelerated data PATH (to modem IPA), MBIM protocol */ 650 { .chan = "IP_HW0_MBIM", .driver_data = 0 }, 651 {} 652 }; 653 MODULE_DEVICE_TABLE(mhi, mhi_mbim_id_table); 654 655 static struct mhi_driver mhi_mbim_driver = { 656 .probe = mhi_mbim_probe, 657 .remove = mhi_mbim_remove, 658 .dl_xfer_cb = mhi_mbim_dl_callback, 659 .ul_xfer_cb = mhi_mbim_ul_callback, 660 .id_table = mhi_mbim_id_table, 661 .driver = { 662 .name = "mhi_wwan_mbim", 663 }, 664 }; 665 666 module_mhi_driver(mhi_mbim_driver); 667 668 MODULE_AUTHOR("Loic Poulain <loic.poulain@linaro.org>"); 669 MODULE_DESCRIPTION("Network/MBIM over MHI"); 670 MODULE_LICENSE("GPL v2"); 671