/**
* struct canque_slot_t - one CAN message slot in the CAN FIFO queue
* @next: pointer to the next/younger slot
- * @mrs_do_inp: space for flags and optional command describing action
+ * @slot_flags: space for flags and optional command describing action
* associated with slot data
* @msg: space for one CAN message
*
* @head: pointer to the FIFO head, oldest slot
* @tail: pointer to the location, where pointer to newly inserted slot
* should be added
- * @tail: pointer to the location, where pointer to newly inserted slot
+ * @flist: pointer to list of the free slots associated with queue
* @entry: pointer to the memory allocated for the list slots.
* @fifo_lock: the lock to ensure atomicity of slot manipulation operations.
*
struct chip_t;
/**
- * canque_edge_t - CAN message delivery subsystem graph edge
+ * struct canque_edge_t - CAN message delivery subsystem graph edge
* @fifo: place where primitive @struct canque_fifo_t FIFO is located.
* @filtid: the possible CAN message identifiers filter.
* @filtmask: the filter mask, the comparison considers only
* @edge_used: the atomic usage counter, mainly used for safe destruction of the edge.
* @edge_prio: the assigned queue priority from the range 0 to %CANQUEUE_PRIO_NR-1
* @edge_num: edge sequential number intended for debugging purposes only
+ *
+ * This structure represents one direction connection from messages source
+ * (@inends) to message consumer (@outends) fifo ends hub. The edge contains
+ * &struct canque_fifo_t for message fifo implementation.
*/
struct canque_edge_t {
struct canque_fifo_t fifo;
};
/**
- * canque_edge_t - CAN message delivery subsystem graph vertex (FIFO ends)
+ * struct canque_ends_t - CAN message delivery subsystem graph vertex (FIFO ends)
* @active: the array of the lists of active edges directed to the ends structure
* with ready messages. The array is indexed by the edges priorities.
* @idle: the list of the edges directed to the ends structure with empty FIFOs.
* %CANQUEUE_NOTIFY_PROC (in->out call) - empty state negated => out side is requested to process slots.
* %CANQUEUE_NOTIFY_NOUSR (both) - notify, that the last user has released the edge usage
* called with some lock to prevent edge disappear.
+ * %CANQUEUE_NOTIFY_DEAD (both) - edge is in progress of deletion.
+ * %CANQUEUE_NOTIFY_ATACH (both) - new edge has been attached to end.
+ * %CANQUEUE_NOTIFY_FILTCH (out->in call) - edge filter rules changed
+ * %CANQUEUE_NOTIFY_ERROR (out->in call) - error in messages processing.
* @context: space to store ends user specific information
* @endinfo: space to store some other ends usage specific informations
* mainly for waking-up by the notify calls.
+ *
+ * Structure represents place to connect edges to for CAN communication entity.
+ * The zero, one or more incoming and outgoing edges can be connected to
+ * this structure.
*/
struct canque_ends_t {
struct list_head active[CANQUEUE_PRIO_NR];
#define CANQUEUE_NOTIFY_ERRTX_SEND 0x11002 /* tx send error */
#define CANQUEUE_NOTIFY_ERRTX_BUS 0x11003 /* tx bus error */
+/**
+ * canque_notify_inends - request to send notification to the input ends
+ * @qedge: pointer to the edge structure
+ * @what: notification type
+ */
static inline
void canque_notify_inends(struct canque_edge_t *qedge, int what)
{
qedge->inends->notify(qedge->inends,qedge,what);
}
+/**
+ * canque_notify_outends - request to send notification to the output ends
+ * @qedge: pointer to the edge structure
+ * @what: notification type
+ */
static inline
void canque_notify_outends(struct canque_edge_t *qedge, int what)
{
qedge->outends->notify(qedge->outends,qedge,what);
}
+/**
+ * canque_notify_bothends - request to send notification to the both ends
+ * @qedge: pointer to the edge structure
+ * @what: notification type
+ */
static inline
void canque_notify_bothends(struct canque_edge_t *qedge, int what)
{
canque_notify_outends(qedge, what);
}
+/**
+ * canque_activate_edge - mark output end of the edge as active
+ * @qedge: pointer to the edge structure
+ * @inends: input side of the edge
+ *
+ * Function call moves output side of the edge from idle onto active edges
+ * list.
+ */
static inline
void canque_activate_edge(struct canque_ends_t *inends, struct canque_edge_t *qedge)
{
spin_unlock_irqrestore(&inends->ends_lock, flags);
}
+/**
+ * canque_filtid2internal - converts message ID and filter flags into internal format
+ * @id: CAN message 11 or 29 bit identifier
+ * @filtflags: CAN message flags
+ *
+ * This function maps message ID and %MSG_RTR, %MSG_EXT and %MSG_LOCAL into one 32 bit number
+ */
+static inline
+unsigned int canque_filtid2internal(unsigned long id, int filtflags)
+{
+ filtflags &= MSG_RTR|MSG_EXT|MSG_LOCAL;
+ filtflags += filtflags&MSG_RTR;
+ return (id&MSG_ID_MASK) | (filtflags<<28);
+}
+
int canque_get_inslot(struct canque_ends_t *qends,
struct canque_edge_t **qedgep, struct canque_slot_t **slotp, int cmd);
struct canque_edge_t *qedge, struct canque_slot_t *slot);
int canque_set_filt(struct canque_edge_t *qedge,
- unsigned long filtid, unsigned long filtmask);
-
+ unsigned long filtid, unsigned long filtmask, int flags);
+
int canque_flush(struct canque_edge_t *qedge);
struct canque_edge_t *canque_new_edge_kern(int slotsnr);
projects / lincan.git / blobdiff