Lines Matching full:message
81 * - A TX message: a combination of a message header, payload
87 * Closed: we are not appending more payloads to this TX message
89 * whichever). We have appended padding so the whole message
93 * - Most of the time we keep a TX message open to which we append
97 * the end of the FIFO), we close the message, mark the rest of the
98 * FIFO space unusable (skip_tail), create a new message at the
99 * beginning of the FIFO (if there is space) and append the message
103 * engine. So we don't write a message to the remaining FIFO space
106 * - We overload one of the fields in the message header to use it as
107 * 'size' of the TX message, so we can iterate over them. It also
135 * - The whole message has to be padded to i2400m->bus_tx_block_size;
140 * When we append a message, we tell the bus specific code to kick in
142 * the lockin we do. The TX code will only send a TX message at the
144 * course, when the bus-specific driver attempts to TX a message that
148 * partially full FIFO, with a closed message ready to be delivered
149 * (with a moved message header to make sure it is size-aligned to
150 * 16), TAIL room that was unusable (and thus is marked with a message
152 * incomplete message with a couple of payloads.
162 * | TX message padding | |
186 * | msg_hdr (size X) [this message is closed] | \|/
219 * | msg_hdr (size X) \|/ [message is open] |
230 * i2400m_tx_new() Opens a new message in the FIFO
231 * i2400m_tx_fits() Checks if a new payload fits in the message
232 * i2400m_tx_close() Closes an open message in the FIFO
240 * i2400m_tx_msg_get() Gets first message ready to go
242 * i2400m_tx_msg_sent() Ack the message is sent; repeat from
267 * Message header and payload descriptors have to be 16
278 * documents, the maximum number of payloads per message can be
279 * up to 60. Increasing the number of payloads to 60 per message
288 * documents, the maximum size of each message can be up to 16KiB.
414 * i2400m_tx() calls i2400m_tx_close() to close the message, since there
417 * i2400m_tx_new() to allocate space for new message header calling
419 * to accommodate the message header, but there is enough head space.
452 * If the tail room space is not enough to push the message in i2400m_tx_fifo_push()
455 * this message in the TX FIFO. in i2400m_tx_fifo_push()
457 * in tail room of the TX FIFO to accommodate the message. in i2400m_tx_fifo_push()
459 * can figure out, if the caller wants to push the message in i2400m_tx_fifo_push()
462 * cannot accommodate the message. in i2400m_tx_fifo_push()
490 * Tail room can get to be zero if a message was opened when there was
523 * message (if there are still descriptors left unused).
526 * 0 if the message won't fit, 1 if it will.
530 * Assumes a TX message is active (i2400m->tx_msg).
544 * Start a new TX message header in the queue.
547 * the message header.
549 * We allocate the biggest TX message header we might need (one that'd
555 * Assumes that the previous message is CLOSED (eg: either
569 * accommodate the new message header I2400M_TX_PLD_SIZE, but in i2400m_tx_new()
571 * Adding bus_tx_room_min padding while allocating a new TX message in i2400m_tx_new()
582 d_printf(2, dev, "new TX message: tail full, trying head\n"); in i2400m_tx_new()
590 d_printf(2, dev, "new TX message: %p @%zu\n", in i2400m_tx_new()
596 * Finalize the current TX message header
598 * Sets the message header to be at the proper location depending on
602 * Appends padding bytes to make sure the whole TX message (counting
603 * from the 'relocated' message header) is aligned to
609 * TX message, as the "msg header and payload descriptors" will be
625 /* We can get this situation when a new message was started in i2400m_tx_close()
632 /* Relocate the message header in i2400m_tx_close()
640 * figure out where the next TX message starts (and where the in i2400m_tx_close()
651 * message so the size is a multiple of i2400m->bus_tx_block_size. in i2400m_tx_close()
692 * room for the message in the queue).
702 * Whenever we write to a message, we increase msg->size, so it
703 * reflects exactly how big the message is. This is needed so that if
729 /* If there is no current TX message, create one; if the in i2400m_tx()
743 d_printf(2, dev, "closing TX message (fits %u singleton " in i2400m_tx()
753 * TX message. The total message size must not exceed the maximum in i2400m_tx()
754 * size of each message I2400M_TX_MSG_SIZE. If it exceeds, in i2400m_tx()
755 * close the current message and push this skb into the new message. in i2400m_tx()
758 d_printf(2, dev, "TX: message too big, going new\n"); in i2400m_tx()
764 /* So we have a current message header; now append space for in i2400m_tx()
765 * the message -- if there is not enough, try the head */ in i2400m_tx()
812 * i2400m_tx_msg_get - Get the first TX message in the FIFO to start sending it
815 * @bus_size: where to place the size of the TX message
817 * Called by the bus-specific driver to get the first TX message at
821 * transferring that message (i2400m->tx_msg_size).
827 * The size of the TX message to be transmitted might be smaller than
828 * that of the TX message in the FIFO (in case the header was
830 * use. We keep the message's size in i2400m->tx_msg_size so that
885 /* Now we have a valid TX message (with payloads) to TX */ in i2400m_tx_msg_get()
919 * i2400m_tx_msg_sent - indicate the transmission of a TX message
923 * Called by the bus-specific driver when a message has been sent;
927 * Should be called even if the message send failed and we are
928 * dropping this TX message.