The MSM_IPC Router provides a connectionless message oriented routing mechanism between the processes running in Qualcomm MSM. The MSM_IPC Router uses the client/server model in order to provide this routing service.
Change-Id: I0ad4e3453d4708956d732430aa341f201a81a41d Signed-off-by: Karthikeyan Ramasubramanian <[email protected]> --- include/linux/msm_ipc.h | 27 + net/Kconfig | 2 +- net/Makefile | 1 + net/msm_ipc/Kconfig | 15 + net/msm_ipc/Makefile | 3 + net/msm_ipc/msm_ipc_router.c | 1671 ++++++++++++++++++++++++++++++++++++++++++ net/msm_ipc/msm_ipc_router.h | 187 +++++ 7 files changed, 1905 insertions(+), 1 deletions(-) create mode 100644 include/linux/msm_ipc.h create mode 100644 net/msm_ipc/Kconfig create mode 100644 net/msm_ipc/Makefile create mode 100644 net/msm_ipc/msm_ipc_router.c create mode 100644 net/msm_ipc/msm_ipc_router.h diff --git a/include/linux/msm_ipc.h b/include/linux/msm_ipc.h new file mode 100644 index 0000000..47d678c --- /dev/null +++ b/include/linux/msm_ipc.h @@ -0,0 +1,27 @@ +#ifndef _LINUX_MSM_IPC_H_ +#define _LINUX_MSM_IPC_H_ + +#include <linux/types.h> + +#define MSM_IPC_ADDR_NAME 1 +#define MSM_IPC_ADDR_ID 2 + +struct msm_ipc_port_addr { + uint32_t node_id; + uint32_t port_id; +}; + +struct msm_ipc_port_name { + uint32_t service; + uint32_t instance; +}; + +struct msm_ipc_addr { + unsigned char addrtype; + union { + struct msm_ipc_port_addr port_addr; + struct msm_ipc_port_name port_name; + } addr; +}; + +#endif diff --git a/net/Kconfig b/net/Kconfig index 79cabf1..b2d8e4e 100644 --- a/net/Kconfig +++ b/net/Kconfig @@ -308,6 +308,6 @@ source "net/rfkill/Kconfig" source "net/9p/Kconfig" source "net/caif/Kconfig" source "net/ceph/Kconfig" - +source "net/msm_ipc/Kconfig" endif # if NET diff --git a/net/Makefile b/net/Makefile index a51d946..0820826 100644 --- a/net/Makefile +++ b/net/Makefile @@ -68,3 +68,4 @@ obj-$(CONFIG_WIMAX) += wimax/ obj-$(CONFIG_DNS_RESOLVER) += dns_resolver/ obj-$(CONFIG_CEPH_LIB) += ceph/ obj-$(CONFIG_BATMAN_ADV) += batman-adv/ +obj-$(CONFIG_MSM_IPC) += msm_ipc/ diff --git a/net/msm_ipc/Kconfig b/net/msm_ipc/Kconfig new file mode 100644 index 0000000..9114d7d --- /dev/null +++ b/net/msm_ipc/Kconfig @@ -0,0 +1,15 @@ +# +# MSM_IPC net configurations +# + +menuconfig MSM_IPC + tristate "MSM_IPC support" + default n + ---help--- + The "Mobile Station Modem Inter-Process Communication" (MSM_IPC) + is a connectionless message/packet oriented Routing protocol + developed by Qualcomm for use with its modems. It is accessed + from user space as sockets (PF_MSM_IPC). + + Say Y (or M) here if you build for a phone product (e.g. Android) + that uses MSM_IPC as transport, if unsure say N. diff --git a/net/msm_ipc/Makefile b/net/msm_ipc/Makefile new file mode 100644 index 0000000..461c510 --- /dev/null +++ b/net/msm_ipc/Makefile @@ -0,0 +1,3 @@ +obj-$(CONFIG_MSM_IPC) := msm_ipc.o + +msm_ipc-y += msm_ipc_router.o diff --git a/net/msm_ipc/msm_ipc_router.c b/net/msm_ipc/msm_ipc_router.c new file mode 100644 index 0000000..76deacb --- /dev/null +++ b/net/msm_ipc/msm_ipc_router.c @@ -0,0 +1,1671 @@ +/* Copyright (c) 2011, Code Aurora Forum. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + + +#include <linux/slab.h> +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/string.h> +#include <linux/errno.h> +#include <linux/init.h> +#include <linux/types.h> +#include <linux/delay.h> +#include <linux/err.h> +#include <linux/sched.h> +#include <linux/poll.h> +#include <linux/platform_device.h> +#include <linux/uaccess.h> +#include <linux/debugfs.h> +#include <linux/uaccess.h> + +#include <asm/byteorder.h> + +#include "msm_ipc_router.h" + +static LIST_HEAD(control_ports); +static DEFINE_MUTEX(control_ports_lock); + +#define LP_HASH_SIZE 32 +static struct list_head local_ports[LP_HASH_SIZE]; +static DEFINE_MUTEX(local_ports_lock); + +#define SRV_HASH_SIZE 32 +static struct list_head server_list[SRV_HASH_SIZE]; +static DEFINE_MUTEX(server_list_lock); +static wait_queue_head_t newserver_wait; + +struct msm_ipc_server { + struct list_head list; + struct msm_ipc_port_name name; + struct list_head server_port_list; +}; + +struct msm_ipc_server_port { + struct list_head list; + struct msm_ipc_port_addr server_addr; +}; + +#define RP_HASH_SIZE 32 +struct msm_ipc_router_remote_port { + struct list_head list; + uint32_t node_id; + uint32_t port_id; + wait_queue_head_t quota_wait; + uint32_t tx_quota_cnt; + struct mutex quota_lock; +}; + +struct msm_ipc_router_xprt_info { + struct list_head list; + + struct msm_ipc_router_xprt *xprt; + uint32_t remote_node_id; + uint32_t initialized; + struct list_head pkt_list; + wait_queue_head_t read_wait; + struct mutex rx_lock; + struct mutex tx_lock; + uint32_t need_len; + struct work_struct read_data; + struct workqueue_struct *workqueue; +}; + +#define RT_HASH_SIZE 4 +struct msm_ipc_routing_table_entry { + struct list_head list; + uint32_t node_id; + struct list_head remote_port_list[RP_HASH_SIZE]; + struct msm_ipc_router_xprt_info *xprt_info; + struct mutex lock; + unsigned long num_tx_bytes; + unsigned long num_rx_bytes; +}; + +static struct list_head routing_table[RT_HASH_SIZE]; +static DEFINE_MUTEX(routing_table_lock); +static int routing_table_inited; + +static LIST_HEAD(msm_ipc_board_dev_list); +static DEFINE_MUTEX(msm_ipc_board_dev_list_lock); + +static void do_read_data(struct work_struct *work); + +static LIST_HEAD(xprt_info_list); +static DEFINE_MUTEX(xprt_info_list_lock); + +static uint32_t next_port_id; +static DEFINE_MUTEX(next_port_id_lock); + +enum { + CLIENT_PORT, + SERVER_PORT, + CONTROL_PORT, +}; + +enum { + DOWN, + UP, +}; + +static void init_routing_table(void) +{ + int i; + for (i = 0; i < RT_HASH_SIZE; i++) + INIT_LIST_HEAD(&routing_table[i]); +} + +static struct msm_ipc_routing_table_entry *alloc_routing_table_entry( + uint32_t node_id) +{ + int i; + struct msm_ipc_routing_table_entry *rt_entry; + + rt_entry = kmalloc(sizeof(struct msm_ipc_routing_table_entry), + GFP_KERNEL); + if (!rt_entry) { + pr_err("%s: rt_entry allocation failed for %d\n", + __func__, node_id); + return NULL; + } + + for (i = 0; i < RP_HASH_SIZE; i++) + INIT_LIST_HEAD(&rt_entry->remote_port_list[i]); + + mutex_init(&rt_entry->lock); + rt_entry->node_id = node_id; + rt_entry->xprt_info = NULL; + return rt_entry; +} + +/*Please take routing_table_lock before calling this function*/ +static int add_routing_table_entry( + struct msm_ipc_routing_table_entry *rt_entry) +{ + uint32_t key; + + if (!rt_entry) + return -EINVAL; + + key = (rt_entry->node_id % RT_HASH_SIZE); + list_add_tail(&rt_entry->list, &routing_table[key]); + return 0; +} + +/*Please take routing_table_lock before calling this function*/ +static struct msm_ipc_routing_table_entry *lookup_routing_table( + uint32_t node_id) +{ + uint32_t key = (node_id % RT_HASH_SIZE); + struct msm_ipc_routing_table_entry *rt_entry; + + list_for_each_entry(rt_entry, &routing_table[key], list) { + if (rt_entry->node_id == node_id) + return rt_entry; + } + return NULL; +} + +struct rr_packet *rr_read(struct msm_ipc_router_xprt_info *xprt_info) +{ + struct rr_packet *temp_pkt; + + if (!xprt_info) + return NULL; + + mutex_lock(&xprt_info->rx_lock); + while (list_empty(&xprt_info->pkt_list)) { + mutex_unlock(&xprt_info->rx_lock); + wait_event(xprt_info->read_wait, + !list_empty(&xprt_info->pkt_list)); + mutex_lock(&xprt_info->rx_lock); + } + temp_pkt = list_first_entry(&xprt_info->pkt_list, + struct rr_packet, list); + list_del(&temp_pkt->list); + mutex_unlock(&xprt_info->rx_lock); + return temp_pkt; +} + +struct rr_packet *clone_pkt(struct rr_packet *pkt) +{ + struct rr_packet *cloned_pkt; + struct sk_buff *temp_skb, *cloned_skb; + struct sk_buff_head *pkt_fragment_q; + + cloned_pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL); + if (!cloned_pkt) { + pr_err("%s: failure\n", __func__); + return NULL; + } + + pkt_fragment_q = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL); + if (!pkt_fragment_q) { + pr_err("%s: pkt_frag_q alloc failure\n", __func__); + kfree(cloned_pkt); + return NULL; + } + skb_queue_head_init(pkt_fragment_q); + + skb_queue_walk(pkt->pkt_fragment_q, temp_skb) { + cloned_skb = skb_clone(temp_skb, GFP_KERNEL); + if (!cloned_skb) + goto fail_clone; + skb_queue_tail(pkt_fragment_q, cloned_skb); + } + cloned_pkt->pkt_fragment_q = pkt_fragment_q; + cloned_pkt->length = pkt->length; + return cloned_pkt; + +fail_clone: + while (!skb_queue_empty(pkt_fragment_q)) { + temp_skb = skb_dequeue(pkt_fragment_q); + kfree_skb(temp_skb); + } + kfree(pkt_fragment_q); + kfree(cloned_pkt); + return NULL; +} + +struct rr_packet *create_pkt(struct sk_buff_head *data) +{ + struct rr_packet *pkt; + struct sk_buff *temp_skb; + + pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL); + if (!pkt) { + pr_err("%s: failure\n", __func__); + return NULL; + } + + pkt->pkt_fragment_q = data; + skb_queue_walk(pkt->pkt_fragment_q, temp_skb) + pkt->length += temp_skb->len; + return pkt; +} + +void release_pkt(struct rr_packet *pkt) +{ + struct sk_buff *temp_skb; + + if (!pkt) + return; + + if (!pkt->pkt_fragment_q) { + kfree(pkt); + return; + } + + while (!skb_queue_empty(pkt->pkt_fragment_q)) { + temp_skb = skb_dequeue(pkt->pkt_fragment_q); + kfree_skb(temp_skb); + } + kfree(pkt->pkt_fragment_q); + kfree(pkt); + return; +} + +static int post_control_ports(struct rr_packet *pkt) +{ + struct msm_ipc_port *port_ptr; + struct rr_packet *cloned_pkt; + + if (!pkt) + return -EINVAL; + + mutex_lock(&control_ports_lock); + list_for_each_entry(port_ptr, &control_ports, list) { + mutex_lock(&port_ptr->port_rx_q_lock); + cloned_pkt = clone_pkt(pkt); + list_add_tail(&cloned_pkt->list, &port_ptr->port_rx_q); + wake_up(&port_ptr->port_rx_wait_q); + mutex_unlock(&port_ptr->port_rx_q_lock); + } + mutex_unlock(&control_ports_lock); + return 0; +} + +static uint32_t allocate_port_id(void) +{ + uint32_t port_id = 0, prev_port_id, key; + struct msm_ipc_port *port_ptr; + + mutex_lock(&next_port_id_lock); + prev_port_id = next_port_id; + mutex_lock(&local_ports_lock); + do { + next_port_id++; + if ((next_port_id & 0xFFFFFFFE) == 0xFFFFFFFE) + next_port_id = 1; + + key = (next_port_id & (LP_HASH_SIZE - 1)); + if (list_empty(&local_ports[key])) { + port_id = next_port_id; + break; + } + list_for_each_entry(port_ptr, &local_ports[key], list) { + if (port_ptr->this_port.port_id == next_port_id) { + port_id = next_port_id; + break; + } + } + if (!port_id) { + port_id = next_port_id; + break; + } + port_id = 0; + } while (next_port_id != prev_port_id); + mutex_unlock(&local_ports_lock); + mutex_unlock(&next_port_id_lock); + + return port_id; +} + +void msm_ipc_router_add_local_port(struct msm_ipc_port *port_ptr) +{ + uint32_t key; + + if (!port_ptr) + return; + + key = (port_ptr->this_port.port_id & (LP_HASH_SIZE - 1)); + mutex_lock(&local_ports_lock); + list_add_tail(&port_ptr->list, &local_ports[key]); + mutex_unlock(&local_ports_lock); +} + +struct msm_ipc_port *msm_ipc_router_create_raw_port(void *endpoint, + void (*notify)(unsigned event, void *data, + void *addr, void *priv), + void *priv) +{ + struct msm_ipc_port *port_ptr; + + port_ptr = kzalloc(sizeof(struct msm_ipc_port), GFP_KERNEL); + if (!port_ptr) + return NULL; + + port_ptr->this_port.node_id = IPC_ROUTER_NID_LOCAL; + port_ptr->this_port.port_id = allocate_port_id(); + if (!port_ptr->this_port.port_id) { + pr_err("%s: All port ids are in use\n", __func__); + kfree(port_ptr); + return NULL; + } + + spin_lock_init(&port_ptr->port_lock); + INIT_LIST_HEAD(&port_ptr->incomplete); + mutex_init(&port_ptr->incomplete_lock); + INIT_LIST_HEAD(&port_ptr->port_rx_q); + mutex_init(&port_ptr->port_rx_q_lock); + init_waitqueue_head(&port_ptr->port_rx_wait_q); + + port_ptr->endpoint = endpoint; + port_ptr->notify = notify; + port_ptr->priv = priv; + + msm_ipc_router_add_local_port(port_ptr); + return port_ptr; +} + +static struct msm_ipc_port *msm_ipc_router_lookup_local_port(uint32_t port_id) +{ + int key = (port_id & (LP_HASH_SIZE - 1)); + struct msm_ipc_port *port_ptr; + + mutex_lock(&local_ports_lock); + list_for_each_entry(port_ptr, &local_ports[key], list) { + if (port_ptr->this_port.port_id == port_id) { + mutex_unlock(&local_ports_lock); + return port_ptr; + } + } + mutex_unlock(&local_ports_lock); + return NULL; +} + +static struct msm_ipc_router_remote_port *msm_ipc_router_lookup_remote_port( + uint32_t node_id, + uint32_t port_id) +{ + struct msm_ipc_router_remote_port *rport_ptr; + struct msm_ipc_routing_table_entry *rt_entry; + int key = (port_id & (RP_HASH_SIZE - 1)); + + mutex_lock(&routing_table_lock); + rt_entry = lookup_routing_table(node_id); + if (!rt_entry) { + mutex_unlock(&routing_table_lock); + pr_err("%s: Node is not up\n", __func__); + return NULL; + } + + mutex_lock(&rt_entry->lock); + list_for_each_entry(rport_ptr, + &rt_entry->remote_port_list[key], list) { + if (rport_ptr->port_id == port_id) { + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + return rport_ptr; + } + } + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + return NULL; +} + +static struct msm_ipc_router_remote_port *msm_ipc_router_create_remote_port( + uint32_t node_id, + uint32_t port_id) +{ + struct msm_ipc_router_remote_port *rport_ptr; + struct msm_ipc_routing_table_entry *rt_entry; + int key = (port_id & (RP_HASH_SIZE - 1)); + + mutex_lock(&routing_table_lock); + rt_entry = lookup_routing_table(node_id); + if (!rt_entry) { + mutex_unlock(&routing_table_lock); + pr_err("%s: Node is not up\n", __func__); + return NULL; + } + + mutex_lock(&rt_entry->lock); + rport_ptr = kmalloc(sizeof(struct msm_ipc_router_remote_port), + GFP_KERNEL); + if (!rport_ptr) { + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + pr_err("%s: Remote port alloc failed\n", __func__); + return NULL; + } + rport_ptr->port_id = port_id; + rport_ptr->node_id = node_id; + rport_ptr->tx_quota_cnt = 0; + init_waitqueue_head(&rport_ptr->quota_wait); + mutex_init(&rport_ptr->quota_lock); + list_add_tail(&rport_ptr->list, + &rt_entry->remote_port_list[key]); + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + return rport_ptr; +} + +static void msm_ipc_router_destroy_remote_port( + struct msm_ipc_router_remote_port *rport_ptr) +{ + uint32_t node_id; + struct msm_ipc_routing_table_entry *rt_entry; + + if (!rport_ptr) + return; + + node_id = rport_ptr->node_id; + mutex_lock(&routing_table_lock); + rt_entry = lookup_routing_table(node_id); + if (!rt_entry) { + mutex_unlock(&routing_table_lock); + pr_err("%s: Node %d is not up\n", __func__, node_id); + return; + } + + mutex_lock(&rt_entry->lock); + list_del(&rport_ptr->list); + kfree(rport_ptr); + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + return; +} + +static struct msm_ipc_server *msm_ipc_router_lookup_server( + uint32_t service, + uint32_t instance, + uint32_t node_id, + uint32_t port_id) +{ + struct msm_ipc_server *server; + struct msm_ipc_server_port *server_port; + int key = (instance & (SRV_HASH_SIZE - 1)); + + mutex_lock(&server_list_lock); + list_for_each_entry(server, &server_list[key], list) { + if ((server->name.service != service) || + (server->name.instance != instance)) + continue; + if ((node_id == 0) && (port_id == 0)) { + mutex_unlock(&server_list_lock); + return server; + } + list_for_each_entry(server_port, &server->server_port_list, + list) { + if ((server_port->server_addr.node_id == node_id) && + (server_port->server_addr.port_id == port_id)) { + mutex_unlock(&server_list_lock); + return server; + } + } + } + mutex_unlock(&server_list_lock); + return NULL; +} + +static struct msm_ipc_server *msm_ipc_router_create_server( + uint32_t service, + uint32_t instance, + uint32_t node_id, + uint32_t port_id) +{ + struct msm_ipc_server *server = NULL; + struct msm_ipc_server_port *server_port; + int key = (instance & (SRV_HASH_SIZE - 1)); + + mutex_lock(&server_list_lock); + list_for_each_entry(server, &server_list[key], list) { + if ((server->name.service == service) && + (server->name.instance == instance)) + goto create_srv_port; + } + + server = kmalloc(sizeof(struct msm_ipc_server), GFP_KERNEL); + if (!server) { + mutex_unlock(&server_list_lock); + pr_err("%s: Server allocation failed\n", __func__); + return NULL; + } + server->name.service = service; + server->name.instance = instance; + INIT_LIST_HEAD(&server->server_port_list); + list_add_tail(&server->list, &server_list[key]); + +create_srv_port: + server_port = kmalloc(sizeof(struct msm_ipc_server_port), GFP_KERNEL); + if (!server_port) { + if (list_empty(&server->server_port_list)) { + list_del(&server->list); + kfree(server); + } + mutex_unlock(&server_list_lock); + pr_err("%s: Server Port allocation failed\n", __func__); + return NULL; + } + server_port->server_addr.node_id = node_id; + server_port->server_addr.port_id = port_id; + list_add_tail(&server_port->list, &server->server_port_list); + mutex_unlock(&server_list_lock); + + return server; +} + +static void msm_ipc_router_destroy_server(struct msm_ipc_server *server, + uint32_t node_id, uint32_t port_id) +{ + struct msm_ipc_server_port *server_port; + + if (!server) + return; + + mutex_lock(&server_list_lock); + list_for_each_entry(server_port, &server->server_port_list, list) { + if ((server_port->server_addr.node_id == node_id) && + (server_port->server_addr.port_id == port_id)) + break; + } + if (server_port) { + list_del(&server_port->list); + kfree(server_port); + } + if (list_empty(&server->server_port_list)) { + list_del(&server->list); + kfree(server); + } + mutex_unlock(&server_list_lock); + return; +} + +static int msm_ipc_router_send_control_msg( + struct msm_ipc_router_xprt_info *xprt_info, + union rr_control_msg *msg) +{ + struct rr_packet *pkt; + struct sk_buff *ipc_rtr_pkt; + struct rr_header *hdr; + int pkt_size; + void *data; + struct sk_buff_head *pkt_fragment_q; + int ret; + + if (!xprt_info || ((msg->cmd != IPC_ROUTER_CTRL_CMD_HELLO) && + !xprt_info->initialized)) { + pr_err("%s: xprt_info not initialized\n", __func__); + return -EINVAL; + } + + if (xprt_info->remote_node_id == IPC_ROUTER_NID_LOCAL) + return 0; + + pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL); + if (!pkt) { + pr_err("%s: pkt alloc failed\n", __func__); + return -ENOMEM; + } + + pkt_fragment_q = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL); + if (!pkt_fragment_q) { + pr_err("%s: pkt_fragment_q alloc failed\n", __func__); + kfree(pkt); + return -ENOMEM; + } + skb_queue_head_init(pkt_fragment_q); + + pkt_size = IPC_ROUTER_HDR_SIZE + sizeof(*msg); + ipc_rtr_pkt = alloc_skb(pkt_size, GFP_KERNEL); + if (!ipc_rtr_pkt) { + pr_err("%s: ipc_rtr_pkt alloc failed\n", __func__); + kfree(pkt_fragment_q); + kfree(pkt); + return -ENOMEM; + } + + skb_reserve(ipc_rtr_pkt, IPC_ROUTER_HDR_SIZE); + data = skb_put(ipc_rtr_pkt, sizeof(*msg)); + memcpy(data, msg, sizeof(*msg)); + hdr = (struct rr_header *)skb_push(ipc_rtr_pkt, IPC_ROUTER_HDR_SIZE); + if (!hdr) { + pr_err("%s: skb_push failed\n", __func__); + kfree_skb(ipc_rtr_pkt); + kfree(pkt_fragment_q); + kfree(pkt); + return -ENOMEM; + } + + hdr->version = IPC_ROUTER_VERSION; + hdr->type = msg->cmd; + hdr->src_node_id = IPC_ROUTER_NID_LOCAL; + hdr->src_port_id = IPC_ROUTER_ADDRESS; + hdr->confirm_rx = 0; + hdr->size = sizeof(*msg); + hdr->dst_node_id = xprt_info->remote_node_id; + hdr->dst_port_id = IPC_ROUTER_ADDRESS; + skb_queue_tail(pkt_fragment_q, ipc_rtr_pkt); + pkt->pkt_fragment_q = pkt_fragment_q; + pkt->length = pkt_size; + + mutex_lock(&xprt_info->tx_lock); + ret = xprt_info->xprt->write(pkt, pkt_size, 0); + mutex_unlock(&xprt_info->tx_lock); + + release_pkt(pkt); + return ret; +} + +static int msm_ipc_router_send_server_list( + struct msm_ipc_router_xprt_info *xprt_info) +{ + union rr_control_msg ctl; + struct msm_ipc_server *server; + struct msm_ipc_server_port *server_port; + int i; + + if (!xprt_info || !xprt_info->initialized) { + pr_err("%s: Xprt info not initialized\n", __func__); + return -EINVAL; + } + + ctl.cmd = IPC_ROUTER_CTRL_CMD_NEW_SERVER; + + mutex_lock(&server_list_lock); + for (i = 0; i < SRV_HASH_SIZE; i++) { + list_for_each_entry(server, &server_list[i], list) { + ctl.srv.service = server->name.service; + ctl.srv.instance = server->name.instance; + list_for_each_entry(server_port, + &server->server_port_list, list) { + if (server_port->server_addr.node_id == + xprt_info->remote_node_id) + continue; + + ctl.srv.node_id = + server_port->server_addr.node_id; + ctl.srv.port_id = + server_port->server_addr.port_id; + msm_ipc_router_send_control_msg(xprt_info, + &ctl); + } + } + } + mutex_unlock(&server_list_lock); + + return 0; +} + +static int broadcast_ctl_msg_locally(union rr_control_msg *msg) +{ + struct rr_packet *pkt; + struct sk_buff *ipc_rtr_pkt; + struct rr_header *hdr; + int pkt_size; + void *data; + struct sk_buff_head *pkt_fragment_q; + int ret; + + pkt = kzalloc(sizeof(struct rr_packet), GFP_KERNEL); + if (!pkt) { + pr_err("%s: pkt alloc failed\n", __func__); + return -ENOMEM; + } + + pkt_fragment_q = kmalloc(sizeof(struct sk_buff_head), GFP_KERNEL); + if (!pkt_fragment_q) { + pr_err("%s: pkt_fragment_q alloc failed\n", __func__); + kfree(pkt); + return -ENOMEM; + } + skb_queue_head_init(pkt_fragment_q); + + pkt_size = IPC_ROUTER_HDR_SIZE + sizeof(*msg); + ipc_rtr_pkt = alloc_skb(pkt_size, GFP_KERNEL); + if (!ipc_rtr_pkt) { + pr_err("%s: ipc_rtr_pkt alloc failed\n", __func__); + kfree(pkt_fragment_q); + kfree(pkt); + return -ENOMEM; + } + + skb_reserve(ipc_rtr_pkt, IPC_ROUTER_HDR_SIZE); + data = skb_put(ipc_rtr_pkt, sizeof(*msg)); + memcpy(data, msg, sizeof(*msg)); + hdr = (struct rr_header *)skb_push(ipc_rtr_pkt, IPC_ROUTER_HDR_SIZE); + if (!hdr) { + pr_err("%s: skb_push failed\n", __func__); + kfree_skb(ipc_rtr_pkt); + kfree(pkt_fragment_q); + kfree(pkt); + return -ENOMEM; + } + hdr->version = IPC_ROUTER_VERSION; + hdr->type = msg->cmd; + hdr->src_node_id = IPC_ROUTER_NID_LOCAL; + hdr->src_port_id = IPC_ROUTER_ADDRESS; + hdr->confirm_rx = 0; + hdr->size = sizeof(*msg); + hdr->dst_node_id = IPC_ROUTER_NID_LOCAL; + hdr->dst_port_id = IPC_ROUTER_ADDRESS; + skb_queue_tail(pkt_fragment_q, ipc_rtr_pkt); + pkt->pkt_fragment_q = pkt_fragment_q; + pkt->length = pkt_size; + + ret = post_control_ports(pkt); + release_pkt(pkt); + return ret; +} + +static int broadcast_ctl_msg(union rr_control_msg *ctl) +{ + struct msm_ipc_router_xprt_info *xprt_info; + + mutex_lock(&xprt_info_list_lock); + list_for_each_entry(xprt_info, &xprt_info_list, list) { + msm_ipc_router_send_control_msg(xprt_info, ctl); + } + mutex_unlock(&xprt_info_list_lock); + + return 0; +} + +static int relay_msg(struct msm_ipc_router_xprt_info *xprt_info, + struct rr_packet *pkt) +{ + struct msm_ipc_router_xprt_info *fwd_xprt_info; + + if (!xprt_info || !pkt) + return -EINVAL; + + mutex_lock(&xprt_info_list_lock); + list_for_each_entry(fwd_xprt_info, &xprt_info_list, list) { + mutex_lock(&fwd_xprt_info->tx_lock); + if (xprt_info->xprt->link_id != fwd_xprt_info->xprt->link_id) + fwd_xprt_info->xprt->write(pkt, pkt->length, 0); + mutex_unlock(&fwd_xprt_info->tx_lock); + } + mutex_unlock(&xprt_info_list_lock); + return 0; +} + +static int forward_msg(struct msm_ipc_router_xprt_info *xprt_info, + struct rr_packet *pkt) +{ + uint32_t dst_node_id; + struct sk_buff *head_pkt; + struct rr_header *hdr; + struct msm_ipc_router_xprt_info *fwd_xprt_info; + struct msm_ipc_routing_table_entry *rt_entry; + + if (!xprt_info || !pkt) + return -EINVAL; + + head_pkt = skb_peek(pkt->pkt_fragment_q); + if (!head_pkt) + return -EINVAL; + + hdr = (struct rr_header *)head_pkt->data; + dst_node_id = hdr->dst_node_id; + mutex_lock(&routing_table_lock); + rt_entry = lookup_routing_table(dst_node_id); + if (!(rt_entry) || !(rt_entry->xprt_info)) { + mutex_unlock(&routing_table_lock); + pr_err("%s: Routing table not initialized\n", __func__); + return -ENODEV; + } + + mutex_lock(&rt_entry->lock); + fwd_xprt_info = rt_entry->xprt_info; + mutex_lock(&fwd_xprt_info->tx_lock); + if (xprt_info->remote_node_id == fwd_xprt_info->remote_node_id) { + mutex_unlock(&fwd_xprt_info->tx_lock); + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + pr_err("%s: Discarding Command to route back\n", __func__); + return -EINVAL; + } + + if (xprt_info->xprt->link_id == fwd_xprt_info->xprt->link_id) { + mutex_unlock(&fwd_xprt_info->tx_lock); + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + pr_err("%s: DST in the same cluster\n", __func__); + return 0; + } + fwd_xprt_info->xprt->write(pkt, pkt->length, 0); + mutex_unlock(&fwd_xprt_info->tx_lock); + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + + return 0; +} + +static int process_control_msg(struct msm_ipc_router_xprt_info *xprt_info, + struct rr_packet *pkt) +{ + union rr_control_msg ctl; + union rr_control_msg *msg; + struct msm_ipc_router_remote_port *rport_ptr; + int rc = 0; + struct sk_buff *temp_ptr; + struct rr_header *hdr; + struct msm_ipc_server *server; + struct msm_ipc_routing_table_entry *rt_entry; + + if (pkt->length != (IPC_ROUTER_HDR_SIZE + sizeof(*msg))) { + pr_err("%s: r2r msg size %d != %d\n", __func__, pkt->length, + (IPC_ROUTER_HDR_SIZE + sizeof(*msg))); + return -EINVAL; + } + + temp_ptr = skb_peek(pkt->pkt_fragment_q); + hdr = (struct rr_header *)temp_ptr->data; + msg = (union rr_control_msg *)((char *)hdr + IPC_ROUTER_HDR_SIZE); + + switch (msg->cmd) { + case IPC_ROUTER_CTRL_CMD_HELLO: + xprt_info->remote_node_id = hdr->src_node_id; + + mutex_lock(&routing_table_lock); + rt_entry = lookup_routing_table(hdr->src_node_id); + if (!rt_entry) { + rt_entry = alloc_routing_table_entry(hdr->src_node_id); + if (!rt_entry) { + mutex_unlock(&routing_table_lock); + pr_err("%s: rt_entry allocation failed\n", + __func__); + return -ENOMEM; + } + } + mutex_lock(&rt_entry->lock); + rt_entry->xprt_info = xprt_info; + mutex_unlock(&rt_entry->lock); + add_routing_table_entry(rt_entry); + mutex_unlock(&routing_table_lock); + + memset(&ctl, 0, sizeof(ctl)); + ctl.cmd = IPC_ROUTER_CTRL_CMD_HELLO; + msm_ipc_router_send_control_msg(xprt_info, &ctl); + + xprt_info->initialized = 1; + + /* Send list of servers one at a time */ + msm_ipc_router_send_server_list(xprt_info); + + break; + case IPC_ROUTER_CTRL_CMD_RESUME_TX: + + rport_ptr = msm_ipc_router_lookup_remote_port(msg->cli.node_id, + msg->cli.port_id); + if (!rport_ptr) { + pr_err("%s: Unable to resume client\n", __func__); + break; + } + mutex_lock(&rport_ptr->quota_lock); + rport_ptr->tx_quota_cnt = 0; + mutex_unlock(&rport_ptr->quota_lock); + wake_up(&rport_ptr->quota_wait); + break; + + case IPC_ROUTER_CTRL_CMD_NEW_SERVER: + if (msg->srv.instance == 0) { + pr_err( + "rpcrouter: Server create rejected, version = 0, " + "service = %08x\n", msg->srv.service); + break; + } + + mutex_lock(&routing_table_lock); + rt_entry = lookup_routing_table(msg->srv.node_id); + if (!rt_entry) { + rt_entry = alloc_routing_table_entry(msg->srv.node_id); + if (!rt_entry) { + mutex_unlock(&routing_table_lock); + pr_err("%s: rt_entry allocation failed\n", + __func__); + return -ENOMEM; + } + mutex_lock(&rt_entry->lock); + rt_entry->xprt_info = xprt_info; + mutex_unlock(&rt_entry->lock); + add_routing_table_entry(rt_entry); + } + mutex_unlock(&routing_table_lock); + + server = msm_ipc_router_lookup_server(msg->srv.service, + msg->srv.instance, + msg->srv.node_id, + msg->srv.port_id); + if (!server) { + server = msm_ipc_router_create_server( + msg->srv.service, msg->srv.instance, + msg->srv.node_id, msg->srv.port_id); + if (!server) { + pr_err("%s: Server Create failed\n", __func__); + return -ENOMEM; + } + + if (!msm_ipc_router_lookup_remote_port( + msg->srv.node_id, msg->srv.port_id)) { + rport_ptr = msm_ipc_router_create_remote_port( + msg->srv.node_id, msg->srv.port_id); + if (!rport_ptr) + pr_err("%s: Remote port create " + "failed\n", __func__); + } + wake_up(&newserver_wait); + } + + relay_msg(xprt_info, pkt); + post_control_ports(pkt); + break; + case IPC_ROUTER_CTRL_CMD_REMOVE_SERVER: + server = msm_ipc_router_lookup_server(msg->srv.service, + msg->srv.instance, + msg->srv.node_id, + msg->srv.port_id); + if (server) { + msm_ipc_router_destroy_server(server, + msg->srv.node_id, + msg->srv.port_id); + relay_msg(xprt_info, pkt); + post_control_ports(pkt); + } + break; + case IPC_ROUTER_CTRL_CMD_REMOVE_CLIENT: + rport_ptr = msm_ipc_router_lookup_remote_port(msg->cli.node_id, + msg->cli.port_id); + if (rport_ptr) + msm_ipc_router_destroy_remote_port(rport_ptr); + + relay_msg(xprt_info, pkt); + post_control_ports(pkt); + break; + case IPC_ROUTER_CTRL_CMD_PING: + /* No action needed for ping messages received */ + break; + default: + rc = -ENOSYS; + } + + return rc; +} + +static void do_read_data(struct work_struct *work) +{ + struct rr_header *hdr; + struct rr_packet *pkt = NULL; + struct msm_ipc_port *port_ptr; + struct sk_buff *head_skb; + struct msm_ipc_port_addr *src_addr; + uint32_t resume_tx, resume_tx_node_id, resume_tx_port_id; + + struct msm_ipc_router_xprt_info *xprt_info = + container_of(work, + struct msm_ipc_router_xprt_info, + read_data); + + pkt = rr_read(xprt_info); + if (!pkt) { + pr_err("%s: rr_read failed\n", __func__); + goto fail_io; + } + + if (pkt->length < IPC_ROUTER_HDR_SIZE || + pkt->length > MAX_IPC_PKT_SIZE) { + pr_err("%s: Invalid pkt length %d\n", __func__, pkt->length); + goto fail_data; + } + + head_skb = skb_peek(pkt->pkt_fragment_q); + if (!head_skb) { + pr_err("%s: head_skb is invalid\n", __func__); + goto fail_data; + } + + hdr = (struct rr_header *)(head_skb->data); + + if (hdr->version != IPC_ROUTER_VERSION) { + pr_err("version %d != %d\n", hdr->version, IPC_ROUTER_VERSION); + goto fail_data; + } + + if ((hdr->dst_node_id != IPC_ROUTER_NID_LOCAL) && + ((hdr->type == IPC_ROUTER_CTRL_CMD_RESUME_TX) || + (hdr->type == IPC_ROUTER_CTRL_CMD_DATA))) { + forward_msg(xprt_info, pkt); + release_pkt(pkt); + goto done; + } + + if ((hdr->dst_port_id == IPC_ROUTER_ADDRESS) || + (hdr->type == IPC_ROUTER_CTRL_CMD_HELLO)) { + process_control_msg(xprt_info, pkt); + release_pkt(pkt); + goto done; + } + + resume_tx = hdr->confirm_rx; + resume_tx_node_id = hdr->dst_node_id; + resume_tx_port_id = hdr->dst_port_id; + + port_ptr = msm_ipc_router_lookup_local_port(hdr->dst_port_id); + if (!port_ptr) { + pr_err("%s: No local port id %08x\n", __func__, + hdr->dst_port_id); + release_pkt(pkt); + goto process_done; + } + + if (!port_ptr->notify) { + mutex_lock(&port_ptr->port_rx_q_lock); + list_add_tail(&pkt->list, &port_ptr->port_rx_q); + wake_up(&port_ptr->port_rx_wait_q); + mutex_unlock(&port_ptr->port_rx_q_lock); + } else { + src_addr = kmalloc(sizeof(struct msm_ipc_port_addr), + GFP_KERNEL); + if (src_addr) { + src_addr->node_id = hdr->src_node_id; + src_addr->port_id = hdr->src_port_id; + } + skb_pull(head_skb, IPC_ROUTER_HDR_SIZE); + port_ptr->notify(MSM_IPC_ROUTER_READ_CB, pkt->pkt_fragment_q, + src_addr, port_ptr->priv); + pkt->pkt_fragment_q = NULL; + src_addr = NULL; + release_pkt(pkt); + } + +process_done: + if (resume_tx) { + union rr_control_msg msg; + + msg.cmd = IPC_ROUTER_CTRL_CMD_RESUME_TX; + msg.cli.node_id = resume_tx_node_id; + msg.cli.port_id = resume_tx_port_id; + + msm_ipc_router_send_control_msg(xprt_info, &msg); + } + +done: + queue_work(xprt_info->workqueue, &xprt_info->read_data); + return; + +fail_data: + release_pkt(pkt); +fail_io: + pr_err("ipc_router has died\n"); +} + +int msm_ipc_router_register_server(struct msm_ipc_port *port_ptr, + struct msm_ipc_addr *name) +{ + struct msm_ipc_server *server; + unsigned long flags; + union rr_control_msg ctl; + + if (!port_ptr || !name) + return -EINVAL; + + if (name->addrtype != MSM_IPC_ADDR_NAME) + return -EINVAL; + + server = msm_ipc_router_lookup_server(name->addr.port_name.service, + name->addr.port_name.instance, + IPC_ROUTER_NID_LOCAL, + port_ptr->this_port.port_id); + if (server) { + pr_err("%s: Server already present\n", __func__); + return -EINVAL; + } + + server = msm_ipc_router_create_server(name->addr.port_name.service, + name->addr.port_name.instance, + IPC_ROUTER_NID_LOCAL, + port_ptr->this_port.port_id); + if (!server) { + pr_err("%s: Server Creation failed\n", __func__); + return -EINVAL; + } + + ctl.cmd = IPC_ROUTER_CTRL_CMD_NEW_SERVER; + ctl.srv.service = server->name.service; + ctl.srv.instance = server->name.instance; + ctl.srv.node_id = IPC_ROUTER_NID_LOCAL; + ctl.srv.port_id = port_ptr->this_port.port_id; + broadcast_ctl_msg(&ctl); + spin_lock_irqsave(&port_ptr->port_lock, flags); + port_ptr->type = SERVER_PORT; + port_ptr->port_name.service = server->name.service; + port_ptr->port_name.instance = server->name.instance; + spin_unlock_irqrestore(&port_ptr->port_lock, flags); + return 0; +} + +int msm_ipc_router_unregister_server(struct msm_ipc_port *port_ptr) +{ + struct msm_ipc_server *server; + unsigned long flags; + union rr_control_msg ctl; + + if (!port_ptr) + return -EINVAL; + + if (port_ptr->type != SERVER_PORT) { + pr_err("%s: Trying to unregister a non-server port\n", + __func__); + return -EINVAL; + } + + if (port_ptr->this_port.node_id != IPC_ROUTER_NID_LOCAL) { + pr_err("%s: Trying to unregister a remote server locally\n", + __func__); + return -EINVAL; + } + + server = msm_ipc_router_lookup_server(port_ptr->port_name.service, + port_ptr->port_name.instance, + port_ptr->this_port.node_id, + port_ptr->this_port.port_id); + if (!server) { + pr_err("%s: Server lookup failed\n", __func__); + return -ENODEV; + } + + ctl.cmd = IPC_ROUTER_CTRL_CMD_REMOVE_SERVER; + ctl.srv.service = server->name.service; + ctl.srv.instance = server->name.instance; + ctl.srv.node_id = IPC_ROUTER_NID_LOCAL; + ctl.srv.port_id = port_ptr->this_port.port_id; + broadcast_ctl_msg(&ctl); + msm_ipc_router_destroy_server(server, port_ptr->this_port.node_id, + port_ptr->this_port.port_id); + spin_lock_irqsave(&port_ptr->port_lock, flags); + port_ptr->type = CLIENT_PORT; + spin_unlock_irqrestore(&port_ptr->port_lock, flags); + return 0; +} + +static int loopback_data(struct msm_ipc_port *src, + uint32_t port_id, + struct sk_buff_head *data) +{ + struct sk_buff *head_skb; + struct rr_header *hdr; + struct msm_ipc_port *port_ptr; + struct rr_packet *pkt; + + if (!data) { + pr_err("%s: Invalid pkt pointer\n", __func__); + return -EINVAL; + } + + pkt = create_pkt(data); + if (!pkt) { + pr_err("%s: New pkt create failed\n", __func__); + return -ENOMEM; + } + + head_skb = skb_peek(pkt->pkt_fragment_q); + hdr = (struct rr_header *)skb_push(head_skb, IPC_ROUTER_HDR_SIZE); + if (!hdr) { + pr_err("%s: Prepend Header failed\n", __func__); + release_pkt(pkt); + return -ENOMEM; + } + hdr->version = IPC_ROUTER_VERSION; + hdr->type = IPC_ROUTER_CTRL_CMD_DATA; + hdr->src_node_id = src->this_port.node_id; + hdr->src_port_id = src->this_port.port_id; + hdr->size = pkt->length; + hdr->confirm_rx = 0; + hdr->dst_node_id = IPC_ROUTER_NID_LOCAL; + hdr->dst_port_id = port_id; + pkt->length += IPC_ROUTER_HDR_SIZE; + + port_ptr = msm_ipc_router_lookup_local_port(port_id); + if (!port_ptr) { + pr_err("%s: Local port %d not present\n", __func__, port_id); + release_pkt(pkt); + return -ENODEV; + } + + mutex_lock(&port_ptr->port_rx_q_lock); + list_add_tail(&pkt->list, &port_ptr->port_rx_q); + wake_up(&port_ptr->port_rx_wait_q); + mutex_unlock(&port_ptr->port_rx_q_lock); + + return pkt->length; +} + +static int msm_ipc_router_write_pkt(struct msm_ipc_port *src, + struct msm_ipc_router_remote_port *rport_ptr, + struct rr_packet *pkt) +{ + struct sk_buff *head_skb; + struct rr_header *hdr; + struct msm_ipc_router_xprt_info *xprt_info; + struct msm_ipc_routing_table_entry *rt_entry; + int ret; + DEFINE_WAIT(__wait); + + if (!rport_ptr || !src || !pkt) + return -EINVAL; + + head_skb = skb_peek(pkt->pkt_fragment_q); + hdr = (struct rr_header *)skb_push(head_skb, IPC_ROUTER_HDR_SIZE); + if (!hdr) { + pr_err("%s: Prepend Header failed\n", __func__); + return -ENOMEM; + } + hdr->version = IPC_ROUTER_VERSION; + hdr->type = IPC_ROUTER_CTRL_CMD_DATA; + hdr->src_node_id = src->this_port.node_id; + hdr->src_port_id = src->this_port.port_id; + hdr->size = pkt->length; + hdr->confirm_rx = 0; + hdr->dst_node_id = rport_ptr->node_id; + hdr->dst_port_id = rport_ptr->port_id; + pkt->length += IPC_ROUTER_HDR_SIZE; + + for (;;) { + prepare_to_wait(&rport_ptr->quota_wait, &__wait, + TASK_INTERRUPTIBLE); + mutex_lock(&rport_ptr->quota_lock); + if (rport_ptr->tx_quota_cnt < + IPC_ROUTER_DEFAULT_RX_QUOTA) + break; + if (signal_pending(current)) + break; + mutex_unlock(&rport_ptr->quota_lock); + schedule(); + } + finish_wait(&rport_ptr->quota_wait, &__wait); + + if (signal_pending(current)) { + mutex_unlock(&rport_ptr->quota_lock); + return -ERESTARTSYS; + } + rport_ptr->tx_quota_cnt++; + if (rport_ptr->tx_quota_cnt == IPC_ROUTER_DEFAULT_RX_QUOTA) + hdr->confirm_rx = 1; + mutex_unlock(&rport_ptr->quota_lock); + + mutex_lock(&routing_table_lock); + rt_entry = lookup_routing_table(hdr->dst_node_id); + if (!rt_entry || !rt_entry->xprt_info) { + mutex_unlock(&routing_table_lock); + pr_err("%s: Remote node %d not up\n", + __func__, hdr->dst_node_id); + return -ENODEV; + } + mutex_lock(&rt_entry->lock); + xprt_info = rt_entry->xprt_info; + mutex_lock(&xprt_info->tx_lock); + ret = xprt_info->xprt->write(pkt, pkt->length, 0); + mutex_unlock(&xprt_info->tx_lock); + mutex_unlock(&rt_entry->lock); + mutex_unlock(&routing_table_lock); + + if (ret < 0) { + pr_err("%s: Write on XPRT failed\n", __func__); + return ret; + } + + return pkt->length; +} + +int msm_ipc_router_send_to(struct msm_ipc_port *src, + struct sk_buff_head *data, + struct msm_ipc_addr *dest) +{ + uint32_t dst_node_id = 0, dst_port_id = 0; + struct msm_ipc_server *server; + struct msm_ipc_server_port *server_port; + struct msm_ipc_router_remote_port *rport_ptr = NULL; + struct rr_packet *pkt; + int ret; + + if (!src || !data || !dest) { + pr_err("%s: Invalid Parameters\n", __func__); + return -EINVAL; + } + + /* Resolve Address*/ + if (dest->addrtype == MSM_IPC_ADDR_ID) { + dst_node_id = dest->addr.port_addr.node_id; + dst_port_id = dest->addr.port_addr.port_id; + } else if (dest->addrtype == MSM_IPC_ADDR_NAME) { + server = msm_ipc_router_lookup_server( + dest->addr.port_name.service, + dest->addr.port_name.instance, + 0, 0); + if (!server) { + pr_err("%s: Destination not reachable\n", __func__); + return -ENODEV; + } + mutex_lock(&server_list_lock); + server_port = list_first_entry(&server->server_port_list, + struct msm_ipc_server_port, + list); + dst_node_id = server_port->server_addr.node_id; + dst_port_id = server_port->server_addr.port_id; + mutex_unlock(&server_list_lock); + } + if (dst_node_id == IPC_ROUTER_NID_LOCAL) { + ret = loopback_data(src, dst_port_id, data); + return ret; + } + + /* Achieve Flow control */ + rport_ptr = msm_ipc_router_lookup_remote_port(dst_node_id, + dst_port_id); + if (!rport_ptr) { + rport_ptr = msm_ipc_router_create_remote_port(dst_node_id, + dst_port_id); + if (!rport_ptr) { + pr_err("%s: Could not create remote port\n", __func__); + return -ENOMEM; + } + } + + pkt = create_pkt(data); + if (!pkt) { + pr_err("%s: Pkt creation failed\n", __func__); + return -ENOMEM; + } + + ret = msm_ipc_router_write_pkt(src, rport_ptr, pkt); + release_pkt(pkt); + + return ret; +} + +int msm_ipc_router_read(struct msm_ipc_port *port_ptr, + struct sk_buff_head **data, + size_t buf_len) +{ + struct rr_packet *pkt; + int ret; + + if (!port_ptr || !data) + return -EINVAL; + + mutex_lock(&port_ptr->port_rx_q_lock); + if (list_empty(&port_ptr->port_rx_q)) { + mutex_unlock(&port_ptr->port_rx_q_lock); + return -EAGAIN; + } + + pkt = list_first_entry(&port_ptr->port_rx_q, struct rr_packet, list); + if ((buf_len) && ((pkt->length - IPC_ROUTER_HDR_SIZE) > buf_len)) { + mutex_unlock(&port_ptr->port_rx_q_lock); + return -ETOOSMALL; + } + list_del(&pkt->list); + *data = pkt->pkt_fragment_q; + ret = pkt->length; + kfree(pkt); + mutex_unlock(&port_ptr->port_rx_q_lock); + + return ret; +} + +int msm_ipc_router_recv_from(struct msm_ipc_port *port_ptr, + struct sk_buff_head **data, + struct msm_ipc_addr *src, + unsigned long timeout) +{ + int ret, data_len, align_size; + struct sk_buff *temp_skb; + struct rr_header *hdr = NULL; + + if (!port_ptr || !data) { + pr_err("%s: Invalid pointers being passed\n", __func__); + return -EINVAL; + } + + *data = NULL; + mutex_lock(&port_ptr->port_rx_q_lock); + while (list_empty(&port_ptr->port_rx_q)) { + mutex_unlock(&port_ptr->port_rx_q_lock); + if (timeout < 0) { + ret = wait_event_interruptible( + port_ptr->port_rx_wait_q, + !list_empty(&port_ptr->port_rx_q)); + if (ret) + return ret; + } else if (timeout > 0) { + timeout = wait_event_interruptible_timeout( + port_ptr->port_rx_wait_q, + !list_empty(&port_ptr->port_rx_q), + timeout); + if (timeout < 0) + return -EFAULT; + } + if (timeout == 0) + return -ETIMEDOUT; + mutex_lock(&port_ptr->port_rx_q_lock); + } + mutex_unlock(&port_ptr->port_rx_q_lock); + + ret = msm_ipc_router_read(port_ptr, data, 0); + if (ret <= 0 || !(*data)) + return ret; + + temp_skb = skb_peek(*data); + hdr = (struct rr_header *)(temp_skb->data); + if (src) { + src->addrtype = MSM_IPC_ADDR_ID; + src->addr.port_addr.node_id = hdr->src_node_id; + src->addr.port_addr.port_id = hdr->src_port_id; + } + + data_len = hdr->size; + skb_pull(temp_skb, IPC_ROUTER_HDR_SIZE); + align_size = ALIGN_SIZE(data_len); + if (align_size) { + temp_skb = skb_peek_tail(*data); + skb_trim(temp_skb, (temp_skb->len - align_size)); + } + return data_len; +} + +struct msm_ipc_port *msm_ipc_router_create_port( + void (*notify)(unsigned event, void *data, void *addr, void *priv), + void *priv) +{ + struct msm_ipc_port *port_ptr; + + port_ptr = msm_ipc_router_create_raw_port(NULL, notify, priv); + if (!port_ptr) + pr_err("%s: port_ptr alloc failed\n", __func__); + + return port_ptr; +} + +int msm_ipc_router_close_port(struct msm_ipc_port *port_ptr) +{ + union rr_control_msg msg; + struct rr_packet *pkt, *temp_pkt; + struct msm_ipc_server *server; + + if (!port_ptr) + return -EINVAL; + + if (port_ptr->type == SERVER_PORT || port_ptr->type == CLIENT_PORT) { + if (port_ptr->type == SERVER_PORT) { + msg.cmd = IPC_ROUTER_CTRL_CMD_REMOVE_SERVER; + msg.srv.service = port_ptr->port_name.service; + msg.srv.instance = port_ptr->port_name.instance; + msg.srv.node_id = port_ptr->this_port.node_id; + msg.srv.port_id = port_ptr->this_port.port_id; + } else if (port_ptr->type == CLIENT_PORT) { + msg.cmd = IPC_ROUTER_CTRL_CMD_REMOVE_CLIENT; + msg.cli.node_id = port_ptr->this_port.node_id; + msg.cli.port_id = port_ptr->this_port.port_id; + } + broadcast_ctl_msg(&msg); + broadcast_ctl_msg_locally(&msg); + } + + mutex_lock(&port_ptr->port_rx_q_lock); + list_for_each_entry_safe(pkt, temp_pkt, &port_ptr->port_rx_q, list) { + list_del(&pkt->list); + release_pkt(pkt); + } + mutex_unlock(&port_ptr->port_rx_q_lock); + + if (port_ptr->type == SERVER_PORT) { + server = msm_ipc_router_lookup_server( + port_ptr->port_name.service, + port_ptr->port_name.instance, + port_ptr->this_port.node_id, + port_ptr->this_port.port_id); + if (server) + msm_ipc_router_destroy_server(server, + port_ptr->this_port.node_id, + port_ptr->this_port.port_id); + mutex_lock(&local_ports_lock); + list_del(&port_ptr->list); + mutex_unlock(&local_ports_lock); + } else if (port_ptr->type == CLIENT_PORT) { + mutex_lock(&local_ports_lock); + list_del(&port_ptr->list); + mutex_unlock(&local_ports_lock); + } else if (port_ptr->type == CONTROL_PORT) { + mutex_lock(&control_ports_lock); + list_del(&port_ptr->list); + mutex_unlock(&control_ports_lock); + } + + kfree(port_ptr); + return 0; +} + +int msm_ipc_router_get_curr_pkt_size(struct msm_ipc_port *port_ptr) +{ + struct rr_packet *pkt; + int rc = 0; + + if (!port_ptr) + return -EINVAL; + + mutex_lock(&port_ptr->port_rx_q_lock); + if (!list_empty(&port_ptr->port_rx_q)) { + pkt = list_first_entry(&port_ptr->port_rx_q, + struct rr_packet, list); + rc = pkt->length; + } + mutex_unlock(&port_ptr->port_rx_q_lock); + + return rc; +} + +int msm_ipc_router_bind_control_port(struct msm_ipc_port *port_ptr) +{ + if (!port_ptr) + return -EINVAL; + + mutex_lock(&local_ports_lock); + list_del(&port_ptr->list); + mutex_unlock(&local_ports_lock); + port_ptr->type = CONTROL_PORT; + mutex_lock(&control_ports_lock); + list_add_tail(&port_ptr->list, &control_ports); + mutex_unlock(&control_ports_lock); + + return 0; +} + +int msm_ipc_router_lookup_server_name(struct msm_ipc_port_name *srv_name, + struct msm_ipc_port_addr *srv_addr, + int num_entries_in_array) +{ + struct msm_ipc_server *server; + struct msm_ipc_server_port *server_port; + int i = 0; /*num_entries_found*/ + + if (!srv_name || !srv_addr) { + pr_err("%s: Invalid srv_addr/name\n", __func__); + return -EINVAL; + } + + server = msm_ipc_router_lookup_server(srv_name->service, + srv_name->instance, 0, 0); + if (!server) + return -ENODEV; + + mutex_lock(&server_list_lock); + list_for_each_entry(server_port, &server->server_port_list, list) { + if (i < num_entries_in_array) { + srv_addr[i].node_id = server_port->server_addr.node_id; + srv_addr[i].port_id = server_port->server_addr.port_id; + } + i++; + } + mutex_unlock(&server_list_lock); + + return i; +} + +int msm_ipc_router_close(void) +{ + struct msm_ipc_router_xprt_info *xprt_info, *tmp_xprt_info; + + mutex_lock(&xprt_info_list_lock); + list_for_each_entry_safe(xprt_info, tmp_xprt_info, + &xprt_info_list, list) { + xprt_info->xprt->close(); + list_del(&xprt_info->list); + kfree(xprt_info); + } + mutex_unlock(&xprt_info_list_lock); + return 0; +} + +static int __init msm_ipc_router_init(void) +{ + int i; + struct msm_ipc_routing_table_entry *rt_entry; +#if !defined(CONFIG_MSM_IPC_ROUTER_SMD_XPRT) + struct work_struct dummy_work; + + INIT_WORK(&dummy_work, do_read_data); +#endif + + for (i = 0; i < SRV_HASH_SIZE; i++) + INIT_LIST_HEAD(&server_list[i]); + + for (i = 0; i < LP_HASH_SIZE; i++) + INIT_LIST_HEAD(&local_ports[i]); + + mutex_lock(&routing_table_lock); + if (!routing_table_inited) { + init_routing_table(); + rt_entry = alloc_routing_table_entry(IPC_ROUTER_NID_LOCAL); + add_routing_table_entry(rt_entry); + routing_table_inited = 1; + } + mutex_unlock(&routing_table_lock); + + init_waitqueue_head(&newserver_wait); + + return 0; +} + +module_init(msm_ipc_router_init); +MODULE_DESCRIPTION("MSM IPC Router"); +MODULE_LICENSE("GPL v2"); diff --git a/net/msm_ipc/msm_ipc_router.h b/net/msm_ipc/msm_ipc_router.h new file mode 100644 index 0000000..4d30c8f --- /dev/null +++ b/net/msm_ipc/msm_ipc_router.h @@ -0,0 +1,187 @@ +/* Copyright (c) 2011, Code Aurora Forum. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef _MSM_IPC_ROUTER_H +#define _MSM_IPC_ROUTER_H + +#include <linux/types.h> +#include <linux/socket.h> +#include <linux/errno.h> +#include <linux/mm.h> +#include <linux/list.h> +#include <linux/cdev.h> +#include <linux/platform_device.h> +#include <net/sock.h> +#include <linux/msm_ipc.h> + +#include <mach/msm_smd.h> + +/* definitions for the R2R wire protcol */ +#define IPC_ROUTER_VERSION 1 +#define IPC_ROUTER_PROCESSORS_MAX 4 + +#define IPC_ROUTER_CLIENT_BCAST_ID 0xffffffff +#define IPC_ROUTER_ADDRESS 0xfffffffe + +#define IPC_ROUTER_NID_LOCAL 1 +#define IPC_ROUTER_NID_REMOTE 0 + +#define IPC_ROUTER_CTRL_CMD_DATA 1 +#define IPC_ROUTER_CTRL_CMD_HELLO 2 +#define IPC_ROUTER_CTRL_CMD_BYE 3 +#define IPC_ROUTER_CTRL_CMD_NEW_SERVER 4 +#define IPC_ROUTER_CTRL_CMD_REMOVE_SERVER 5 +#define IPC_ROUTER_CTRL_CMD_REMOVE_CLIENT 6 +#define IPC_ROUTER_CTRL_CMD_RESUME_TX 7 +#define IPC_ROUTER_CTRL_CMD_EXIT 8 +#define IPC_ROUTER_CTRL_CMD_PING 9 + +#define IPC_ROUTER_DEFAULT_RX_QUOTA 5 + +#define IPC_ROUTER_XPRT_EVENT_DATA 1 +#define IPC_ROUTER_XPRT_EVENT_OPEN 2 +#define IPC_ROUTER_XPRT_EVENT_CLOSE 3 + +#define NUM_NODES 2 + +#define IPC_ROUTER_INFINITY -1 +#define DEFAULT_RCV_TIMEO IPC_ROUTER_INFINITY + +#define ALIGN_SIZE(x) ((4 - ((x) & 3)) & 3) + +enum { + MSM_IPC_ROUTER_READ_CB = 0, + MSM_IPC_ROUTER_WRITE_DONE, +}; + +union rr_control_msg { + uint32_t cmd; + struct { + uint32_t cmd; + uint32_t service; + uint32_t instance; + uint32_t node_id; + uint32_t port_id; + } srv; + struct { + uint32_t cmd; + uint32_t node_id; + uint32_t port_id; + } cli; +}; + +struct rr_header { + uint32_t version; + uint32_t type; + uint32_t src_node_id; + uint32_t src_port_id; + uint32_t confirm_rx; + uint32_t size; + uint32_t dst_node_id; + uint32_t dst_port_id; +}; + +#define IPC_ROUTER_HDR_SIZE sizeof(struct rr_header) +#define MAX_IPC_PKT_SIZE 66000 +/* internals */ + +#define IPC_ROUTER_MAX_REMOTE_SERVERS 100 + +struct rr_packet { + struct list_head list; + struct sk_buff_head *pkt_fragment_q; + uint32_t length; +}; + +struct msm_ipc_port { + struct list_head list; + + struct msm_ipc_port_addr this_port; + struct msm_ipc_port_name port_name; + uint32_t type; + unsigned flags; + spinlock_t port_lock; + + struct list_head incomplete; + struct mutex incomplete_lock; + + struct list_head port_rx_q; + struct mutex port_rx_q_lock; + wait_queue_head_t port_rx_wait_q; + + int restart_state; + spinlock_t restart_lock; + wait_queue_head_t restart_wait; + + void *endpoint; + void (*notify)(unsigned event, void *data, void *addr, void *priv); + + uint32_t num_tx; + uint32_t num_rx; + unsigned long num_tx_bytes; + unsigned long num_rx_bytes; + void *priv; +}; + +struct msm_ipc_router_xprt { + char *name; + uint32_t link_id; + void *priv; + + int (*read_avail)(void); + int (*read)(void *data, uint32_t len); + int (*write_avail)(void); + int (*write)(void *data, uint32_t len, uint32_t type); + int (*close)(void); +}; + +extern struct completion msm_ipc_remote_router_up; + +void msm_ipc_router_xprt_notify(struct msm_ipc_router_xprt *xprt, + unsigned event, + void *data); + + +struct rr_packet *clone_pkt(struct rr_packet *pkt); +void release_pkt(struct rr_packet *pkt); + + +struct msm_ipc_port *msm_ipc_router_create_raw_port(void *endpoint, + void (*notify)(unsigned event, void *data, + void *addr, void *priv), + void *priv); +int msm_ipc_router_send_to(struct msm_ipc_port *src, + struct sk_buff_head *data, + struct msm_ipc_addr *dest); +int msm_ipc_router_read(struct msm_ipc_port *port_ptr, + struct sk_buff_head **data, + size_t buf_len); +int msm_ipc_router_get_curr_pkt_size(struct msm_ipc_port *port_ptr); +int msm_ipc_router_bind_control_port(struct msm_ipc_port *port_ptr); +int msm_ipc_router_lookup_server_name(struct msm_ipc_port_name *srv_name, + struct msm_ipc_port_addr *port_addr, + int num_entries_in_array); +int msm_ipc_router_close_port(struct msm_ipc_port *port_ptr); + +struct msm_ipc_port *msm_ipc_router_create_port( + void (*notify)(unsigned event, void *data, + void *addr, void *priv), + void *priv); +int msm_ipc_router_recv_from(struct msm_ipc_port *port_ptr, + struct sk_buff_head **data, + struct msm_ipc_addr *src_addr, + unsigned long timeout); +int msm_ipc_router_register_server(struct msm_ipc_port *server_port, + struct msm_ipc_addr *name); +int msm_ipc_router_unregister_server(struct msm_ipc_port *server_port); + +#endif -- 1.7.3.3 Sent by an employee of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum. -- To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
