Initial Contribution
msm-2.6.38: tag AU_LINUX_ANDROID_GINGERBREAD.02.03.04.00.142
Signed-off-by: Bryan Huntsman <bryanh@codeaurora.org>
diff --git a/arch/arm/mach-msm/rpm_log.c b/arch/arm/mach-msm/rpm_log.c
new file mode 100644
index 0000000..3ed55da
--- /dev/null
+++ b/arch/arm/mach-msm/rpm_log.c
@@ -0,0 +1,363 @@
+/* Copyright (c) 2010-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/debugfs.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+#include <asm/uaccess.h>
+
+#include <mach/msm_iomap.h>
+
+#include "rpm_log.h"
+
+/* registers in MSM_RPM_LOG_PAGE_INDICES */
+enum {
+ MSM_RPM_LOG_TAIL,
+ MSM_RPM_LOG_HEAD
+};
+
+/* used to 4 byte align message lengths */
+#define PADDED_LENGTH(x) (0xFFFFFFFC & ((x) + 3))
+
+/* calculates the character string length of a message of byte length x */
+#define PRINTED_LENGTH(x) ((x) * 6 + 3)
+
+/* number of ms to wait between checking for new messages in the RPM log */
+#define RECHECK_TIME (50)
+
+struct msm_rpm_log_buffer {
+ char *data;
+ u32 len;
+ u32 pos;
+ u32 max_len;
+ u32 read_idx;
+ struct msm_rpm_log_platform_data *pdata;
+};
+
+/******************************************************************************
+ * Internal functions
+ *****************************************************************************/
+
+static inline u32
+msm_rpm_log_read(const struct msm_rpm_log_platform_data *pdata, u32 page,
+ u32 reg)
+{
+ return readl_relaxed(pdata->reg_base + pdata->reg_offsets[page]
+ + reg * 4);
+}
+
+/*
+ * msm_rpm_log_copy() - Copies messages from a volatile circular buffer in
+ * the RPM's shared memory into a private local buffer
+ * msg_buffer: pointer to local buffer (string)
+ * buf_len: length of local buffer in bytes
+ * read_start_idx: index into shared memory buffer
+ *
+ * Return value: number of bytes written to the local buffer
+ *
+ * Copies messages stored in a circular buffer in the RPM Message Memory into
+ * a specified local buffer. The RPM processor is unaware of these reading
+ * efforts, so care is taken to make sure that messages are valid both before
+ * and after reading. The RPM processor utilizes a ULog driver to write the
+ * log. The RPM processor maintains tail and head indices. These correspond
+ * to the next byte to write into, and the first valid byte, respectively.
+ * Both indices increase monotonically (except for rollover).
+ *
+ * Messages take the form of [(u32)length] [(char)data0,1,...] in which the
+ * length specifies the number of payload bytes. Messages must be 4 byte
+ * aligned, so padding is added at the end of a message as needed.
+ *
+ * Print format:
+ * - 0xXX, 0xXX, 0xXX
+ * - 0xXX
+ * etc...
+ */
+static u32 msm_rpm_log_copy(const struct msm_rpm_log_platform_data *pdata,
+ char *msg_buffer, u32 buf_len, u32 *read_idx)
+{
+ u32 head_idx, tail_idx;
+ u32 pos = 0;
+ u32 i = 0;
+ u32 msg_len;
+ u32 pos_start;
+ char temp[4];
+
+ tail_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES,
+ MSM_RPM_LOG_TAIL);
+ head_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES,
+ MSM_RPM_LOG_HEAD);
+
+ /* loop while the remote buffer has valid messages left to read */
+ while (tail_idx - head_idx > 0 && tail_idx - *read_idx > 0) {
+ head_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES,
+ MSM_RPM_LOG_HEAD);
+ /* check if the message to be read is valid */
+ if (tail_idx - *read_idx > tail_idx - head_idx) {
+ *read_idx = head_idx;
+ continue;
+ }
+ /*
+ * Ensure that the reported buffer size is within limits of
+ * known maximum size and that all indices are 4 byte aligned.
+ * These conditions are required to interact with a ULog buffer
+ * properly.
+ */
+ if (tail_idx - head_idx > pdata->log_len ||
+ !IS_ALIGNED((tail_idx | head_idx | *read_idx), 4))
+ break;
+
+ msg_len = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_BUFFER,
+ (*read_idx >> 2) & pdata->log_len_mask);
+
+ /* handle messages that claim to be longer than the log */
+ if (PADDED_LENGTH(msg_len) > tail_idx - *read_idx - 4)
+ msg_len = tail_idx - *read_idx - 4;
+
+ /* check that the local buffer has enough space for this msg */
+ if (pos + PRINTED_LENGTH(msg_len) > buf_len)
+ break;
+
+ pos_start = pos;
+ pos += scnprintf(msg_buffer + pos, buf_len - pos, "- ");
+
+ /* copy message payload to local buffer */
+ for (i = 0; i < msg_len; i++) {
+ /* read from shared memory 4 bytes at a time */
+ if (IS_ALIGNED(i, 4))
+ *((u32 *)temp) = msm_rpm_log_read(pdata,
+ MSM_RPM_LOG_PAGE_BUFFER,
+ ((*read_idx + 4 + i) >> 2) &
+ pdata->log_len_mask);
+
+ pos += scnprintf(msg_buffer + pos, buf_len - pos,
+ "0x%02X, ", temp[i & 0x03]);
+ }
+
+ pos += scnprintf(msg_buffer + pos, buf_len - pos, "\n");
+
+ head_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES,
+ MSM_RPM_LOG_HEAD);
+
+ /* roll back if message that was read is not still valid */
+ if (tail_idx - *read_idx > tail_idx - head_idx)
+ pos = pos_start;
+
+ *read_idx += PADDED_LENGTH(msg_len) + 4;
+ }
+
+ return pos;
+}
+
+
+/*
+ * msm_rpm_log_file_read() - Reads in log buffer messages then outputs them to a
+ * user buffer
+ *
+ * Return value:
+ * 0: success
+ * -ENOMEM: no memory available
+ * -EINVAL: user buffer null or requested bytes 0
+ * -EFAULT: user buffer not writeable
+ * -EAGAIN: no bytes available at the moment
+ */
+static ssize_t msm_rpm_log_file_read(struct file *file, char __user *bufu,
+ size_t count, loff_t *ppos)
+{
+ u32 out_len, remaining;
+ struct msm_rpm_log_platform_data *pdata;
+ struct msm_rpm_log_buffer *buf;
+
+ buf = file->private_data;
+ pdata = buf->pdata;
+ if (!pdata)
+ return -EINVAL;
+ if (!buf)
+ return -ENOMEM;
+ if (!buf->data)
+ return -ENOMEM;
+ if (!bufu || count < 0)
+ return -EINVAL;
+ if (!access_ok(VERIFY_WRITE, bufu, count))
+ return -EFAULT;
+
+ /* check for more messages if local buffer empty */
+ if (buf->pos == buf->len) {
+ buf->pos = 0;
+ buf->len = msm_rpm_log_copy(pdata, buf->data, buf->max_len,
+ &(buf->read_idx));
+ }
+
+ if ((file->f_flags & O_NONBLOCK) && buf->len == 0)
+ return -EAGAIN;
+
+ /* loop until new messages arrive */
+ while (buf->len == 0) {
+ cond_resched();
+ if (msleep_interruptible(RECHECK_TIME))
+ break;
+ buf->len = msm_rpm_log_copy(pdata, buf->data, buf->max_len,
+ &(buf->read_idx));
+ }
+
+ out_len = ((buf->len - buf->pos) < count ? buf->len - buf->pos : count);
+
+ remaining = __copy_to_user(bufu, &(buf->data[buf->pos]), out_len);
+ buf->pos += out_len - remaining;
+
+ return out_len - remaining;
+}
+
+
+/*
+ * msm_rpm_log_file_open() - Allows a new reader to open the RPM log virtual
+ * file
+ *
+ * One local buffer is kmalloc'ed for each reader, so no resource sharing has
+ * to take place (besides the read only access to the RPM log buffer).
+ *
+ * Return value:
+ * 0: success
+ * -ENOMEM: no memory available
+ */
+static int msm_rpm_log_file_open(struct inode *inode, struct file *file)
+{
+ struct msm_rpm_log_buffer *buf;
+ struct msm_rpm_log_platform_data *pdata;
+
+ pdata = inode->i_private;
+ if (!pdata)
+ return -EINVAL;
+
+ file->private_data =
+ kmalloc(sizeof(struct msm_rpm_log_buffer), GFP_KERNEL);
+ if (!file->private_data) {
+ pr_err("%s: ERROR kmalloc failed to allocate %d bytes\n",
+ __func__, sizeof(struct msm_rpm_log_buffer));
+ return -ENOMEM;
+ }
+ buf = file->private_data;
+
+ buf->data = kmalloc(PRINTED_LENGTH(pdata->log_len), GFP_KERNEL);
+ if (!buf->data) {
+ kfree(file->private_data);
+ file->private_data = NULL;
+ pr_err("%s: ERROR kmalloc failed to allocate %d bytes\n",
+ __func__, PRINTED_LENGTH(pdata->log_len));
+ return -ENOMEM;
+ }
+
+ buf->pdata = pdata;
+ buf->len = 0;
+ buf->pos = 0;
+ buf->max_len = PRINTED_LENGTH(pdata->log_len);
+ buf->read_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES,
+ MSM_RPM_LOG_HEAD);
+ return 0;
+}
+
+static int msm_rpm_log_file_close(struct inode *inode, struct file *file)
+{
+ kfree(((struct msm_rpm_log_buffer *)file->private_data)->data);
+ kfree(file->private_data);
+ return 0;
+}
+
+
+static const struct file_operations msm_rpm_log_file_fops = {
+ .owner = THIS_MODULE,
+ .open = msm_rpm_log_file_open,
+ .read = msm_rpm_log_file_read,
+ .release = msm_rpm_log_file_close,
+};
+
+static int __devinit msm_rpm_log_probe(struct platform_device *pdev)
+{
+ struct dentry *dent;
+ struct msm_rpm_log_platform_data *pdata;
+
+ pdata = pdev->dev.platform_data;
+ if (!pdata)
+ return -EINVAL;
+
+ pdata->reg_base = ioremap(pdata->phys_addr_base, pdata->phys_size);
+ if (!pdata->reg_base) {
+ pr_err("%s: ERROR could not ioremap: start=%p, len=%u\n",
+ __func__, (void *) pdata->phys_addr_base,
+ pdata->phys_size);
+ return -EBUSY;
+ }
+
+ dent = debugfs_create_file("rpm_log", S_IRUGO, NULL,
+ pdev->dev.platform_data, &msm_rpm_log_file_fops);
+ if (!dent) {
+ pr_err("%s: ERROR debugfs_create_file failed\n", __func__);
+ return -ENOMEM;
+ }
+
+ platform_set_drvdata(pdev, dent);
+
+ pr_notice("%s: OK\n", __func__);
+ return 0;
+}
+
+static int __devexit msm_rpm_log_remove(struct platform_device *pdev)
+{
+ struct dentry *dent;
+ struct msm_rpm_log_platform_data *pdata;
+
+ pdata = pdev->dev.platform_data;
+
+ iounmap(pdata->reg_base);
+
+ dent = platform_get_drvdata(pdev);
+ debugfs_remove(dent);
+ platform_set_drvdata(pdev, NULL);
+
+ pr_notice("%s: OK\n", __func__);
+ return 0;
+}
+
+static struct platform_driver msm_rpm_log_driver = {
+ .probe = msm_rpm_log_probe,
+ .remove = __devexit_p(msm_rpm_log_remove),
+ .driver = {
+ .name = "msm_rpm_log",
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init msm_rpm_log_init(void)
+{
+ return platform_driver_register(&msm_rpm_log_driver);
+}
+
+static void __exit msm_rpm_log_exit(void)
+{
+ platform_driver_unregister(&msm_rpm_log_driver);
+}
+
+module_init(msm_rpm_log_init);
+module_exit(msm_rpm_log_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("MSM RPM Log driver");
+MODULE_VERSION("1.0");
+MODULE_ALIAS("platform:msm_rpm_log");