gmane.linux.ports.arm.msm

[PATCH 1/3] ARM: msm: Remove gpiomux-v2 and re-organize MSM_GPIOMUX configs

Rohit Vaswani — 2013-05-23T00:29:22

Remove gpiomux-v2 as it's not being used and make way for future improvements.

Signed-off-by: Rohit Vaswani <rvaswani< at >codeaurora.org>
---
 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 ---
 drivers/gpio/gpio-msm-v2.c       |    5 +--
 8 files changed, 24 insertions(+), 125 deletions(-)
 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

diff --git a/arch/arm/mach-msm/Kconfig b/arch/arm/mach-msm/Kconfig
index fceb093..614e41e 100644
--- a/arch/arm/mach-msm/Kconfig
+++ b/arch/arm/mach-msm/Kconfig
< at >< at > -48,9 +48,7 < at >< at > config ARCH_MSM8X60
 select CPU_V7
 select GPIO_MSM_V2
 select HAVE_SMP
-select MSM_GPIOMUX
 select MSM_SCM if SMP
-select MSM_V2_TLMM
 select USE_OF
 
 config ARCH_MSM8960
< at >< at > -58,9 +56,8 < at >< at > config ARCH_MSM8960
 select ARM_GIC
 select CPU_V7
 select HAVE_SMP
-select MSM_GPIOMUX
+select GPIO_MSM_V2
 select MSM_SCM if SMP
-select MSM_V2_TLMM
 select USE_OF
 
 config MSM_HAS_DEBUG_UART_HS
< at >< at > -124,10 +121,10 < at >< at > config MSM_SMD
 bool
 
 config MSM_GPIOMUX
-bool
-
-config MSM_V2_TLMM
-bool
+depends on !(ARCH_MSM8X60 || ARCH_MSM8960)
+bool "MSM V1 TLMM GPIOMUX architecture"
+help
+  Support for MSM V1 TLMM GPIOMUX architecture.
 
 config MSM_SCM
 bool
diff --git a/arch/arm/mach-msm/Makefile b/arch/arm/mach-msm/Makefile
index 17519fa..1a26d04 100644
--- a/arch/arm/mach-msm/Makefile
+++ b/arch/arm/mach-msm/Makefile
< at >< at > -27,7 +27,5 < at >< at > obj-$(CONFIG_ARCH_MSM7X30) += board-msm7x30.o devices-msm7x30.o
 obj-$(CONFIG_ARCH_QSD8X50) += board-qsd8x50.o devices-qsd8x50.o
 obj-$(CONFIG_ARCH_MSM8X60) += board-dt-8660.o
 obj-$(CONFIG_ARCH_MSM8960) += board-dt-8960.o
