lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening PHC | |
Open Source and information security mailing list archives
| ||
|
Date: Mon, 30 Nov 2009 16:00:46 +0100 From: sjur.brandeland@...ricsson.com To: netdev@...r.kernel.org, stefano.babic@...ic.homelinux.org Cc: randy.dunlap@...cle.com, kim.xx.lilliestierna@...ricsson.com, christian.bejram@...ricsson.com, daniel.martensson@...ricsson.com, Sjur Braendeland <sjur.brandeland@...ricsson.com> Subject: [RFC PATCH v3 2/8] CAIF Protocol Stack From: Sjur Braendeland <sjur.brandeland@...ricsson.com> Signed-off-by: Sjur Braendeland <sjur.brandeland@...ricsson.com> --- include/net/caif/generic/caif_layer.h | 341 +++++++++++++++++++++++++++++++++ include/net/caif/generic/cfcnfg.h | 211 ++++++++++++++++++++ include/net/caif/generic/cfctrl.h | 137 +++++++++++++ include/net/caif/generic/cffrml.h | 20 ++ include/net/caif/generic/cfglue.h | 174 +++++++++++++++++ include/net/caif/generic/cfloopcfg.h | 16 ++ include/net/caif/generic/cflst.h | 19 ++ include/net/caif/generic/cfmsll.h | 13 ++ include/net/caif/generic/cfmuxl.h | 22 ++ include/net/caif/generic/cfpkt.h | 264 +++++++++++++++++++++++++ include/net/caif/generic/cfserl.h | 20 ++ include/net/caif/generic/cfshml.h | 12 ++ include/net/caif/generic/cfspil.h | 85 ++++++++ include/net/caif/generic/cfsrvl.h | 33 ++++ include/net/caif/generic/cfusbl.h | 13 ++ include/net/caif/generic/fcs.h | 13 ++ 16 files changed, 1393 insertions(+), 0 deletions(-) create mode 100644 include/net/caif/generic/caif_layer.h create mode 100644 include/net/caif/generic/cfcnfg.h create mode 100644 include/net/caif/generic/cfctrl.h create mode 100644 include/net/caif/generic/cffrml.h create mode 100644 include/net/caif/generic/cfglue.h create mode 100644 include/net/caif/generic/cfloopcfg.h create mode 100644 include/net/caif/generic/cflst.h create mode 100644 include/net/caif/generic/cfmsll.h create mode 100644 include/net/caif/generic/cfmuxl.h create mode 100644 include/net/caif/generic/cfpkt.h create mode 100644 include/net/caif/generic/cfserl.h create mode 100644 include/net/caif/generic/cfshml.h create mode 100644 include/net/caif/generic/cfspil.h create mode 100644 include/net/caif/generic/cfsrvl.h create mode 100644 include/net/caif/generic/cfusbl.h create mode 100644 include/net/caif/generic/fcs.h diff --git a/include/net/caif/generic/caif_layer.h b/include/net/caif/generic/caif_layer.h new file mode 100644 index 0000000..0ae98b5 --- /dev/null +++ b/include/net/caif/generic/caif_layer.h @@ -0,0 +1,341 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Braendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CAIF_LAYER_H_ +#define CAIF_LAYER_H_ + +#include <net/caif/generic/cfglue.h> + +struct layer; +struct cfpkt; +struct cfpktq; +struct transmt_info; +struct caif_packet_funcs; + +#define CAIF_MAX_FRAMESIZE 4096 +#define CAIF_MAX_PAYLOAD_SIZE (4096 - 64) +#define CAIF_NEEDED_HEADROOM (10) +#define CAIF_NEEDED_TAILROOM (2) + + +#define CAIF_LAYER_NAME_SZ 16 +#define CAIF_SUCCESS 1 +#define CAIF_FAILURE 0 + +/*! \addtogroup GenCaifExternal + * Additional documentation for group `GenCaifExternal' + * @{ + */ + +/** CAIF Control Signaling. + * These commands are sent upwards in the CAIF stack. They are used for + * signaling originating from the modem. + * These are either responses (*_RSP) or events (*_IND). + */ +enum caif_ctrlcmd { + /** Flow Control is OFF, transmit function should stop sending data */ + CAIF_CTRLCMD_FLOW_OFF_IND = 0, + /** Flow Control is ON, transmit function can start sending data */ + CAIF_CTRLCMD_FLOW_ON_IND = 1, + /** Remote end modem has decided to close down channel */ + CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND = 5, + /** Called initially when the layer below has finished initialization */ + CAIF_CTRLCMD_INIT_RSP = 3, + /** Called when de-initialization is complete */ + CAIF_CTRLCMD_DEINIT_RSP = 4, + /** Called if initialization fails */ + CAIF_CTRLCMD_INIT_FAIL_RSP = 6, + /** Note: Only used internally in GenCaif. + * Called if physical interface cannot send more packets. + */ + _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND = 7, + /** Note: Only used internally in GenCaif. + * Called if physical interface is able to send packets again. + */ + _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND = 8, + _CAIF_CTRLCMD_PHYIF_DOWN_IND = 9, +}; + +/** Modem Control Signaling. + * These are requests sent 'downwards' in the stack. + * Flow ON, OFF can be indicated to the modem. + */ +enum caif_modemcmd { + /** Flow Control is ON, transmit function can start sending data */ + CAIF_MODEMCMD_FLOW_ON_REQ = 0, + /** Flow Control is OFF, transmit function should stop sending data */ + CAIF_MODEMCMD_FLOW_OFF_REQ = 1, + /** Notify physical layer that it is in use */ + _CAIF_MODEMCMD_PHYIF_USEFULL = 3, + /** Notify physical layer that it is no longer in use */ + _CAIF_MODEMCMD_PHYIF_USELESS = 4 +}; + +/** CAIF Packet Direction. + * Indicate if a packet is to be sent \b out or to be received \b in. + */ +enum caif_direction { + CAIF_DIR_IN = 0, /*!< Incoming packet received. */ + CAIF_DIR_OUT = 1 /*!< Outgoing packet to be transmitted. */ +}; + +/** This structure defines the generic layered structure in CAIF. + * It is inspired by the "Protocol Layer Design Pattern" (Streams). + * + * It defines a generic layering structure, used by all CAIF Layers and the + * layers interfacing CAIF. + * + * In order to integrate with CAIF an adaptation layer on top of the CAIF stack + * and PHY layer below the CAIF stack + * must be implemented. These layer must follow the design principles below. + * + * Principles for layering of protocol layers: + * -# All layers must use this structure. If embedding it, then place this + * structure first in the layer specific structure. + * -# Each layer should not depend on any others layer private data. + * -# In order to send data upwards do + * \code layer->up->receive(layer->up, packet); \endcode + * -# In order to send data downwards do + * \code layer->dn->transmit(layer->dn, info, packet); \endcode + * + * + * + */ +struct layer { + + struct layer *up; /*!< Pointer to the layer above */ + struct layer *dn; /*!< Pointer to the layer below */ + /*! + * Receive Function. + * Contract: Each layer must implement a receive function passing the + * CAIF packets upwards in the stack. + * Packet handling rules: + * -# The CAIF packet (cfpkt) cannot be accessed after + * passing it to the next layer using up->receive(). + * -# If parsing of the packet fails, the packet must be + * destroyed and -1 returned from the function. + * -# If parsing succeeds (and above layers return OK) then + * the function must return a value > 0. + * + * @param[in] layr Pointer to the current layer the receive function is + * implemented for (this pointer). + * @param[in] cfpkt Pointer to CaifPacket to be handled. + * @return result < 0 indicates an error, 0 or positive value + * indicates success. + */ + int (*receive)(struct layer *layr, struct cfpkt *cfpkt); + + /*! + * Transmit Function. + * Contract: Each layer must implement a transmit function passing the + * CAIF packet downwards in the stack. + * Packet handling rules: + * -# The CAIF packet (cfpkt) ownership is passed to the + * transmit function. This means that the the packet + * cannot be accessed after passing it to the below + * layer using dn->transmit(). + * + * -# If transmit fails, however, the ownership is returned + * to thecaller. The caller of "dn->transmit()" must + * destroy or resend packet. + * + * -# Return value less than zero means error, zero or + * greater than zero means OK. + * + * @param[in] layr Pointer to the current layer the receive function + * is implemented for (this pointer). + * @param[in] cfpkt Pointer to CaifPacket to be handled. + * @param[in] info Info about physical layer (filled in by MUX layer) + * and CAIF header size (each layer adds to hdr_len). + * @return result < 0 indicates an error, 0 or positive value + * indicate success. + */ + int (*transmit) (struct layer *layr, struct transmt_info *info, + struct cfpkt *cfpkt); + + /*! + * Control Function used to signal upwards in the CAIF stack. + * Used for signaling responses (CAIF_CTRLCMD_*_RSP) + * and asynchronous events from the modem (CAIF_CTRLCMD_*_IND) + * + * @param[in] layr Pointer to the current layer the receive function + * is implemented for (this pointer). + * @param[in] ctrl Control Command. + */ + void (*ctrlcmd) (struct layer *layr, enum caif_ctrlcmd ctrl, + int phyid); + + /*! + * Control Function used for controlling the modem. Used to signal + * down-wards in the CAIF stack. + * @returns 0 on success, < 0 upon failure. + * @param[in] layr Pointer to the current layer the receive function + * is implemented for (this pointer). + * @param[in] ctrl Control Command. + */ + int (*modemcmd) (struct layer *layr, enum caif_modemcmd ctrl); + + struct layer *next; /*!< Pointer to chain of layers, up/dn will + * then point at the first element of a + * which then should be iterated through + * the next pointer. + */ + unsigned short prio; /*!< Priority of this layer */ + unsigned int id; /*!< The identity of this layer. */ + unsigned int type; /*<! The type of this layer */ + char name[CAIF_LAYER_NAME_SZ]; /*!< Name of the layer */ +}; +/** Set the up pointer for a specified layer. + * @param layr Layer where up pointer shall be set. + * @param above Layer above. + */ +#define layer_set_up(layr, above) ((layr)->up = (struct layer *)(above)) + +/** Set the dn pointer for a specified layer. + * @param layr Layer where down pointer shall be set. + * @param below Layer below. + */ +#define layer_set_dn(layr, below) ((layr)->dn = (struct layer *)(below)) + +/** + * Transmit info, passed downwards in protocol layers. + */ +struct transmt_info { + /** Channel ID of the logical CAIF connection. + * Used by the service layer to indicate to mux the PHY-layer + * (Physical-ID) to send packet over. + */ + unsigned short channel_id; + + /** Physical ID of the physical connection used by the logical CAIF + * connection. Used by service layers to identify their physical id + * to Caif MUX (CFMUXL)so that the MUX can add the correct physical + * ID to the packet. + */ + unsigned short phid; + + /** Header length, used to align pay load on 32bit boundary. + * Used by SPI Layer (CFSPIL) to align start of pay-load data (IP header + * start) to 16 or 32 bits boundary. + * All layers add the number of header bytes they are using, then SPI + * layer adds padding to get correct alignment. + */ + unsigned short hdr_len; + + /** Packet priority. */ + unsigned char prio; +}; + +/** Packet functions needed by the adaptation layer and PHY layer are exported + * in this structure. + * + */ +struct caif_packet_funcs { + + /** Used to map from a "native" packet (e.g. Linux Socket Buffer) + * to a CAIF packet. + * @param dir - Direction, indicating whether this packet is to be + * sent or received. + * @param nativepkt - The native packet to be transformed to a CAIF + * packet. + * @returns the mapped CAIF packet CFPKT. + */ + struct cfpkt * + (*cfpkt_fromnative)(enum caif_direction dir, void *nativepkt); + + /** Used to map from a CAIF packet to a "native" packet + * (e.g. Linux Socket Buffer). + * @param pkt - The CAIF packet to be transformed to a "native" + * packet. + * @returns the native packet transformed from a CAIF packet. + */ + void *(*cfpkt_tonative)(struct cfpkt *pkt); + + /** Used by "app" layer to create an outgoing CAIF packet to be sent + * out of the CAIF Stack. + * @param data - Packet data to copy into the packet. + * If NULL then copying will not take place. + * @param len - Length of data to copy into the packet. + * @returns a new CAIF packet CFPKT. + * @deprecated Use \b cfpkt_create_pkt (above) instead. + */ + struct cfpkt * + (*cfpkt_create_recv_pkt)(const unsigned char *data, + unsigned int len); + + /** Used by PHY layer to create an incoming CAIF packet to be + * processed by the CAIF Stack. + * @param data - Packet data to copy into the packet. If NULL then + * copying will not take place. + * @param len - Length of data to copy into the packet. + * @returns a new CAIF packet CFPKT. + * @deprecated Use \b cfpkt_create_pkt (above) instead. + */ + struct cfpkt * + (*cfpkt_create_xmit_pkt)(const unsigned char *data, + unsigned int len); + + /** Used to extract data from a CAIF packet. + * @param cfpkt Packet to extract data from. + * @param buf Buffer to hold the data to be extracted from the + * CAIF packet. + * @param buflen Length of the buffer (maximum length of the + * data to copy into the buffer). + * @param actual_len Number of bytes copied from the packet into + * the buffer. + */ + void + (*cfpkt_extract)(struct cfpkt *cfpkt, void *buf, unsigned int buflen, + unsigned int *actual_len); + + /** Releases a CAIF packet. + * @param cfpkt Packet to destroy. + */ + void + (*cfpkt_destroy)(struct cfpkt *cfpkt); + + /** Append by giving user access to the packet buffer. + * @param pkt Packet to append to. + * @param buf Buffer inside pkt that user shall copy data into. + * @param buflen Length of buffer and number of bytes added to packet. + * @return < 0 on error. + */ + int (*cfpkt_raw_append)(struct cfpkt *cfpkt, void **buf, + unsigned int buflen); + + /** Extract by giving user access to the packet buffer. + * @param pkt Packet to extract from. + * @param buf Buffer inside pkt that user shall copy data from. + * @param buflen Length of buffer and number of bytes removed from + * packet. + * @return < 0 on error + */ + int (*cfpkt_raw_extract)(struct cfpkt *cfpkt, void **buf, + unsigned int buflen); + + /** Creates a packet queue. */ + struct cfpktq *(*cfpktq_create)(void); + + /** Inserts a packet into the packet queue, packets are ordered by + * priority. + * If the same priority is used packets are ordered as a FIFO. + */ + void (*cfpkt_queue)(struct cfpktq *pktq, struct cfpkt *pkt, + unsigned short prio); + + /** Peek into the first packet in the queue. */ + struct cfpkt *(*cfpkt_qpeek)(struct cfpktq *pktq); + + /** Dequeue a packet from the queue. */ + struct cfpkt *(*cfpkt_dequeue)(struct cfpktq *pktq); + + /** Get length of a packet */ + uint16(*cfpkt_getlen)(struct cfpkt *pkt); +}; + +/*! @} */ + +#endif /* CAIF_LAYER_H_ */ diff --git a/include/net/caif/generic/cfcnfg.h b/include/net/caif/generic/cfcnfg.h new file mode 100644 index 0000000..7e4fc44 --- /dev/null +++ b/include/net/caif/generic/cfcnfg.h @@ -0,0 +1,211 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFCNFG_H_ +#define CFCNFG_H_ +#include <net/caif/generic/caif_layer.h> +#include <net/caif/generic/cfctrl.h> + +struct cfcnfg; + +/*! \addtogroup GenCaifExternal + * Additional documentation for group `GenCaifExternal' + * @{ + */ + +/** Types of physical layers defined in CAIF Stack */ +enum cfcnfg_phy_type { + CFPHYTYPE_UNKNOWN = 0, + CFPHYTYPE_SERIAL = 1, /*!< Serial physical interface */ + CFPHYTYPE_SPI = 2, /*!< SPI physical interface */ + CFPHYTYPE_MSL = 3, /*!< MSL physical interface */ + CFPHYTYPE_SHM = 4, /*!< Shared memory physical interface */ + CFPHYTYPE_LOOP = 5, /*!< Loopback physical interface */ + CFPHYTYPE_USB = 6, /*!< USB physical interface */ + CFPHYTYPE_MAX = 7 +}; + +/** Physical preference - HW Abstraction */ +enum cfcnfg_phy_preference { + /** Default physical interface */ + CFPHYPREF_UNSPECIFIED = 0xa0, + /** Default physical interface for low-latency traffic */ + CFPHYPREF_LOW_LAT = 0xd0, + /** Default physical interface for high-bandwidth traffic */ + CFPHYPREF_HIGH_BW = 0xe0, + /** \b TEST \b ONLY Loopback interface simulating modem responses */ + CFPHYPREF_LOOP = 0x70, + /** \b TEST \b ONLY Raw loopback interface */ + CFPHYPREF_RAW_LOOP = 0x80 +}; + +/** Types of CAIF Links defined in CAIF Stack + * @obsolete + */ +enum cfcnfg_link_type { + _CF_DECM = 0, /*!< DECM link - NOT SUPPORTED */ + CF_VEI = CFCTRL_SRV_VEI, /*!< VEI link - AT */ + CF_VIDEO = CFCTRL_SRV_VIDEO, /*!< Video link */ + CF_DEBUG = CFCTRL_SRV_DBG, /*!< Debug link */ + CF_DATAGRAM = CFCTRL_SRV_DATAGRAM, /*!< Datagram link */ + CF_RFM = CFCTRL_SRV_RFM, /*!< RFM link */ + CF_UTILITY = CFCTRL_SRV_UTIL /*!< Utility link */ +}; + +/** Configuration parameters for a physical layer (e.g. serial) */ +struct cfcnfg_phy_param { + int foo; +}; + +/** Configuration information used to setup the CAIF physical interface */ +struct cfcnfg_phy_config { + /** CAIF physical type */ + enum cfcnfg_phy_type phy_type; + /** Instance number, e.g. UART number */ + uint8 phy_sub_instance; + /** Preference low-latency/high-bandwidth */ + enum cfcnfg_phy_preference pref; + /** Device name */ + char name[20]; + /** Checksum is used for interface */ + bool checksum; + /** Configuration parameter specific to the PHY Type */ + struct cfcnfg_phy_param param; + /** Pointer to layer above */ + struct layer *up; +}; + +/** Registration information used to set up the CAIF physical interface */ +struct cfcnfg_phy_mgmt { + /** Registration of type */ + enum cfcnfg_phy_type type; + /** Creates an instance of the physical layer (e.g. serial) + * and configures it + */ + struct layer *(*create_phy) (struct cfcnfg_phy_config *config); + /** Delete an instance of the physical layer (e.g. serial) */ + int (*delete_phy) (struct layer *l); +}; + +/** + * This variable is used as a global flag, in order to set whether STX is used in + * serial communication. + * NOTE: This is not a fully future-proof solution. + */ +extern int serial_use_stx; + +/** + * These variable is used as a global flag, in order to configure padding on SPI communication. + * NOTE: This is not a fully future-proof solution. + */ +extern int spi_up_head_align; +extern int spi_up_tail_align; +extern int spi_down_head_align; +extern int spi_down_tail_align; + +/** + * Create the CAIF configuration object. + * @return The created instance of a CFCNFG object. + */ +struct cfcnfg *cfcnfg_create(void); + +/** + * Adds a physical layer to the CAIF stack. + * @param cnfg Pointer to a CAIF configuration object, created by + * cfcnfg_create(). + * @param phy_type Specifies the type of physical interface, e.g. + * CFPHYTYPE_SERIAL. + * @param phy_layer Specify the physical layer. The transmit function + * MUST be set in the structure. + * @param phyid [out] The assigned physical ID for this layer, + * used in \ref cfcnfg_add_adapt_layer to specify + * PHY for the link. + */ + +void +cfcnfg_add_phy_layer(struct cfcnfg *cnfg, enum cfcnfg_phy_type phy_type, + struct layer *phy_layer, uint16 *phyid, + enum cfcnfg_phy_preference pref); + +/** + * Deletes an adaptation layer from the CAIF stack. + * + * @param cnfg Pointer to a CAIF configuration object, created by + * cfcnfg_create(). + * @param adap_layer Adaptation layer to be removed. + * @return 0 on success. + */ +int cfcnfg_del_adapt_layer(struct cfcnfg *cnfg, struct layer *adap_layer); + +/** + * Adds an adaptation layer to the CAIF stack. + * The adaptation Layer is where the interface to application or higher-level + * driver functionality is implemented. + * + * @param cnfg Pointer to a CAIF configuration object, created by + * cfcnfg_create(). + * @param linktype Type of link that is set up, e.g. CF_AT_PLAIN. + * @param connid Connection ID, used for datagram links. + * @param phyid PHY ID received from \ref cfcnfg_add_phy_layer, + * specifying the PHY device to use for this link. + * @param adap_layer Specify the adaptation layer; the receive + * and flow-control functions MUST be set in the structure. + * @return true on success, false upon failure. + */ +bool +cfcnfg_add_adapt_layer(struct cfcnfg *cnfg, enum cfcnfg_link_type linktype, + uint32 connid, uint16 phyid, struct layer *adap_layer); + +/** + * Adds an adaptation layer to the CAIF stack. + * The adaptation Layer is where the interface to application or higher-level + * driver functionality is implemented. + * + * @param cnfg Pointer to a CAIF configuration object, created by + * cfcnfg_create(). + * @param param Link setup parameters. + * @param adap_layer Specify the adaptation layer; the receive and flow-control + functions MUST be set in the structure. + * @return true on success, false upon failure. + */ +bool +cfcnfg_add_adaptation_layer(struct cfcnfg *cnfg, + struct cfctrl_link_param *param, + struct layer *adap_layer); + +/** + * Returns a handle to the packet functions used to create packets with + * content and to extract information from packets. + */ +struct caif_packet_funcs cfcnfg_get_packet_funcs(void); + +/** Get physical ID, given type. + * @return Returns one of the physical interfaces matching the given type. + * Zero if no match is found. + */ +int cfcnfg_get_phyid(struct cfcnfg *cnfg, + enum cfcnfg_phy_preference phy_pref); + +/** Get physical ID, given name. + * @return Returns the physical interface matching the specified name. + */ +int cfcnfg_get_named(struct cfcnfg *cnfg, char *name); + +int cfcnfg_instanciate(struct cfcnfg *cnfg, + struct cfcnfg_phy_config *phy_config); +int cfcnfg_instanciate2(struct cfcnfg *cnfg, enum cfcnfg_phy_type phy_type, + uint8 instance, char *name, bool checksum, + enum cfcnfg_phy_preference pref, + struct cfcnfg_phy_param *param); +int cfcnfg_delete_phy_inst(struct cfcnfg *cfg, char *name); +int cfcnfg_unregister_phy_type(struct cfcnfg *cfg, + enum cfcnfg_phy_type type); +int cfcnfg_register_phy_type(struct cfcnfg *cfg, + struct cfcnfg_phy_mgmt *mgmt); +int cfcnfg_del_phy_layer(struct cfcnfg *cnfg, struct layer *phy_layer); + +/*! @} */ +#endif /* CFCNFG_H_ */ diff --git a/include/net/caif/generic/cfctrl.h b/include/net/caif/generic/cfctrl.h new file mode 100644 index 0000000..8d0fcc3 --- /dev/null +++ b/include/net/caif/generic/cfctrl.h @@ -0,0 +1,137 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFCTRL_H_ +#define CFCTRL_H_ +#include <net/caif/generic/caif_layer.h> +#include <net/caif/generic/cfsrvl.h> + +/* CAIF Control packet commands*/ +enum cfctrl_cmd { + CFCTRL_CMD_LINK_SETUP = 0, + CFCTRL_CMD_LINK_DESTROY = 1, + CFCTRL_CMD_LINK_ERR = 2, + CFCTRL_CMD_ENUM = 3, + CFCTRL_CMD_SLEEP = 4, + CFCTRL_CMD_WAKE = 5, + CFCTRL_CMD_LINK_RECONF = 6, + CFCTRL_CMD_START_REASON = 7, + CFCTRL_CMD_RADIO_SET = 8, + CFCTRL_CMD_MODEM_SET = 9, + CFCTRL_CMD_DATA = 0, + CFCTRL_CMD_MASK = 0xf +}; + +enum cfctrl_srv { + CFCTRL_SRV_DECM = 0, + CFCTRL_SRV_VEI = 1, + CFCTRL_SRV_VIDEO = 2, + CFCTRL_SRV_DBG = 3, + CFCTRL_SRV_DATAGRAM = 4, + CFCTRL_SRV_RFM = 5, + CFCTRL_SRV_UTIL = 6, + CFCTRL_SRV_MASK = 0xf +}; + +#define CFCTRL_RSP_BIT 0x20 +#define CFCTRL_ERR_BIT 0x10 + +struct cfctrl_rsp { + void (*linksetup_rsp)(struct layer *layer, uint8 linkid, + enum cfctrl_srv serv, uint8 phyid, + struct layer *adapt_layer); + void (*linkdestroy_rsp)(struct layer *layer, uint8 linkid, + struct layer *client_layer); + void (*linkerror_ind)(void); + void (*enum_rsp)(void); + void (*sleep_rsp)(void); + void (*wake_rsp)(void); + void (*restart_rsp)(void); + void (*radioset_rsp)(void); + void (*reject_rsp)(struct layer *layer, uint8 linkid, + struct layer *client_layer);; +}; + +/** Link Setup Parameters for CAIF-Links. */ +struct cfctrl_link_param { + enum cfctrl_srv linktype;/*!< (T3,T0) Type of Channel */ + uint8 priority; /*!< (P4,P0) Priority of the channel */ + uint8 phyid; /*!< (U2-U0) Physical interface to connect */ + uint8 endpoint; /*!< (E1,E0) Endpoint for data channels */ + uint8 chtype; /*!< (H1,H0) Channel-Type, applies to + * VEI, DEBUG */ + union { + struct { + uint8 connid; /*!< (D7,D0) Video LinkId */ + } video; + + struct { + uint32 connid; /*!< (N31,Ngit0) Connection ID used + * for Datagram */ + } datagram; + + struct { + uint32 connid; /*!< Connection ID used for RFM */ + char volume[20]; /*!< Volume to mount for RFM */ + } rfm; /*!< Configuration for RFM */ + + struct { + uint16 fifosize_kb; /*!< Psock FIFO size in KB */ + uint16 fifosize_bufs; /*!< Psock # signal buffers */ + char name[16]; /*!< Name of the PSOCK service */ + uint8 params[255]; /*!< Link setup Parameters> */ + uint16 paramlen; /*!< Length of Link Setup + * Parameters */ + } utility; /*!< Configuration for Utility Links (Psock) */ + } u; +}; + +/** This structure is used internally in CFCTRL */ +struct cfctrl_request_info { + int sequence_no; + enum cfctrl_cmd cmd; + uint8 channel_id; + struct cfctrl_link_param param; + struct cfctrl_request_info *next; + struct layer *client_layer; +}; + +struct cfctrl { + struct cfsrvl serv; + struct cfctrl_rsp res; + cfglu_atomic_t req_seq_no; + cfglu_atomic_t rsp_seq_no; + struct cfctrl_request_info *first_req; + cfglu_lock_t info_list_lock; +#ifndef CAIF_NO_LOOP + uint8 loop_linkid; + int loop_linkused[256]; + cfglu_lock_t loop_linkid_lock; +#endif + +}; + +void cfctrl_enum_req(struct layer *cfctrl, uint8 physlinkid); +void cfctrl_linkup_request(struct layer *cfctrl, + struct cfctrl_link_param *param, + struct layer *user_layer); +int cfctrl_linkdown_req(struct layer *cfctrl, uint8 linkid, + struct layer *client); +void cfctrl_sleep_req(struct layer *cfctrl); +void cfctrl_wake_req(struct layer *cfctrl); +void cfctrl_getstartreason_req(struct layer *cfctrl); +struct layer *cfctrl_create(void); +void cfctrl_set_dnlayer(struct layer *this, struct layer *dn); +void cfctrl_set_uplayer(struct layer *this, struct layer *up); +void cfctrl_set_respfuncs(struct layer *this, + struct cfctrl_rsp *respfuncs); +bool cfctrl_req_eq(struct cfctrl_request_info *r1, + struct cfctrl_request_info *r2); +void cfctrl_insert_req(struct cfctrl *ctrl, + struct cfctrl_request_info *req); +struct cfctrl_request_info *cfctrl_remove_req(struct cfctrl *ctrl, + struct cfctrl_request_info *req); +#endif /* CFCTRL_H_ */ diff --git a/include/net/caif/generic/cffrml.h b/include/net/caif/generic/cffrml.h new file mode 100644 index 0000000..b946111 --- /dev/null +++ b/include/net/caif/generic/cffrml.h @@ -0,0 +1,20 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFFRM_H_ +#define CFFRM_H_ +#include <net/caif/generic/cfglue.h> +#include <net/caif/generic/caif_layer.h> +#include <net/caif/generic/cflst.h> + +struct cffrml; + +struct layer *cffrml_create(uint16 phyid, bool DoFCS); +void cffrml_set_uplayer(struct layer *this, struct layer *up); +void cffrml_set_dnlayer(struct layer *this, struct layer *dn); +void cffrml_destroy(struct layer *layer); + +#endif /* CFFRM_H_ */ diff --git a/include/net/caif/generic/cfglue.h b/include/net/caif/generic/cfglue.h new file mode 100644 index 0000000..c84d39c --- /dev/null +++ b/include/net/caif/generic/cfglue.h @@ -0,0 +1,174 @@ +/* + * This file contains the OS and HW dependencies for CAIF. + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFGLU_H_ +#define CFGLU_H_ + +/*! \addtogroup GenCaifGlue + * Additional documentation for group `GenCaifGlue' + * @{ + */ + +#define CFLOG_LEVEL_ERROR 1 +#define CFLOG_LEVEL_WARNING 2 +#define CFLOG_LEVEL_TRACE 3 +#define CFLOG_LEVEL_TRACE2 4 +#define CFLOG_LEVEL_TRACE3 5 +#define CFLOG_LEVEL_FUNC 6 + +#include <linux/module.h> +#include <linux/string.h> +#include <linux/slab.h> +#include <linux/spinlock.h> +#include <linux/kernel.h> +#include "linux/stddef.h" +#include "linux/types.h" + +/** Unsigned 8 bit */ +typedef __u8 uint8; + +/** Unsigned 16 bit */ +typedef __u16 uint16; + +/** Unsigned 32 bit */ +typedef __u32 uint32; + +/****************************************** + * HANDLING ENDIANNES. + * CAIF uses little-endian byte order. + ******************************************/ + +/** CAIF Endian handling Net to Host of 16 bits unsigned */ +#define cfglu_le16_to_cpu(v) le16_to_cpu(v) + +/** CAIF Endian handling Host to Net of 16 bits unsigned */ +#define cfglu_cpu_to_le16(v) cpu_to_le16(v) + +/** CAIF Endian handling Host to Net of 32 bits unsigned */ +#define cfglu_le32_to_cpu(v) le32_to_cpu(v) + +/** CAIF Endian handling Net to Host of 32 bits unsigned */ +#define cfglu_cpu_to_le32(v) cpu_to_le32(v) + +extern int caif_dbg_level; + +/* LOGGING */ +#define _CFLOG_FATAL(format, args...) \ + do {if (caif_dbg_level > CFLOG_LEVEL_ERROR) {\ + printk(KERN_ERR "<%s:%d, FATAL> " format "\n",\ + __func__, __LINE__ , ## args); } } while (0) + +#define CFLOG_FATAL(format) _CFLOG_FATAL format + +/** CAIF Error Logging. */ +#define _CFLOG_ERROR(format, args...)\ + do {if (caif_dbg_level > CFLOG_LEVEL_ERROR) {\ + printk(KERN_ERR "<%s:%d, ERROR> " format "\n",\ + __func__, __LINE__ , ## args); } } while (0) + +#define CFLOG_ERROR(format) _CFLOG_ERROR format + +/** CAIF Warning Logging. */ +#define _CFLOG_WARN(format, args...)\ + do {if (caif_dbg_level > CFLOG_LEVEL_WARNING) {\ + printk(KERN_WARNING "<%s:%d, WARN> " format "\n",\ + __func__, __LINE__ , ## args); } } while (0) + +#ifdef CAIF_DEBUG_ON +#define CFLOG_WARN(format) _CFLOG_WARN format + +/** CAIF Trace Control Logging. Level 1 control trace (Channel setup etc) */ +#define _CFLOG_TRACE(format, args...) \ + do { if (caif_dbg_level > CFLOG_LEVEL_TRACE) {\ + printk(KERN_INFO "<%s:%d, TRACE> " format, \ + __func__, __LINE__ , ## args); } } while (0) + +#define CFLOG_TRACE(format) _CFLOG_TRACE format + +/** CAIF Trace Payload Logging. Level payload trace */ +#define _CFLOG_TRACE2(format, args...) \ + do {if (caif_dbg_level > CFLOG_LEVEL_TRACE2) {\ + printk(KERN_INFO "<%s:%d, TRACE2> " format, \ + __func__, __LINE__ , ## args); } } while (0) + +#define CFLOG_TRACE2(format) _CFLOG_TRACE2 format + +/** CAIF Trace Detailed Logging including packet dumps */ +#define _CFLOG_TRACE3(format, args...)\ + do {if (caif_dbg_level > CFLOG_LEVEL_TRACE3) {\ + printk(KERN_INFO "<%s:%d, TRACE3> " format, \ + __func__, __LINE__ , ## args); } } while (0) + +#define CFLOG_TRACE3(format) _CFLOG_TRACE3 format + +/** CAIF Trace Entering Function */ +#define _CFLOG_ENTER(format, args...) \ + do {if (caif_dbg_level > CFLOG_LEVEL_FUNC) {\ + printk("KERN_INFO <%s:%d, ENTER> " format, \ + __func__, __LINE__ , ## args); } } while (0) +#define CFLOG_ENTER(format) _CFLOG_ENTER format + +/** CAIF Trace Exiting Function */ + +#define _CFLOG_EXIT(format, args...) \ + do {if (caif_dbg_level > CFLOG_LEVEL_FUNC) {\ + printk("KERN_INFO <%s:%d, EXIT> " format "\n",\ + __func__, __LINE__ , ## args); } } while (0) +#define CFLOG_EXIT(format) _CFLOG_EXIT format + +#else + +#define CFLOG_WARN(args) +#define CFLOG_TRACE(args) +#define CFLOG_TRACE2(args) +#define CFLOG_TRACE3(args) +#define CFLOG_ENTER(args) +#define CFLOG_EXIT(args) + +#endif + +/* Critical Section support, one thread only between startsync + * and endsync + */ +#define cfglu_lock_t spinlock_t +#define cfglu_init_lock(sync) spin_lock_init(&(sync)) +#define cfglu_lock(sync) spin_lock_bh(&(sync)) +#define cfglu_unlock(sync) spin_unlock_bh(&(sync)) +#define cfglu_deinit_lock(sync) + +/* Atomic counting */ +#define cfglu_atomic_t atomic_t +#define cfglu_atomic_read(a) atomic_read(&a) +#define cfglu_atomic_set(a, val) atomic_set(&a, val) +#define cfglu_atomic_inc(a) atomic_inc(&a) +#define cfglu_atomic_dec(a) atomic_dec(&a) + +/* HEAP */ +#define cfglu_alloc(size) kmalloc(size, GFP_ATOMIC) +#define cfglu_free(ptr) kfree(ptr) +#define cfglu_container_of(p, t, m) container_of(p, t, m) + +/*FIXME: Comment error codes*/ +enum cfglu_errno { + CFGLU_EOK = 0, + CFGLU_EPKT = -EPROTO, + CFGLU_EADDRINUSE = -EADDRINUSE, + CFGLU_EIO = -EIO, + CFGLU_EFCS = -EILSEQ, + CFGLU_EBADPARAM = -EINVAL, + CFGLU_EINVAL = -EINVAL, + CFGLU_ENODEV = -ENODEV, + CFGLU_ENOTCONN = -ENOTCONN, + CFGLU_EPROTO = -EPROTO, + CFGLU_EOVERFLOW = -EOVERFLOW, + CFGLU_ENOMEM = -ENOMEM, + CFGLU_ERETRY = -EAGAIN, + CFGLU_ENOSPC = -ENOSPC, + CFGLU_ENXIO = -ENXIO +}; + +#endif /* CFGLU_H_ */ diff --git a/include/net/caif/generic/cfloopcfg.h b/include/net/caif/generic/cfloopcfg.h new file mode 100644 index 0000000..3cffd73 --- /dev/null +++ b/include/net/caif/generic/cfloopcfg.h @@ -0,0 +1,16 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFLOOPCFG_H_ +#define CFLOOPCFG_H_ +#include <net/caif/generic/caif_layer.h> + +struct cfloopcfg *cfloopcfg_create(void); +void cfloopcfg_add_phy_layer(struct cfloopcfg *cnfg, + enum cfcnfg_phy_type phy_type, + struct layer *phy_layer); +struct layer *cflooplayer_create(void); +#endif /* CFLOOPCFG_H_ */ diff --git a/include/net/caif/generic/cflst.h b/include/net/caif/generic/cflst.h new file mode 100644 index 0000000..29e4d33 --- /dev/null +++ b/include/net/caif/generic/cflst.h @@ -0,0 +1,19 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFLST_H_ +#define CFLST_H_ + +#include <net/caif/generic/cfglue.h> + +bool cflst_put(struct layer **lst, uint8 id, struct layer *node); +struct layer *cflst_get(struct layer **lst, uint8 id); +struct layer *cflst_del(struct layer **lst, uint8 id); +#define CFLST_FIRST(lst) lst +#define CFLST_MORE(node) ((node) != NULL) +#define CFLST_NEXT(node) ((node)->next) +void cflst_init(struct layer **lst); +#endif /* CFLST_H_ */ diff --git a/include/net/caif/generic/cfmsll.h b/include/net/caif/generic/cfmsll.h new file mode 100644 index 0000000..4339af8 --- /dev/null +++ b/include/net/caif/generic/cfmsll.h @@ -0,0 +1,13 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFMSLL_H_ +#define CFMSLL_H_ +#include <net/caif/generic/caif_layer.h> +#include <net/caif/generic/cfglue.h> +struct layer *cfmsll_create(int type, int instance); + +#endif /* CFMSLL_H_ */ diff --git a/include/net/caif/generic/cfmuxl.h b/include/net/caif/generic/cfmuxl.h new file mode 100644 index 0000000..0790574 --- /dev/null +++ b/include/net/caif/generic/cfmuxl.h @@ -0,0 +1,22 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFMUXL_H_ +#define CFMUXL_H_ +#include <net/caif/generic/caif_layer.h> + +struct cfsrvl; +struct cffrml; + +struct layer *cfmuxl_create(void); +bool cfmuxl_set_uplayer(struct layer *layr, struct layer *up, uint8 linkid); +struct layer *cfmuxl_remove_dnlayer(struct layer *layr, uint8 phyid); +bool cfmuxl_set_dnlayer(struct layer *layr, struct layer *up, uint8 phyid); +struct layer *cfmuxl_remove_uplayer(struct layer *layr, uint8 linkid); +bool cfmuxl_is_phy_inuse(struct layer *layr, uint8 phyid); +uint8 cfmuxl_get_phyid(struct layer *layr, uint8 channel_id); + +#endif /* CFMUXL_H_ */ diff --git a/include/net/caif/generic/cfpkt.h b/include/net/caif/generic/cfpkt.h new file mode 100644 index 0000000..874f09b --- /dev/null +++ b/include/net/caif/generic/cfpkt.h @@ -0,0 +1,264 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFPKT_H_ +#define CFPKT_H_ +#include <net/caif/generic/caif_layer.h> + +struct cfpkt; +/*! \addtogroup GenCaifGlue + * Additional documentation for group `GenCaifGlue' + * @{ + */ + +/** Checksum iteration function used to iterate buffers + * (we may have packets consisting of a chain of buffers) + * @param chs Checksum calculated so far. + * @param buf Pointer to the buffer to checksum + * @param len Length of buf. + * @return Checksum of buffer + */ +typedef uint16(*iterfunc_t)(uint16 chks, void *buf, uint16 len); + +struct caif_packet_funcs caif_get_packet_funcs(void); + +/** Create a CAIF packet. + * @param len Length of packet to be created + * @return New packet. + */ +struct cfpkt *cfpkt_create(uint16 len); + +/** + * Destroy a CAIF Packet. + * @param pkt Packet to be destoyed. + */ +void cfpkt_destroy(struct cfpkt *pkt); + +/** + * Extract header from packet. + * + * @param pkt Packet to extract header data from. + * @param data Pointer to copy the header data into. + * @param len Length of head data to copy. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_extr_head(struct cfpkt *pkt, void *data, uint16 len); + +/** + * Peek header from packet. + * Reads data from packet without changing packet. + * + * @param pkt Packet to extract header data from. + * @param data Pointer to copy the header data into. + * @param len Length of head data to copy. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_peek_head(struct cfpkt *pkt, void *data, uint16 len); + +/** + * Extract header from trailer (end of packet). + * + * @param pkt Packet to extract header data from. + * @param data Pointer to copy the trailer data into. + * @param len Length of header data to copy. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_extr_trail(struct cfpkt *pkt, void *data, uint16 len); + +/** + * Add header to packet. + * + * + * @param pkt Packet to add header data to. + * @param data Pointer to data to copy into the header. + * @param len Length of header data to copy. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_add_head(struct cfpkt *pkt, const void *data, uint16 len); + +/** + * Add trailer to packet. + * + * + * @param pkt Packet to add trailer data to. + * @param data Pointer to data to copy into the trailer. + * @param len Length of trailer data to copy. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_add_trail(struct cfpkt *pkt, const void *data, uint16 len); + +/** + * Pad trailer on packet. + * Moves data pointer in packet, no content copied. + * + * @param pkt Packet in which to pad trailer. + * @param len Length of padding to add. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_pad_trail(struct cfpkt *pkt, uint16 len); + +/** + * Add a single byte to packet body (tail). + * + * @param pkt Packet in which to add byte. + * @param data Byte to add. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_addbdy(struct cfpkt *pkt, const uint8 data); + +/** + * Add a data to packet body (tail). + * + * @param pkt Packet in which to add data. + * @param data Pointer to data to copy into the packet body. + * @param len Length of data to add. + * @return \ref true on success \ref false on failure + */ +bool cfpkt_add_body(struct cfpkt *pkt, const void *data, uint16 len); + +/** + * Checks whether there are more data to process in packet. + * @param pkt Packet to check. + * @return \ref true if more data are available in packet \ref false if no more data can be extracted + */ +bool cfpkt_more(struct cfpkt *pkt); + +/** + * Checks whether the packet is erroneous, i.e. if it has been attempted to extract more data than available in packet + * or writing more data than has been allocated in \ref cfpkt_create(). + * @param pkt Packet to check. + * @return \ref true on error \ref false otherwise + */ +bool cfpkt_erroneous(struct cfpkt *pkt); + +/** + * Get the packet length. + * @param pkt Packet to get length from. + * @return Number of bytes in packet. + */ +uint16 cfpkt_getlen(struct cfpkt *pkt); + +/** + * Set the packet length, by adjusting the trailer pointer according to length. + * @param pkt Packet to set length. + * @param len Packet length. + * @return Number of bytes in packet. + */ +int cfpkt_setlen(struct cfpkt *pkt, uint16 len); + +/** + * Appends a packet's data to another packet. + * NB: Input packets will be destroyed after appending and cannot be used + * after calling this function. + * @param dstpkt Packet to append data into, WILL BE FREED BY THIS FUNCTION + * @param addpkt Packet to be appended and automatically released, WILL BE FREED BY THIS FUNCTION. + * @param expectlen Packet's expected total length. This should be considered as a hint. + * @return The new appended packet. + */ +struct cfpkt *cfpkt_append(struct cfpkt *dstpkt, struct cfpkt *addpkt, + uint16 expectlen); + +/** + * Split a packet into two packets at the specified split point. + * @param pkt Packet to be split (will contain the first part of the data on exit) + * @param pos Position to split packet in two parts. + * @return The new packet, containing the second part of the data. + */ +struct cfpkt *cfpkt_split(struct cfpkt *pkt, uint16 pos); + +/** Iteration function, iterates the packet buffers from start to end.*/ +uint16 cfpkt_iterate(struct cfpkt *pkt, iterfunc_t func, uint16 data); + +void +cfpkt_extract(struct cfpkt *cfpkt, void *buf, unsigned int buflen, + unsigned int *actual_len); + +/** Append by giving user access to packet buffer + * @param pkt Packet to append to + * @param buf Buffer inside pkt that user shall copy data into + * @param buflen Length of buffer and number of bytes added to packet + * @return 0 on error, 1 on success + */ +int cfpkt_raw_append(struct cfpkt *cfpkt, void **buf, unsigned int buflen); + +/** Extract by giving user access to packet buffer + * @param pkt Packet to extract from + * @param buf Buffer inside pkt that user shall copy data from + * @param buflen Length of buffer and number of bytes removed from packet + * @return 0 on error, 1 on success + */ +int cfpkt_raw_extract(struct cfpkt *cfpkt, void **buf, unsigned int buflen); + +/** Map from a "native" packet (e.g. Linux Socket Buffer) to a CAIF packet. + * @param dir - Direction indicating whether this packet is to be sent or received. + * @param nativepkt - The native packet to be transformed to a CAIF packet + * @return The mapped CAIF Packet CFPKT. + */ +struct cfpkt *cfpkt_fromnative(enum caif_direction dir, void *nativepkt); + +/** Map from a CAIF packet to a "native" packet (e.g. Linux Socket Buffer). + * @param pkt - The CAIF packet to be transformed into a "native" packet. + * @return The native packet transformed from a CAIF packet. + */ +void *cfpkt_tonative(struct cfpkt *pkt); + +struct caif_packet_funcs cfpkt_get_packet_funcs(void); + +/** + * Insert a packet in the packet queue. + * @param pkt Packet to be inserted in queue + * @param pktq Packet queue to insert into + * @param prio Priority of packet + */ +void cfpkt_queue(struct cfpktq *pktq, struct cfpkt *pkt, + unsigned short prio); + +/** + * Remove a packet from the packet queue. + * @param pktq Packet queue to fetch packets from. + * @return Dequeued packet. + */ +struct cfpkt *cfpkt_dequeue(struct cfpktq *pktq); + +/** + * Peek into a packet from the packet queue. + * @param pktq Packet queue to fetch packets from. + * @return Peeked packet. + */ +struct cfpkt *cfpkt_qpeek(struct cfpktq *pktq); + +/** + * Initiates the packet queue. + * @return Pointer to new packet queue. + */ +struct cfpktq *cfpktq_create(void); + +/** + * Get the number of packets in the queue. + * @param pktq Packet queue to fetch count from. + * @return Number of packets in queue. + */ +int cfpkt_qcount(struct cfpktq *pktq); + +/** + * Put content of packet into buffer for debuging purposes. + * @param pkt Packet to copy data from + * @param buf Buffer to copy data into + * @param buflen Length of data to copy + * @return Pointer to copied data + */ +char *cfpkt_log_pkt(struct cfpkt *pkt, char *buf, int buflen); + +/** + * Clones a packet and releases the original packet. + * This is used for taking ownership of a packet e.g queueing. + * @param pkt Packet to clone and release. + * @return Cloned packet. + */ +struct cfpkt *cfpkt_clone_release(struct cfpkt *pkt); + +/*! @} */ +#endif /* CFPKT_H_ */ diff --git a/include/net/caif/generic/cfserl.h b/include/net/caif/generic/cfserl.h new file mode 100644 index 0000000..794ee85 --- /dev/null +++ b/include/net/caif/generic/cfserl.h @@ -0,0 +1,20 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFSERL_H_ +#define CFSERL_H_ +#include <net/caif/generic/caif_layer.h> +#include <net/caif/generic/cfglue.h> + +/** + * This variable is used as a global flag, in order to set whether STX is + * used on serial communication. + * NOTE: This is not a fully future proof solution. + */ +extern int serial_use_stx; +struct layer *cfserl_create(int type, int instance, bool use_stx); + +#endif /* CFSERL_H_ */ diff --git a/include/net/caif/generic/cfshml.h b/include/net/caif/generic/cfshml.h new file mode 100644 index 0000000..0757b02 --- /dev/null +++ b/include/net/caif/generic/cfshml.h @@ -0,0 +1,12 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFSHML_H_ +#define CFSHML_H_ + +struct layer *cfshml_create(int type, int instance); + +#endif /* CFSHML_H_ */ diff --git a/include/net/caif/generic/cfspil.h b/include/net/caif/generic/cfspil.h new file mode 100644 index 0000000..0145190 --- /dev/null +++ b/include/net/caif/generic/cfspil.h @@ -0,0 +1,85 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFSPIL_H_ +#define CFSPIL_H_ +#include <net/caif/generic/cfpkt.h> + +struct cfspipad { + uint16 up_head_align; /* Current uplink head alignment: 0 for byte + alignment, 1 for 16bits, 3 for 32bits */ + uint16 up_tail_align; /* Current uplink tail alignment: 0 for byte + alignment, 1 for 16bits, 3 for 32bits */ + uint16 down_head_align; /* Current downlink head alignment: 0 for byte + alignment, 1 for 16bits, 3 for 32bits */ + uint16 down_tail_align; /* Current downlink tail alignment: 0 for byte + alignment, 1 for 16bits, 3 for 32bits */ +}; + +/* Forward declarations */ +struct cfspil; + +extern int spi_up_head_align; +extern int spi_up_tail_align; +extern int spi_down_head_align; +extern int spi_down_tail_align; + + + +/** @page SPI PHY Layer description. + * + * SPI Physical layer is not implemented in GenCaif. The SPI PHY Layer + * is HW dependent. However, the CFSPIL (CAIF SPI Layer) provides support + * for implementing the SPI Layer Protocol. + * + * SPI PHY uses a different paradigm for transmit from the rest of GenCaif. + * SPI PHY is pulling packets from CFSPIL. The SPI PHY gets a notification + * about a transfer; it then requests transfer length and data to transfer + * in the following way: + * + * -# Wait for transmit request (packet will be \b null pointer), indicating + * GenCaif wants something to be sent to the modem. + * -# Request the transfer length by using function \ref cfspil_xmitlen, + * -# Add CAIF SPI command to SPI transfer. + * -# When SPI is ready for transfer, call \ref cfspil_getxmitpkt to get + * the transfer packet. + * -# Request new transfer length ( \ref cfspil_xmitlen) unless zero + * length is returned. + * -# Wait for next transfer request. + * + * + * * CFSPIL Specification: + * \see { GenCaifSPI } + * + */ +/*! \addtogroup GenCaifSPI + * Additional documentation for group `GenCaifSPI' + * @{ + */ + +/** + * Create and initialize SPI layer. + */ +struct layer *cfspil_create(int type, int instance, struct cfspipad); + +/** + * Check the length of the next SPI frame to send. + * @param layr Pointer to SPI layer + * @return Length of next SPI transfer, 0 if nothing to send. + */ +int cfspil_xmitlen(struct cfspil *layr); + +/** + * Get the next CAIF SPI frame to send. This packet is guaranteed to have equal size to the + * length given in \ref cfspil_getxmitpkt. + * @param layr Pointer to SPI layer + * @return The CAIF packet to be sent. + */ +struct cfpkt *cfspil_getxmitpkt(struct cfspil *layr); + +/*! @} */ + +#endif /* CFSPIL_H_ */ diff --git a/include/net/caif/generic/cfsrvl.h b/include/net/caif/generic/cfsrvl.h new file mode 100644 index 0000000..c69f0e7 --- /dev/null +++ b/include/net/caif/generic/cfsrvl.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFSRVL_H_ +#define CFSRVL_H_ +#include <net/caif/generic/cflst.h> +#include <net/caif/generic/cfglue.h> +#include <stddef.h> + +struct cfsrvl { + struct layer layer; + /** Physical ID of the logical physical connection */ + uint8 phid; + bool open; + bool phy_flow_on; + bool modem_flow_on; +}; + +struct layer *cfvei_create(uint8 linkid, uint8 phyid); +struct layer *cfdgml_create(uint8 linkid, uint8 phyid); +struct layer *cfutill_create(uint8 linkid, uint8 phyid); +struct layer *cfvidl_create(uint8 linkid, uint8 phyid); +struct layer *cfrfml_create(uint8 linkid, uint8 phyid); +bool cfsrvl_phyid_match(struct layer *layer, int phyid); +void cfservl_destroy(struct layer *layer); +void cfsrvl_init(struct cfsrvl *service, uint8 channel_id, uint8 phyid); +bool cfsrvl_ready(struct cfsrvl *service, int *err); +uint8 cfsrvl_getphyid(struct layer *layer); + +#endif /* CFSRVL_H_ */ diff --git a/include/net/caif/generic/cfusbl.h b/include/net/caif/generic/cfusbl.h new file mode 100644 index 0000000..cd83b39 --- /dev/null +++ b/include/net/caif/generic/cfusbl.h @@ -0,0 +1,13 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef CFUSBL_H_ +#define CFUSBL_H_ +#include <net/caif/generic/caif_layer.h> +#include <net/caif/generic/cfglue.h> +struct layer *cfusbl_create(int type, int instance); + +#endif /* CFUSBL_H_ */ diff --git a/include/net/caif/generic/fcs.h b/include/net/caif/generic/fcs.h new file mode 100644 index 0000000..041f5c5 --- /dev/null +++ b/include/net/caif/generic/fcs.h @@ -0,0 +1,13 @@ +/* + * Copyright (C) ST-Ericsson AB 2009 + * Author: Sjur Brendeland/sjur.brandeland@...ricsson.com + * License terms: GNU General Public License (GPL) version 2 + */ + +#ifndef FCS_H_ +#define FCS_H_ + +uint16 +fcs16(uint16 fcs, uint8 *cp, uint16 len); + +#endif /* FCS_H_ */ -- 1.6.2.2.1669.g7eaf8 -- To unsubscribe from this list: send the line "unsubscribe netdev" in the body of a message to majordomo@...r.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Powered by blists - more mailing lists