Merge "msm: ipc: Migrate to wakeup sources from wake locks"

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/list.h>

#include <linux/wakelock.h>

#include <linux/pm.h>

#include <linux/msm_ipc.h>

#include <linux/device.h>

#define MAX_WAKELOCK_NAME_SZ 32

/* Maximum Wakeup Source Name Size */

#define MAX_WS_NAME_SZ 32

/**

 * enum msm_ipc_router_event - Events that will be generated by IPC Router

 * @mode_info: Communication mode of the port owner.

 * @port_rx_q: Receive queue where incoming messages are queued.

 * @port_rx_q_lock_lhb3: Lock to protect access to the port's rx_q.

 * @rx_wakelock_name: Name of the receive wakelock.

 * @port_rx_wake_lock: Wakelock to prevent suspend until the rx_q is empty.

 * @rx_ws_name: Name of the receive wakeup source.

 * @port_rx_ws: Wakeup source to prevent suspend until the rx_q is empty.

 * @port_rx_wait_q: Wait queue to wait for the incoming messages.

 * @restart_state: Flag to hold the restart state information.

 * @restart_lock: Lock to protect access to the restart_state.

	struct list_head port_rx_q;

	struct mutex port_rx_q_lock_lhb3;

	char rx_wakelock_name[MAX_WAKELOCK_NAME_SZ];

	struct wake_lock port_rx_wake_lock;

	char rx_ws_name[MAX_WS_NAME_SZ];

	struct wakeup_source port_rx_ws;

	wait_queue_head_t port_rx_wait_q;

	int restart_state;

#include <linux/err.h>

#include <linux/sched.h>

#include <linux/poll.h>

#include <linux/wakelock.h>

#include <linux/pm.h>

#include <linux/platform_device.h>

#include <linux/uaccess.h>

#include <linux/debugfs.h>

	uint32_t remote_node_id;

	uint32_t initialized;

	struct list_head pkt_list;

	struct wake_lock wakelock;

	struct wakeup_source ws;

	struct mutex rx_lock_lhb2;

	struct mutex tx_lock_lhb2;

	uint32_t need_len;

				    struct rr_packet, list);

	list_del(&temp_pkt->list);

	if (list_empty(&xprt_info->pkt_list))

		wake_unlock(&xprt_info->wakelock);

		__pm_relax(&xprt_info->ws);

	mutex_unlock(&xprt_info->rx_lock_lhb2);

	return temp_pkt;

}

	}

	mutex_lock(&port_ptr->port_rx_q_lock_lhb3);

	wake_lock(&port_ptr->port_rx_wake_lock);

	__pm_stay_awake(&port_ptr->port_rx_ws);

	list_add_tail(&temp_pkt->list, &port_ptr->port_rx_q);

	wake_up(&port_ptr->port_rx_wait_q);

	notify = port_ptr->notify;

	INIT_LIST_HEAD(&port_ptr->port_rx_q);

	mutex_init(&port_ptr->port_rx_q_lock_lhb3);

	init_waitqueue_head(&port_ptr->port_rx_wait_q);

	snprintf(port_ptr->rx_wakelock_name, MAX_WAKELOCK_NAME_SZ,

	snprintf(port_ptr->rx_ws_name, MAX_WS_NAME_SZ,

		 "ipc%08x_%s",

		 port_ptr->this_port.port_id,

		 current->comm);

	wake_lock_init(&port_ptr->port_rx_wake_lock,

			WAKE_LOCK_SUSPEND, port_ptr->rx_wakelock_name);

	wakeup_source_init(&port_ptr->port_rx_ws, port_ptr->rx_ws_name);

	port_ptr->endpoint = endpoint;

	port_ptr->notify = notify;

	}

	list_del(&pkt->list);

	if (list_empty(&port_ptr->port_rx_q))

		wake_unlock(&port_ptr->port_rx_wake_lock);

		__pm_relax(&port_ptr->port_rx_ws);

	*read_pkt = pkt;

	mutex_unlock(&port_ptr->port_rx_q_lock_lhb3);

	if (pkt->hdr.control_flag & CONTROL_FLAG_CONFIRM_RX)

		up_write(&server_list_lock_lha2);

	}

	wake_lock_destroy(&port_ptr->port_rx_wake_lock);

	wakeup_source_trash(&port_ptr->port_rx_ws);

	kfree(port_ptr);

	return 0;

}

	INIT_LIST_HEAD(&xprt_info->pkt_list);

	mutex_init(&xprt_info->rx_lock_lhb2);

	mutex_init(&xprt_info->tx_lock_lhb2);

	wake_lock_init(&xprt_info->wakelock,

			WAKE_LOCK_SUSPEND, xprt->name);

	wakeup_source_init(&xprt_info->ws, xprt->name);

	xprt_info->need_len = 0;

	xprt_info->abort_data_read = 0;

	INIT_WORK(&xprt_info->read_data, do_read_data);

		flush_workqueue(xprt_info->workqueue);

		destroy_workqueue(xprt_info->workqueue);

		wake_lock_destroy(&xprt_info->wakelock);

		wakeup_source_trash(&xprt_info->ws);

		xprt->priv = 0;

		kfree(xprt_info);

	mutex_lock(&xprt_info->rx_lock_lhb2);

	list_add_tail(&pkt->list, &xprt_info->pkt_list);

	wake_lock(&xprt_info->wakelock);

	__pm_stay_awake(&xprt_info->ws);

	mutex_unlock(&xprt_info->rx_lock_lhb2);

	queue_work(xprt_info->workqueue, &xprt_info->read_data);

}