drivers/net/wwan/iosm/iosm_ipc_protocol_ops.h

   1 /* SPDX-License-Identifier: GPL-2.0-only
   2  *
   3  * Copyright (C) 2020-21 Intel Corporation.
   4  */
   5
   6 #ifndef IOSM_IPC_PROTOCOL_OPS_H
   7 #define IOSM_IPC_PROTOCOL_OPS_H
   8
   9 #define SIZE_MASK 0x00FFFFFF
  10 #define COMPLETION_STATUS 24
  11 #define RESET_BIT 7
  12
  13 /**
  14  * enum ipc_mem_td_cs - Completion status of a TD
  15  * @IPC_MEM_TD_CS_INVALID:            Initial status - td not yet used.
  16  * @IPC_MEM_TD_CS_PARTIAL_TRANSFER:   More data pending -> next TD used for this
  17  * @IPC_MEM_TD_CS_END_TRANSFER:       IO transfer is complete.
  18  * @IPC_MEM_TD_CS_OVERFLOW:           IO transfer to small for the buff to write
  19  * @IPC_MEM_TD_CS_ABORT:              TD marked as abort and shall be discarded
  20  *                                    by AP.
  21  * @IPC_MEM_TD_CS_ERROR:              General error.
  22  */
  23 enum ipc_mem_td_cs {
  24         IPC_MEM_TD_CS_INVALID,
  25         IPC_MEM_TD_CS_PARTIAL_TRANSFER,
  26         IPC_MEM_TD_CS_END_TRANSFER,
  27         IPC_MEM_TD_CS_OVERFLOW,
  28         IPC_MEM_TD_CS_ABORT,
  29         IPC_MEM_TD_CS_ERROR,
  30 };
  31
  32 /**
  33  * enum ipc_mem_msg_cs - Completion status of IPC Message
  34  * @IPC_MEM_MSG_CS_INVALID:     Initial status.
  35  * @IPC_MEM_MSG_CS_SUCCESS:     IPC Message completion success.
  36  * @IPC_MEM_MSG_CS_ERROR:       Message send error.
  37  */
  38 enum ipc_mem_msg_cs {
  39         IPC_MEM_MSG_CS_INVALID,
  40         IPC_MEM_MSG_CS_SUCCESS,
  41         IPC_MEM_MSG_CS_ERROR,
  42 };
  43
  44 /**
  45  * struct ipc_msg_prep_args_pipe - struct for pipe args for message preparation
  46  * @pipe:       Pipe to open/close
  47  */
  48 struct ipc_msg_prep_args_pipe {
  49         struct ipc_pipe *pipe;
  50 };
  51
  52 /**
  53  * struct ipc_msg_prep_args_sleep - struct for sleep args for message
  54  *                                  preparation
  55  * @target:     0=host, 1=device
  56  * @state:      0=enter sleep, 1=exit sleep
  57  */
  58 struct ipc_msg_prep_args_sleep {
  59         unsigned int target;
  60         unsigned int state;
  61 };
  62
  63 /**
  64  * struct ipc_msg_prep_feature_set - struct for feature set argument for
  65  *                                   message preparation
  66  * @reset_enable:       0=out-of-band, 1=in-band-crash notification
  67  */
  68 struct ipc_msg_prep_feature_set {
  69         u8 reset_enable;
  70 };
  71
  72 /**
  73  * struct ipc_msg_prep_map - struct for map argument for message preparation
  74  * @region_id:  Region to map
  75  * @addr:       Pcie addr of region to map
  76  * @size:       Size of the region to map
  77  */
  78 struct ipc_msg_prep_map {
  79         unsigned int region_id;
  80         unsigned long addr;
  81         size_t size;
  82 };
  83
  84 /**
  85  * struct ipc_msg_prep_unmap - struct for unmap argument for message preparation
  86  * @region_id:  Region to unmap
  87  */
  88 struct ipc_msg_prep_unmap {
  89         unsigned int region_id;
  90 };
  91
  92 /**
  93  * struct ipc_msg_prep_args - Union to handle different message types
  94  * @pipe_open:          Pipe open message preparation struct
  95  * @pipe_close:         Pipe close message preparation struct
  96  * @sleep:              Sleep message preparation struct
  97  * @feature_set:        Feature set message preparation struct
  98  * @map:                Memory map message preparation struct
  99  * @unmap:              Memory unmap message preparation struct
 100  */
 101 union ipc_msg_prep_args {
 102         struct ipc_msg_prep_args_pipe pipe_open;
 103         struct ipc_msg_prep_args_pipe pipe_close;
 104         struct ipc_msg_prep_args_sleep sleep;
 105         struct ipc_msg_prep_feature_set feature_set;
 106         struct ipc_msg_prep_map map;
 107         struct ipc_msg_prep_unmap unmap;
 108 };
 109
 110 /**
 111  * enum ipc_msg_prep_type - Enum for message prepare actions
 112  * @IPC_MSG_PREP_SLEEP:         Sleep message preparation type
 113  * @IPC_MSG_PREP_PIPE_OPEN:     Pipe open message preparation type
 114  * @IPC_MSG_PREP_PIPE_CLOSE:    Pipe close message preparation type
 115  * @IPC_MSG_PREP_FEATURE_SET:   Feature set message preparation type
 116  * @IPC_MSG_PREP_MAP:           Memory map message preparation type
 117  * @IPC_MSG_PREP_UNMAP:         Memory unmap message preparation type
 118  */
 119 enum ipc_msg_prep_type {
 120         IPC_MSG_PREP_SLEEP,
 121         IPC_MSG_PREP_PIPE_OPEN,
 122         IPC_MSG_PREP_PIPE_CLOSE,
 123         IPC_MSG_PREP_FEATURE_SET,
 124         IPC_MSG_PREP_MAP,
 125         IPC_MSG_PREP_UNMAP,
 126 };
 127
 128 /**
 129  * struct ipc_rsp - Response to sent message
 130  * @completion: For waking up requestor
 131  * @status:     Completion status
 132  */
 133 struct ipc_rsp {
 134         struct completion completion;
 135         enum ipc_mem_msg_cs status;
 136 };
 137
 138 /**
 139  * enum ipc_mem_msg - Type-definition of the messages.
 140  * @IPC_MEM_MSG_OPEN_PIPE:      AP ->CP: Open a pipe
 141  * @IPC_MEM_MSG_CLOSE_PIPE:     AP ->CP: Close a pipe
 142  * @IPC_MEM_MSG_ABORT_PIPE:     AP ->CP: wait for completion of the
 143  *                              running transfer and abort all pending
 144  *                              IO-transfers for the pipe
 145  * @IPC_MEM_MSG_SLEEP:          AP ->CP: host enter or exit sleep
 146  * @IPC_MEM_MSG_FEATURE_SET:    AP ->CP: Intel feature configuration
 147  */
 148 enum ipc_mem_msg {
 149         IPC_MEM_MSG_OPEN_PIPE = 0x01,
 150         IPC_MEM_MSG_CLOSE_PIPE = 0x02,
 151         IPC_MEM_MSG_ABORT_PIPE = 0x03,
 152         IPC_MEM_MSG_SLEEP = 0x04,
 153         IPC_MEM_MSG_FEATURE_SET = 0xF0,
 154 };
 155
 156 /**
 157  * struct ipc_mem_msg_open_pipe - Message structure for open pipe
 158  * @tdr_addr:                   Tdr address
 159  * @tdr_entries:                Tdr entries
 160  * @pipe_nr:                    Pipe number
 161  * @type_of_message:            Message type
 162  * @irq_vector:                 MSI vector number
 163  * @accumulation_backoff:       Time in usec for data accumalation
 164  * @completion_status:          Message Completion Status
 165  */
 166 struct ipc_mem_msg_open_pipe {
 167         __le64 tdr_addr;
 168         __le16 tdr_entries;
 169         u8 pipe_nr;
 170         u8 type_of_message;
 171         __le32 irq_vector;
 172         __le32 accumulation_backoff;
 173         __le32 completion_status;
 174 };
 175
 176 /**
 177  * struct ipc_mem_msg_close_pipe - Message structure for close pipe
 178  * @reserved1:                  Reserved
 179  * @reserved2:                  Reserved
 180  * @pipe_nr:                    Pipe number
 181  * @type_of_message:            Message type
 182  * @reserved3:                  Reserved
 183  * @reserved4:                  Reserved
 184  * @completion_status:          Message Completion Status
 185  */
 186 struct ipc_mem_msg_close_pipe {
 187         __le32 reserved1[2];
 188         __le16 reserved2;
 189         u8 pipe_nr;
 190         u8 type_of_message;
 191         __le32  reserved3;
 192         __le32 reserved4;
 193         __le32 completion_status;
 194 };
 195
 196 /**
 197  * struct ipc_mem_msg_abort_pipe - Message structure for abort pipe
 198  * @reserved1:                  Reserved
 199  * @reserved2:                  Reserved
 200  * @pipe_nr:                    Pipe number
 201  * @type_of_message:            Message type
 202  * @reserved3:                  Reserved
 203  * @reserved4:                  Reserved
 204  * @completion_status:          Message Completion Status
 205  */
 206 struct ipc_mem_msg_abort_pipe {
 207         __le32  reserved1[2];
 208         __le16 reserved2;
 209         u8 pipe_nr;
 210         u8 type_of_message;
 211         __le32 reserved3;
 212         __le32 reserved4;
 213         __le32 completion_status;
 214 };
 215
 216 /**
 217  * struct ipc_mem_msg_host_sleep - Message structure for sleep message.
 218  * @reserved1:          Reserved
 219  * @target:             0=host, 1=device, host or EP devie
 220  *                      is the message target
 221  * @state:              0=enter sleep, 1=exit sleep,
 222  *                      2=enter sleep no protocol
 223  * @reserved2:          Reserved
 224  * @type_of_message:    Message type
 225  * @reserved3:          Reserved
 226  * @reserved4:          Reserved
 227  * @completion_status:  Message Completion Status
 228  */
 229 struct ipc_mem_msg_host_sleep {
 230         __le32 reserved1[2];
 231         u8 target;
 232         u8 state;
 233         u8 reserved2;
 234         u8 type_of_message;
 235         __le32 reserved3;
 236         __le32 reserved4;
 237         __le32 completion_status;
 238 };
 239
 240 /**
 241  * struct ipc_mem_msg_feature_set - Message structure for feature_set message
 242  * @reserved1:                  Reserved
 243  * @reserved2:                  Reserved
 244  * @reset_enable:               0=out-of-band, 1=in-band-crash notification
 245  * @type_of_message:            Message type
 246  * @reserved3:                  Reserved
 247  * @reserved4:                  Reserved
 248  * @completion_status:          Message Completion Status
 249  */
 250 struct ipc_mem_msg_feature_set {
 251         __le32 reserved1[2];
 252         __le16 reserved2;
 253         u8 reset_enable;
 254         u8 type_of_message;
 255         __le32 reserved3;
 256         __le32 reserved4;
 257         __le32 completion_status;
 258 };
 259
 260 /**
 261  * struct ipc_mem_msg_common - Message structure for completion status update.
 262  * @reserved1:                  Reserved
 263  * @reserved2:                  Reserved
 264  * @type_of_message:            Message type
 265  * @reserved3:                  Reserved
 266  * @reserved4:                  Reserved
 267  * @completion_status:          Message Completion Status
 268  */
 269 struct ipc_mem_msg_common {
 270         __le32 reserved1[2];
 271         u8 reserved2[3];
 272         u8 type_of_message;
 273         __le32 reserved3;
 274         __le32 reserved4;
 275         __le32 completion_status;
 276 };
 277
 278 /**
 279  * union ipc_mem_msg_entry - Union with all possible messages.
 280  * @open_pipe:          Open pipe message struct
 281  * @close_pipe:         Close pipe message struct
 282  * @abort_pipe:         Abort pipe message struct
 283  * @host_sleep:         Host sleep message struct
 284  * @feature_set:        Featuer set message struct
 285  * @common:             Used to access msg_type and to set the completion status
 286  */
 287 union ipc_mem_msg_entry {
 288         struct ipc_mem_msg_open_pipe open_pipe;
 289         struct ipc_mem_msg_close_pipe close_pipe;
 290         struct ipc_mem_msg_abort_pipe abort_pipe;
 291         struct ipc_mem_msg_host_sleep host_sleep;
 292         struct ipc_mem_msg_feature_set feature_set;
 293         struct ipc_mem_msg_common common;
 294 };
 295
 296 /* Transfer descriptor definition. */
 297 struct ipc_protocol_td {
 298         union {
 299                 /*   0 :  63 - 64-bit address of a buffer in host memory. */
 300                 dma_addr_t address;
 301                 struct {
 302                         /*   0 :  31 - 32 bit address */
 303                         __le32 address;
 304                         /*  32 :  63 - corresponding descriptor */
 305                         __le32 desc;
 306                 } __packed shm;
 307         } buffer;
 308
 309         /*      0 - 2nd byte - Size of the buffer.
 310          *      The host provides the size of the buffer queued.
 311          *      The EP device reads this value and shall update
 312          *      it for downlink transfers to indicate the
 313          *      amount of data written in buffer.
 314          *      3rd byte - This field provides the completion status
 315          *      of the TD. When queuing the TD, the host sets
 316          *      the status to 0. The EP device updates this
 317          *      field when completing the TD.
 318          */
 319         __le32 scs;
 320
 321         /*      0th - nr of following descriptors
 322          *      1 - 3rd byte - reserved
 323          */
 324         __le32 next;
 325 } __packed;
 326
 327 /**
 328  * ipc_protocol_msg_prep - Prepare message based upon message type
 329  * @ipc_imem:   iosm_protocol instance
 330  * @msg_type:   message prepare type
 331  * @args:       message arguments
 332  *
 333  * Return: 0 on success and failure value on error
 334  */
 335 int ipc_protocol_msg_prep(struct iosm_imem *ipc_imem,
 336                           enum ipc_msg_prep_type msg_type,
 337                           union ipc_msg_prep_args *args);
 338
 339 /**
 340  * ipc_protocol_msg_hp_update - Function for head pointer update
 341  *                              of message ring
 342  * @ipc_imem:   iosm_protocol instance
 343  */
 344 void ipc_protocol_msg_hp_update(struct iosm_imem *ipc_imem);
 345
 346 /**
 347  * ipc_protocol_msg_process - Function for processing responses
 348  *                            to IPC messages
 349  * @ipc_imem:   iosm_protocol instance
 350  * @irq:        IRQ vector
 351  *
 352  * Return:      True on success, false if error
 353  */
 354 bool ipc_protocol_msg_process(struct iosm_imem *ipc_imem, int irq);
 355
 356 /**
 357  * ipc_protocol_ul_td_send - Function for sending the data to CP
 358  * @ipc_protocol:       iosm_protocol instance
 359  * @pipe:               Pipe instance
 360  * @p_ul_list:          uplink sk_buff list
 361  *
 362  * Return: true in success, false in case of error
 363  */
 364 bool ipc_protocol_ul_td_send(struct iosm_protocol *ipc_protocol,
 365                              struct ipc_pipe *pipe,
 366                              struct sk_buff_head *p_ul_list);
 367
 368 /**
 369  * ipc_protocol_ul_td_process - Function for processing the sent data
 370  * @ipc_protocol:       iosm_protocol instance
 371  * @pipe:               Pipe instance
 372  *
 373  * Return: sk_buff instance
 374  */
 375 struct sk_buff *ipc_protocol_ul_td_process(struct iosm_protocol *ipc_protocol,
 376                                            struct ipc_pipe *pipe);
 377
 378 /**
 379  * ipc_protocol_dl_td_prepare - Function for providing DL TDs to CP
 380  * @ipc_protocol:       iosm_protocol instance
 381  * @pipe:               Pipe instance
 382  *
 383  * Return: true in success, false in case of error
 384  */
 385 bool ipc_protocol_dl_td_prepare(struct iosm_protocol *ipc_protocol,
 386                                 struct ipc_pipe *pipe);
 387
 388 /**
 389  * ipc_protocol_dl_td_process - Function for processing the DL data
 390  * @ipc_protocol:       iosm_protocol instance
 391  * @pipe:               Pipe instance
 392  *
 393  * Return: sk_buff instance
 394  */
 395 struct sk_buff *ipc_protocol_dl_td_process(struct iosm_protocol *ipc_protocol,
 396                                            struct ipc_pipe *pipe);
 397
 398 /**
 399  * ipc_protocol_get_head_tail_index - Function for getting Head and Tail
 400  *                                    pointer index of given pipe
 401  * @ipc_protocol:       iosm_protocol instance
 402  * @pipe:               Pipe Instance
 403  * @head:               head pointer index of the given pipe
 404  * @tail:               tail pointer index of the given pipe
 405  */
 406 void ipc_protocol_get_head_tail_index(struct iosm_protocol *ipc_protocol,
 407                                       struct ipc_pipe *pipe, u32 *head,
 408                                       u32 *tail);
 409 /**
 410  * ipc_protocol_get_ipc_status - Function for getting the IPC Status
 411  * @ipc_protocol:       iosm_protocol instance
 412  *
 413  * Return: Returns IPC State
 414  */
 415 enum ipc_mem_device_ipc_state ipc_protocol_get_ipc_status(struct iosm_protocol
 416                                                           *ipc_protocol);
 417
 418 /**
 419  * ipc_protocol_pipe_cleanup - Function to cleanup pipe resources
 420  * @ipc_protocol:       iosm_protocol instance
 421  * @pipe:               Pipe instance
 422  */
 423 void ipc_protocol_pipe_cleanup(struct iosm_protocol *ipc_protocol,
 424                                struct ipc_pipe *pipe);
 425
 426 /**
 427  * ipc_protocol_get_ap_exec_stage - Function for getting AP Exec Stage
 428  * @ipc_protocol:       pointer to struct iosm protocol
 429  *
 430  * Return: returns BOOT Stages
 431  */
 432 enum ipc_mem_exec_stage
 433 ipc_protocol_get_ap_exec_stage(struct iosm_protocol *ipc_protocol);
 434
 435 /**
 436  * ipc_protocol_pm_dev_get_sleep_notification - Function for getting Dev Sleep
 437  *                                              notification
 438  * @ipc_protocol:       iosm_protocol instance
 439  *
 440  * Return: Returns dev PM State
 441  */
 442 u32 ipc_protocol_pm_dev_get_sleep_notification(struct iosm_protocol
 443                                                *ipc_protocol);
 444 #endif