Merge tag 'qcom-soc-for-4.7' of... (f6396838) · Commits · 戴 / test

MAINTAINERS

+3 −0

Original line number	Diff line number	Diff line
		@@ -1470,7 +1470,10 @@ F: arch/arm/boot/dts/qcom-*.dts
		F: arch/arm/boot/dts/qcom-*.dtsi
		F: arch/arm/mach-qcom/
		F: arch/arm64/boot/dts/qcom/*
		F: drivers/i2c/busses/i2c-qup.c
		F: drivers/clk/qcom/
		F: drivers/soc/qcom/
		F: drivers/spi/spi-qup.c
		F: drivers/tty/serial/msm_serial.h
		F: drivers/tty/serial/msm_serial.c
		F: drivers//pm8???-

drivers/soc/qcom/smd.c

+172 −57

Original line number	Diff line number	Diff line
		@@ -106,9 +106,9 @@ static const struct {
		* @channels: list of all channels detected on this edge
		* @channels_lock: guard for modifications of @channels
		* @allocated: array of bitmaps representing already allocated channels
		* @need_rescan: flag that the @work needs to scan smem for new channels
		* @smem_available: last available amount of smem triggering a channel scan
		* @work: work item for edge house keeping
		* @scan_work: work item for discovering new channels
		* @state_work: work item for edge state changes
		*/
		struct qcom_smd_edge {
		struct qcom_smd *smd;
		@@ -127,10 +127,12 @@ struct qcom_smd_edge {

		DECLARE_BITMAP(allocated[SMD_ALLOC_TBL_COUNT], SMD_ALLOC_TBL_SIZE);

		bool need_rescan;
		unsigned smem_available;

		struct work_struct work;
		wait_queue_head_t new_channel_event;

		struct work_struct scan_work;
		struct work_struct state_work;
		};

		/*
		@@ -186,13 +188,14 @@ struct qcom_smd_channel {
		int fifo_size;

		void *bounce_buffer;
		int (cb)(struct qcom_smd_device , const void *, size_t);
		qcom_smd_cb_t cb;

		spinlock_t recv_lock;

		int pkt_size;

		struct list_head list;
		struct list_head dev_list;
		};

		/**
		@@ -377,6 +380,19 @@ static void qcom_smd_channel_reset(struct qcom_smd_channel *channel)
		channel->pkt_size = 0;
		}

		/*
		* Set the callback for a channel, with appropriate locking
		*/
		static void qcom_smd_channel_set_callback(struct qcom_smd_channel *channel,
		qcom_smd_cb_t cb)
		{
		unsigned long flags;

		spin_lock_irqsave(&channel->recv_lock, flags);
		channel->cb = cb;
		spin_unlock_irqrestore(&channel->recv_lock, flags);
		};

		/*
		* Calculate the amount of data available in the rx fifo
		*/
		@@ -601,7 +617,8 @@ static irqreturn_t qcom_smd_edge_intr(int irq, void *data)
		struct qcom_smd_edge *edge = data;
		struct qcom_smd_channel *channel;
		unsigned available;
		bool kick_worker = false;
		bool kick_scanner = false;
		bool kick_state = false;

		/*
		* Handle state changes or data on each of the channels on this edge
		@@ -609,7 +626,7 @@ static irqreturn_t qcom_smd_edge_intr(int irq, void *data)
		spin_lock(&edge->channels_lock);
		list_for_each_entry(channel, &edge->channels, list) {
		spin_lock(&channel->recv_lock);
		kick_worker \|= qcom_smd_channel_intr(channel);
		kick_state \|= qcom_smd_channel_intr(channel);
		spin_unlock(&channel->recv_lock);
		}
		spin_unlock(&edge->channels_lock);
		@@ -622,12 +639,13 @@ static irqreturn_t qcom_smd_edge_intr(int irq, void *data)
		available = qcom_smem_get_free_space(edge->remote_pid);
		if (available != edge->smem_available) {
		edge->smem_available = available;
		edge->need_rescan = true;
		kick_worker = true;
		kick_scanner = true;
		}

		if (kick_worker)
		schedule_work(&edge->work);
		if (kick_scanner)
		schedule_work(&edge->scan_work);
		if (kick_state)
		schedule_work(&edge->state_work);

		return IRQ_HANDLED;
		}
		@@ -793,18 +811,12 @@ static int qcom_smd_dev_match(struct device dev, struct device_driver drv)
		}

		/*
		* Probe the smd client.
		*
		* The remote side have indicated that it want the channel to be opened, so
		* complete the state handshake and probe our client driver.
		* Helper for opening a channel
		*/
		static int qcom_smd_dev_probe(struct device *dev)
		static int qcom_smd_channel_open(struct qcom_smd_channel *channel,
		qcom_smd_cb_t cb)
		{
		struct qcom_smd_device *qsdev = to_smd_device(dev);
		struct qcom_smd_driver *qsdrv = to_smd_driver(dev);
		struct qcom_smd_channel *channel = qsdev->channel;
		size_t bb_size;
		int ret;

		/*
		* Packets are maximum 4k, but reduce if the fifo is smaller
		@@ -814,12 +826,44 @@ static int qcom_smd_dev_probe(struct device *dev)
		if (!channel->bounce_buffer)
		return -ENOMEM;

		channel->cb = qsdrv->callback;

		qcom_smd_channel_set_callback(channel, cb);
		qcom_smd_channel_set_state(channel, SMD_CHANNEL_OPENING);

		qcom_smd_channel_set_state(channel, SMD_CHANNEL_OPENED);

		return 0;
		}

		/*
		* Helper for closing and resetting a channel
		*/
		static void qcom_smd_channel_close(struct qcom_smd_channel *channel)
		{
		qcom_smd_channel_set_callback(channel, NULL);

		kfree(channel->bounce_buffer);
		channel->bounce_buffer = NULL;

		qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSED);
		qcom_smd_channel_reset(channel);
		}

		/*
		* Probe the smd client.
		*
		* The remote side have indicated that it want the channel to be opened, so
		* complete the state handshake and probe our client driver.
		*/
		static int qcom_smd_dev_probe(struct device *dev)
		{
		struct qcom_smd_device *qsdev = to_smd_device(dev);
		struct qcom_smd_driver *qsdrv = to_smd_driver(dev);
		struct qcom_smd_channel *channel = qsdev->channel;
		int ret;

		ret = qcom_smd_channel_open(channel, qsdrv->callback);
		if (ret)
		return ret;

		ret = qsdrv->probe(qsdev);
		if (ret)
		goto err;
		@@ -831,11 +875,7 @@ static int qcom_smd_dev_probe(struct device *dev)
		err:
		dev_err(&qsdev->dev, "probe failed\n");

		channel->cb = NULL;
		kfree(channel->bounce_buffer);
		channel->bounce_buffer = NULL;

		qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSED);
		qcom_smd_channel_close(channel);
		return ret;
		}

		@@ -850,16 +890,15 @@ static int qcom_smd_dev_remove(struct device *dev)
		struct qcom_smd_device *qsdev = to_smd_device(dev);
		struct qcom_smd_driver *qsdrv = to_smd_driver(dev);
		struct qcom_smd_channel *channel = qsdev->channel;
		unsigned long flags;
		struct qcom_smd_channel *tmp;
		struct qcom_smd_channel *ch;

		qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSING);

		/*
		* Make sure we don't race with the code receiving data.
		*/
		spin_lock_irqsave(&channel->recv_lock, flags);
		channel->cb = NULL;
		spin_unlock_irqrestore(&channel->recv_lock, flags);
		qcom_smd_channel_set_callback(channel, NULL);

		/* Wake up any sleepers in qcom_smd_send() */
		wake_up_interruptible(&channel->fblockread_event);
		@@ -872,15 +911,14 @@ static int qcom_smd_dev_remove(struct device *dev)
		qsdrv->remove(qsdev);

		/*
		* The client is now gone, cleanup and reset the channel state.
		* The client is now gone, close and release all channels associated
		* with this sdev
		*/
		channel->qsdev = NULL;
		kfree(channel->bounce_buffer);
		channel->bounce_buffer = NULL;

		qcom_smd_channel_set_state(channel, SMD_CHANNEL_CLOSED);

		qcom_smd_channel_reset(channel);
		list_for_each_entry_safe(ch, tmp, &channel->dev_list, dev_list) {
		qcom_smd_channel_close(ch);
		list_del(&ch->dev_list);
		ch->qsdev = NULL;
		}

		return 0;
		}
		@@ -1006,6 +1044,77 @@ void qcom_smd_driver_unregister(struct qcom_smd_driver *qsdrv)
		}
		EXPORT_SYMBOL(qcom_smd_driver_unregister);

		static struct qcom_smd_channel *
		qcom_smd_find_channel(struct qcom_smd_edge edge, const char name)
		{
		struct qcom_smd_channel *channel;
		struct qcom_smd_channel *ret = NULL;
		unsigned long flags;
		unsigned state;

		spin_lock_irqsave(&edge->channels_lock, flags);
		list_for_each_entry(channel, &edge->channels, list) {
		if (strcmp(channel->name, name))
		continue;

		state = GET_RX_CHANNEL_INFO(channel, state);
		if (state != SMD_CHANNEL_OPENING &&
		state != SMD_CHANNEL_OPENED)
		continue;

		ret = channel;
		break;
		}
		spin_unlock_irqrestore(&edge->channels_lock, flags);

		return ret;
		}

		/**
		* qcom_smd_open_channel() - claim additional channels on the same edge
		* @sdev: smd_device handle
		* @name: channel name
		* @cb: callback method to use for incoming data
		*
		* Returns a channel handle on success, or -EPROBE_DEFER if the channel isn't
		* ready.
		*/
		struct qcom_smd_channel qcom_smd_open_channel(struct qcom_smd_device sdev,
		const char *name,
		qcom_smd_cb_t cb)
		{
		struct qcom_smd_channel *channel;
		struct qcom_smd_edge *edge = sdev->channel->edge;
		int ret;

		/* Wait up to HZ for the channel to appear */
		ret = wait_event_interruptible_timeout(edge->new_channel_event,
		(channel = qcom_smd_find_channel(edge, name)) != NULL,
		HZ);
		if (!ret)
		return ERR_PTR(-ETIMEDOUT);

		if (channel->state != SMD_CHANNEL_CLOSED) {
		dev_err(&sdev->dev, "channel %s is busy\n", channel->name);
		return ERR_PTR(-EBUSY);
		}

		channel->qsdev = sdev;
		ret = qcom_smd_channel_open(channel, cb);
		if (ret) {
		channel->qsdev = NULL;
		return ERR_PTR(ret);
		}

		/*
		* Append the list of channel to the channels associated with the sdev
		*/
		list_add_tail(&channel->dev_list, &sdev->channel->dev_list);

		return channel;
		}
		EXPORT_SYMBOL(qcom_smd_open_channel);

		/*
		* Allocate the qcom_smd_channel object for a newly found smd channel,
		* retrieving and validating the smem items involved.
		@@ -1027,6 +1136,7 @@ static struct qcom_smd_channel qcom_smd_create_channel(struct qcom_smd_edge ed
		if (!channel)
		return ERR_PTR(-ENOMEM);

		INIT_LIST_HEAD(&channel->dev_list);
		channel->edge = edge;
		channel->name = devm_kstrdup(smd->dev, name, GFP_KERNEL);
		if (!channel->name)
		@@ -1089,8 +1199,9 @@ free_name_and_channel:
		* qcom_smd_create_channel() to create representations of these and add
		* them to the edge's list of channels.
		*/
		static void qcom_discover_channels(struct qcom_smd_edge *edge)
		static void qcom_channel_scan_worker(struct work_struct *work)
		{
		struct qcom_smd_edge *edge = container_of(work, struct qcom_smd_edge, scan_work);
		struct qcom_smd_alloc_entry *alloc_tbl;
		struct qcom_smd_alloc_entry *entry;
		struct qcom_smd_channel *channel;
		@@ -1140,10 +1251,12 @@ static void qcom_discover_channels(struct qcom_smd_edge *edge)

		dev_dbg(smd->dev, "new channel found: '%s'\n", channel->name);
		set_bit(i, edge->allocated[tbl]);

		wake_up_interruptible(&edge->new_channel_event);
		}
		}

		schedule_work(&edge->work);
		schedule_work(&edge->state_work);
		}

		/*
		@@ -1151,29 +1264,23 @@ static void qcom_discover_channels(struct qcom_smd_edge *edge)
		* then scans all registered channels for state changes that should be handled
		* by creating or destroying smd client devices for the registered channels.
		*
		* LOCKING: edge->channels_lock is not needed to be held during the traversal
		* of the channels list as it's done synchronously with the only writer.
		* LOCKING: edge->channels_lock only needs to cover the list operations, as the
		* worker is killed before any channels are deallocated
		*/
		static void qcom_channel_state_worker(struct work_struct *work)
		{
		struct qcom_smd_channel *channel;
		struct qcom_smd_edge *edge = container_of(work,
		struct qcom_smd_edge,
		work);
		state_work);
		unsigned remote_state;

		/*
		* Rescan smem if we have reason to belive that there are new channels.
		*/
		if (edge->need_rescan) {
		edge->need_rescan = false;
		qcom_discover_channels(edge);
		}
		unsigned long flags;

		/*
		* Register a device for any closed channel where the remote processor
		* is showing interest in opening the channel.
		*/
		spin_lock_irqsave(&edge->channels_lock, flags);
		list_for_each_entry(channel, &edge->channels, list) {
		if (channel->state != SMD_CHANNEL_CLOSED)
		continue;
		@@ -1183,7 +1290,9 @@ static void qcom_channel_state_worker(struct work_struct *work)
		remote_state != SMD_CHANNEL_OPENED)
		continue;

		spin_unlock_irqrestore(&edge->channels_lock, flags);
		qcom_smd_create_device(channel);
		spin_lock_irqsave(&edge->channels_lock, flags);
		}

		/*
		@@ -1200,8 +1309,11 @@ static void qcom_channel_state_worker(struct work_struct *work)
		remote_state == SMD_CHANNEL_OPENED)
		continue;

		spin_unlock_irqrestore(&edge->channels_lock, flags);
		qcom_smd_destroy_device(channel);
		spin_lock_irqsave(&edge->channels_lock, flags);
		}
		spin_unlock_irqrestore(&edge->channels_lock, flags);
		}

		/*
		@@ -1219,7 +1331,8 @@ static int qcom_smd_parse_edge(struct device *dev,
		INIT_LIST_HEAD(&edge->channels);
		spin_lock_init(&edge->channels_lock);

		INIT_WORK(&edge->work, qcom_channel_state_worker);
		INIT_WORK(&edge->scan_work, qcom_channel_scan_worker);
		INIT_WORK(&edge->state_work, qcom_channel_state_worker);

		edge->of_node = of_node_get(node);

		@@ -1303,13 +1416,13 @@ static int qcom_smd_probe(struct platform_device *pdev)
		for_each_available_child_of_node(pdev->dev.of_node, node) {
		edge = &smd->edges[i++];
		edge->smd = smd;
		init_waitqueue_head(&edge->new_channel_event);

		ret = qcom_smd_parse_edge(&pdev->dev, node, edge);
		if (ret)
		continue;

		edge->need_rescan = true;
		schedule_work(&edge->work);
		schedule_work(&edge->scan_work);
		}

		platform_set_drvdata(pdev, smd);
		@@ -1332,8 +1445,10 @@ static int qcom_smd_remove(struct platform_device *pdev)
		edge = &smd->edges[i];

		disable_irq(edge->irq);
		cancel_work_sync(&edge->work);
		cancel_work_sync(&edge->scan_work);
		cancel_work_sync(&edge->state_work);

		/* No need to lock here, because the writer is gone */
		list_for_each_entry(channel, &edge->channels, list) {
		if (!channel->qsdev)
		continue;

drivers/soc/qcom/spm.c

+3 −5

Original line number	Diff line number	Diff line
		@@ -2,6 +2,8 @@
		* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
		* Copyright (c) 2014,2015, Linaro Ltd.
		*
		* SAW power controller driver
		*
		* 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.
		@@ -12,7 +14,6 @@
		* GNU General Public License for more details.
		*/

		#include <linux/module.h>
		#include <linux/kernel.h>
		#include <linux/init.h>
		#include <linux/io.h>
		@@ -378,8 +379,5 @@ static struct platform_driver spm_driver = {
		.of_match_table = spm_match_table,
		},
		};
		module_platform_driver(spm_driver);

		MODULE_LICENSE("GPL v2");
		MODULE_DESCRIPTION("SAW power controller driver");
		MODULE_ALIAS("platform:saw");
		builtin_platform_driver(spm_driver);

