[linux-2.6-block.git] / drivers / soc / qcom / smd-rpm.c

/*
 * Copyright (c) 2015, Sony Mobile Communications AB.
 * Copyright (c) 2012-2013, The Linux Foundation. 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/module.h>
#include <linux/platform_device.h>
#include <linux/of_platform.h>
#include <linux/io.h>
#include <linux/interrupt.h>
#include <linux/slab.h>

#include <linux/soc/qcom/smd.h>
#include <linux/soc/qcom/smd-rpm.h>

#define RPM_REQUEST_TIMEOUT     (5 * HZ)

/**
 * struct qcom_smd_rpm - state of the rpm device driver
 * @rpm_channel:	reference to the smd channel
 * @ack:		completion for acks
 * @lock:		mutual exclusion around the send/complete pair
 * @ack_status:		result of the rpm request
 */
struct qcom_smd_rpm {
	struct qcom_smd_channel *rpm_channel;
	struct device *dev;

	struct completion ack;
	struct mutex lock;
	int ack_status;
};

/**
 * struct qcom_rpm_header - header for all rpm requests and responses
 * @service_type:	identifier of the service
 * @length:		length of the payload
 */
struct qcom_rpm_header {
	__le32 service_type;
	__le32 length;
};

/**
 * struct qcom_rpm_request - request message to the rpm
 * @msg_id:	identifier of the outgoing message
 * @flags:	active/sleep state flags
 * @type:	resource type
 * @id:		resource id
 * @data_len:	length of the payload following this header
 */
struct qcom_rpm_request {
	__le32 msg_id;
	__le32 flags;
	__le32 type;
	__le32 id;
	__le32 data_len;
};

/**
 * struct qcom_rpm_message - response message from the rpm
 * @msg_type:	indicator of the type of message
 * @length:	the size of this message, including the message header
 * @msg_id:	message id
 * @message:	textual message from the rpm
 *
 * Multiple of these messages can be stacked in an rpm message.
 */
struct qcom_rpm_message {
	__le32 msg_type;
	__le32 length;
	union {
		__le32 msg_id;
		u8 message[0];
	};
};

#define RPM_SERVICE_TYPE_REQUEST	0x00716572 /* "req\0" */

#define RPM_MSG_TYPE_ERR		0x00727265 /* "err\0" */
#define RPM_MSG_TYPE_MSG_ID		0x2367736d /* "msg#" */

/**
 * qcom_rpm_smd_write - write @buf to @type:@id
 * @rpm:	rpm handle
 * @type:	resource type
 * @id:		resource identifier
 * @buf:	the data to be written
 * @count:	number of bytes in @buf
 */
int qcom_rpm_smd_write(struct qcom_smd_rpm *rpm,
		       int state,
		       u32 type, u32 id,
		       void *buf,
		       size_t count)
{
	static unsigned msg_id = 1;
	int left;
	int ret;
	struct {
		struct qcom_rpm_header hdr;
		struct qcom_rpm_request req;
		u8 payload[];
	} *pkt;
	size_t size = sizeof(*pkt) + count;

	/* SMD packets to the RPM may not exceed 256 bytes */
	if (WARN_ON(size >= 256))
		return -EINVAL;

	pkt = kmalloc(size, GFP_KERNEL);
	if (!pkt)
		return -ENOMEM;

	mutex_lock(&rpm->lock);

	pkt->hdr.service_type = cpu_to_le32(RPM_SERVICE_TYPE_REQUEST);
	pkt->hdr.length = cpu_to_le32(sizeof(struct qcom_rpm_request) + count);

	pkt->req.msg_id = cpu_to_le32(msg_id++);
	pkt->req.flags = cpu_to_le32(state);
	pkt->req.type = cpu_to_le32(type);
	pkt->req.id = cpu_to_le32(id);
	pkt->req.data_len = cpu_to_le32(count);
	memcpy(pkt->payload, buf, count);

	ret = qcom_smd_send(rpm->rpm_channel, pkt, size);
	if (ret)
		goto out;

	left = wait_for_completion_timeout(&rpm->ack, RPM_REQUEST_TIMEOUT);
	if (!left)
		ret = -ETIMEDOUT;
	else
		ret = rpm->ack_status;

out:
	kfree(pkt);
	mutex_unlock(&rpm->lock);
	return ret;
}
EXPORT_SYMBOL(qcom_rpm_smd_write);

