gmane.linux.ports.arm.msm
http://blog.gmane.org/gmane.linux.ports.arm.msm
hourly11901-01-01T00:00+00:00Gmanehttp://gmane.org/img/gmane-25t.png
http://gmane.org
[PATCH] arch: arm: mach-msm: using strlcpy instead of strncpy
http://comments.gmane.org/gmane.linux.ports.arm.msm/4056
<pre>
For NULL terminated string, need always be sure of ended by zero.
Or the next 'ptr' in 'for' looping may cause issue.
Signed-off-by: Chen Gang <gang.chen< at >asianux.com>
---
arch/arm/mach-msm/clock-debug.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/arch/arm/mach-msm/clock-debug.c b/arch/arm/mach-msm/clock-debug.c
index 4886404..b0fbdf1 100644
--- a/arch/arm/mach-msm/clock-debug.c
+++ b/arch/arm/mach-msm/clock-debug.c
< at >< at > -104,7 +104,7 < at >< at > int __init clock_debug_add(struct clk *clock)
if (!debugfs_base)
return -ENOMEM;
-strncpy(temp, clock->dbg_name, ARRAY_SIZE(temp)-1);
+strlcpy(temp, clock->dbg_name, ARRAY_SIZE(temp));
for (ptr = temp; *ptr; ptr++)
*ptr = tolower(*ptr);
</pre>Chen Gang2013-05-26T06:54:34[PATCHv3 0/3] Cleanup MSM_GPIOMUX and add DT support for gpio-msm
http://comments.gmane.org/gmane.linux.ports.arm.msm/4051
<pre>Hi Linus,
Could this series go through David's tree or is there a better way to do this?
It would be great if I can have you ack for the gpio patch.
Thanks,
Rohit
Rohit Vaswani (3):
ARM: msm: Remove gpiomux-v2 and re-organize MSM_GPIOMUX configs
ARM: msm: Remove unused and unmapped MSM_TLMM_BASE for 8x60
gpio: msm: Add device tree and irqdomain support for gpio-msm-v2
.../devicetree/bindings/gpio/gpio-msm.txt | 26 +++
arch/arm/boot/dts/msm8660-surf.dts | 11 ++
arch/arm/boot/dts/msm8960-cdp.dts | 11 ++
arch/arm/mach-msm/Kconfig | 13 +-
arch/arm/mach-msm/Makefile | 6 +-
arch/arm/mach-msm/gpiomux-8x60.c | 19 ---
arch/arm/mach-msm/gpiomux-v2.c | 25 ---
arch/arm/mach-msm/gpiomux-v2.h | 61 -------
arch/arm/mach-msm/gpiomux.c | 15 ++
arch/arm/mach-msm/gpiomux.h | 5 -
arch/arm/mach-msm/include/mach/msm_iomap-8x60.h | 4 -
drivers/gpio/Kconfig | 2 +-
drivers/gpio/gpio-msm-v2.c | 170 ++++++++++++--------
13 files changed, 176 insertions(+), 192 deletions(-)
create mode 100644 Documentation/devicetree/bindings/gpio/gpio-msm.txt
delete mode 100644 arch/arm/mach-msm/gpiomux-8x60.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.h
</pre>Rohit Vaswani2013-05-24T18:32:19[PATCHv2 0/3] Cleanup MSM_GPIOMUX and add DT support for gpio-msm
http://comments.gmane.org/gmane.linux.ports.arm.msm/4050
<pre>Hi Linus,
Could this series go through David's tree or is there a better way to do this?
It would be great if I can have you ack for the gpio patch.
Thanks,
Rohit
Rohit Vaswani (3):
ARM: msm: Remove gpiomux-v2 and re-organize MSM_GPIOMUX configs
ARM: msm: Remove unused and unmapped MSM_TLMM_BASE for 8x60
gpio: msm: Add device tree and irqdomain support for gpio-msm-v2
.../devicetree/bindings/gpio/gpio-msm.txt | 26 +++
arch/arm/boot/dts/msm8660-surf.dts | 11 ++
arch/arm/boot/dts/msm8960-cdp.dts | 11 ++
arch/arm/mach-msm/Kconfig | 13 +-
arch/arm/mach-msm/Makefile | 6 +-
arch/arm/mach-msm/gpiomux-8x60.c | 19 ---
arch/arm/mach-msm/gpiomux-v2.c | 25 ---
arch/arm/mach-msm/gpiomux-v2.h | 61 -------
arch/arm/mach-msm/gpiomux.c | 15 ++
arch/arm/mach-msm/gpiomux.h | 5 -
arch/arm/mach-msm/include/mach/msm_iomap-8x60.h | 4 -
drivers/gpio/Kconfig | 2 +-
drivers/gpio/gpio-msm-v2.c | 170 ++++++++++++--------
13 files changed, 176 insertions(+), 192 deletions(-)
create mode 100644 Documentation/devicetree/bindings/gpio/gpio-msm.txt
delete mode 100644 arch/arm/mach-msm/gpiomux-8x60.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.h
</pre>Rohit Vaswani2013-05-24T18:30:56[PATCHv2 0/3] Cleanup MSM_GPIOMUX and add DT support for gpio-msm
http://comments.gmane.org/gmane.linux.ports.arm.msm/4040
<pre>Hi Linus,
Could this series go through David's tree or is there a better way to do this?
It would be great if I can have you ack for the gpio patch.
Thanks,
Rohit
Rohit Vaswani (3):
ARM: msm: Remove gpiomux-v2 and re-organize MSM_GPIOMUX configs
ARM: msm: Remove unused and unmapped MSM_TLMM_BASE for 8x60
gpio: msm: Add device tree and irqdomain support for gpio-msm-v2
.../devicetree/bindings/gpio/gpio-msm.txt | 26 +++
arch/arm/boot/dts/msm8660-surf.dts | 11 ++
arch/arm/boot/dts/msm8960-cdp.dts | 11 ++
arch/arm/mach-msm/Kconfig | 13 +-
arch/arm/mach-msm/Makefile | 6 +-
arch/arm/mach-msm/gpiomux-8x60.c | 19 --
arch/arm/mach-msm/gpiomux-v2.c | 25 ---
arch/arm/mach-msm/gpiomux-v2.h | 61 -------
arch/arm/mach-msm/gpiomux.c | 15 ++
arch/arm/mach-msm/gpiomux.h | 5 -
arch/arm/mach-msm/include/mach/msm_iomap-8x60.h | 4 -
drivers/gpio/Kconfig | 2 +-
drivers/gpio/gpio-msm-v2.c | 173 +++++++++++++-------
13 files changed, 181 insertions(+), 190 deletions(-)
create mode 100644 Documentation/devicetree/bindings/gpio/gpio-msm.txt
delete mode 100644 arch/arm/mach-msm/gpiomux-8x60.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.h
</pre>Rohit Vaswani2013-05-23T00:29:21[RFC/PATCH 0/2] Remove most of_device_match() calls
http://comments.gmane.org/gmane.linux.ports.arm.msm/4036
<pre>Sending this as an RFC with one driver converted to see what people
think. The goal is to avoid having to run the match twice and be
similar to how platform_device_id works right now. If people agree
I can go through and send out patches for all the drivers doing
the duplicate search (~100 files).
Stephen Boyd (2):
of: Assign of_device_id to matching device_node
gpio/omap: Use of_node->id_entry directly
drivers/gpio/gpio-omap.c | 4 +---
drivers/of/device.c | 18 ++++++++++++++++++
include/linux/of.h | 1 +
include/linux/of_device.h | 12 ++----------
4 files changed, 22 insertions(+), 13 deletions(-)
</pre>Stephen Boyd2013-05-22T20:40:15[PATCH 0/3] Cleanup MSM_GPIOMUX and add device-tree support for
http://comments.gmane.org/gmane.linux.ports.arm.msm/4032
<pre>Hi Linus,
Could this series go through David's tree or is there a better way to do this?
It would be great if I can have you ack for the gpio patch.
Thanks,
Rohit
Rohit Vaswani (3):
ARM: msm: Remove gpiomux-v2 and re-organize MSM_GPIOMUX configs
ARM: msm: Remove unused and unmapped MSM_TLMM_BASE for 8x60
gpio: msm: Add device tree and irqdomain support for gpio-msm-v2
.../devicetree/bindings/gpio/gpio-msm.txt | 26 ++++
arch/arm/boot/dts/msm8660-surf.dts | 11 ++
arch/arm/boot/dts/msm8960-cdp.dts | 11 ++
arch/arm/mach-msm/Kconfig | 13 +-
arch/arm/mach-msm/Makefile | 6 +-
arch/arm/mach-msm/gpiomux-8x60.c | 19 ---
arch/arm/mach-msm/gpiomux-v2.c | 25 ---
arch/arm/mach-msm/gpiomux-v2.h | 61 --------
arch/arm/mach-msm/gpiomux.c | 15 ++
arch/arm/mach-msm/gpiomux.h | 5 -
arch/arm/mach-msm/include/mach/msm_iomap-8x60.h | 4 -
drivers/gpio/Kconfig | 2 +-
drivers/gpio/gpio-msm-v2.c | 158 ++++++++++++++------
13 files changed, 183 insertions(+), 173 deletions(-)
create mode 100644 Documentation/devicetree/bindings/gpio/gpio-msm.txt
delete mode 100644 arch/arm/mach-msm/gpiomux-8x60.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.c
delete mode 100644 arch/arm/mach-msm/gpiomux-v2.h
</pre>Rohit Vaswani2013-05-21T18:32:40[PATCH] ARM: dts: msm: Fix bad register addresses
http://comments.gmane.org/gmane.linux.ports.arm.msm/4031
<pre>Some bad copy/paste got in as well as too many zeroes. Fix
everything up so that the registers after the < at > sign are
consistent with the first reg property.
Signed-off-by: Stephen Boyd <sboyd< at >codeaurora.org>
---
arch/arm/boot/dts/msm8660-surf.dts | 4 ++--
arch/arm/boot/dts/msm8960-cdp.dts | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/arch/arm/boot/dts/msm8660-surf.dts b/arch/arm/boot/dts/msm8660-surf.dts
index 9bf49b3..d347082 100644
--- a/arch/arm/boot/dts/msm8660-surf.dts
+++ b/arch/arm/boot/dts/msm8660-surf.dts
< at >< at > -15,7 +15,7 < at >< at >
< 0x02081000 0x1000 >;
};
-timer< at >2000004 {
+timer< at >2000000 {
compatible = "qcom,scss-timer", "qcom,msm-timer";
interrupts = <1 0 0x301>,
<1 1 0x301>,
< at >< at > -26,7 +26,7 < at >< at >
cpu-offset = <0x40000>;
};
-serial< at >19c400000 {
+serial< at >19c40000 {
compatible = "qcom,msm-hsuart", "qcom,msm-uart";
reg = <0x19c40000 0x1000>,
<0x19c00000 0x1000>;
diff --git a/arch/arm/boot/dts/msm8960-cdp.dts b/arch/arm/boot/dts/msm8960-cdp.dts
index 2e4d87a..7c9ef9b 100644
--- a/arch/arm/boot/dts/msm8960-cdp.dts
+++ b/arch/arm/boot/dts/msm8960-cdp.dts
< at >< at > -26,7 +26,7 < at >< at >
cpu-offset = <0x80000>;
};
-serial< at >19c400000 {
+serial< at >16440000 {
compatible = "qcom,msm-hsuart", "qcom,msm-uart";
reg = <0x16440000 0x1000>,
<0x16400000 0x1000>;
</pre>Stephen Boyd2013-05-21T00:50:37[PATCH 1/1] diag: fix userspace read-write freeze during high logging rates
http://comments.gmane.org/gmane.linux.ports.arm.msm/4027
<pre>At very high diagchar logging rates (a HSPA+ ftp download with many
instantaneous diag log response messages enabled) on quad-core phones,
it was observed that after about 2 to 20 minutes (depends on logging rate)
- the userspace read to /dev/diag would block, causing a freeze effect
to the userspace program - and further attempts to log would randomly
freeze at an earlier stage then a phone restart was required to do any
meaningful logging. You can test this with "diag_mdlog", use a diag.cfg
with high logging rate log_response_messages like 0x4222, 0x4179 and other
fast logs.
The patched kernel was tested on a "Google Nexus 4 with Android 4.2.2"
(mako) phone - and had no more freezes even after 13 Hours of logging diag
for over-night ftp tests, an older sister-kernel (essentially the same -
but with many more pr_debug() to identify the causes) was also tested
sucessfully on two other "Google Nexus 4" phones, one of them logged
successfully through about 10 hours of fast ftp downloads - no freezes too.
This fix consists of 4 main parts:
1. There were cases that diag_device_write() completed the "enque" and sets
the data_ready flag during an ongoing diagchar_read() which would then
clear the flag on completion - resulting in a lost data_ready notification
and diagchar_read() would block by waiting for the lost wakeup.
The extra flag (array) "data_ready_while_busy" was introduced to
handle that situation.
2. It was observed that zero length buffers in
diag_hsic_read_complete_callback() was causing problems too
- sending zero length entries to the hsic_buf_tbl queue could cause it to
never be properly dequeued and never "diagmem_free()". This is because
diagfwd.c's diag_device_write() would successfully "enqueue" it but then
diagchar_core.c's diagchar_read() would omit it because
"if (driver->hsic_buf_tbl[i].length > 0)".
So it won't be "dequeued" and also diagmem_free would not be called on it.
This is fixed by not allowing zero-length entries into diag_device_write()
- and then calling diagmem_free() on it instead.
3. Consecutive writes (try 10+ conf writes before reading) to diagchar
from userspace would block, although normal steps and ioctl were done.
This was because the diagchar_write() was blocked in
wait_event_interruptible() but the diag_hsic_write_complete_callback()
didn't wake it up. I simply added a wake_up_interruptible() in that
callback and now the consecutive writes complete sucessfully.
4. At very high logging rates (on the Nexus 4 quad-core phone), it was
observed that "count_hsic_write_pool" faced read/write race conditions
(to increment and decrement) and became incorrect - even negative - and
"diag_read_hsic_work_fn" would use it to "determine the current number of
available buffers for writing after reading from the HSIC has completed"
- so the code was modified to determine the number of entries available by
iterating through "hsic_buf_tbl" instead.
Also, added a "driver->num_clients--" to diagchar_close() to update
num_clints on close() from userspace.
Signed-off-by: Kasidit Yusuf <kasidit< at >azenqos.com>
---
drivers/char/diag/diagchar.h | 1 +
drivers/char/diag/diagchar_core.c | 21 ++++++++++-
drivers/char/diag/diagfwd.c | 16 ++++++++
drivers/char/diag/diagfwd_hsic.c | 79 ++++++++++++++++++++++++++++++++-------
4 files changed, 103 insertions(+), 14 deletions(-)
diff --git a/drivers/char/diag/diagchar.h b/drivers/char/diag/diagchar.h
index 8d87cf9..4281912 100644
--- a/drivers/char/diag/diagchar.h
+++ b/drivers/char/diag/diagchar.h
< at >< at > -142,6 +142,7 < at >< at > struct diagchar_dev {
wait_queue_head_t wait_q;
struct diag_client_map *client_map;
int *data_ready;
+int *data_ready_while_busy;
int num_clients;
int polling_reg_flag;
struct diag_write_device *buf_tbl;
diff --git a/drivers/char/diag/diagchar_core.c b/drivers/char/diag/diagchar_core.c
index 2c572ed..9132fcb 100644
--- a/drivers/char/diag/diagchar_core.c
+++ b/drivers/char/diag/diagchar_core.c
< at >< at > -182,6 +182,13 < at >< at > static int diagchar_open(struct inode *inode, struct file *file)
goto fail;
else
driver->data_ready = temp;
+temp = krealloc(driver->data_ready_while_busy
+, (driver->num_clients) * sizeof(int),
+GFP_KERNEL);
+if (!temp)
+goto fail;
+else
+driver->data_ready_while_busy = temp;
diag_add_client(i, file);
} else {
mutex_unlock(&driver->diagchar_mutex);
< at >< at > -221,6 +228,8 < at >< at > static int diagchar_close(struct inode *inode, struct file *file)
struct diagchar_priv *diagpriv_data = file->private_data;
pr_debug("diag: process exit %s\n", current->comm);
+driver->num_clients--;
+
if (!(file->private_data)) {
pr_alert("diag: Invalid file pointer");
return -ENOMEM;
< at >< at > -804,6 +813,7 < at >< at > static int diagchar_read(struct file *file, char __user *buf, size_t count,
wait_event_interruptible(driver->wait_q,
driver->data_ready[index]);
+driver->data_ready_while_busy[index] = 0;
mutex_lock(&driver->diagchar_mutex);
if ((driver->data_ready[index] & USER_SPACE_LOG_TYPE) && (driver->
< at >< at > -981,7 +991,16 < at >< at > drop_hsic:
/* copy number of data fields */
COPY_USER_SPACE_OR_EXIT(buf+4, num_data, 4);
ret -= 4;
-driver->data_ready[index] ^= USER_SPACE_LOG_TYPE;
+
+/* At very high logging rates, it was observed that
+ * sometimes diag_device_write() completed the "enqueue"
+ * and sets the data_ready flag during an ongoing read
+ * in the lines above - so we should not clear the flag
+ * in these cases
+ */
+if (driver->data_ready_while_busy[index] == 0)
+driver->data_ready[index] ^= USER_SPACE_LOG_TYPE;
+
if (driver->ch)
queue_work(driver->diag_wq,
&(driver->diag_read_smd_work));
diff --git a/drivers/char/diag/diagfwd.c b/drivers/char/diag/diagfwd.c
index 4419309..7f12a3f 100644
--- a/drivers/char/diag/diagfwd.c
+++ b/drivers/char/diag/diagfwd.c
< at >< at > -332,6 +332,12 < at >< at > int diag_device_write(void *buf, int proc_num, struct diag_request *write_ptr)
driver->logging_process_id)
break;
if (i < driver->num_clients) {
+/* Set a "data_ready_while_busy" flag to
+ * prevent diagchar_read() from clearing new
+ * data_ready sets that came during its ongoing read.
+ */
+driver->data_ready_while_busy[i] |= USER_SPACE_LOG_TYPE;
+
driver->data_ready[i] |= USER_SPACE_LOG_TYPE;
pr_debug("diag: wake up logging process\n");
wake_up_interruptible(&driver->wait_q);
< at >< at > -2056,6 +2062,14 < at >< at > void diagfwd_init(void)
, GFP_KERNEL)) == NULL)
goto err;
kmemleak_not_leak(driver->data_ready);
+if (driver->data_ready_while_busy == NULL) {
+driver->data_ready_while_busy = kzalloc(driver->num_clients
+* sizeof(int)
+, GFP_KERNEL);
+if (driver->data_ready_while_busy == NULL)
+goto err;
+}
+kmemleak_not_leak(driver->data_ready_while_busy);
if (driver->table == NULL &&
(driver->table = kzalloc(diag_max_reg*
sizeof(struct diag_master_table),
< at >< at > -2166,6 +2180,7 < at >< at > err:
kfree(driver->client_map);
kfree(driver->buf_tbl);
kfree(driver->data_ready);
+kfree(driver->data_ready_while_busy);
kfree(driver->table);
kfree(driver->pkt_buf);
kfree(driver->write_ptr_1);
< at >< at > -2217,6 +2232,7 < at >< at > void diagfwd_exit(void)
kfree(driver->client_map);
kfree(driver->buf_tbl);
kfree(driver->data_ready);
+kfree(driver->data_ready_while_busy);
kfree(driver->table);
kfree(driver->pkt_buf);
kfree(driver->write_ptr_1);
diff --git a/drivers/char/diag/diagfwd_hsic.c b/drivers/char/diag/diagfwd_hsic.c
index bd8c52b..94d8b9d 100644
--- a/drivers/char/diag/diagfwd_hsic.c
+++ b/drivers/char/diag/diagfwd_hsic.c
< at >< at > -45,6 +45,7 < at >< at > static void diag_read_hsic_work_fn(struct work_struct *work)
int num_reads_submitted = 0;
int err = 0;
int write_ptrs_available;
+int i;
if (!driver->hsic_ch) {
pr_err("DIAG in %s: driver->hsic_ch == 0\n", __func__);
< at >< at > -55,12 +56,30 < at >< at > static void diag_read_hsic_work_fn(struct work_struct *work)
* Determine the current number of available buffers for writing after
* reading from the HSIC has completed.
*/
-if (driver->logging_mode == MEMORY_DEVICE_MODE)
-write_ptrs_available = driver->poolsize_hsic_write -
-driver->num_hsic_buf_tbl_entries;
-else
+if (driver->logging_mode == MEMORY_DEVICE_MODE) {
+/*
+ * At very high logging rates on multi-core phones,
+ * it was observed that "count_hsic_write_pool" faced read/write
+ * race conditions (to increment and decrement) and became
+ * incorrect - so don't use it to determine the number of
+ * entries available - iterate through "hsic_buf_tbl" instead.
+ */
+write_ptrs_available = 0;
+i = (driver->poolsize_hsic_write) - 1;
+for (; i >= 0; i--)
+if (driver->hsic_buf_tbl[i].length == 0)
+write_ptrs_available++;
+} else {
write_ptrs_available = driver->poolsize_hsic_write -
driver->count_hsic_write_pool;
+}
+
+if (driver->logging_mode == MEMORY_DEVICE_MODE &&
+(write_ptrs_available <= 0 ||
+write_ptrs_available > driver->poolsize_hsic_write)) {
+pr_debug("diag: warning - probe write_ptrs_available: %d"
+, write_ptrs_available);
+}
/*
* Queue up a read on the HSIC for all available buffers in the
< at >< at > -138,17 +157,50 < at >< at > static void diag_hsic_read_complete_callback(void *ctxt, char *buf,
if (!buf) {
pr_err("diag: Out of diagmem for HSIC\n");
} else {
-/*
- * Send data in buf to be written on the
- * appropriate device, e.g. USB MDM channel
+
+/* Contradicting with the original comment above to send
+ * zero length entries, sending 0 length entries to the
+ * hsic_buf_tbl queue could cause it to never be
+ * properly dequeued and never "diagmem_free()".
+ *
+ * This is because diagfwd.c's diag_device_write() would
+ * successfully "enqueue" it but then diagchar_core.c's
+ * diagchar_read() would omit it -
+ * because "if (driver->hsic_buf_tbl[i].length > 0)"...
+ * So it won't be "dequeued" and also diagmem_free would
+ * not be called on it.
+ *
+ * Also, other diag_device_write() calls with non-0
+ * length entries would also overwrite this 0-length
+ * entry because of the
+ * "if (driver->hsic_buf_tbl[i].length == 0)" check.
+ *
+ * Threrefore, if the actual_size is > 0, send it,
+ * but if the size is 0 then call diagmem_free
+ * on it and don't send it.
*/
-driver->write_len_mdm = actual_size;
-err = diag_device_write((void *)buf, HSIC_DATA, NULL);
-/* If an error, return buffer to the pool */
-if (err) {
+
+if (actual_size > 0) {
+/*
+ * Send data in buf to be written on the
+ * appropriate device, e.g. USB MDM channel
+ */
+driver->write_len_mdm = actual_size;
+err = diag_device_write((void *)buf,
+HSIC_DATA, NULL);
+/* If an error, return buffer to the pool */
+if (err) {
+diagmem_free(driver, buf,
+POOL_TYPE_HSIC);
+pr_err("diag: In %s, error calling diag_device_write, err: %d\n",
+__func__, err);
+}
+} else {
+/* if we reach here this means actual_size is 0
+ * then free and omit it.
+ */
+err = 0;
diagmem_free(driver, buf, POOL_TYPE_HSIC);
-pr_err("diag: In %s, error calling diag_device_write, err: %d\n",
-__func__, err);
}
}
} else {
< at >< at > -179,6 +231,7 < at >< at > static void diag_hsic_write_complete_callback(void *ctxt, char *buf,
{
/* The write of the data to the HSIC bridge is complete */
driver->in_busy_hsic_write = 0;
+wake_up_interruptible(&driver->wait_q);
if (!driver->hsic_ch) {
pr_err("DIAG in %s: driver->hsic_ch == 0\n", __func__);
</pre>Kasidit Yusuf2013-05-20T08:17:39Would like to form a pool of Linux copyright holders for faster GPL enforcement against Anthrax Kernels
http://comments.gmane.org/gmane.linux.ports.arm.msm/4025
<pre>Background on Anthrax Kernels and their GPL violation:
http://pastebin.com/X5Cciy03
Would anyone be interested in forming such a pool? I am willing to wait
years for this to be resolved through certain organizations, but I
believe we can do better.
Last I checked, I have 1 long-time poster of the gpl-violations list on
board. Would anyone else like to join? Ideally I'd like to get the LKML
(which I have CC'd among others) involved so that authors of critical
Linux components be a part of this. I'm not sure if my defconfig commits
to Android kernel branches count as contributions, so I'm not going to
consider myself a Linux contributor unless told otherwise.
This pool would be used in the following manner:
* Formally requesting source for binaries (means to request source is
actively hidden)
* Formally requesting removal of critical copyrighted code that Linux
cannot function without
* Informing interested parties with respect to refusals of the above
The CTO of Anthrax's hosting server is very interested in terminating
Chad Goodman's account. Bullet point #3 might come into effect here.
If this is a bad idea, breaks list etiquette, uses incorrect logic, or
does not follow the conventions of GPL enforcement, feel free to shoot
this idea down with utmost prejudice.
- Eric
</pre>Eric Appleman2013-05-18T08:21:13[PATCHv2] arm: mm: Use phys_addr_t properly for ioremap functions
http://comments.gmane.org/gmane.linux.ports.arm.msm/3989
<pre>Several of the ioremap functions use unsigned long in places
resulting in truncation if physical addresses greater than
4G are passed in. Change the types of the functions and the
callers accordingly.
Cc: Krzysztof Halasa <khc< at >pm.waw.pl>
Cc: Arnd Bergmann <arnd< at >arndb.de>
Cc: Stephen Boyd <sboyd< at >codeaurora.org>
Cc: Russell King <linux< at >arm.linux.org.uk>
Signed-off-by: Laura Abbott <lauraa< at >codeaurora.org>
---
arch/arm/include/asm/io.h | 8 ++++----
arch/arm/mach-ebsa110/core.c | 2 +-
arch/arm/mach-imx/mm-imx3.c | 2 +-
arch/arm/mach-iop13xx/io.c | 2 +-
arch/arm/mach-ixp4xx/common.c | 2 +-
arch/arm/mach-msm/common.h | 2 +-
arch/arm/mach-msm/io.c | 2 +-
arch/arm/mm/ioremap.c | 10 +++++-----
arch/arm/mm/nommu.c | 6 +++---
9 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/arch/arm/include/asm/io.h b/arch/arm/include/asm/io.h
index 652b560..d070741 100644
--- a/arch/arm/include/asm/io.h
+++ b/arch/arm/include/asm/io.h
< at >< at > -130,16 +130,16 < at >< at > static inline u32 __raw_readl(const volatile void __iomem *addr)
*/
extern void __iomem *__arm_ioremap_pfn_caller(unsigned long, unsigned long,
size_t, unsigned int, void *);
-extern void __iomem *__arm_ioremap_caller(unsigned long, size_t, unsigned int,
+extern void __iomem *__arm_ioremap_caller(phys_addr_t, size_t, unsigned int,
void *);
extern void __iomem *__arm_ioremap_pfn(unsigned long, unsigned long, size_t, unsigned int);
-extern void __iomem *__arm_ioremap(unsigned long, size_t, unsigned int);
-extern void __iomem *__arm_ioremap_exec(unsigned long, size_t, bool cached);
+extern void __iomem *__arm_ioremap(phys_addr_t, size_t, unsigned int);
+extern void __iomem *__arm_ioremap_exec(phys_addr_t, size_t, bool cached);
extern void __iounmap(volatile void __iomem *addr);
extern void __arm_iounmap(volatile void __iomem *addr);
-extern void __iomem * (*arch_ioremap_caller)(unsigned long, size_t,
+extern void __iomem * (*arch_ioremap_caller)(phys_addr_t, size_t,
unsigned int, void *);
extern void (*arch_iounmap)(volatile void __iomem *);
diff --git a/arch/arm/mach-ebsa110/core.c b/arch/arm/mach-ebsa110/core.c
index b13cc74..8a53f34 100644
--- a/arch/arm/mach-ebsa110/core.c
+++ b/arch/arm/mach-ebsa110/core.c
< at >< at > -116,7 +116,7 < at >< at > static void __init ebsa110_map_io(void)
iotable_init(ebsa110_io_desc, ARRAY_SIZE(ebsa110_io_desc));
}
-static void __iomem *ebsa110_ioremap_caller(unsigned long cookie, size_t size,
+static void __iomem *ebsa110_ioremap_caller(phys_addr_t cookie, size_t size,
unsigned int flags, void *caller)
{
return (void __iomem *)cookie;
diff --git a/arch/arm/mach-imx/mm-imx3.c b/arch/arm/mach-imx/mm-imx3.c
index e0e69a6..eed32ca 100644
--- a/arch/arm/mach-imx/mm-imx3.c
+++ b/arch/arm/mach-imx/mm-imx3.c
< at >< at > -65,7 +65,7 < at >< at > static void imx3_idle(void)
: "=r" (reg));
}
-static void __iomem *imx3_ioremap_caller(unsigned long phys_addr, size_t size,
+static void __iomem *imx3_ioremap_caller(phys_addr_t phys_addr, size_t size,
unsigned int mtype, void *caller)
{
if (mtype == MT_DEVICE) {
diff --git a/arch/arm/mach-iop13xx/io.c b/arch/arm/mach-iop13xx/io.c
index 183dc8b..faaf7d4 100644
--- a/arch/arm/mach-iop13xx/io.c
+++ b/arch/arm/mach-iop13xx/io.c
< at >< at > -23,7 +23,7 < at >< at >
#include "pci.h"
-static void __iomem *__iop13xx_ioremap_caller(unsigned long cookie,
+static void __iomem *__iop13xx_ioremap_caller(phys_addr_t cookie,
size_t size, unsigned int mtype, void *caller)
{
void __iomem * retval;
diff --git a/arch/arm/mach-ixp4xx/common.c b/arch/arm/mach-ixp4xx/common.c
index 6600cff..d7223b3 100644
--- a/arch/arm/mach-ixp4xx/common.c
+++ b/arch/arm/mach-ixp4xx/common.c
< at >< at > -559,7 +559,7 < at >< at > void ixp4xx_restart(char mode, const char *cmd)
* fallback to the default.
*/
-static void __iomem *ixp4xx_ioremap_caller(unsigned long addr, size_t size,
+static void __iomem *ixp4xx_ioremap_caller(phys_addr_t addr, size_t size,
unsigned int mtype, void *caller)
{
if (!is_pci_memory(addr))
diff --git a/arch/arm/mach-msm/common.h b/arch/arm/mach-msm/common.h
index ce8215a..421cf77 100644
--- a/arch/arm/mach-msm/common.h
+++ b/arch/arm/mach-msm/common.h
< at >< at > -23,7 +23,7 < at >< at > extern void msm_map_msm8x60_io(void);
extern void msm_map_msm8960_io(void);
extern void msm_map_qsd8x50_io(void);
-extern void __iomem *__msm_ioremap_caller(unsigned long phys_addr, size_t size,
+extern void __iomem *__msm_ioremap_caller(phys_addr_t phys_addr, size_t size,
unsigned int mtype, void *caller);
extern struct smp_operations msm_smp_ops;
diff --git a/arch/arm/mach-msm/io.c b/arch/arm/mach-msm/io.c
index 123ef9c..fd65b6d 100644
--- a/arch/arm/mach-msm/io.c
+++ b/arch/arm/mach-msm/io.c
< at >< at > -172,7 +172,7 < at >< at > void __init msm_map_msm7x30_io(void)
}
#endif /* CONFIG_ARCH_MSM7X30 */
-void __iomem *__msm_ioremap_caller(unsigned long phys_addr, size_t size,
+void __iomem *__msm_ioremap_caller(phys_addr_t phys_addr, size_t size,
unsigned int mtype, void *caller)
{
if (mtype == MT_DEVICE) {
diff --git a/arch/arm/mm/ioremap.c b/arch/arm/mm/ioremap.c
index 04d9006..f123d6e 100644
--- a/arch/arm/mm/ioremap.c
+++ b/arch/arm/mm/ioremap.c
< at >< at > -331,10 +331,10 < at >< at > void __iomem * __arm_ioremap_pfn_caller(unsigned long pfn,
return (void __iomem *) (offset + addr);
}
-void __iomem *__arm_ioremap_caller(unsigned long phys_addr, size_t size,
+void __iomem *__arm_ioremap_caller(phys_addr_t phys_addr, size_t size,
unsigned int mtype, void *caller)
{
-unsigned long last_addr;
+phys_addr_t last_addr;
unsigned long offset = phys_addr & ~PAGE_MASK;
unsigned long pfn = __phys_to_pfn(phys_addr);
< at >< at > -367,12 +367,12 < at >< at > __arm_ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size,
}
EXPORT_SYMBOL(__arm_ioremap_pfn);
-void __iomem * (*arch_ioremap_caller)(unsigned long, size_t,
+void __iomem * (*arch_ioremap_caller)(phys_addr_t, size_t,
unsigned int, void *) =
__arm_ioremap_caller;
void __iomem *
-__arm_ioremap(unsigned long phys_addr, size_t size, unsigned int mtype)
+__arm_ioremap(phys_addr_t phys_addr, size_t size, unsigned int mtype)
{
return arch_ioremap_caller(phys_addr, size, mtype,
__builtin_return_address(0));
< at >< at > -387,7 +387,7 < at >< at > EXPORT_SYMBOL(__arm_ioremap);
* CONFIG_GENERIC_ALLOCATOR for allocating external memory.
*/
void __iomem *
-__arm_ioremap_exec(unsigned long phys_addr, size_t size, bool cached)
+__arm_ioremap_exec(phys_addr_t phys_addr, size_t size, bool cached)
{
unsigned int mtype;
diff --git a/arch/arm/mm/nommu.c b/arch/arm/mm/nommu.c
index d51225f..31bd77b 100644
--- a/arch/arm/mm/nommu.c
+++ b/arch/arm/mm/nommu.c
< at >< at > -81,16 +81,16 < at >< at > void __iomem *__arm_ioremap_pfn_caller(unsigned long pfn, unsigned long offset,
return __arm_ioremap_pfn(pfn, offset, size, mtype);
}
-void __iomem *__arm_ioremap(unsigned long phys_addr, size_t size,
+void __iomem *__arm_ioremap(phys_addr_t phys_addr, size_t size,
unsigned int mtype)
{
return (void __iomem *)phys_addr;
}
EXPORT_SYMBOL(__arm_ioremap);
-void __iomem * (*arch_ioremap_caller)(unsigned long, size_t, unsigned int, void *);
+void __iomem * (*arch_ioremap_caller)(phys_addr_t, size_t, unsigned int, void *);
-void __iomem *__arm_ioremap_caller(unsigned long phys_addr, size_t size,
+void __iomem *__arm_ioremap_caller(phys_addr_t phys_addr, size_t size,
unsigned int mtype, void *caller)
{
return __arm_ioremap(phys_addr, size, mtype);
</pre>Laura Abbott2013-05-14T19:33:50[PATCH] timer: Don't reinitialize the cpu base lock during CPU_UP_PREPARE
http://comments.gmane.org/gmane.linux.ports.arm.msm/3958
<pre>An inactive timer's base can refer to a offline cpu's base.
In the current code, cpu_base's lock is blindly reinitialized
each time a CPU is brought up. If a CPU is brought online
during the period that another thread is trying to modify an
inactive timer on that CPU with holding its timer base lock,
then the lock will be reinitialized under its feet. This leads
to following SPIN_BUG().
<0> BUG: spinlock already unlocked on CPU#3, kworker/u:3/1466
<0> lock: 0xe3ebe000, .magic: dead4ead, .owner: kworker/u:3/1466, .owner_cpu: 1
<4> [<c0013dc4>] (unwind_backtrace+0x0/0x11c) from [<c026e794>] (do_raw_spin_unlock+0x40/0xcc)
<4> [<c026e794>] (do_raw_spin_unlock+0x40/0xcc) from [<c076c160>] (_raw_spin_unlock+0x8/0x30)
<4> [<c076c160>] (_raw_spin_unlock+0x8/0x30) from [<c009b858>] (mod_timer+0x294/0x310)
<4> [<c009b858>] (mod_timer+0x294/0x310) from [<c00a5e04>] (queue_delayed_work_on+0x104/0x120)
<4> [<c00a5e04>] (queue_delayed_work_on+0x104/0x120) from [<c04eae00>] (sdhci_msm_bus_voting+0x88/0x9c)
<4> [<c04eae00>] (sdhci_msm_bus_voting+0x88/0x9c) from [<c04d8780>] (sdhci_disable+0x40/0x48)
<4> [<c04d8780>] (sdhci_disable+0x40/0x48) from [<c04bf300>] (mmc_release_host+0x4c/0xb0)
<4> [<c04bf300>] (mmc_release_host+0x4c/0xb0) from [<c04c7aac>] (mmc_sd_detect+0x90/0xfc)
<4> [<c04c7aac>] (mmc_sd_detect+0x90/0xfc) from [<c04c2504>] (mmc_rescan+0x7c/0x2c4)
<4> [<c04c2504>] (mmc_rescan+0x7c/0x2c4) from [<c00a6a7c>] (process_one_work+0x27c/0x484)
<4> [<c00a6a7c>] (process_one_work+0x27c/0x484) from [<c00a6e94>] (worker_thread+0x210/0x3b0)
<4> [<c00a6e94>] (worker_thread+0x210/0x3b0) from [<c00aad9c>] (kthread+0x80/0x8c)
<4> [<c00aad9c>] (kthread+0x80/0x8c) from [<c000ea80>] (kernel_thread_exit+0x0/0x8)
As an example, this particular crash occurred when CPU #3 is executing
mod_timer() on an inactive timer whose base is refered to offlined CPU #2.
The code locked the timer_base corresponding to CPU #2. Before it could
proceed, CPU #2 came online and reinitialized the spinlock corresponding
to its base. Thus now CPU #3 held a lock which was reinitialized. When
CPU #3 finally ended up unlocking the old cpu_base corresponding to CPU #2,
we hit the above SPIN_BUG().
CPU #0CPU #3 CPU #2
------------- -------
..... ...... <Offline>
mod_timer()
lock_timer_base
spin_lock_irqsave(&base->lock)
cpu_up(2) ..... ......
init_timers_cpu()
.... ..... spin_lock_init(&base->lock)
..... spin_unlock_irqrestore(&base->lock) ......
<spin_bug>
Allocation of per_cpu timer vector bases is done only once under
"tvec_base_done[]" check. In the current code, spinlock_initialization
of base->lock isn't under this check. When a CPU is up each time the base
lock is reinitialized. Move base spinlock initialization under the check.
Signed-off-by: Tirupathi Reddy <tirupath< at >codeaurora.org>
---
kernel/timer.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/kernel/timer.c b/kernel/timer.c
index dbf7a78..1b399c8 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
< at >< at > -1678,12 +1678,12 < at >< at > static int __cpuinit init_timers_cpu(int cpu)
boot_done = 1;
base = &boot_tvec_bases;
}
+spin_lock_init(&base->lock);
tvec_base_done[cpu] = 1;
} else {
base = per_cpu(tvec_bases, cpu);
}
-spin_lock_init(&base->lock);
for (j = 0; j < TVN_SIZE; j++) {
INIT_LIST_HEAD(base->tv5.vec + j);
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
hosted by The Linux Foundation
</pre>Tirupathi Reddy2013-05-14T08:29:02[PATCHv3 0/4] Memory mapped architected timers
http://comments.gmane.org/gmane.linux.ports.arm.msm/3937
<pre>This patchset adds support for memory mapped architected timers. We
don't have any other global broadcast timer in our system, so we use the
mmio timer during low power modes. The first patch is the binding.
The next two patches lay some groundwork so that the last patch is simpler.
The final patch adds support for mmio timers.
Patches are based on a patch from Mark that removes the
physical count reading (clocksource: arch_timer: use virtual counter,
message id <1364404312-4427-4-git-send-email-mark.rutland< at >arm.com>).
Updates since v2:
* Rebased onto v3.10-rc1
Updates since v1:
* Assigned counter reading function and commented why for arm64
* Updated DT binding to replace frame-id with frame-number and use status
property
Stephen Boyd (4):
Documentation: Add memory mapped ARM architected timer binding
clocksource: arch_timer: Pass clock event to set_mode callback
clocksource: arch_timer: Push the read/write wrappers deeper
clocksource: arch_timer: Add support for memory mapped timers
.../devicetree/bindings/arm/arch_timer.txt | 59 ++-
arch/arm/include/asm/arch_timer.h | 5 +-
arch/arm64/include/asm/arch_timer.h | 4 +-
drivers/clocksource/arm_arch_timer.c | 452 +++++++++++++++++----
include/clocksource/arm_arch_timer.h | 4 +-
5 files changed, 448 insertions(+), 76 deletions(-)
</pre>Stephen Boyd2013-05-13T19:56:33[PATCHv6 00/11] Remove ARM local timer API
http://comments.gmane.org/gmane.linux.ports.arm.msm/3926
<pre>In light of Mark Rutland's recent work on divorcing the ARM architected
timers from the ARM local timer API and introducing a generic arch hook for
broadcast it seems that we should remove the local timer API entirely.
Doing so will reduce the architecture dependencies of our timer drivers,
reduce code in ARM core, and simplify timer drivers because they no longer
go through an architecture layer that is essentially a hotplug notifier.
Previous attempts have been made[1] unsuccessfully. I'm hoping this can
be accepted now so that we can clean up the timer drivers that are
used in both UP and SMP situations. Right now these drivers have to ignore
the timer setup callback on the boot CPU to avoid registering clockevents
twice. This is not very symmetric and causes convuluted code that does
the same thing in two places.
Patches based on next-20130418
I'm still looking for Acks/Tested-by on EXYNOS and PRIMA2.
[1] http://article.gmane.org/gmane.linux.ports.arm.kernel/145705
Note: A hotplug notifier is used by both x86 for the apb_timer (see
apbt_cpuhp_notify) and by metag (see arch_timer_cpu_notify in
metag_generic.c) so this is not new.
Changes since v5:
* Rebased onto v3.10-rc1
* Rebase caused minor updates to mct patch
Changes since v4:
* Rebased onto next-20130418
* Rebase caused minor updates to mct patch and twd Kconfig
Changes since v3:
* New patch to fix SMP with dummy timers registered after a global timer
* Push this_cpu_ptr lower to avoid preemptible false positive warnings
* Collected acks/tested-bys
Changes since v2:
* Bug fixes in smp_twd from Tony Lindgren's testing
* Move smp_twd to use late_time_init hook
* Collected Acks
Changes since v1:
* Picked up Mark's generic dummy timer driver
* Split out omap changes into new patch
Mark Rutland (1):
clocksource: add generic dummy timer driver
Stephen Boyd (10):
clockevents: Prefer CPU local devices over global devices
ARM: smp: Remove duplicate dummy timer implementation
ARM: smp_twd: Divorce smp_twd from local timer API
ARM: OMAP2+: Divorce from local timer API
ARM: EXYNOS4: Divorce mct from local timer API
ARM: PRIMA2: Divorce timer-marco from local timer API
ARM: msm: Divorce msm_timer from local timer API
clocksource: time-armada-370-xp: Fix sparse warning
clocksource: time-armada-370-xp: Divorce from local timer API
ARM: smp: Remove local timer API
arch/arm/Kconfig | 12 +--
arch/arm/include/asm/localtimer.h | 34 ---------
arch/arm/kernel/smp.c | 87 ---------------------
arch/arm/kernel/smp_twd.c | 64 ++++++++++------
arch/arm/mach-highbank/Kconfig | 2 +-
arch/arm/mach-imx/Kconfig | 2 +-
arch/arm/mach-msm/timer.c | 126 +++++++++++++++++--------------
arch/arm/mach-omap2/Kconfig | 3 +-
arch/arm/mach-omap2/timer.c | 7 --
arch/arm/mach-realview/Kconfig | 8 +-
arch/arm/mach-spear/Kconfig | 2 +-
arch/arm/mach-tegra/Kconfig | 2 +-
arch/arm/mach-ux500/Kconfig | 2 +-
arch/arm/mach-vexpress/Kconfig | 2 +-
arch/arm/mach-zynq/Kconfig | 2 +-
drivers/clocksource/Makefile | 1 +
drivers/clocksource/dummy_timer.c | 69 +++++++++++++++++
drivers/clocksource/exynos_mct.c | 60 ++++++++++-----
drivers/clocksource/time-armada-370-xp.c | 92 +++++++++++-----------
drivers/clocksource/timer-marco.c | 100 +++++++++++++-----------
include/linux/time-armada-370-xp.h | 4 +-
kernel/time/tick-common.c | 5 +-
22 files changed, 340 insertions(+), 346 deletions(-)
delete mode 100644 arch/arm/include/asm/localtimer.h
create mode 100644 drivers/clocksource/dummy_timer.c
</pre>Stephen Boyd2013-05-13T19:26:04[PATCH V1 0/8] ufs patch siries
http://comments.gmane.org/gmane.linux.ports.arm.msm/3908
<pre>This patch series clusters the latest version of all the UFS patches in the
SCSI mailing list. It gives a stable functional base line for the UFS driver.
It includes the following versions:
But does not include:
Dolev Raviv (8):
Documentation: devicetree: Add DT bindings for UFS host controller
scsi: ufs: Fix the response UPIU length setting
scsi: ufs: wrap the i/o access operations
scsi: ufs: amend interrupt configuration
scsi: ufs: fix interrupt status clears
scsi: ufs: rework link start-up process
scsi: ufs: Add support for sending NOP OUT UPIU
scsi: ufs: Set fDeviceInit flag to initiate device initialization
.../devicetree/bindings/ufs/ufshcd-pltfrm.txt | 16 +
drivers/scsi/ufs/ufs.h | 10 +-
drivers/scsi/ufs/ufshcd.c | 839 ++++++++++++++++----
drivers/scsi/ufs/ufshcd.h | 25 +-
drivers/scsi/ufs/ufshci.h | 5 +-
5 files changed, 721 insertions(+), 174 deletions(-)
create mode 100644 Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt
</pre>Dolev Raviv2013-05-13T10:02:10[PATCH V1 0/8] ufs patch siries
http://comments.gmane.org/gmane.linux.ports.arm.msm/3879
<pre>This patch series clusters the latest version of all the UFS patches in the
SCSI mailing list. It gives a stable functional base line for the UFS driver.
It includes the following versions:
But does not include:
Dolev Raviv (8):
Documentation: devicetree: Add DT bindings for UFS host controller
scsi: ufs: Fix the response UPIU length setting
scsi: ufs: wrap the i/o access operations
scsi: ufs: amend interrupt configuration
scsi: ufs: fix interrupt status clears
scsi: ufs: rework link start-up process
scsi: ufs: Add support for sending NOP OUT UPIU
scsi: ufs: Set fDeviceInit flag to initiate device initialization
.../devicetree/bindings/ufs/ufshcd-pltfrm.txt | 16 +
drivers/scsi/ufs/ufs.h | 10 +-
drivers/scsi/ufs/ufshcd.c | 839 ++++++++++++++++----
drivers/scsi/ufs/ufshcd.h | 25 +-
drivers/scsi/ufs/ufshci.h | 5 +-
5 files changed, 721 insertions(+), 174 deletions(-)
create mode 100644 Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt
</pre>Dolev Raviv2013-05-12T14:23:52[PATCH V1 0/8] ufs patch siries
http://comments.gmane.org/gmane.linux.ports.arm.msm/3878
<pre>This patch series clusters the latest version of all the UFS patches in the
SCSI mailing list. It gives a stable functional base line for the UFS driver.
It includes the following versions:
But does not include:
Dolev Raviv (8):
Documentation: devicetree: Add DT bindings for UFS host controller
scsi: ufs: Fix the response UPIU length setting
scsi: ufs: wrap the i/o access operations
scsi: ufs: amend interrupt configuration
scsi: ufs: fix interrupt status clears
scsi: ufs: rework link start-up process
scsi: ufs: Add support for sending NOP OUT UPIU
scsi: ufs: Set fDeviceInit flag to initiate device initialization
.../devicetree/bindings/ufs/ufshcd-pltfrm.txt | 16 +
drivers/scsi/ufs/ufs.h | 10 +-
drivers/scsi/ufs/ufshcd.c | 839 ++++++++++++++++----
drivers/scsi/ufs/ufshcd.h | 25 +-
drivers/scsi/ufs/ufshci.h | 5 +-
5 files changed, 721 insertions(+), 174 deletions(-)
create mode 100644 Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt
</pre>Dolev Raviv2013-05-12T14:22:22[PATCH v6 2/3] block: Add API for urgent request handling
http://comments.gmane.org/gmane.linux.ports.arm.msm/3876
<pre>This patch add support in block & elevator layers for handling
urgent requests. The decision if a request is urgent or not is taken
by the scheduler. Request is marked as urgent in cmd_flags (by the
scheduler) with a new flag - REQ_URGENT.
Urgent request notification is passed to the underlying
block device driver (eMMC for example). Block device driver may decide to
interrupt the currently running low priority request to serve the new
urgent request. By doing so READ latency is greatly reduced in read&write
collision scenarios.
Note that if the current scheduler doesn't implement the urgent request
mechanism, this code path is never activated.
Signed-off-by: Tatyana Brokhman <tlinder< at >codeaurora.org>
diff --git a/block/blk-core.c b/block/blk-core.c
index adab72d..ac298a4 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
< at >< at > -296,6 +296,13 < at >< at > EXPORT_SYMBOL(blk_sync_queue);
* This variant runs the queue whether or not the queue has been
* stopped. Must be called with the queue lock held and interrupts
* disabled. See also < at >blk_run_queue.
+ *
+ * Device driver will be notified of an urgent request
+ * pending under the following conditions:
+ * 1. The driver and the current scheduler support urgent reques handling
+ * 2. There is an urgent request pending in the scheduler
+ * 3. There isn't already an urgent request in flight, meaning previously
+ * notified urgent request completed (!q->notified_urgent)
*/
inline void __blk_run_queue_uncond(struct request_queue *q)
{
< at >< at > -310,7 +317,16 < at >< at > inline void __blk_run_queue_uncond(struct request_queue *q)
* can wait until all these request_fn calls have finished.
*/
q->request_fn_active++;
-q->request_fn(q);
+
+if (!q->notified_urgent &&
+q->elevator->type->ops.elevator_is_urgent_fn &&
+q->urgent_request_fn &&
+q->elevator->type->ops.elevator_is_urgent_fn(q)) {
+q->notified_urgent = true;
+q->urgent_request_fn(q);
+} else
+q->request_fn(q);
+
q->request_fn_active--;
}
< at >< at > -2183,6 +2199,10 < at >< at > struct request *blk_peek_request(struct request_queue *q)
*/
rq->cmd_flags |= REQ_STARTED;
trace_block_rq_issue(q, rq);
+if (rq->cmd_flags & REQ_URGENT) {
+WARN_ON(q->dispatched_urgent);
+q->dispatched_urgent = true;
+}
}
if (!q->boundary_rq || q->boundary_rq == rq) {
diff --git a/block/blk-settings.c b/block/blk-settings.c
index c50ecf0..420c551 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
< at >< at > -193,6 +193,18 < at >< at > void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
EXPORT_SYMBOL(blk_queue_make_request);
/**
+ * blk_urgent_request() - Set an urgent_request handler function for queue
+ * < at >q:queue
+ * < at >fn:handler for urgent requests
+ *
+ */
+void blk_urgent_request(struct request_queue *q, request_fn_proc *fn)
+{
+q->urgent_request_fn = fn;
+}
+EXPORT_SYMBOL(blk_urgent_request);
+
+/**
* blk_queue_bounce_limit - set bounce buffer limit for queue
* < at >q: the request queue for the device
* < at >dma_mask: the maximum address the device can handle
diff --git a/block/elevator.c b/block/elevator.c
index e28011b..06f4320 100644
--- a/block/elevator.c
+++ b/block/elevator.c
< at >< at > -788,6 +788,11 < at >< at > void elv_completed_request(struct request_queue *q, struct request *rq)
{
struct elevator_queue *e = q->elevator;
+if (rq->cmd_flags & REQ_URGENT) {
+q->notified_urgent = false;
+WARN_ON(!q->dispatched_urgent);
+q->dispatched_urgent = false;
+}
/*
* request is released from the driver, io must be done
*/
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 9d3cafa..933b673 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
< at >< at > -163,7 +163,7 < at >< at > enum rq_flag_bits {
* throttling rules. Don't do it again. */
/* request only flags */
-__REQ_SORTED,/* elevator knows about this request */
+__REQ_SORTED = __REQ_RAHEAD,/* elevator knows about this request */
__REQ_SOFTBARRIER,/* may not be passed by ioscheduler */
__REQ_NOMERGE,/* don't touch this for merging */
__REQ_STARTED,/* drive already may have started this one */
< at >< at > -180,6 +180,7 < at >< at > enum rq_flag_bits {
__REQ_MIXED_MERGE,/* merge of different types, fail separately */
__REQ_KERNEL, /* direct IO to kernel pages */
__REQ_PM,/* runtime pm request */
+__REQ_URGENT,/* urgent request */
__REQ_NR_BITS,/* stops here */
};
< at >< at > -193,6 +194,7 < at >< at > enum rq_flag_bits {
#define REQ_DISCARD(1 << __REQ_DISCARD)
#define REQ_WRITE_SAME(1 << __REQ_WRITE_SAME)
#define REQ_NOIDLE(1 << __REQ_NOIDLE)
+#define REQ_URGENT(1 << __REQ_URGENT)
#define REQ_FAILFAST_MASK \
(REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 102d217..28f8361 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
< at >< at > -304,6 +304,7 < at >< at > struct request_queue {
struct request_listroot_rl;
request_fn_proc*request_fn;
+request_fn_proc*urgent_request_fn;
make_request_fn*make_request_fn;
prep_rq_fn*prep_rq_fn;
unprep_rq_fn*unprep_rq_fn;
< at >< at > -404,6 +405,8 < at >< at > struct request_queue {
#endif
struct queue_limitslimits;
+boolnotified_urgent;
+booldispatched_urgent;
/*
* sg stuff
< at >< at > -918,6 +921,7 < at >< at > extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
request_fn_proc *, spinlock_t *);
+extern void blk_urgent_request(struct request_queue *q, request_fn_proc *fn);
extern void blk_cleanup_queue(struct request_queue *);
extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
extern void blk_queue_bounce_limit(struct request_queue *, u64);
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index d703f94..e753f88 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
< at >< at > -25,6 +25,7 < at >< at > typedef int (elevator_dispatch_fn) (struct request_queue *, int);
typedef void (elevator_add_req_fn) (struct request_queue *, struct request *);
typedef int (elevator_reinsert_req_fn) (struct request_queue *,
struct request *);
+typedef bool (elevator_is_urgent_fn) (struct request_queue *);
typedef struct request *(elevator_request_list_fn) (struct request_queue *, struct request *);
typedef void (elevator_completed_req_fn) (struct request_queue *, struct request *);
typedef int (elevator_may_queue_fn) (struct request_queue *, int);
< at >< at > -51,6 +52,7 < at >< at > struct elevator_ops
elevator_dispatch_fn *elevator_dispatch_fn;
elevator_add_req_fn *elevator_add_req_fn;
elevator_reinsert_req_fn *elevator_reinsert_req_fn;
+elevator_is_urgent_fn *elevator_is_urgent_fn;
elevator_activate_req_fn *elevator_activate_req_fn;
elevator_deactivate_req_fn *elevator_deactivate_req_fn;
</pre>Tanya Brokhman2013-05-12T10:34:24[PATCH 1/1] timer: Don't reinitialize the cpu base lock during CPU_UP_PREPARE
http://comments.gmane.org/gmane.linux.ports.arm.msm/3872
<pre>An inactive timer's base can refer to a offline cpu's base.
In the current code, cpu_base's lock is blindly reinitialized
each time a CPU is brought up. If a CPU is brought online
during the period that another thread is trying to modify an
inactive timer on that CPU with holding its timer base lock,
then the lock will be reinitialized under its feet. This leads
to following SPIN_BUG().
<0> BUG: spinlock already unlocked on CPU#3, kworker/u:3/1466
<0> lock: 0xe3ebe000, .magic: dead4ead, .owner: kworker/u:3/1466, .owner_cpu: 1
<4> [<c0013dc4>] (unwind_backtrace+0x0/0x11c) from [<c026e794>] (do_raw_spin_unlock+0x40/0xcc)
<4> [<c026e794>] (do_raw_spin_unlock+0x40/0xcc) from [<c076c160>] (_raw_spin_unlock+0x8/0x30)
<4> [<c076c160>] (_raw_spin_unlock+0x8/0x30) from [<c009b858>] (mod_timer+0x294/0x310)
<4> [<c009b858>] (mod_timer+0x294/0x310) from [<c00a5e04>] (queue_delayed_work_on+0x104/0x120)
<4> [<c00a5e04>] (queue_delayed_work_on+0x104/0x120) from [<c04eae00>] (sdhci_msm_bus_voting+0x88/0x9c)
<4> [<c04eae00>] (sdhci_msm_bus_voting+0x88/0x9c) from [<c04d8780>] (sdhci_disable+0x40/0x48)
<4> [<c04d8780>] (sdhci_disable+0x40/0x48) from [<c04bf300>] (mmc_release_host+0x4c/0xb0)
<4> [<c04bf300>] (mmc_release_host+0x4c/0xb0) from [<c04c7aac>] (mmc_sd_detect+0x90/0xfc)
<4> [<c04c7aac>] (mmc_sd_detect+0x90/0xfc) from [<c04c2504>] (mmc_rescan+0x7c/0x2c4)
<4> [<c04c2504>] (mmc_rescan+0x7c/0x2c4) from [<c00a6a7c>] (process_one_work+0x27c/0x484)
<4> [<c00a6a7c>] (process_one_work+0x27c/0x484) from [<c00a6e94>] (worker_thread+0x210/0x3b0)
<4> [<c00a6e94>] (worker_thread+0x210/0x3b0) from [<c00aad9c>] (kthread+0x80/0x8c)
<4> [<c00aad9c>] (kthread+0x80/0x8c) from [<c000ea80>] (kernel_thread_exit+0x0/0x8)
As an example, this particular crash occurred when CPU #3 is executing
mod_timer() on an inactive timer whose base is refered to offlined CPU #2.
The code locked the timer_base corresponding to CPU #2. Before it could
proceed, CPU #2 came online and reinitialized the spinlock corresponding
to its base. Thus now CPU #3 held a lock which was reinitialized. When
CPU #3 finally ended up unlocking the old cpu_base corresponding to CPU #2,
we hit the above SPIN_BUG().
CPU #0CPU #3 CPU #2
------------- -------
..... ...... <Offline>
mod_timer()
lock_timer_base
spin_lock_irqsave(&base->lock)
cpu_up(2) ..... ......
init_timers_cpu()
.... ..... spin_lock_init(&base->lock)
..... spin_unlock_irqrestore(&base->lock) ......
<spin_bug>
Allocation of per_cpu timer vector bases is done only once under
"tvec_base_done[]" check. In the current code, spinlock_initialization
of base->lock isn't under this check. When a CPU is up each time the base
lock is reinitialized. Move base spinlock initialization under the check.
Change-Id: I73b48440fffb227a60af9180e318c851048530dd
Signed-off-by: Tirupathi Reddy <tirupath< at >codeaurora.org>
---
kernel/timer.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/kernel/timer.c b/kernel/timer.c
index dbf7a78..1b399c8 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
< at >< at > -1678,12 +1678,12 < at >< at > static int __cpuinit init_timers_cpu(int cpu)
boot_done = 1;
base = &boot_tvec_bases;
}
+spin_lock_init(&base->lock);
tvec_base_done[cpu] = 1;
} else {
base = per_cpu(tvec_bases, cpu);
}
-spin_lock_init(&base->lock);
for (j = 0; j < TVN_SIZE; j++) {
INIT_LIST_HEAD(base->tv5.vec + j);
--
sent by an employee of the Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
hosted by The Linux Foundation
</pre>Tirupathi Reddy2013-05-10T13:38:12[PATCH 1/2] Documentation: devicetree: Add DT bindings for UFS host controller
http://comments.gmane.org/gmane.linux.ports.arm.msm/3868
<pre>Compatible list is used in commit 03b1781 but is not documented.
Add necessary device tree bindings to describe on-chip UFS host
controllers.
Signed-off-by: Sujit Reddy Thumma <sthumma< at >codeaurora.org>
---
.../devicetree/bindings/ufs/ufshcd-pltfrm.txt | 16 ++++++++++++++++
1 files changed, 16 insertions(+), 0 deletions(-)
create mode 100644 Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt
diff --git a/Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt b/Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt
new file mode 100644
index 0000000..20468b2
--- /dev/null
+++ b/Documentation/devicetree/bindings/ufs/ufshcd-pltfrm.txt
< at >< at > -0,0 +1,16 < at >< at >
+* Universal Flash Storage (UFS) Host Controller
+
+UFSHC nodes are defined to describe on-chip UFS host controllers.
+Each UFS controller instance should have its own node.
+
+Required properties:
+- compatible : compatible list, contains "jedec,ufs-1.1"
+- interrupts : <interrupt mapping for UFS host controller IRQ>
+- reg : <registers mapping>
+
+Example:
+ufshc< at >0xfc598000 {
+compatible = "jedec,ufs-1.1";
+reg = <0xfc598000 0x800>;
+interrupts = <0 28 0>;
+};
</pre>Sujit Reddy Thumma2013-05-10T04:48:37[PATCH V4] scsi: ufs: Set fDeviceInit flag to initiate device initialization
http://comments.gmane.org/gmane.linux.ports.arm.msm/3852
<pre>Allow UFS device to complete its initialization and accept
SCSI commands by setting fDeviceInit flag. The device may take
time for this operation and hence the host should poll until
fDeviceInit flag is toggled to zero. This step is mandated by
UFS device specification for device initialization completion.
Signed-off-by: Dolev Raviv <draviv< at >codeaurora.org>
Signed-off-by: Sujit Reddy Thumma <sthumma< at >codeaurora.org>
--
Changes for V4:
- Add NULL pointer check
- Changed fix from v3 to bug on since hba can't be null
Changes for V3:
- Fix static checker error
Changes for V2:
- Add the query sending api via SCSI from the original query patch
diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index 086ff03..742363d 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
< at >< at > -107,8 +107,13 < at >< at > enum {
UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST = 0x81,
};
+/* Flag idn for Query Requests*/
+enum flag_idn {
+QUERY_FLAG_IDN_FDEVICEINIT = 0x01,
+};
+
/* UTP QUERY Transaction Specific Fields OpCode */
-enum {
+enum query_opcode {
UPIU_QUERY_OPCODE_NOP= 0x0,
UPIU_QUERY_OPCODE_READ_DESC= 0x1,
UPIU_QUERY_OPCODE_WRITE_DESC= 0x2,
< at >< at > -208,6 +213,9 < at >< at > struct utp_upiu_query {
u32 reserved[2];
};
+/* Expose the flag value from utp_upiu_query.value */
+#define MASK_QUERY_UPIU_FLAG_LOC 0xFF
+
/**
* struct utp_upiu_req - general upiu request structure
* < at >header:UPIU header structure DW-0 to DW-2
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index bcdc576..2248189 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
< at >< at > -51,6 +51,15 < at >< at >
/* Reserved tag for internal commands */
#define INTERNAL_CMD_TAG 0
+/* Query request standart retries */
+#define QUERY_REQ_RETRIES 10
+/* Query request standart timeout in seconds */
+#define QUERY_REQ_TIMEOUT 5
+/* Send Query Requst with default parameters */
+#define send_query_request(ARG1, ARG2, ARG3, ARG4)\
+ufshcd_query_request(ARG1, ARG2, ARG3, ARG4,\
+QUERY_REQ_TIMEOUT, QUERY_REQ_RETRIES)
+
enum {
UFSHCD_MAX_CHANNEL= 0,
UFSHCD_MAX_ID= 1,
< at >< at > -887,6 +896,164 < at >< at > out:
}
/**
+ * ufshcd_query_request() - Entry point for issuing query request to a
+ * ufs device.
+ * < at >hba: ufs driver context
+ * < at >query: params for query request
+ * < at >descriptor: buffer for sending/receiving descriptor
+ * < at >response: pointer to a buffer that will contain the response code and
+ * response upiu
+ * < at >timeout: time limit for the command in seconds
+ * < at >retries: number of times to try executing the command
+ *
+ * The query request is submitted to the same request queue as the rest of
+ * the scsi commands passed to the UFS controller. In order to use this
+ * queue, we need to receive a tag, same as all other commands. The tags
+ * are issued from the block layer. To simulate a request from the block
+ * layer, we use the same interface as the SCSI layer does when it issues
+ * commands not generated by users. To distinguish a query request from
+ * the SCSI commands, we use a vendor specific unused SCSI command
+ * op-code. This op-code is not part of the SCSI command subset used in
+ * UFS. In such way it is easy to check the command in the driver and
+ * handle it appropriately.
+ *
+ * All necessary fields for issuing a query and receiving its response are
+ * stored in the UFS hba struct. We can use this method since we know
+ * there is only one active query request at all times.
+ *
+ * The request that will pass to the device is stored in "query" argument
+ * passed to this function, while the "response" argument (which is output
+ * field) will hold the query response from the device along with the
+ * response code.
+ */
+int ufshcd_query_request(struct ufs_hba *hba,
+struct ufs_query_req *query,
+u8 *descriptor,
+struct ufs_query_res *response,
+int timeout,
+int retries)
+{
+struct scsi_device *sdev;
+u8 cmd[UFS_QUERY_CMD_SIZE] = {0};
+int result;
+bool sdev_lookup = true;
+
+BUG_ON(!hba);
+if (!query || !response) {
+dev_err(hba->dev,
+"%s: NULL pointer hba = %p, query = %p response = %p\n",
+__func__, hba, query, response);
+return -EINVAL;
+}
+
+/*
+ * A SCSI command structure is composed from opcode at the
+ * begining and 0 at the end.
+ */
+cmd[0] = UFS_QUERY_RESERVED_SCSI_CMD;
+
+/* extracting the SCSI Device */
+sdev = scsi_device_lookup(hba->host, 0, 0, 0);
+if (!sdev) {
+/**
+ * There are some Query Requests that are sent during device
+ * initialization, this happens before the scsi device was
+ * initialized. If there is no scsi device, we generate a
+ * temporary device to allow the Query Request flow.
+ */
+sdev_lookup = false;
+sdev = scsi_get_host_dev(hba->host);
+}
+
+if (!sdev) {
+dev_err(hba->dev, "%s: Could not fetch scsi device\n",
+__func__);
+return -ENODEV;
+}
+
+mutex_lock(&hba->query.lock_ufs_query);
+hba->query.request = query;
+hba->query.descriptor = descriptor;
+hba->query.response = response;
+
+/* wait until request is completed */
+result = scsi_execute(sdev, cmd, DMA_NONE, NULL, 0, NULL,
+timeout, retries, 0, NULL);
+if (result) {
+dev_err(hba->dev,
+"%s: Query with opcode 0x%x, failed with result %d\n",
+__func__, query->upiu_req.opcode, result);
+result = -EIO;
+}
+
+hba->query.request = NULL;
+hba->query.descriptor = NULL;
+hba->query.response = NULL;
+mutex_unlock(&hba->query.lock_ufs_query);
+
+/* Releasing scsi device resource */
+if (sdev_lookup)
+scsi_device_put(sdev);
+else
+scsi_free_host_dev(sdev);
+
+return result;
+}
+
+/**
+ * ufshcd_query_flag() - Helper function for composing flag query requests
+ * hba: per-adapter instance
+ * query_opcode: flag query to perform
+ * idn: flag idn to access
+ * flag_res: the flag value after the query request completes
+ *
+ * Returns 0 for success, non-zero in case of failure
+ */
+int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode,
+enum flag_idn idn, bool *flag_res)
+{
+struct ufs_query_req query = {0};
+struct ufs_query_res response = {0};
+int err;
+
+switch (opcode) {
+case UPIU_QUERY_OPCODE_SET_FLAG:
+case UPIU_QUERY_OPCODE_CLEAR_FLAG:
+case UPIU_QUERY_OPCODE_TOGGLE_FLAG:
+query.query_func = UPIU_QUERY_FUNC_STANDARD_WRITE_REQUEST;
+break;
+case UPIU_QUERY_OPCODE_READ_FLAG:
+query.query_func = UPIU_QUERY_FUNC_STANDARD_READ_REQUEST;
+break;
+default:
+dev_err(hba->dev,
+"%s: Expected query flag opcode but got = %d\n",
+__func__, opcode);
+err = -EINVAL;
+goto out;
+}
+query.upiu_req.opcode = opcode;
+query.upiu_req.idn = idn;
+
+/* Send query request */
+err = send_query_request(hba, &query, NULL, &response);
+
+if (err) {
+dev_err(hba->dev,
+"%s: Sending flag query for idn %d failed, err = %d\n",
+__func__, idn, err);
+goto out;
+}
+
+if (flag_res)
+*flag_res = (response.upiu_res.value &
+MASK_QUERY_UPIU_FLAG_LOC) & 0x1;
+
+out:
+return err;
+}
+
+/**
* ufshcd_memory_alloc - allocate memory for host memory space data structures
* < at >hba: per adapter instance
*
< at >< at > -1324,6 +1491,44 < at >< at > out:
}
/**
+ * ufshcd_validate_device_init() - checks device readines
+ * hba: per-adapter instance
+ *
+ * Set fDeviceInit flag, than, query the flag untill the device clears the
+ * flag.
+ */
+static int ufshcd_validate_device_init(struct ufs_hba *hba)
+{
+int i, err;
+bool flag_res = 0;
+
+err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_SET_FLAG,
+QUERY_FLAG_IDN_FDEVICEINIT, &flag_res);
+if (err) {
+dev_err(hba->dev,
+"%s setting fDeviceInit flag failed with error %d\n",
+__func__, err);
+goto out;
+}
+
+for (i = 0; i < QUERY_REQ_RETRIES && !err && flag_res; i++) {
+err = ufshcd_query_flag(hba, UPIU_QUERY_OPCODE_READ_FLAG,
+QUERY_FLAG_IDN_FDEVICEINIT, &flag_res);
+}
+if (err)
+dev_err(hba->dev,
+"%s reading fDeviceInit flag failed with error %d\n",
+__func__, err);
+else if (flag_res)
+dev_err(hba->dev,
+"%s fDeviceInit was not cleared by the device\n",
+__func__);
+
+out:
+return err;
+}
+
+/**
* ufshcd_make_hba_operational - Make UFS controller operational
* < at >hba: per adapter instance
*
< at >< at > -2153,6 +2358,10 < at >< at > static void ufshcd_async_scan(void *data, async_cookie_t cookie)
if (ret)
goto out;
+ret = ufshcd_validate_device_init(hba);
+if (ret)
+goto out;
+
scsi_scan_host(hba->host);
out:
return;
diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h
index a91c558..76485da 100644
--- a/drivers/scsi/ufs/ufshcd.h
+++ b/drivers/scsi/ufs/ufshcd.h
< at >< at > -286,4 +286,11 < at >< at > static inline int ufshcd_dme_hibern8_exit(struct ufs_hba *hba)
return ufshcd_dme_hibern8_ctrl(hba, 0);
}
+int ufs_query_request(struct ufs_hba *hba,
+struct ufs_query_req *query,
+u8 *descriptor,
+struct ufs_query_res *response,
+int timeout,
+int retries);
+
#endif /* End of Header */
</pre>Dolev Raviv2013-05-09T10:06:30[PATCH 0/3] Fix disable of unused clk/regulator with deferred probe
http://comments.gmane.org/gmane.linux.ports.arm.msm/3846
<pre>Clock and regulator frameworks have support for disabling unused clocks and
regulators at system init to save power when bootloaders leave them in a less
than desirable state. If no driver has requested for a clock/regulator to be
ON by the time kernel init reaches late_initcall level, they were considered
unused.
This worked well/good enough for compiled in drivers before deferred probe
was introduced. But with deferred probe, it's quite likely that devices that
match with compiled in drivers will continue to probe well past late_initcall
(at least as far as I can understand). So, we need to wait for deferred
probing during kernel init to complete before we do the disable of unused
clocks/regulators.
If there's a better or more obvious solution, I'm all ears. Another approach
would have been to add a "probe_done_initcall" level. But that seems overkill
and I don't think adding yet another initcall level is a great idea.
Thanks,
Saravana
Saravana Kannan (3):
driver core: Add API to wait for deferred probe to complete during
init
clk: Disable unused clocks after deferred probing is done
regulator: core: Disable unused regulators after deferred probing is
done
drivers/base/dd.c | 8 ++++++++
drivers/clk/clk.c | 4 +++-
drivers/regulator/core.c | 4 +++-
include/linux/device.h | 1 +
4 files changed, 15 insertions(+), 2 deletions(-)
</pre>Saravana Kannan2013-05-09T05:18:43Search EngineSearch the mailing list at Gmanequery
http://search.gmane.org/?group=$group=gmane.linux.ports.arm.msm