-
-obj-$(CONFIG_ARCH_MSM7X30) += gpiomux-v1.o gpiomux.o
-obj-$(CONFIG_ARCH_QSD8X50) += gpiomux-8x50.o gpiomux-v1.o gpiomux.o
-obj-$(CONFIG_ARCH_MSM8X60) += gpiomux-8x60.o gpiomux-v2.o gpiomux.o
+obj-$(CONFIG_MSM_GPIOMUX) += gpiomux.o
+obj-$(CONFIG_ARCH_QSD8X50) += gpiomux-8x50.o
diff --git a/arch/arm/mach-msm/gpiomux-8x60.c b/arch/arm/mach-msm/gpiomux-8x60.c
deleted file mode 100644
index 7b380b3..0000000
--- a/arch/arm/mach-msm/gpiomux-8x60.c
+++ /dev/null
< at >< at > -1,19 +0,0 < at >< at >
-/* Copyright (c) 2010, 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-#include "gpiomux.h"
-
-struct msm_gpiomux_config msm_gpiomux_configs[GPIOMUX_NGPIOS] = {};
diff --git a/arch/arm/mach-msm/gpiomux-v2.c b/arch/arm/mach-msm/gpiomux-v2.c
deleted file mode 100644
index 273396d..0000000
--- a/arch/arm/mach-msm/gpiomux-v2.c
+++ /dev/null
< at >< at > -1,25 +0,0 < at >< at >
-/* Copyright (c) 2010, 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-#include <linux/io.h>
-#include <mach/msm_iomap.h>
-#include "gpiomux.h"
-
-void __msm_gpiomux_write(unsigned gpio, gpiomux_config_t val)
-{
-writel(val & ~GPIOMUX_CTL_MASK,
-       MSM_TLMM_BASE + 0x1000 + (0x10 * gpio));
-}
diff --git a/arch/arm/mach-msm/gpiomux-v2.h b/arch/arm/mach-msm/gpiomux-v2.h
deleted file mode 100644
index 3bf10e7..0000000
--- a/arch/arm/mach-msm/gpiomux-v2.h
+++ /dev/null
< at >< at > -1,61 +0,0 < at >< at >
-/* Copyright (c) 2010, 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-#ifndef __ARCH_ARM_MACH_MSM_GPIOMUX_V2_H
-#define __ARCH_ARM_MACH_MSM_GPIOMUX_V2_H
-
-#define GPIOMUX_NGPIOS 173
-
-typedef u16 gpiomux_config_t;
-
-enum {
-GPIOMUX_DRV_2MA  = 0UL << 6,
-GPIOMUX_DRV_4MA  = 1UL << 6,
-GPIOMUX_DRV_6MA  = 2UL << 6,
-GPIOMUX_DRV_8MA  = 3UL << 6,
-GPIOMUX_DRV_10MA = 4UL << 6,
-GPIOMUX_DRV_12MA = 5UL << 6,
-GPIOMUX_DRV_14MA = 6UL << 6,
-GPIOMUX_DRV_16MA = 7UL << 6,
-};
-
-enum {
-GPIOMUX_FUNC_GPIO = 0UL  << 2,
-GPIOMUX_FUNC_1    = 1UL  << 2,
-GPIOMUX_FUNC_2    = 2UL  << 2,
-GPIOMUX_FUNC_3    = 3UL  << 2,
-GPIOMUX_FUNC_4    = 4UL  << 2,
-GPIOMUX_FUNC_5    = 5UL  << 2,
-GPIOMUX_FUNC_6    = 6UL  << 2,
-GPIOMUX_FUNC_7    = 7UL  << 2,
-GPIOMUX_FUNC_8    = 8UL  << 2,
-GPIOMUX_FUNC_9    = 9UL  << 2,
-GPIOMUX_FUNC_A    = 10UL << 2,
-GPIOMUX_FUNC_B    = 11UL << 2,
-GPIOMUX_FUNC_C    = 12UL << 2,
-GPIOMUX_FUNC_D    = 13UL << 2,
-GPIOMUX_FUNC_E    = 14UL << 2,
-GPIOMUX_FUNC_F    = 15UL << 2,
-};
-
-enum {
-GPIOMUX_PULL_NONE   = 0UL,
-GPIOMUX_PULL_DOWN   = 1UL,
-GPIOMUX_PULL_KEEPER = 2UL,
-GPIOMUX_PULL_UP     = 3UL,
-};
-
-#endif
diff --git a/arch/arm/mach-msm/gpiomux.c b/arch/arm/mach-msm/gpiomux.c
index 53af21a..2b8e2d2 100644
--- a/arch/arm/mach-msm/gpiomux.c
+++ b/arch/arm/mach-msm/gpiomux.c
< at >< at > -17,9 +17,24 < at >< at >
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include "gpiomux.h"
+#include "proc_comm.h"
 
 static DEFINE_SPINLOCK(gpiomux_lock);
 
+static void __msm_gpiomux_write(unsigned gpio, gpiomux_config_t val)
+{
+unsigned tlmm_config  = (val & ~GPIOMUX_CTL_MASK) |
+((gpio & 0x3ff) << 4);
+unsigned tlmm_disable = 0;
+int rc;
+
+rc = msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX,
+   &tlmm_config, &tlmm_disable);
+if (rc)
+pr_err("%s: unexpected proc_comm failure %d: %08x %08x\n",
+       __func__, rc, tlmm_config, tlmm_disable);
+}
+
 int msm_gpiomux_write(unsigned gpio,
       gpiomux_config_t active,
       gpiomux_config_t suspended)
diff --git a/arch/arm/mach-msm/gpiomux.h b/arch/arm/mach-msm/gpiomux.h
index 00459f6..8e82f41 100644
--- a/arch/arm/mach-msm/gpiomux.h
+++ b/arch/arm/mach-msm/gpiomux.h
< at >< at > -20,12 +20,7 < at >< at >
 #include <linux/bitops.h>
 #include <linux/errno.h>
 #include <mach/msm_gpiomux.h>
-
-#if defined(CONFIG_MSM_V2_TLMM)
-#include "gpiomux-v2.h"
-#else
 #include "gpiomux-v1.h"
-#endif
 
 /**
  * struct msm_gpiomux_config: gpiomux settings for one gpio line.
diff --git a/drivers/gpio/gpio-msm-v2.c b/drivers/gpio/gpio-msm-v2.c
index dd2edde..75cc821 100644
--- a/drivers/gpio/gpio-msm-v2.c
+++ b/drivers/gpio/gpio-msm-v2.c
< at >< at > -29,7 +29,6 < at >< at >
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
 
-#include <mach/msm_gpiomux.h>
 #include <mach/msm_iomap.h>
 
 /* Bits of interest in the GPIO_IN_OUT register.
< at >< at > -159,12 +158,12 < at >< at > static int msm_gpio_direction_output(struct gpio_chip *chip,
 
 static int msm_gpio_request(struct gpio_chip *chip, unsigned offset)
 {
-return msm_gpiomux_get(chip->base + offset);
+return 0;
 }
 
 static void msm_gpio_free(struct gpio_chip *chip, unsigned offset)
 {
-msm_gpiomux_put(chip->base + offset);
+return;
 }
 
 static int msm_gpio_to_irq(struct gpio_chip *chip, unsigned offset)

[PATCHv2 0/3] Cleanup MSM_GPIOMUX and add DT support for gpio-msm

Rohit Vaswani — 2013-05-23T00:29:21

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

Re: [RFC/PATCH 0/2] Remove most of_device_match() calls

Rob Herring — 2013-05-22T21:27:55

See this commit:

commit b1608d69cb804e414d0887140ba08a9398e4e638
Author: Grant Likely <grant.likely< at >secretlab.ca>
Date:   Wed May 18 11:19:24 2011 -0600

    drivercore: revert addition of of_match to struct device

    Commit b826291c, "drivercore/dt: add a match table pointer to struct
    device" added an of_match pointer to struct device to cache the
    of_match_table entry discovered at driver match time.  This was unsafe
    because matching is not an atomic operation with probing a driver.  If
    two or more drivers are attempted to be matched to a driver at the
    same time, then the cached matching entry pointer could get
    overwritten.

    This patch reverts the of_match cache pointer and reworks all users to
    call of_match_device() directly instead.

    Signed-off-by: Grant Likely <grant.likely< at >secretlab.ca>

[RFC/PATCH 0/2] Remove most of_device_match() calls

Stephen Boyd — 2013-05-22T20:40:15

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(-)

Re: [PATCH v2 1/2] clk: Disable unused clocks after deferred probing is done

Jean-Christophe PLAGNIOL-VILLARD — 2013-05-22T10:35:25

so this feature is nightmare we need to KILL it

Best Regards,
J.

[PATCH 0/3] Cleanup MSM_GPIOMUX and add device-tree support for

Rohit Vaswani — 2013-05-21T18:32:40

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

[PATCH] ARM: dts: msm: Fix bad register addresses

Stephen Boyd — 2013-05-21T00:50:37

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>;

Re: [PATCHv6 03/11] ARM: smp: Remove duplicate dummy timer implementation

Stephen Boyd — 2013-05-20T21:55:54

Russell, can you please ack this patch and patch #11?

Re: Would like to form a pool of Linux copyright holders for faster GPL enforcement against Anthrax Kernels

Bradley M. Kuhn — 2013-05-20T15:13:00

Eric Appleman wrote at 04:26 (EDT) on Saturday:

As some on these lists likely already know, Conservancy's GPL Compliance
Project for Linux Developers [0] is aware of this matter and is
considering what actions to take, and how such actions should be ranked
in priority given the queue of the hundreds of known GPL violations on
Linux occurring every day.

We very much appreciate that Eric has brought the matter to our
attention and I'm continuing to correspond with Eric privately in the
hopes that we can resolve the matter.

If anyone wants to join Conservancy's GPL Compliance Project for Linux
Developers, please do contact me!

[0] More details on Conservancy's GPL Compliance Project for Linux
    Developers can be found at
    https://sfconservancy.org/news/2012/may/29/compliance/

Sincerely,

[PATCH 1/1] diag: fix userspace read-write freeze during high logging rates

Kasidit Yusuf — 2013-05-20T08:17:39

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__);

Would like to form a pool of Linux copyright holders for faster GPL enforcement against Anthrax Kernels

Eric Appleman — 2013-05-18T08:21:13

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

Re: [PATCH v2] clk: Fix race condition between clk_set_parent and clk_enable()

Saravana Kannan — 2013-05-16T21:31:23

Thanks Mike. I forgot to add the Ack by Ulf. Would be nice if you can 
put that in.

Btw, I did send this email to the list. But looks like this mail is 
wedged in the series of tubes in the arm mailing list.

-Saravana

Re: [PATCH v2] clk: Fix race condition between clk_set_parent and clk_enable()

Mike Turquette — 2013-05-16T20:44:55

Quoting Saravana Kannan (2013-05-15 21:07:24)

Updated to this version in clk-next.

Thanks,
Mike

Re: [PATCH v2 1/2] clk: Disable unused clocks after deferred probing is done

Saravana Kannan — 2013-05-16T19:23:12

No, we are just reordering the steps.

-Saravana

Re: [PATCH v2 1/2] clk: Disable unused clocks after deferred probing is done

Ulf Hansson — 2013-05-16T12:55:46

Without giving this too much thinking... Will boot time be affected
with this change?

Kind regards
Ulf Hansson

Re: [PATCH v2 1/2] clk: Disable unused clocks after deferred probing is done

Saravana Kannan — 2013-05-16T04:34:03

Mike,

Thoughts? Picking it up? Removing the existing auto-disable code (I 
think they are still useful)?

-Saravana

[PATCH v2] clk: Fix race condition between clk_set_parent and clk_enable()

Saravana Kannan — 2013-05-16T04:07:24

Without this patch, the following race condition is possible.
* clk-A has two parents - clk-X and clk-Y.
* All three are disabled and clk-X is current parent.
* Thread A: clk_set_parent(clk-A, clk-Y).
* Thread A: <snip execution flow>
* Thread A: Grabs enable lock.
* Thread A: Sees enable count of clk-A is 0, so doesn't enable clk-Y.
* Thread A: Updates clk-A SW parent to clk-Y
* Thread A: Releases enable lock.
* Thread B: clk_enable(clk-A).
* Thread B: clk_enable() enables clk-Y, then enabled clk-A and returns.

clk-A is now enabled in software, but not clocking in hardware since the
hardware parent is still clk-X.

The only way to avoid race conditions between clk_set_parent() and
clk_enable/disable() is to ensure that clk_enable/disable() calls don't
require changes to hardware enable state between changes to software clock
topology and hardware clock topology.

The options to achieve the above are:
1. Grab the enable lock before changing software/hardware topology and
   release it afterwards.
2. Keep the clock enabled for the duration of software/hardware topology
   change so that any additional enable/disable calls don't try to change
   the hardware state. Once the topology change is complete, the clock can
   be put back in its original enable state.

Option (1) is not an acceptable solution since the set_parent() ops might
need to sleep.

Therefore, this patch implements option (2).

This patch doesn't violate any API semantics. clk_disable() doesn't
guarantee that the clock is actually disabled. So, no clients of a clock
can assume that a clock is disabled after their last call to clk_disable().
So, enabling the clock during a parent change is not a violation of any API
semantics.

This also has the nice side effect of simplifying the error handling code.

Signed-off-by: Saravana Kannan <skannan< at >codeaurora.org>
---
 drivers/clk/clk.c |   91 ++++++++++++++++++++++++++---------------------------
 1 files changed, 45 insertions(+), 46 deletions(-)

diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 934cfd1..b4dbb8c 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
< at >< at > -1377,67 +1377,61 < at >< at > static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
 unsigned long flags;
 int ret = 0;
 struct clk *old_parent = clk->parent;
-bool migrated_enable = false;
 
-/* migrate prepare */
-if (clk->prepare_count)
+/*
+ * Migrate prepare state between parents and prevent race with
+ * clk_enable().
+ *
+ * If the clock is not prepared, then a race with
+ * clk_enable/disable() is impossible since we already have the
+ * prepare lock (future calls to clk_enable() need to be preceded by
+ * a clk_prepare()).
+ *
+ * If the clock is prepared, migrate the prepared state to the new
+ * parent and also protect against a race with clk_enable() by
+ * forcing the clock and the new parent on.  This ensures that all
+ * future calls to clk_enable() are practically NOPs with respect to
+ * hardware and software states.
+ *
+ * See also: Comment for clk_set_parent() below.
+ */
+if (clk->prepare_count) {
 __clk_prepare(parent);
-
-flags = clk_enable_lock();
-
-/* migrate enable */
-if (clk->enable_count) {
-__clk_enable(parent);
-migrated_enable = true;
+clk_enable(parent);
+clk_enable(clk);
 }
 
 /* update the clk tree topology */
+flags = clk_enable_lock();
 clk_reparent(clk, parent);
-
 clk_enable_unlock(flags);
 
 /* change clock input source */
 if (parent && clk->ops->set_parent)
 ret = clk->ops->set_parent(clk->hw, p_index);
-
 if (ret) {
-/*
- * The error handling is tricky due to that we need to release
- * the spinlock while issuing the .set_parent callback. This
- * means the new parent might have been enabled/disabled in
- * between, which must be considered when doing rollback.
- */
-flags = clk_enable_lock();
 
+flags = clk_enable_lock();
 clk_reparent(clk, old_parent);
-
-if (migrated_enable && clk->enable_count) {
-__clk_disable(parent);
-} else if (migrated_enable && (clk->enable_count == 0)) {
-__clk_disable(old_parent);
-} else if (!migrated_enable && clk->enable_count) {
-__clk_disable(parent);
-__clk_enable(old_parent);
-}
-
 clk_enable_unlock(flags);
 
-if (clk->prepare_count)
+if (clk->prepare_count) {
+clk_disable(clk);
+clk_disable(parent);
 __clk_unprepare(parent);
-
+}
 return ret;
 }
 
-/* clean up enable for old parent if migration was done */
-if (migrated_enable) {
-flags = clk_enable_lock();
-__clk_disable(old_parent);
-clk_enable_unlock(flags);
-}
-
-/* clean up prepare for old parent if migration was done */
-if (clk->prepare_count)
+/*
+ * Finish the migration of prepare state and undo the changes done
+ * for preventing a race with clk_enable().
+ */
+if (clk->prepare_count) {
+clk_disable(clk);
+clk_disable(old_parent);
 __clk_unprepare(old_parent);
+}
 
 /* update debugfs with new clk tree topology */
 clk_debug_reparent(clk, parent);
< at >< at > -1449,12 +1443,17 < at >< at > static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index)
  * < at >clk: the mux clk whose input we are switching
  * < at >parent: the new input to clk
  *
