1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2021, Linaro Ltd <loic.poulain@linaro.org> */ 3 #include <linux/kernel.h> 4 #include <linux/mhi.h> 5 #include <linux/mod_devicetable.h> 6 #include <linux/module.h> 7 #include <linux/wwan.h> 8 9 /* MHI wwan flags */ 10 #define MHI_WWAN_DL_CAP BIT(0) 11 #define MHI_WWAN_UL_CAP BIT(1) 12 #define MHI_WWAN_RX_REFILL BIT(2) 13 14 #define MHI_WWAN_MAX_MTU 0x8000 15 16 struct mhi_wwan_dev { 17 /* Lower level is a mhi dev, upper level is a wwan port */ 18 struct mhi_device *mhi_dev; 19 struct wwan_port *wwan_port; 20 21 /* State and capabilities */ 22 unsigned long flags; 23 size_t mtu; 24 25 /* Protect against concurrent TX and TX-completion (bh) */ 26 spinlock_t tx_lock; 27 28 /* Protect RX budget and rx_refill scheduling */ 29 spinlock_t rx_lock; 30 struct work_struct rx_refill; 31 32 /* RX budget is initially set to the size of the MHI RX queue and is 33 * used to limit the number of allocated and queued packets. It is 34 * decremented on data queueing and incremented on data release. 35 */ 36 unsigned int rx_budget; 37 }; 38 39 /* Increment RX budget and schedule RX refill if necessary */ 40 static void mhi_wwan_rx_budget_inc(struct mhi_wwan_dev *mhiwwan) 41 { 42 spin_lock(&mhiwwan->rx_lock); 43 44 mhiwwan->rx_budget++; 45 46 if (test_bit(MHI_WWAN_RX_REFILL, &mhiwwan->flags)) 47 schedule_work(&mhiwwan->rx_refill); 48 49 spin_unlock(&mhiwwan->rx_lock); 50 } 51 52 /* Decrement RX budget if non-zero and return true on success */ 53 static bool mhi_wwan_rx_budget_dec(struct mhi_wwan_dev *mhiwwan) 54 { 55 bool ret = false; 56 57 spin_lock(&mhiwwan->rx_lock); 58 59 if (mhiwwan->rx_budget) 60 mhiwwan->rx_budget--; 61 62 if (mhiwwan->rx_budget && test_bit(MHI_WWAN_RX_REFILL, &mhiwwan->flags)) 63 ret = true; 64 65 spin_unlock(&mhiwwan->rx_lock); 66 67 return ret; 68 } 69 70 static void __mhi_skb_destructor(struct sk_buff *skb) 71 { 72 /* RX buffer has been consumed, increase the allowed budget */ 73 mhi_wwan_rx_budget_inc(skb_shinfo(skb)->destructor_arg); 74 } 75 76 static void mhi_wwan_ctrl_refill_work(struct work_struct *work) 77 { 78 struct mhi_wwan_dev *mhiwwan = container_of(work, struct mhi_wwan_dev, rx_refill); 79 struct mhi_device *mhi_dev = mhiwwan->mhi_dev; 80 81 while (mhi_wwan_rx_budget_dec(mhiwwan)) { 82 struct sk_buff *skb; 83 84 skb = alloc_skb(mhiwwan->mtu, GFP_KERNEL); 85 if (!skb) { 86 mhi_wwan_rx_budget_inc(mhiwwan); 87 break; 88 } 89 90 /* To prevent unlimited buffer allocation if nothing consumes 91 * the RX buffers (passed to WWAN core), track their lifespan 92 * to not allocate more than allowed budget. 93 */ 94 skb->destructor = __mhi_skb_destructor; 95 skb_shinfo(skb)->destructor_arg = mhiwwan; 96 97 if (mhi_queue_skb(mhi_dev, DMA_FROM_DEVICE, skb, mhiwwan->mtu, MHI_EOT)) { 98 dev_err(&mhi_dev->dev, "Failed to queue buffer\n"); 99 kfree_skb(skb); 100 break; 101 } 102 } 103 } 104 105 static int mhi_wwan_ctrl_start(struct wwan_port *port) 106 { 107 struct mhi_wwan_dev *mhiwwan = wwan_port_get_drvdata(port); 108 int ret; 109 110 /* Start mhi device's channel(s) */ 111 ret = mhi_prepare_for_transfer(mhiwwan->mhi_dev); 112 if (ret) 113 return ret; 114 115 /* Don't allocate more buffers than MHI channel queue size */ 116 mhiwwan->rx_budget = mhi_get_free_desc_count(mhiwwan->mhi_dev, DMA_FROM_DEVICE); 117 118 /* Add buffers to the MHI inbound queue */ 119 if (test_bit(MHI_WWAN_DL_CAP, &mhiwwan->flags)) { 120 set_bit(MHI_WWAN_RX_REFILL, &mhiwwan->flags); 121 mhi_wwan_ctrl_refill_work(&mhiwwan->rx_refill); 122 } 123 124 return 0; 125 } 126 127 static void mhi_wwan_ctrl_stop(struct wwan_port *port) 128 { 129 struct mhi_wwan_dev *mhiwwan = wwan_port_get_drvdata(port); 130 131 spin_lock(&mhiwwan->rx_lock); 132 clear_bit(MHI_WWAN_RX_REFILL, &mhiwwan->flags); 133 spin_unlock(&mhiwwan->rx_lock); 134 135 cancel_work_sync(&mhiwwan->rx_refill); 136 137 mhi_unprepare_from_transfer(mhiwwan->mhi_dev); 138 } 139 140 static int mhi_wwan_ctrl_tx(struct wwan_port *port, struct sk_buff *skb) 141 { 142 struct mhi_wwan_dev *mhiwwan = wwan_port_get_drvdata(port); 143 int ret; 144 145 if (skb->len > mhiwwan->mtu) 146 return -EMSGSIZE; 147 148 if (!test_bit(MHI_WWAN_UL_CAP, &mhiwwan->flags)) 149 return -EOPNOTSUPP; 150 151 /* Queue the packet for MHI transfer and check fullness of the queue */ 152 spin_lock_bh(&mhiwwan->tx_lock); 153 ret = mhi_queue_skb(mhiwwan->mhi_dev, DMA_TO_DEVICE, skb, skb->len, MHI_EOT); 154 if (mhi_queue_is_full(mhiwwan->mhi_dev, DMA_TO_DEVICE)) 155 wwan_port_txoff(port); 156 spin_unlock_bh(&mhiwwan->tx_lock); 157 158 return ret; 159 } 160 161 static const struct wwan_port_ops wwan_pops = { 162 .start = mhi_wwan_ctrl_start, 163 .stop = mhi_wwan_ctrl_stop, 164 .tx = mhi_wwan_ctrl_tx, 165 }; 166 167 static void mhi_ul_xfer_cb(struct mhi_device *mhi_dev, 168 struct mhi_result *mhi_result) 169 { 170 struct mhi_wwan_dev *mhiwwan = dev_get_drvdata(&mhi_dev->dev); 171 struct wwan_port *port = mhiwwan->wwan_port; 172 struct sk_buff *skb = mhi_result->buf_addr; 173 174 dev_dbg(&mhi_dev->dev, "%s: status: %d xfer_len: %zu\n", __func__, 175 mhi_result->transaction_status, mhi_result->bytes_xferd); 176 177 /* MHI core has done with the buffer, release it */ 178 consume_skb(skb); 179 180 /* There is likely new slot available in the MHI queue, re-allow TX */ 181 spin_lock_bh(&mhiwwan->tx_lock); 182 if (!mhi_queue_is_full(mhiwwan->mhi_dev, DMA_TO_DEVICE)) 183 wwan_port_txon(port); 184 spin_unlock_bh(&mhiwwan->tx_lock); 185 } 186 187 static void mhi_dl_xfer_cb(struct mhi_device *mhi_dev, 188 struct mhi_result *mhi_result) 189 { 190 struct mhi_wwan_dev *mhiwwan = dev_get_drvdata(&mhi_dev->dev); 191 struct wwan_port *port = mhiwwan->wwan_port; 192 struct sk_buff *skb = mhi_result->buf_addr; 193 194 dev_dbg(&mhi_dev->dev, "%s: status: %d receive_len: %zu\n", __func__, 195 mhi_result->transaction_status, mhi_result->bytes_xferd); 196 197 if (mhi_result->transaction_status && 198 mhi_result->transaction_status != -EOVERFLOW) { 199 kfree_skb(skb); 200 return; 201 } 202 203 /* MHI core does not update skb->len, do it before forward */ 204 skb_put(skb, mhi_result->bytes_xferd); 205 wwan_port_rx(port, skb); 206 207 /* Do not increment rx budget nor refill RX buffers now, wait for the 208 * buffer to be consumed. Done from __mhi_skb_destructor(). 209 */ 210 } 211 212 static int mhi_wwan_ctrl_probe(struct mhi_device *mhi_dev, 213 const struct mhi_device_id *id) 214 { 215 struct mhi_controller *cntrl = mhi_dev->mhi_cntrl; 216 struct mhi_wwan_dev *mhiwwan; 217 struct wwan_port *port; 218 219 mhiwwan = kzalloc(sizeof(*mhiwwan), GFP_KERNEL); 220 if (!mhiwwan) 221 return -ENOMEM; 222 223 mhiwwan->mhi_dev = mhi_dev; 224 mhiwwan->mtu = MHI_WWAN_MAX_MTU; 225 INIT_WORK(&mhiwwan->rx_refill, mhi_wwan_ctrl_refill_work); 226 spin_lock_init(&mhiwwan->tx_lock); 227 spin_lock_init(&mhiwwan->rx_lock); 228 229 if (mhi_dev->dl_chan) 230 set_bit(MHI_WWAN_DL_CAP, &mhiwwan->flags); 231 if (mhi_dev->ul_chan) 232 set_bit(MHI_WWAN_UL_CAP, &mhiwwan->flags); 233 234 dev_set_drvdata(&mhi_dev->dev, mhiwwan); 235 236 /* Register as a wwan port, id->driver_data contains wwan port type */ 237 port = wwan_create_port(&cntrl->mhi_dev->dev, id->driver_data, 238 &wwan_pops, mhiwwan); 239 if (IS_ERR(port)) { 240 kfree(mhiwwan); 241 return PTR_ERR(port); 242 } 243 244 mhiwwan->wwan_port = port; 245 246 return 0; 247 }; 248 249 static void mhi_wwan_ctrl_remove(struct mhi_device *mhi_dev) 250 { 251 struct mhi_wwan_dev *mhiwwan = dev_get_drvdata(&mhi_dev->dev); 252 253 wwan_remove_port(mhiwwan->wwan_port); 254 kfree(mhiwwan); 255 } 256 257 static const struct mhi_device_id mhi_wwan_ctrl_match_table[] = { 258 { .chan = "DUN", .driver_data = WWAN_PORT_AT }, 259 { .chan = "MBIM", .driver_data = WWAN_PORT_MBIM }, 260 { .chan = "QMI", .driver_data = WWAN_PORT_QMI }, 261 { .chan = "DIAG", .driver_data = WWAN_PORT_QCDM }, 262 { .chan = "FIREHOSE", .driver_data = WWAN_PORT_FIREHOSE }, 263 {}, 264 }; 265 MODULE_DEVICE_TABLE(mhi, mhi_wwan_ctrl_match_table); 266 267 static struct mhi_driver mhi_wwan_ctrl_driver = { 268 .id_table = mhi_wwan_ctrl_match_table, 269 .remove = mhi_wwan_ctrl_remove, 270 .probe = mhi_wwan_ctrl_probe, 271 .ul_xfer_cb = mhi_ul_xfer_cb, 272 .dl_xfer_cb = mhi_dl_xfer_cb, 273 .driver = { 274 .name = "mhi_wwan_ctrl", 275 }, 276 }; 277 278 module_mhi_driver(mhi_wwan_ctrl_driver); 279 280 MODULE_LICENSE("GPL v2"); 281 MODULE_DESCRIPTION("MHI WWAN CTRL Driver"); 282 MODULE_AUTHOR("Loic Poulain <loic.poulain@linaro.org>"); 283