include/linux/soc/qcom/smd.h

+7 −1

Original line number	Diff line number	Diff line
		@@ -26,6 +26,8 @@ struct qcom_smd_device {
		struct qcom_smd_channel *channel;
		};

		typedef int (qcom_smd_cb_t)(struct qcom_smd_device , const void *, size_t);

		/**
		* struct qcom_smd_driver - smd driver struct
		* @driver: underlying device driver
		@@ -42,7 +44,7 @@ struct qcom_smd_driver {

		int (probe)(struct qcom_smd_device dev);
		void (remove)(struct qcom_smd_device dev);
		int (callback)(struct qcom_smd_device , const void *, size_t);
		qcom_smd_cb_t callback;
		};

		int qcom_smd_driver_register(struct qcom_smd_driver *drv);
		@@ -54,4 +56,8 @@ void qcom_smd_driver_unregister(struct qcom_smd_driver *drv);

		int qcom_smd_send(struct qcom_smd_channel channel, const void data, int len);

		struct qcom_smd_channel qcom_smd_open_channel(struct qcom_smd_device sdev,
		const char *name,
		qcom_smd_cb_t cb);

		#endif

include/linux/soc/qcom/smem_state.h

+35 −0

Original line number	Diff line number	Diff line
		#ifndef __QCOM_SMEM_STATE__
		#define __QCOM_SMEM_STATE__

		#include <linux/errno.h>

		struct device_node;
		struct qcom_smem_state;

		struct qcom_smem_state_ops {
		int (update_bits)(void , u32, u32);
		};

		#ifdef CONFIG_QCOM_SMEM_STATE

		struct qcom_smem_state qcom_smem_state_get(struct device dev, const char con_id, unsigned bit);
		void qcom_smem_state_put(struct qcom_smem_state *);

		@@ -15,4 +20,34 @@ int qcom_smem_state_update_bits(struct qcom_smem_state *state, u32 mask, u32 val
		struct qcom_smem_state qcom_smem_state_register(struct device_node of_node, const struct qcom_smem_state_ops ops, void data);
		void qcom_smem_state_unregister(struct qcom_smem_state *state);

		#else

		static inline struct qcom_smem_state qcom_smem_state_get(struct device dev,
		const char con_id, unsigned bit)
		{
		return ERR_PTR(-EINVAL);
		}

		static inline void qcom_smem_state_put(struct qcom_smem_state *state)
		{
		}

		static inline int qcom_smem_state_update_bits(struct qcom_smem_state *state,
		u32 mask, u32 value)
		{
		return -EINVAL;
		}

		static inline struct qcom_smem_state qcom_smem_state_register(struct device_node of_node,
		const struct qcom_smem_state_ops ops, void data)
		{
		return ERR_PTR(-EINVAL);
		}

		static inline void qcom_smem_state_unregister(struct qcom_smem_state *state)
		{
		}

		#endif

		#endif

Admin message