- * Re-parent clk to use parent as it's new input source.  If clk has the
- * CLK_SET_PARENT_GATE flag set then clk must be gated for this
- * operation to succeed.  After successfully changing clk's parent
- * clk_set_parent will update the clk topology, sysfs topology and
- * propagate rate recalculation via __clk_recalc_rates.  Returns 0 on
- * success, -EERROR otherwise.
+ * Re-parent clk to use parent as its new input source.  If clk is in
+ * prepared state, the clk will get enabled for the duration of this call. If
+ * that's not acceptable for a specific clk (Eg: the consumer can't handle
+ * that, the reparenting is glitchy in hardware, etc), use the
+ * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
+ *
+ * After successfully changing clk's parent clk_set_parent will update the
+ * clk topology, sysfs topology and propagate rate recalculation via
+ * __clk_recalc_rates.
+ *
+ * Returns 0 on success, -EERROR otherwise.
  */
 int clk_set_parent(struct clk *clk, struct clk *parent)
 {

Re: [PATCH] ARM: avoid mis-detecting some V7 cores in the decompressor

Stephen Boyd — 2013-05-15T19:38:12

Ping?

Re: [PATCH] clk: Fix race condition between clk_set_parent and clk_enable()

Ulf Hansson — 2013-05-15T19:24:48

Maybe an additional note about that since CLK_SET_PARENT_GATE is a
prerequisite for doing migration of "prepare", we also interpreted
this flags as it is acceptable to enable the clock(s) in this context.


Really good, that we can remove this awkward error handling!


Looks good! Thanks for having another round to fixup this kind of
tricky code. :-)

Acked-by: Ulf Hansson <ulf.hansson< at >linaro.org>

Re: [PATCHv2] arm: mm: Use phys_addr_t properly for ioremapfunctions

Russell King - ARM Linux — 2013-05-15T16:48:54

Maybe there's a project there for someone to remove phys_addr_t or
resource_size_t then - but I suspect Linus won't like the churn
caused by that...

So, let's just go by the one which takes less typing and save our
fingers.  phys_addr_t.

Re: [PATCHv2] arm: mm: Use phys_addr_t properly for ioremap functions

Arnd Bergmann — 2013-05-15T14:15:39

Looks good to me. I wonder a bit whether resource_size_t or phys_addr_t
is the right type here, but they are always defined to the same type
these days.

FWIW, x86 and tile use resource_size_t, while a couple of other architectures
use phys_addr_t.

Arnd