static int qcom_smd_rpm_callback(struct qcom_smd_channel *channel,
				 const void *data,
				 size_t count)
{
	const struct qcom_rpm_header *hdr = data;
	size_t hdr_length = le32_to_cpu(hdr->length);
	const struct qcom_rpm_message *msg;
	struct qcom_smd_rpm *rpm = qcom_smd_get_drvdata(channel);
	const u8 *buf = data + sizeof(struct qcom_rpm_header);
	const u8 *end = buf + hdr_length;
	char msgbuf[32];
	int status = 0;
	u32 len, msg_length;

	if (le32_to_cpu(hdr->service_type) != RPM_SERVICE_TYPE_REQUEST ||
	    hdr_length < sizeof(struct qcom_rpm_message)) {
		dev_err(rpm->dev, "invalid request\n");
		return 0;
	}

	while (buf < end) {
		msg = (struct qcom_rpm_message *)buf;
		msg_length = le32_to_cpu(msg->length);
		switch (le32_to_cpu(msg->msg_type)) {
		case RPM_MSG_TYPE_MSG_ID:
			break;
		case RPM_MSG_TYPE_ERR:
			len = min_t(u32, ALIGN(msg_length, 4), sizeof(msgbuf));
			memcpy_fromio(msgbuf, msg->message, len);
			msgbuf[len - 1] = 0;

			if (!strcmp(msgbuf, "resource does not exist"))
				status = -ENXIO;
			else
				status = -EINVAL;
			break;
		}

		buf = PTR_ALIGN(buf + 2 * sizeof(u32) + msg_length, 4);
	}

	rpm->ack_status = status;
	complete(&rpm->ack);
	return 0;
}

static int qcom_smd_rpm_probe(struct qcom_smd_device *sdev)
{
	struct qcom_smd_rpm *rpm;

	rpm = devm_kzalloc(&sdev->dev, sizeof(*rpm), GFP_KERNEL);
	if (!rpm)
		return -ENOMEM;

	mutex_init(&rpm->lock);
	init_completion(&rpm->ack);

	rpm->dev = &sdev->dev;
	rpm->rpm_channel = sdev->channel;
	qcom_smd_set_drvdata(sdev->channel, rpm);

	dev_set_drvdata(&sdev->dev, rpm);

	return of_platform_populate(sdev->dev.of_node, NULL, NULL, &sdev->dev);
}

static void qcom_smd_rpm_remove(struct qcom_smd_device *sdev)
{
	of_platform_depopulate(&sdev->dev);
}

static const struct of_device_id qcom_smd_rpm_of_match[] = {
	{ .compatible = "qcom,rpm-apq8084" },
	{ .compatible = "qcom,rpm-msm8916" },
	{ .compatible = "qcom,rpm-msm8974" },
	{}
};
MODULE_DEVICE_TABLE(of, qcom_smd_rpm_of_match);

static struct qcom_smd_driver qcom_smd_rpm_driver = {
	.probe = qcom_smd_rpm_probe,
	.remove = qcom_smd_rpm_remove,
	.callback = qcom_smd_rpm_callback,
	.driver  = {
		.name  = "qcom_smd_rpm",
		.owner = THIS_MODULE,
		.of_match_table = qcom_smd_rpm_of_match,
	},
};

static int __init qcom_smd_rpm_init(void)
{
	return qcom_smd_driver_register(&qcom_smd_rpm_driver);
}
arch_initcall(qcom_smd_rpm_init);

static void __exit qcom_smd_rpm_exit(void)
{
	qcom_smd_driver_unregister(&qcom_smd_rpm_driver);
}
module_exit(qcom_smd_rpm_exit);

MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
MODULE_DESCRIPTION("Qualcomm SMD backed RPM driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
936f14cf BA	1	/*
	2	* Copyright (c) 2015, Sony Mobile Communications AB.
	3	* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 and
	7	* only version 2 as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*/
	14
	15	#include <linux/module.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/of_platform.h>
	18	#include <linux/io.h>
	19	#include <linux/interrupt.h>
50e1b29b	20	#include <linux/slab.h>
936f14cf BA	21
	22	#include <linux/soc/qcom/smd.h>
	23	#include <linux/soc/qcom/smd-rpm.h>
	24
	25	#define RPM_REQUEST_TIMEOUT (5 * HZ)
	26
	27	/**
	28	* struct qcom_smd_rpm - state of the rpm device driver
	29	* @rpm_channel: reference to the smd channel
	30	* @ack: completion for acks
	31	* @lock: mutual exclusion around the send/complete pair
	32	* @ack_status: result of the rpm request
	33	*/
	34	struct qcom_smd_rpm {
	35	struct qcom_smd_channel *rpm_channel;
b853cb96	36	struct device *dev;
936f14cf BA	37
	38	struct completion ack;
	39	struct mutex lock;
	40	int ack_status;
	41	};
	42
	43	/**
	44	* struct qcom_rpm_header - header for all rpm requests and responses
	45	* @service_type: identifier of the service
	46	* @length: length of the payload
	47	*/
	48	struct qcom_rpm_header {
30b7ea5e SB	49	__le32 service_type;
30b7ea5e SB	50	__le32 length;
936f14cf BA	51	};
	52
	53	/**
	54	* struct qcom_rpm_request - request message to the rpm
	55	* @msg_id: identifier of the outgoing message
	56	* @flags: active/sleep state flags
	57	* @type: resource type
	58	* @id: resource id
	59	* @data_len: length of the payload following this header
	60	*/
	61	struct qcom_rpm_request {
30b7ea5e SB	62	__le32 msg_id;
	63	__le32 flags;
	64	__le32 type;
	65	__le32 id;
	66	__le32 data_len;
936f14cf BA	67	};
	68
	69	/**
	70	* struct qcom_rpm_message - response message from the rpm
	71	* @msg_type: indicator of the type of message
	72	* @length: the size of this message, including the message header
	73	* @msg_id: message id
	74	* @message: textual message from the rpm
	75	*
	76	* Multiple of these messages can be stacked in an rpm message.
	77	*/
	78	struct qcom_rpm_message {
30b7ea5e SB	79	__le32 msg_type;
30b7ea5e SB	80	__le32 length;
936f14cf	81	union {
30b7ea5e	82	__le32 msg_id;
936f14cf BA	83	u8 message[0];
	84	};
	85	};
	86
	87	#define RPM_SERVICE_TYPE_REQUEST 0x00716572 /* "req\0" */
	88
	89	#define RPM_MSG_TYPE_ERR 0x00727265 /* "err\0" */
	90	#define RPM_MSG_TYPE_MSG_ID 0x2367736d /* "msg#" */
	91
	92	/**
	93	* qcom_rpm_smd_write - write @buf to @type:@id
	94	* @rpm: rpm handle
	95	* @type: resource type
	96	* @id: resource identifier
	97	* @buf: the data to be written
	98	* @count: number of bytes in @buf
	99	*/
	100	int qcom_rpm_smd_write(struct qcom_smd_rpm *rpm,
	101	int state,
	102	u32 type, u32 id,
	103	void *buf,
	104	size_t count)
	105	{
	106	static unsigned msg_id = 1;
	107	int left;
	108	int ret;
936f14cf BA	109	struct {
	110	struct qcom_rpm_header hdr;
	111	struct qcom_rpm_request req;
50e1b29b SB	112	u8 payload[];
	113	} *pkt;
	114	size_t size = sizeof(*pkt) + count;
936f14cf BA	115
936f14cf BA	116	/* SMD packets to the RPM may not exceed 256 bytes */
50e1b29b	117	if (WARN_ON(size >= 256))
936f14cf BA	118	return -EINVAL;
936f14cf BA	119
50e1b29b SB	120	pkt = kmalloc(size, GFP_KERNEL);
	121	if (!pkt)
	122	return -ENOMEM;
	123
936f14cf BA	124	mutex_lock(&rpm->lock);
936f14cf BA	125
30b7ea5e SB	126	pkt->hdr.service_type = cpu_to_le32(RPM_SERVICE_TYPE_REQUEST);
30b7ea5e SB	127	pkt->hdr.length = cpu_to_le32(sizeof(struct qcom_rpm_request) + count);
936f14cf	128
30b7ea5e	129	pkt->req.msg_id = cpu_to_le32(msg_id++);
a8ddd1b9	130	pkt->req.flags = cpu_to_le32(state);
30b7ea5e SB	131	pkt->req.type = cpu_to_le32(type);
	132	pkt->req.id = cpu_to_le32(id);
	133	pkt->req.data_len = cpu_to_le32(count);
50e1b29b	134	memcpy(pkt->payload, buf, count);
936f14cf	135
d13a5c8c	136	ret = qcom_smd_send(rpm->rpm_channel, pkt, size);
936f14cf BA	137	if (ret)
	138	goto out;
	139
	140	left = wait_for_completion_timeout(&rpm->ack, RPM_REQUEST_TIMEOUT);
	141	if (!left)
	142	ret = -ETIMEDOUT;
	143	else
	144	ret = rpm->ack_status;
	145
	146	out:
50e1b29b	147	kfree(pkt);
936f14cf BA	148	mutex_unlock(&rpm->lock);
	149	return ret;
	150	}
	151	EXPORT_SYMBOL(qcom_rpm_smd_write);
	152
b853cb96	153	static int qcom_smd_rpm_callback(struct qcom_smd_channel *channel,
936f14cf BA	154	const void *data,
	155	size_t count)
	156	{
	157	const struct qcom_rpm_header *hdr = data;
30b7ea5e	158	size_t hdr_length = le32_to_cpu(hdr->length);
936f14cf	159	const struct qcom_rpm_message *msg;
b853cb96	160	struct qcom_smd_rpm *rpm = qcom_smd_get_drvdata(channel);
936f14cf	161	const u8 *buf = data + sizeof(struct qcom_rpm_header);
30b7ea5e	162	const u8 *end = buf + hdr_length;
936f14cf BA	163	char msgbuf[32];
936f14cf BA	164	int status = 0;
30b7ea5e	165	u32 len, msg_length;
936f14cf	166
30b7ea5e SB	167	if (le32_to_cpu(hdr->service_type) != RPM_SERVICE_TYPE_REQUEST \|\|
30b7ea5e SB	168	hdr_length < sizeof(struct qcom_rpm_message)) {
b853cb96	169	dev_err(rpm->dev, "invalid request\n");
936f14cf BA	170	return 0;
	171	}
	172
	173	while (buf < end) {
	174	msg = (struct qcom_rpm_message *)buf;
30b7ea5e SB	175	msg_length = le32_to_cpu(msg->length);
30b7ea5e SB	176	switch (le32_to_cpu(msg->msg_type)) {
936f14cf BA	177	case RPM_MSG_TYPE_MSG_ID:
	178	break;
	179	case RPM_MSG_TYPE_ERR:
30b7ea5e	180	len = min_t(u32, ALIGN(msg_length, 4), sizeof(msgbuf));
936f14cf BA	181	memcpy_fromio(msgbuf, msg->message, len);
	182	msgbuf[len - 1] = 0;
	183
	184	if (!strcmp(msgbuf, "resource does not exist"))
	185	status = -ENXIO;
	186	else
	187	status = -EINVAL;
	188	break;
	189	}
	190
30b7ea5e	191	buf = PTR_ALIGN(buf + 2 * sizeof(u32) + msg_length, 4);
936f14cf BA	192	}
	193
	194	rpm->ack_status = status;
	195	complete(&rpm->ack);
	196	return 0;
	197	}
	198
	199	static int qcom_smd_rpm_probe(struct qcom_smd_device *sdev)
	200	{
	201	struct qcom_smd_rpm *rpm;
	202
	203	rpm = devm_kzalloc(&sdev->dev, sizeof(*rpm), GFP_KERNEL);
	204	if (!rpm)
	205	return -ENOMEM;
	206
	207	mutex_init(&rpm->lock);
	208	init_completion(&rpm->ack);
	209
b853cb96	210	rpm->dev = &sdev->dev;
936f14cf	211	rpm->rpm_channel = sdev->channel;
b853cb96	212	qcom_smd_set_drvdata(sdev->channel, rpm);
936f14cf BA	213
	214	dev_set_drvdata(&sdev->dev, rpm);
	215
	216	return of_platform_populate(sdev->dev.of_node, NULL, NULL, &sdev->dev);
	217	}
	218
	219	static void qcom_smd_rpm_remove(struct qcom_smd_device *sdev)
	220	{
	221	of_platform_depopulate(&sdev->dev);
	222	}
	223
	224	static const struct of_device_id qcom_smd_rpm_of_match[] = {
1f0947fe AG	225	{ .compatible = "qcom,rpm-apq8084" },
1f0947fe AG	226	{ .compatible = "qcom,rpm-msm8916" },
936f14cf BA	227	{ .compatible = "qcom,rpm-msm8974" },
	228	{}
	229	};
	230	MODULE_DEVICE_TABLE(of, qcom_smd_rpm_of_match);
	231
	232	static struct qcom_smd_driver qcom_smd_rpm_driver = {
	233	.probe = qcom_smd_rpm_probe,
	234	.remove = qcom_smd_rpm_remove,
	235	.callback = qcom_smd_rpm_callback,
	236	.driver = {
	237	.name = "qcom_smd_rpm",
	238	.owner = THIS_MODULE,
	239	.of_match_table = qcom_smd_rpm_of_match,
	240	},
	241	};
	242
	243	static int __init qcom_smd_rpm_init(void)
	244	{
	245	return qcom_smd_driver_register(&qcom_smd_rpm_driver);
	246	}
	247	arch_initcall(qcom_smd_rpm_init);
	248
	249	static void __exit qcom_smd_rpm_exit(void)
	250	{
	251	qcom_smd_driver_unregister(&qcom_smd_rpm_driver);
	252	}
	253	module_exit(qcom_smd_rpm_exit);
	254
	255	MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
	256	MODULE_DESCRIPTION("Qualcomm SMD backed RPM driver");
	257	MODULE_LICENSE("GPL v2");