drivers/net/wwan/iosm/iosm_ipc_mux.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2020-21 Intel Corporation.
   4  */
   5
   6 #include "iosm_ipc_mux_codec.h"
   7
   8 /* At the begin of the runtime phase the IP MUX channel shall created. */
   9 static int ipc_mux_channel_create(struct iosm_mux *ipc_mux)
  10 {
  11         int channel_id;
  12
  13         channel_id = ipc_imem_channel_alloc(ipc_mux->imem, ipc_mux->instance_id,
  14                                             IPC_CTYPE_WWAN);
  15
  16         if (channel_id < 0) {
  17                 dev_err(ipc_mux->dev,
  18                         "allocation of the MUX channel id failed");
  19                 ipc_mux->state = MUX_S_ERROR;
  20                 ipc_mux->event = MUX_E_NOT_APPLICABLE;
  21                 goto no_channel;
  22         }
  23
  24         /* Establish the MUX channel in blocking mode. */
  25         ipc_mux->channel = ipc_imem_channel_open(ipc_mux->imem, channel_id,
  26                                                  IPC_HP_NET_CHANNEL_INIT);
  27
  28         if (!ipc_mux->channel) {
  29                 dev_err(ipc_mux->dev, "ipc_imem_channel_open failed");
  30                 ipc_mux->state = MUX_S_ERROR;
  31                 ipc_mux->event = MUX_E_NOT_APPLICABLE;
  32                 return -ENODEV; /* MUX channel is not available. */
  33         }
  34
  35         /* Define the MUX active state properties. */
  36         ipc_mux->state = MUX_S_ACTIVE;
  37         ipc_mux->event = MUX_E_NO_ORDERS;
  38
  39 no_channel:
  40         return channel_id;
  41 }
  42
  43 /* Reset the session/if id state. */
  44 static void ipc_mux_session_free(struct iosm_mux *ipc_mux, int if_id)
  45 {
  46         struct mux_session *if_entry;
  47
  48         if_entry = &ipc_mux->session[if_id];
  49         /* Reset the session state. */
  50         if_entry->wwan = NULL;
  51 }
  52
  53 /* Create and send the session open command. */
  54 static struct mux_cmd_open_session_resp *
  55 ipc_mux_session_open_send(struct iosm_mux *ipc_mux, int if_id)
  56 {
  57         struct mux_cmd_open_session_resp *open_session_resp;
  58         struct mux_acb *acb = &ipc_mux->acb;
  59         union mux_cmd_param param;
  60
  61         /* open_session commands to one ACB and start transmission. */
  62         param.open_session.flow_ctrl = 0;
  63         param.open_session.ipv4v6_hints = 0;
  64         param.open_session.reserved2 = 0;
  65         param.open_session.dl_head_pad_len = cpu_to_le32(IPC_MEM_DL_ETH_OFFSET);
  66
  67         /* Finish and transfer ACB. The user thread is suspended.
  68          * It is a blocking function call, until CP responds or timeout.
  69          */
  70         acb->wanted_response = MUX_CMD_OPEN_SESSION_RESP;
  71         if (ipc_mux_dl_acb_send_cmds(ipc_mux, MUX_CMD_OPEN_SESSION, if_id, 0,
  72                                      &param, sizeof(param.open_session), true,
  73                                  false) ||
  74             acb->got_response != MUX_CMD_OPEN_SESSION_RESP) {
  75                 dev_err(ipc_mux->dev, "if_id %d: OPEN_SESSION send failed",
  76                         if_id);
  77                 return NULL;
  78         }
  79
  80         open_session_resp = &ipc_mux->acb.got_param.open_session_resp;
  81         if (open_session_resp->response != cpu_to_le32(MUX_CMD_RESP_SUCCESS)) {
  82                 dev_err(ipc_mux->dev,
  83                         "if_id %d,session open failed,response=%d", if_id,
  84                         open_session_resp->response);
  85                 return NULL;
  86         }
  87
  88         return open_session_resp;
  89 }
  90
  91 /* Open the first IP session. */
  92 static bool ipc_mux_session_open(struct iosm_mux *ipc_mux,
  93                                  struct mux_session_open *session_open)
  94 {
  95         struct mux_cmd_open_session_resp *open_session_resp;
  96         int if_id;
  97
  98         /* Search for a free session interface id. */
  99         if_id = le32_to_cpu(session_open->if_id);
 100         if (if_id < 0 || if_id >= IPC_MEM_MUX_IP_SESSION_ENTRIES) {
 101                 dev_err(ipc_mux->dev, "invalid interface id=%d", if_id);
 102                 return false;
 103         }
 104
 105         /* Create and send the session open command.
 106          * It is a blocking function call, until CP responds or timeout.
 107          */
 108         open_session_resp = ipc_mux_session_open_send(ipc_mux, if_id);
 109         if (!open_session_resp) {
 110                 ipc_mux_session_free(ipc_mux, if_id);
 111                 session_open->if_id = cpu_to_le32(-1);
 112                 return false;
 113         }
 114
 115         /* Initialize the uplink skb accumulator. */
 116         skb_queue_head_init(&ipc_mux->session[if_id].ul_list);
 117
 118         ipc_mux->session[if_id].dl_head_pad_len = IPC_MEM_DL_ETH_OFFSET;
 119         ipc_mux->session[if_id].ul_head_pad_len =
 120                 le32_to_cpu(open_session_resp->ul_head_pad_len);
 121         ipc_mux->session[if_id].wwan = ipc_mux->wwan;
 122
 123         /* Reset the flow ctrl stats of the session */
 124         ipc_mux->session[if_id].flow_ctl_en_cnt = 0;
 125         ipc_mux->session[if_id].flow_ctl_dis_cnt = 0;
 126         ipc_mux->session[if_id].ul_flow_credits = 0;
 127         ipc_mux->session[if_id].net_tx_stop = false;
 128         ipc_mux->session[if_id].flow_ctl_mask = 0;
 129
 130         /* Save and return the assigned if id. */
 131         session_open->if_id = cpu_to_le32(if_id);
 132         ipc_mux->nr_sessions++;
 133
 134         return true;
 135 }
 136
 137 /* Free pending session UL packet. */
 138 static void ipc_mux_session_reset(struct iosm_mux *ipc_mux, int if_id)
 139 {
 140         /* Reset the session/if id state. */
 141         ipc_mux_session_free(ipc_mux, if_id);
 142
 143         /* Empty the uplink skb accumulator. */
 144         skb_queue_purge(&ipc_mux->session[if_id].ul_list);
 145 }
 146
 147 static void ipc_mux_session_close(struct iosm_mux *ipc_mux,
 148                                   struct mux_session_close *msg)
 149 {
 150         int if_id;
 151
 152         /* Copy the session interface id. */
 153         if_id = le32_to_cpu(msg->if_id);
 154
 155         if (if_id < 0 || if_id >= IPC_MEM_MUX_IP_SESSION_ENTRIES) {
 156                 dev_err(ipc_mux->dev, "invalid session id %d", if_id);
 157                 return;
 158         }
 159
 160         /* Create and send the session close command.
 161          * It is a blocking function call, until CP responds or timeout.
 162          */
 163         if (ipc_mux_dl_acb_send_cmds(ipc_mux, MUX_CMD_CLOSE_SESSION, if_id, 0,
 164                                      NULL, 0, true, false))
 165                 dev_err(ipc_mux->dev, "if_id %d: CLOSE_SESSION send failed",
 166                         if_id);
 167
 168         /* Reset the flow ctrl stats of the session */
 169         ipc_mux->session[if_id].flow_ctl_en_cnt = 0;
 170         ipc_mux->session[if_id].flow_ctl_dis_cnt = 0;
 171         ipc_mux->session[if_id].flow_ctl_mask = 0;
 172
 173         ipc_mux_session_reset(ipc_mux, if_id);
 174         ipc_mux->nr_sessions--;
 175 }
 176
 177 static void ipc_mux_channel_close(struct iosm_mux *ipc_mux,
 178                                   struct mux_channel_close *channel_close_p)
 179 {
 180         int i;
 181
 182         /* Free pending session UL packet. */
 183         for (i = 0; i < IPC_MEM_MUX_IP_SESSION_ENTRIES; i++)
 184                 if (ipc_mux->session[i].wwan)
 185                         ipc_mux_session_reset(ipc_mux, i);
 186
 187         ipc_imem_channel_close(ipc_mux->imem, ipc_mux->channel_id);
 188
 189         /* Reset the MUX object. */
 190         ipc_mux->state = MUX_S_INACTIVE;
 191         ipc_mux->event = MUX_E_INACTIVE;
 192 }
 193
 194 /* CP has interrupted AP. If AP is in IP MUX mode, execute the pending ops. */
 195 static int ipc_mux_schedule(struct iosm_mux *ipc_mux, union mux_msg *msg)
 196 {
 197         enum mux_event order;
 198         bool success;
 199         int ret = -EIO;
 200
 201         if (!ipc_mux->initialized) {
 202                 ret = -EAGAIN;
 203                 goto out;
 204         }
 205
 206         order = msg->common.event;
 207
 208         switch (ipc_mux->state) {
 209         case MUX_S_INACTIVE:
 210                 if (order != MUX_E_MUX_SESSION_OPEN)
 211                         goto out; /* Wait for the request to open a session */
 212
 213                 if (ipc_mux->event == MUX_E_INACTIVE)
 214                         /* Establish the MUX channel and the new state. */
 215                         ipc_mux->channel_id = ipc_mux_channel_create(ipc_mux);
 216
 217                 if (ipc_mux->state != MUX_S_ACTIVE) {
 218                         ret = ipc_mux->channel_id; /* Missing the MUX channel */
 219                         goto out;
 220                 }
 221
 222                 /* Disable the TD update timer and open the first IP session. */
 223                 ipc_imem_td_update_timer_suspend(ipc_mux->imem, true);
 224                 ipc_mux->event = MUX_E_MUX_SESSION_OPEN;
 225                 success = ipc_mux_session_open(ipc_mux, &msg->session_open);
 226
 227                 ipc_imem_td_update_timer_suspend(ipc_mux->imem, false);
 228                 if (success)
 229                         ret = ipc_mux->channel_id;
 230                 goto out;
 231
 232         case MUX_S_ACTIVE:
 233                 switch (order) {
 234                 case MUX_E_MUX_SESSION_OPEN:
 235                         /* Disable the TD update timer and open a session */
 236                         ipc_imem_td_update_timer_suspend(ipc_mux->imem, true);
 237                         ipc_mux->event = MUX_E_MUX_SESSION_OPEN;
 238                         success = ipc_mux_session_open(ipc_mux,
 239                                                        &msg->session_open);
 240                         ipc_imem_td_update_timer_suspend(ipc_mux->imem, false);
 241                         if (success)
 242                                 ret = ipc_mux->channel_id;
 243                         goto out;
 244
 245                 case MUX_E_MUX_SESSION_CLOSE:
 246                         /* Release an IP session. */
 247                         ipc_mux->event = MUX_E_MUX_SESSION_CLOSE;
 248                         ipc_mux_session_close(ipc_mux, &msg->session_close);
 249                         if (!ipc_mux->nr_sessions) {
 250                                 ipc_mux->event = MUX_E_MUX_CHANNEL_CLOSE;
 251                                 ipc_mux_channel_close(ipc_mux,
 252                                                       &msg->channel_close);
 253                         }
 254                         ret = ipc_mux->channel_id;
 255                         goto out;
 256
 257                 case MUX_E_MUX_CHANNEL_CLOSE:
 258                         /* Close the MUX channel pipes. */
 259                         ipc_mux->event = MUX_E_MUX_CHANNEL_CLOSE;
 260                         ipc_mux_channel_close(ipc_mux, &msg->channel_close);
 261                         ret = ipc_mux->channel_id;
 262                         goto out;
 263
 264                 default:
 265                         /* Invalid order. */
 266                         goto out;
 267                 }
 268
 269         default:
 270                 dev_err(ipc_mux->dev,
 271                         "unexpected MUX transition: state=%d, event=%d",
 272                         ipc_mux->state, ipc_mux->event);
 273         }
 274 out:
 275         return ret;
 276 }
 277
 278 struct iosm_mux *ipc_mux_init(struct ipc_mux_config *mux_cfg,
 279                               struct iosm_imem *imem)
 280 {
 281         struct iosm_mux *ipc_mux = kzalloc(sizeof(*ipc_mux), GFP_KERNEL);
 282         int i, j, ul_tds, ul_td_size;
 283         struct sk_buff_head *free_list;
 284         struct sk_buff *skb;
 285         int qlt_size;
 286
 287         if (!ipc_mux)
 288                 return NULL;
 289
 290         ipc_mux->protocol = mux_cfg->protocol;
 291         ipc_mux->ul_flow = mux_cfg->ul_flow;
 292         ipc_mux->instance_id = mux_cfg->instance_id;
 293         ipc_mux->wwan_q_offset = 0;
 294
 295         ipc_mux->pcie = imem->pcie;
 296         ipc_mux->imem = imem;
 297         ipc_mux->ipc_protocol = imem->ipc_protocol;
 298         ipc_mux->dev = imem->dev;
 299         ipc_mux->wwan = imem->wwan;
 300
 301         /* Get the reference to the UL ADB list. */
 302         free_list = &ipc_mux->ul_adb.free_list;
 303
 304         /* Initialize the list with free ADB. */
 305         skb_queue_head_init(free_list);
 306
 307         ul_td_size = IPC_MEM_MAX_DL_MUX_LITE_BUF_SIZE;
 308
 309         ul_tds = IPC_MEM_MAX_TDS_MUX_LITE_UL;
 310
 311         ipc_mux->ul_adb.dest_skb = NULL;
 312
 313         ipc_mux->initialized = true;
 314         ipc_mux->adb_prep_ongoing = false;
 315         ipc_mux->size_needed = 0;
 316         ipc_mux->ul_data_pend_bytes = 0;
 317         ipc_mux->state = MUX_S_INACTIVE;
 318         ipc_mux->ev_mux_net_transmit_pending = false;
 319         ipc_mux->tx_transaction_id = 0;
 320         ipc_mux->rr_next_session = 0;
 321         ipc_mux->event = MUX_E_INACTIVE;
 322         ipc_mux->channel_id = -1;
 323         ipc_mux->channel = NULL;
 324
 325         if (ipc_mux->protocol != MUX_LITE) {
 326                 qlt_size = offsetof(struct mux_qlth, ql) +
 327                                 MUX_QUEUE_LEVEL * sizeof(struct mux_qlth_ql);
 328
 329                 for (i = 0; i < IPC_MEM_MUX_IP_SESSION_ENTRIES; i++) {
 330                         ipc_mux->ul_adb.pp_qlt[i] = kzalloc(qlt_size,
 331                                                             GFP_ATOMIC);
 332                         if (!ipc_mux->ul_adb.pp_qlt[i]) {
 333                                 for (j = i - 1; j >= 0; j--)
 334                                         kfree(ipc_mux->ul_adb.pp_qlt[j]);
 335                                 kfree(ipc_mux);
 336                                 return NULL;
 337                         }
 338                 }
 339
 340                 ul_td_size = IPC_MEM_MAX_UL_ADB_BUF_SIZE;
 341                 ul_tds = IPC_MEM_MAX_TDS_MUX_AGGR_UL;
 342         }
 343
 344         /* Allocate the list of UL ADB. */
 345         for (i = 0; i < ul_tds; i++) {
 346                 dma_addr_t mapping;
 347
 348                 skb = ipc_pcie_alloc_skb(ipc_mux->pcie, ul_td_size, GFP_ATOMIC,
 349                                          &mapping, DMA_TO_DEVICE, 0);
 350                 if (!skb) {
 351                         ipc_mux_deinit(ipc_mux);
 352                         return NULL;
 353                 }
 354                 /* Extend the UL ADB list. */
 355                 skb_queue_tail(free_list, skb);
 356         }
 357
 358         return ipc_mux;
 359 }
 360
 361 /* Informs the network stack to restart transmission for all opened session if
 362  * Flow Control is not ON for that session.
 363  */
 364 static void ipc_mux_restart_tx_for_all_sessions(struct iosm_mux *ipc_mux)
 365 {
 366         struct mux_session *session;
 367         int idx;
 368
 369         for (idx = 0; idx < IPC_MEM_MUX_IP_SESSION_ENTRIES; idx++) {
 370                 session = &ipc_mux->session[idx];
 371
 372                 if (!session->wwan)
 373                         continue;
 374
 375                 /* If flow control of the session is OFF and if there was tx
 376                  * stop then restart. Inform the network interface to restart
 377                  * sending data.
 378                  */
 379                 if (session->flow_ctl_mask == 0) {
 380                         session->net_tx_stop = false;
 381                         ipc_mux_netif_tx_flowctrl(session, idx, false);
 382                 }
 383         }
 384 }
 385
 386 /* Informs the network stack to stop sending further pkt for all opened
 387  * sessions
 388  */
 389 static void ipc_mux_stop_netif_for_all_sessions(struct iosm_mux *ipc_mux)
 390 {
 391         struct mux_session *session;
 392         int idx;
 393
 394         for (idx = 0; idx < IPC_MEM_MUX_IP_SESSION_ENTRIES; idx++) {
 395                 session = &ipc_mux->session[idx];
 396
 397                 if (!session->wwan)
 398                         continue;
 399
 400                 ipc_mux_netif_tx_flowctrl(session, session->if_id, true);
 401         }
 402 }
 403
 404 void ipc_mux_check_n_restart_tx(struct iosm_mux *ipc_mux)
 405 {
 406         if (ipc_mux->ul_flow == MUX_UL) {
 407                 int low_thresh = IPC_MEM_MUX_UL_FLOWCTRL_LOW_B;
 408
 409                 if (ipc_mux->ul_data_pend_bytes < low_thresh)
 410                         ipc_mux_restart_tx_for_all_sessions(ipc_mux);
 411         }
 412 }
 413
 414 int ipc_mux_get_max_sessions(struct iosm_mux *ipc_mux)
 415 {
 416         return ipc_mux ? IPC_MEM_MUX_IP_SESSION_ENTRIES : -EFAULT;
 417 }
 418
 419 enum ipc_mux_protocol ipc_mux_get_active_protocol(struct iosm_mux *ipc_mux)
 420 {
 421         return ipc_mux ? ipc_mux->protocol : MUX_UNKNOWN;
 422 }
 423
 424 int ipc_mux_open_session(struct iosm_mux *ipc_mux, int session_nr)
 425 {
 426         struct mux_session_open *session_open;
 427         union mux_msg mux_msg;
 428
 429         session_open = &mux_msg.session_open;
 430         session_open->event = MUX_E_MUX_SESSION_OPEN;
 431
 432         session_open->if_id = cpu_to_le32(session_nr);
 433         ipc_mux->session[session_nr].flags |= IPC_MEM_WWAN_MUX;
 434         return ipc_mux_schedule(ipc_mux, &mux_msg);
 435 }
 436
 437 int ipc_mux_close_session(struct iosm_mux *ipc_mux, int session_nr)
 438 {
 439         struct mux_session_close *session_close;
 440         union mux_msg mux_msg;
 441         int ret_val;
 442
 443         session_close = &mux_msg.session_close;
 444         session_close->event = MUX_E_MUX_SESSION_CLOSE;
 445
 446         session_close->if_id = cpu_to_le32(session_nr);
 447         ret_val = ipc_mux_schedule(ipc_mux, &mux_msg);
 448         ipc_mux->session[session_nr].flags &= ~IPC_MEM_WWAN_MUX;
 449
 450         return ret_val;
 451 }
 452
 453 void ipc_mux_deinit(struct iosm_mux *ipc_mux)
 454 {
 455         struct mux_channel_close *channel_close;
 456         struct sk_buff_head *free_list;
 457         union mux_msg mux_msg;
 458         struct sk_buff *skb;
 459
 460         if (!ipc_mux->initialized)
 461                 return;
 462         ipc_mux_stop_netif_for_all_sessions(ipc_mux);
 463
 464         if (ipc_mux->state == MUX_S_ACTIVE) {
 465                 channel_close = &mux_msg.channel_close;
 466                 channel_close->event = MUX_E_MUX_CHANNEL_CLOSE;
 467                 ipc_mux_schedule(ipc_mux, &mux_msg);
 468         }
 469
 470         /* Empty the ADB free list. */
 471         free_list = &ipc_mux->ul_adb.free_list;
 472
 473         /* Remove from the head of the downlink queue. */
 474         while ((skb = skb_dequeue(free_list)))
 475                 ipc_pcie_kfree_skb(ipc_mux->pcie, skb);
 476
 477         if (ipc_mux->channel) {
 478                 ipc_mux->channel->ul_pipe.is_open = false;
 479                 ipc_mux->channel->dl_pipe.is_open = false;
 480         }
 481
 482         kfree(ipc_mux);
 483 }